From e34a5eb05f51889882e254e36050760ecc7e9105 Mon Sep 17 00:00:00 2001
From: Samuel Colvin <s@muelcolvin.com>
Date: Wed, 23 Aug 2023 16:58:45 +0100
Subject: [PATCH 001/550] fix big int subclass extraction (#919)

---
 src/input/input_python.rs    | 6 ++----
 src/input/return_enums.rs    | 9 +++++++++
 tests/validators/test_int.py | 2 ++
 3 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index 24f37504f..5ebe9025a 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -304,8 +304,7 @@ impl<'a> Input<'a> for PyAny {
                 Err(ValError::new(ErrorTypeDefaults::IntType, self))
             } else {
                 // force to an int to upcast to a pure python int
-                let int = self.extract::<i64>()?;
-                Ok(EitherInt::I64(int))
+                EitherInt::upcast(self)
             }
         } else {
             Err(ValError::new(ErrorTypeDefaults::IntType, self))
@@ -320,8 +319,7 @@ impl<'a> Input<'a> for PyAny {
             str_as_int(self, &cow_str)
         } else if PyInt::is_type_of(self) {
             // force to an int to upcast to a pure python int to maintain current behaviour
-            let int = self.extract::<i64>()?;
-            Ok(EitherInt::I64(int))
+            EitherInt::upcast(self)
         } else if let Ok(float) = self.extract::<f64>() {
             float_as_int(self, float)
         } else {
diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index 483b1918c..d0f3ba45d 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -820,6 +820,15 @@ pub enum EitherInt<'a> {
 }
 
 impl<'a> EitherInt<'a> {
+    pub fn upcast(py_any: &'a PyAny) -> ValResult<Self> {
+        // Safety: we know that py_any is a python int
+        if let Ok(int_64) = py_any.extract::<i64>() {
+            Ok(Self::I64(int_64))
+        } else {
+            let big_int: BigInt = py_any.extract()?;
+            Ok(Self::BigInt(big_int))
+        }
+    }
     pub fn into_i64(self, py: Python<'a>) -> ValResult<'a, i64> {
         match self {
             EitherInt::I64(i) => Ok(i),
diff --git a/tests/validators/test_int.py b/tests/validators/test_int.py
index 4ef08081e..44a806118 100644
--- a/tests/validators/test_int.py
+++ b/tests/validators/test_int.py
@@ -421,7 +421,9 @@ def test_int_subclass() -> None:
     assert type(v_strict) == int
 
     assert v.validate_python(IntSubclass(1136885225876639845)) == 1136885225876639845
+    assert v.validate_python(IntSubclass(i64_max + 7)) == i64_max + 7
     assert v.validate_python(IntSubclass(1136885225876639845), strict=True) == 1136885225876639845
+    assert v.validate_python(IntSubclass(i64_max + 7), strict=True) == i64_max + 7
 
 
 def test_int_subclass_constraint() -> None:

From c086caec1a200417f19850244282c06b5d4d1650 Mon Sep 17 00:00:00 2001
From: Adrian Garcia Badaracco <1755071+adriangb@users.noreply.github.com>
Date: Wed, 23 Aug 2023 11:19:17 -0500
Subject: [PATCH 002/550] Bump pydantic-core to 2.6.3 (#920)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index f10f86d4a..25119d19c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -242,7 +242,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.6.2"
+version = "2.6.3"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index 93637dda9..b16624acc 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.6.2"
+version = "2.6.3"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From b076a8f41caeebc5df0e0d40fc54696d86ed6227 Mon Sep 17 00:00:00 2001
From: Adrian Garcia Badaracco <1755071+adriangb@users.noreply.github.com>
Date: Wed, 23 Aug 2023 11:43:29 -0500
Subject: [PATCH 003/550] Allow customizing serialization of extras (#911)

---
 python/pydantic_core/core_schema.py           | 24 +++++++--------
 src/serializers/fields.rs                     | 13 ++++++--
 src/serializers/type_serializers/dataclass.rs |  2 +-
 src/serializers/type_serializers/model.rs     |  9 +++++-
 src/serializers/type_serializers/tuple.rs     |  4 +--
 .../type_serializers/typed_dict.rs            | 11 ++++++-
 src/validators/dataclass.rs                   | 25 +++++++++++++++-
 src/validators/model_fields.rs                | 16 +++++-----
 src/validators/tuple.rs                       | 18 +++++------
 src/validators/typed_dict.rs                  | 14 ++++-----
 tests/benchmarks/test_micro_benchmarks.py     |  2 +-
 tests/serializers/test_dataclasses.py         | 30 ++++++++++++++++++-
 tests/serializers/test_list_tuple.py          |  4 +--
 tests/serializers/test_model.py               | 26 +++++++++++++++-
 tests/serializers/test_typed_dict.py          | 15 ++++++++++
 tests/test_json.py                            |  2 +-
 tests/validators/test_model_fields.py         | 16 +++++-----
 tests/validators/test_tuple.py                |  6 ++--
 tests/validators/test_typed_dict.py           | 16 +++++-----
 tests/validators/test_with_default.py         |  2 +-
 20 files changed, 185 insertions(+), 70 deletions(-)

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index 725d41eee..74442b44c 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -1366,7 +1366,7 @@ def list_schema(
 class TuplePositionalSchema(TypedDict, total=False):
     type: Required[Literal['tuple-positional']]
     items_schema: Required[List[CoreSchema]]
-    extra_schema: CoreSchema
+    extras_schema: CoreSchema
     strict: bool
     ref: str
     metadata: Any
@@ -1376,7 +1376,7 @@ class TuplePositionalSchema(TypedDict, total=False):
 def tuple_positional_schema(
     items_schema: list[CoreSchema],
     *,
-    extra_schema: CoreSchema | None = None,
+    extras_schema: CoreSchema | None = None,
     strict: bool | None = None,
     ref: str | None = None,
     metadata: Any = None,
@@ -1397,7 +1397,7 @@ def tuple_positional_schema(
 
     Args:
         items_schema: The value must be a tuple with items that match these schemas
-        extra_schema: The value must be a tuple with items that match this schema
+        extras_schema: The value must be a tuple with items that match this schema
             This was inspired by JSON schema's `prefixItems` and `items` fields.
             In python's `typing.Tuple`, you can't specify a type for "extra" items -- they must all be the same type
             if the length is variable. So this field won't be set from a `typing.Tuple` annotation on a pydantic model.
@@ -1409,7 +1409,7 @@ def tuple_positional_schema(
     return _dict_not_none(
         type='tuple-positional',
         items_schema=items_schema,
-        extra_schema=extra_schema,
+        extras_schema=extras_schema,
         strict=strict,
         ref=ref,
         metadata=metadata,
@@ -2829,7 +2829,7 @@ class TypedDictSchema(TypedDict, total=False):
     fields: Required[Dict[str, TypedDictField]]
     computed_fields: List[ComputedField]
     strict: bool
-    extra_validator: CoreSchema
+    extras_schema: CoreSchema
     # all these values can be set via config, equivalent fields have `typed_dict_` prefix
     extra_behavior: ExtraBehavior
     total: bool  # default: True
@@ -2845,7 +2845,7 @@ def typed_dict_schema(
     *,
     computed_fields: list[ComputedField] | None = None,
     strict: bool | None = None,
-    extra_validator: CoreSchema | None = None,
+    extras_schema: CoreSchema | None = None,
     extra_behavior: ExtraBehavior | None = None,
     total: bool | None = None,
     populate_by_name: bool | None = None,
@@ -2871,7 +2871,7 @@ def typed_dict_schema(
         fields: The fields to use for the typed dict
         computed_fields: Computed fields to use when serializing the model, only applies when directly inside a model
         strict: Whether the typed dict is strict
-        extra_validator: The extra validator to use for the typed dict
+        extras_schema: The extra validator to use for the typed dict
         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
         extra_behavior: The extra behavior to use for the typed dict
@@ -2884,7 +2884,7 @@ def typed_dict_schema(
         fields=fields,
         computed_fields=computed_fields,
         strict=strict,
-        extra_validator=extra_validator,
+        extras_schema=extras_schema,
         extra_behavior=extra_behavior,
         total=total,
         populate_by_name=populate_by_name,
@@ -2948,7 +2948,7 @@ class ModelFieldsSchema(TypedDict, total=False):
     model_name: str
     computed_fields: List[ComputedField]
     strict: bool
-    extra_validator: CoreSchema
+    extras_schema: CoreSchema
     # all these values can be set via config, equivalent fields have `typed_dict_` prefix
     extra_behavior: ExtraBehavior
     populate_by_name: bool  # replaces `allow_population_by_field_name` in pydantic v1
@@ -2964,7 +2964,7 @@ def model_fields_schema(
     model_name: str | None = None,
     computed_fields: list[ComputedField] | None = None,
     strict: bool | None = None,
-    extra_validator: CoreSchema | None = None,
+    extras_schema: CoreSchema | None = None,
     extra_behavior: ExtraBehavior | None = None,
     populate_by_name: bool | None = None,
     from_attributes: bool | None = None,
@@ -2991,7 +2991,7 @@ def model_fields_schema(
         model_name: The name of the model, used for error messages, defaults to "Model"
         computed_fields: Computed fields to use when serializing the model, only applies when directly inside a model
         strict: Whether the typed dict is strict
-        extra_validator: The extra validator to use for the typed dict
+        extras_schema: The extra validator to use for the typed dict
         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
         extra_behavior: The extra behavior to use for the typed dict
@@ -3005,7 +3005,7 @@ def model_fields_schema(
         model_name=model_name,
         computed_fields=computed_fields,
         strict=strict,
-        extra_validator=extra_validator,
+        extras_schema=extras_schema,
         extra_behavior=extra_behavior,
         populate_by_name=populate_by_name,
         from_attributes=from_attributes,
diff --git a/src/serializers/fields.rs b/src/serializers/fields.rs
index c8bf67971..f48f8e0b9 100644
--- a/src/serializers/fields.rs
+++ b/src/serializers/fields.rs
@@ -94,6 +94,7 @@ pub struct GeneralFieldsSerializer {
     fields: AHashMap<String, SerField>,
     computed_fields: Option<ComputedFields>,
     mode: FieldsMode,
+    extra_serializer: Option<Box<CombinedSerializer>>,
     // isize because we look up filter via `.hash()` which returns an isize
     filter: SchemaFilter<isize>,
     required_fields: usize,
@@ -103,12 +104,14 @@ impl GeneralFieldsSerializer {
     pub(super) fn new(
         fields: AHashMap<String, SerField>,
         mode: FieldsMode,
+        extra_serializer: Option<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),
             filter: SchemaFilter::default(),
             computed_fields,
             required_fields,
@@ -205,7 +208,10 @@ impl TypeSerializer for GeneralFieldsSerializer {
                         used_req_fields += 1;
                     }
                 } else if self.mode == FieldsMode::TypedDictAllow {
-                    let value = infer_to_python(value, next_include, next_exclude, &extra)?;
+                    let value = match &self.extra_serializer {
+                        Some(serializer) => serializer.to_python(value, next_include, next_exclude, &extra)?,
+                        None => infer_to_python(value, next_include, next_exclude, &extra)?,
+                    };
                     output_dict.set_item(key, value)?;
                 } else if extra.check == SerCheck::Strict {
                     return Err(PydanticSerializationUnexpectedValue::new_err(None));
@@ -227,7 +233,10 @@ impl TypeSerializer for GeneralFieldsSerializer {
                     continue;
                 }
                 if let Some((next_include, next_exclude)) = self.filter.key_filter(key, include, exclude)? {
-                    let value = infer_to_python(value, next_include, next_exclude, &td_extra)?;
+                    let value = match &self.extra_serializer {
+                        Some(serializer) => serializer.to_python(value, next_include, next_exclude, extra)?,
+                        None => infer_to_python(value, next_include, next_exclude, extra)?,
+                    };
                     output_dict.set_item(key, value)?;
                 }
             }
diff --git a/src/serializers/type_serializers/dataclass.rs b/src/serializers/type_serializers/dataclass.rs
index aa3a180da..787e267dd 100644
--- a/src/serializers/type_serializers/dataclass.rs
+++ b/src/serializers/type_serializers/dataclass.rs
@@ -55,7 +55,7 @@ impl BuildSerializer for DataclassArgsBuilder {
 
         let computed_fields = ComputedFields::new(schema, config, definitions)?;
 
-        Ok(GeneralFieldsSerializer::new(fields, fields_mode, computed_fields).into())
+        Ok(GeneralFieldsSerializer::new(fields, fields_mode, None, computed_fields).into())
     }
 }
 
diff --git a/src/serializers/type_serializers/model.rs b/src/serializers/type_serializers/model.rs
index 9d14dd16b..8a2eeb4e1 100644
--- a/src/serializers/type_serializers/model.rs
+++ b/src/serializers/type_serializers/model.rs
@@ -11,6 +11,7 @@ use super::{
     CombinedSerializer, ComputedFields, Extra, FieldsMode, GeneralFieldsSerializer, ObType, SerCheck, SerField,
     TypeSerializer,
 };
+use crate::build_tools::py_schema_err;
 use crate::build_tools::{py_schema_error_type, ExtraBehavior};
 use crate::definitions::DefinitionsBuilder;
 use crate::serializers::errors::PydanticSerializationUnexpectedValue;
@@ -38,6 +39,12 @@ impl BuildSerializer for ModelFieldsBuilder {
         let fields_dict: &PyDict = schema.get_as_req(intern!(py, "fields"))?;
         let mut fields: AHashMap<String, SerField> = AHashMap::with_capacity(fields_dict.len());
 
+        let extra_serializer = match (schema.get_item(intern!(py, "extras_schema")), &fields_mode) {
+            (Some(v), FieldsMode::ModelExtra) => Some(CombinedSerializer::build(v.extract()?, config, definitions)?),
+            (Some(_), _) => return py_schema_err!("extras_schema can only be used if extra_behavior=allow"),
+            (_, _) => None,
+        };
+
         for (key, value) in fields_dict {
             let key_py: &PyString = key.downcast()?;
             let key: String = key_py.extract()?;
@@ -60,7 +67,7 @@ impl BuildSerializer for ModelFieldsBuilder {
 
         let computed_fields = ComputedFields::new(schema, config, definitions)?;
 
-        Ok(GeneralFieldsSerializer::new(fields, fields_mode, computed_fields).into())
+        Ok(GeneralFieldsSerializer::new(fields, fields_mode, extra_serializer, computed_fields).into())
     }
 }
 
diff --git a/src/serializers/type_serializers/tuple.rs b/src/serializers/type_serializers/tuple.rs
index 46d7ef775..00c61e250 100644
--- a/src/serializers/type_serializers/tuple.rs
+++ b/src/serializers/type_serializers/tuple.rs
@@ -159,8 +159,8 @@ impl BuildSerializer for TuplePositionalSerializer {
         let py = schema.py();
         let items: &PyList = schema.get_as_req(intern!(py, "items_schema"))?;
 
-        let extra_serializer = match schema.get_as::<&PyDict>(intern!(py, "extra_schema"))? {
-            Some(extra_schema) => CombinedSerializer::build(extra_schema, config, definitions)?,
+        let extra_serializer = match schema.get_as::<&PyDict>(intern!(py, "extras_schema"))? {
+            Some(extras_schema) => CombinedSerializer::build(extras_schema, config, definitions)?,
             None => AnySerializer::build(schema, config, definitions)?,
         };
         let items_serializers: Vec<CombinedSerializer> = items
diff --git a/src/serializers/type_serializers/typed_dict.rs b/src/serializers/type_serializers/typed_dict.rs
index 4d0cf4a3c..5967738ae 100644
--- a/src/serializers/type_serializers/typed_dict.rs
+++ b/src/serializers/type_serializers/typed_dict.rs
@@ -4,6 +4,7 @@ use pyo3::types::{PyDict, PyString};
 
 use ahash::AHashMap;
 
+use crate::build_tools::py_schema_err;
 use crate::build_tools::{py_schema_error_type, schema_or_config, ExtraBehavior};
 use crate::definitions::DefinitionsBuilder;
 use crate::tools::SchemaDict;
@@ -34,6 +35,14 @@ impl BuildSerializer for TypedDictBuilder {
         let fields_dict: &PyDict = schema.get_as_req(intern!(py, "fields"))?;
         let mut fields: AHashMap<String, SerField> = AHashMap::with_capacity(fields_dict.len());
 
+        let extra_serializer = match (schema.get_item(intern!(py, "extras_schema")), &fields_mode) {
+            (Some(v), FieldsMode::TypedDictAllow) => {
+                Some(CombinedSerializer::build(v.extract()?, config, definitions)?)
+            }
+            (Some(_), _) => return py_schema_err!("extras_schema can only be used if extra_behavior=allow"),
+            (_, _) => None,
+        };
+
         for (key, value) in fields_dict {
             let key_py: &PyString = key.downcast()?;
             let key: String = key_py.extract()?;
@@ -56,6 +65,6 @@ impl BuildSerializer for TypedDictBuilder {
 
         let computed_fields = ComputedFields::new(schema, config, definitions)?;
 
-        Ok(GeneralFieldsSerializer::new(fields, fields_mode, computed_fields).into())
+        Ok(GeneralFieldsSerializer::new(fields, fields_mode, extra_serializer, computed_fields).into())
     }
 }
diff --git a/src/validators/dataclass.rs b/src/validators/dataclass.rs
index b5f8dc6ba..7b7be282e 100644
--- a/src/validators/dataclass.rs
+++ b/src/validators/dataclass.rs
@@ -38,6 +38,7 @@ pub struct DataclassArgsValidator {
     dataclass_name: String,
     validator_name: String,
     extra_behavior: ExtraBehavior,
+    extras_validator: Option<Box<CombinedValidator>>,
     loc_by_alias: bool,
 }
 
@@ -55,6 +56,12 @@ impl BuildValidator for DataclassArgsValidator {
 
         let extra_behavior = ExtraBehavior::from_schema_or_config(py, schema, config, ExtraBehavior::Ignore)?;
 
+        let extras_validator = match (schema.get_item(intern!(py, "extras_schema")), &extra_behavior) {
+            (Some(v), ExtraBehavior::Allow) => Some(Box::new(build_validator(v, config, definitions)?)),
+            (Some(_), _) => return py_schema_err!("extras_schema can only be used if extra_behavior=allow"),
+            (_, _) => None,
+        };
+
         let fields_schema: &PyList = schema.get_as_req(intern!(py, "fields"))?;
         let mut fields: Vec<Field> = Vec::with_capacity(fields_schema.len());
 
@@ -118,6 +125,7 @@ impl BuildValidator for DataclassArgsValidator {
             dataclass_name,
             validator_name,
             extra_behavior,
+            extras_validator,
             loc_by_alias: config.get_as(intern!(py, "loc_by_alias"))?.unwrap_or(true),
         }
         .into())
@@ -267,7 +275,22 @@ impl Validator for DataclassArgsValidator {
                                                     }
                                                     ExtraBehavior::Ignore => {}
                                                     ExtraBehavior::Allow => {
-                                                        output_dict.set_item(either_str.as_py_string(py), value)?
+                                                        if let Some(ref validator) = self.extras_validator {
+                                                            match validator.validate(py, value, state) {
+                                                                Ok(value) => output_dict
+                                                                    .set_item(either_str.as_py_string(py), value)?,
+                                                                Err(ValError::LineErrors(line_errors)) => {
+                                                                    for err in line_errors {
+                                                                        errors.push(err.with_outer_location(
+                                                                            raw_key.as_loc_item(),
+                                                                        ));
+                                                                    }
+                                                                }
+                                                                Err(err) => return Err(err),
+                                                            }
+                                                        } else {
+                                                            output_dict.set_item(either_str.as_py_string(py), value)?
+                                                        }
                                                     }
                                                 }
                                             }
diff --git a/src/validators/model_fields.rs b/src/validators/model_fields.rs
index 131118cdb..29e9522f2 100644
--- a/src/validators/model_fields.rs
+++ b/src/validators/model_fields.rs
@@ -36,7 +36,7 @@ pub struct ModelFieldsValidator {
     fields: Vec<Field>,
     model_name: String,
     extra_behavior: ExtraBehavior,
-    extra_validator: Option<Box<CombinedValidator>>,
+    extras_validator: Option<Box<CombinedValidator>>,
     strict: bool,
     from_attributes: bool,
     loc_by_alias: bool,
@@ -58,9 +58,9 @@ impl BuildValidator for ModelFieldsValidator {
 
         let extra_behavior = ExtraBehavior::from_schema_or_config(py, schema, config, ExtraBehavior::Ignore)?;
 
-        let extra_validator = match (schema.get_item(intern!(py, "extra_validator")), &extra_behavior) {
+        let extras_validator = match (schema.get_item(intern!(py, "extras_schema")), &extra_behavior) {
             (Some(v), ExtraBehavior::Allow) => Some(Box::new(build_validator(v, config, definitions)?)),
-            (Some(_), _) => return py_schema_err!("extra_validator can only be used if extra_behavior=allow"),
+            (Some(_), _) => return py_schema_err!("extras_schema can only be used if extra_behavior=allow"),
             (_, _) => None,
         };
         let model_name: String = schema
@@ -102,7 +102,7 @@ impl BuildValidator for ModelFieldsValidator {
             fields,
             model_name,
             extra_behavior,
-            extra_validator,
+            extras_validator,
             strict,
             from_attributes,
             loc_by_alias: config.get_as(intern!(py, "loc_by_alias"))?.unwrap_or(true),
@@ -113,7 +113,7 @@ impl BuildValidator for ModelFieldsValidator {
 
 impl_py_gc_traverse!(ModelFieldsValidator {
     fields,
-    extra_validator
+    extras_validator
 });
 
 impl Validator for ModelFieldsValidator {
@@ -265,7 +265,7 @@ impl Validator for ModelFieldsValidator {
                             ExtraBehavior::Ignore => {}
                             ExtraBehavior::Allow => {
                             let py_key = either_str.as_py_string(py);
-                                if let Some(ref validator) = self.extra_validator {
+                                if let Some(ref validator) = self.extras_validator {
                                     match validator.validate(py, value, state) {
                                         Ok(value) => {
                                             model_extra_dict.set_item(py_key, value)?;
@@ -373,7 +373,7 @@ impl Validator for ModelFieldsValidator {
             // For models / typed dicts we forbid assigning extra attributes
             // unless the user explicitly set extra_behavior to 'allow'
             match self.extra_behavior {
-                ExtraBehavior::Allow => match self.extra_validator {
+                ExtraBehavior::Allow => match self.extras_validator {
                     Some(ref validator) => prepare_result(
                         state.with_new_extra(new_extra, |state| validator.validate(py, field_value, state)),
                     ),
@@ -430,7 +430,7 @@ impl Validator for ModelFieldsValidator {
         self.fields
             .iter_mut()
             .try_for_each(|f| f.validator.complete(definitions))?;
-        match &mut self.extra_validator {
+        match &mut self.extras_validator {
             Some(v) => v.complete(definitions),
             None => Ok(()),
         }
diff --git a/src/validators/tuple.rs b/src/validators/tuple.rs
index 1a3033d48..07887fddb 100644
--- a/src/validators/tuple.rs
+++ b/src/validators/tuple.rs
@@ -91,7 +91,7 @@ impl Validator for TupleVariableValidator {
 pub struct TuplePositionalValidator {
     strict: bool,
     items_validators: Vec<CombinedValidator>,
-    extra_validator: Option<Box<CombinedValidator>>,
+    extras_validator: Option<Box<CombinedValidator>>,
     name: String,
 }
 
@@ -117,7 +117,7 @@ impl BuildValidator for TuplePositionalValidator {
         Ok(Self {
             strict: is_strict(schema, config)?,
             items_validators: validators,
-            extra_validator: match schema.get_item(intern!(py, "extra_schema")) {
+            extras_validator: match schema.get_item(intern!(py, "extras_schema")) {
                 Some(v) => Some(Box::new(build_validator(v, config, definitions)?)),
                 None => None,
             },
@@ -134,7 +134,7 @@ fn validate_tuple_positional<'s, 'data, T: Iterator<Item = PyResult<&'data I>>,
     state: &mut ValidationState,
     output: &mut Vec<PyObject>,
     errors: &mut Vec<ValLineError<'data>>,
-    extra_validator: &Option<Box<CombinedValidator>>,
+    extras_validator: &Option<Box<CombinedValidator>>,
     items_validators: &[CombinedValidator],
     collection_iter: &mut T,
     collection_len: Option<usize>,
@@ -160,8 +160,8 @@ fn validate_tuple_positional<'s, 'data, T: Iterator<Item = PyResult<&'data I>>,
     }
     for (index, result) in collection_iter.enumerate() {
         let item = result?;
-        match extra_validator {
-            Some(ref extra_validator) => match extra_validator.validate(py, item, state) {
+        match extras_validator {
+            Some(ref extras_validator) => match extras_validator.validate(py, item, state) {
                 Ok(item) => output.push(item),
                 Err(ValError::LineErrors(line_errors)) => {
                     errors.extend(
@@ -193,7 +193,7 @@ fn validate_tuple_positional<'s, 'data, T: Iterator<Item = PyResult<&'data I>>,
 
 impl_py_gc_traverse!(TuplePositionalValidator {
     items_validators,
-    extra_validator
+    extras_validator
 });
 
 impl Validator for TuplePositionalValidator {
@@ -218,7 +218,7 @@ impl Validator for TuplePositionalValidator {
                     state,
                     &mut output,
                     &mut errors,
-                    &self.extra_validator,
+                    &self.extras_validator,
                     &self.items_validators,
                     &mut $collection_iter,
                     collection_len,
@@ -252,7 +252,7 @@ impl Validator for TuplePositionalValidator {
                 .any(|v| v.different_strict_behavior(definitions, true))
             {
                 true
-            } else if let Some(ref v) = self.extra_validator {
+            } else if let Some(ref v) = self.extras_validator {
                 v.different_strict_behavior(definitions, true)
             } else {
                 false
@@ -270,7 +270,7 @@ impl Validator for TuplePositionalValidator {
         self.items_validators
             .iter_mut()
             .try_for_each(|v| v.complete(definitions))?;
-        match &mut self.extra_validator {
+        match &mut self.extras_validator {
             Some(v) => v.complete(definitions),
             None => Ok(()),
         }
diff --git a/src/validators/typed_dict.rs b/src/validators/typed_dict.rs
index 69fb7f641..a095a52f1 100644
--- a/src/validators/typed_dict.rs
+++ b/src/validators/typed_dict.rs
@@ -35,7 +35,7 @@ impl_py_gc_traverse!(TypedDictField { validator });
 pub struct TypedDictValidator {
     fields: Vec<TypedDictField>,
     extra_behavior: ExtraBehavior,
-    extra_validator: Option<Box<CombinedValidator>>,
+    extras_validator: Option<Box<CombinedValidator>>,
     strict: bool,
     loc_by_alias: bool,
 }
@@ -61,9 +61,9 @@ impl BuildValidator for TypedDictValidator {
 
         let extra_behavior = ExtraBehavior::from_schema_or_config(py, schema, config, ExtraBehavior::Ignore)?;
 
-        let extra_validator = match (schema.get_item(intern!(py, "extra_validator")), &extra_behavior) {
+        let extras_validator = match (schema.get_item(intern!(py, "extras_schema")), &extra_behavior) {
             (Some(v), ExtraBehavior::Allow) => Some(Box::new(build_validator(v, config, definitions)?)),
-            (Some(_), _) => return py_schema_err!("extra_validator can only be used if extra_behavior=allow"),
+            (Some(_), _) => return py_schema_err!("extras_schema can only be used if extra_behavior=allow"),
             (_, _) => None,
         };
 
@@ -129,7 +129,7 @@ impl BuildValidator for TypedDictValidator {
         Ok(Self {
             fields,
             extra_behavior,
-            extra_validator,
+            extras_validator,
             strict,
             loc_by_alias: config.get_as(intern!(py, "loc_by_alias"))?.unwrap_or(true),
         }
@@ -139,7 +139,7 @@ impl BuildValidator for TypedDictValidator {
 
 impl_py_gc_traverse!(TypedDictValidator {
     fields,
-    extra_validator
+    extras_validator
 });
 
 impl Validator for TypedDictValidator {
@@ -261,7 +261,7 @@ impl Validator for TypedDictValidator {
                             ExtraBehavior::Ignore => {}
                             ExtraBehavior::Allow => {
                             let py_key = either_str.as_py_string(py);
-                                if let Some(ref validator) = self.extra_validator {
+                                if let Some(ref validator) = self.extras_validator {
                                     match validator.validate(py, value, state) {
                                         Ok(value) => {
                                             output_dict.set_item(py_key, value)?;
@@ -314,7 +314,7 @@ impl Validator for TypedDictValidator {
         self.fields
             .iter_mut()
             .try_for_each(|f| f.validator.complete(definitions))?;
-        match &mut self.extra_validator {
+        match &mut self.extras_validator {
             Some(v) => v.complete(definitions),
             None => Ok(()),
         }
diff --git a/tests/benchmarks/test_micro_benchmarks.py b/tests/benchmarks/test_micro_benchmarks.py
index 4ac2d30ab..6c9de2fb2 100644
--- a/tests/benchmarks/test_micro_benchmarks.py
+++ b/tests/benchmarks/test_micro_benchmarks.py
@@ -875,7 +875,7 @@ def test_tuple_many_variable(benchmark):
 
 @pytest.mark.benchmark(group='tuple-many')
 def test_tuple_many_positional(benchmark):
-    v = SchemaValidator({'type': 'tuple-positional', 'items_schema': [], 'extra_schema': {'type': 'int'}})
+    v = SchemaValidator({'type': 'tuple-positional', 'items_schema': [], 'extras_schema': {'type': 'int'}})
     assert v.validate_python(list(range(10))) == tuple(range(10))
 
     benchmark(v.validate_python, list(range(10)))
diff --git a/tests/serializers/test_dataclasses.py b/tests/serializers/test_dataclasses.py
index 57b20c4b2..eb4bede97 100644
--- a/tests/serializers/test_dataclasses.py
+++ b/tests/serializers/test_dataclasses.py
@@ -6,7 +6,7 @@
 
 import pytest
 
-from pydantic_core import SchemaSerializer, core_schema
+from pydantic_core import SchemaSerializer, SchemaValidator, core_schema
 
 on_pypy = platform.python_implementation() == 'PyPy'
 # pypy doesn't seem to maintain order of `__dict__`
@@ -164,3 +164,31 @@ class SubModel(Model):
     s = SchemaSerializer(schema)
     assert s.to_python(dc) == {'x': 1, 'x2': 2}
     assert s.to_json(dc) == b'{"x":1,"x2":2}'
+
+
+@pytest.mark.xfail(reason='dataclasses do not serialize extras')
+def test_extra_custom_serializer():
+    @dataclasses.dataclass
+    class Model:
+        pass
+
+    schema = core_schema.dataclass_schema(
+        Model,
+        core_schema.dataclass_args_schema(
+            'Model',
+            [],
+            extra_behavior='allow',
+            # extras_schema=core_schema.any_schema(
+            #     serialization=core_schema.plain_serializer_function_ser_schema(
+            #         lambda v: v + ' bam!',
+            #     )
+            # )
+        ),
+        [],
+    )
+    s = SchemaSerializer(schema)
+    v = SchemaValidator(schema)
+
+    m = v.validate_python({'extra': 'extra'})
+
+    assert s.to_python(m) == {'extra': 'extra bam!'}
diff --git a/tests/serializers/test_list_tuple.py b/tests/serializers/test_list_tuple.py
index 836c7499d..9149941e1 100644
--- a/tests/serializers/test_list_tuple.py
+++ b/tests/serializers/test_list_tuple.py
@@ -358,7 +358,7 @@ def f(prefix, value, _info):
                     serialization=core_schema.plain_serializer_function_ser_schema(partial(f, 'b'), info_arg=True)
                 ),
             ],
-            'extra_schema': core_schema.any_schema(
+            'extras_schema': core_schema.any_schema(
                 serialization=core_schema.plain_serializer_function_ser_schema(partial(f, 'extra'), info_arg=True)
             ),
         }
@@ -396,7 +396,7 @@ def test_tuple_pos_dict_key():
     s = SchemaSerializer(
         core_schema.dict_schema(
             core_schema.tuple_positional_schema(
-                [core_schema.int_schema(), core_schema.str_schema()], extra_schema=core_schema.int_schema()
+                [core_schema.int_schema(), core_schema.str_schema()], extras_schema=core_schema.int_schema()
             ),
             core_schema.int_schema(),
         )
diff --git a/tests/serializers/test_model.py b/tests/serializers/test_model.py
index e13cadb70..16e213b0d 100644
--- a/tests/serializers/test_model.py
+++ b/tests/serializers/test_model.py
@@ -2,7 +2,7 @@
 import json
 import platform
 from random import randint
-from typing import Any, ClassVar
+from typing import Any, ClassVar, Dict
 
 try:
     from functools import cached_property
@@ -915,3 +915,27 @@ class InnerModel:
     s_repr = plain_repr(s)
     assert 'has_extra:true,root_model:false,name:"InnerModel"' in s_repr
     assert 'has_extra:false,root_model:false,name:"OuterModel"' in s_repr
+
+
+def test_extra_custom_serializer():
+    class Model:
+        __slots__ = ('__pydantic_extra__', '__dict__')
+        __pydantic_extra__: Dict[str, Any]
+
+    schema = core_schema.model_schema(
+        Model,
+        core_schema.model_fields_schema(
+            {},
+            extra_behavior='allow',
+            extras_schema=core_schema.any_schema(
+                serialization=core_schema.plain_serializer_function_ser_schema(lambda v: v + ' bam!')
+            ),
+        ),
+        extra_behavior='allow',
+    )
+    s = SchemaSerializer(schema)
+
+    m = Model()
+    m.__pydantic_extra__ = {'extra': 'extra'}
+
+    assert s.to_python(m) == {'extra': 'extra bam!'}
diff --git a/tests/serializers/test_typed_dict.py b/tests/serializers/test_typed_dict.py
index 9bc3c64a9..df507a248 100644
--- a/tests/serializers/test_typed_dict.py
+++ b/tests/serializers/test_typed_dict.py
@@ -318,3 +318,18 @@ def ser_x(data: Model, v: Any, serializer: core_schema.SerializerFunctionWrapHan
         )
     )
     assert json.loads(s.to_json(Model(x=1000))) == {'x': '1_000'}
+
+
+def test_extra_custom_serializer():
+    schema = core_schema.typed_dict_schema(
+        {},
+        extra_behavior='allow',
+        extras_schema=core_schema.any_schema(
+            serialization=core_schema.plain_serializer_function_ser_schema(lambda v: v + ' bam!')
+        ),
+    )
+    s = SchemaSerializer(schema)
+
+    m = {'extra': 'extra'}
+
+    assert s.to_python(m) == {'extra': 'extra bam!'}
diff --git a/tests/test_json.py b/tests/test_json.py
index c29c3ba67..272fb5dcb 100644
--- a/tests/test_json.py
+++ b/tests/test_json.py
@@ -142,7 +142,7 @@ def test_error_loc():
             'fields': {
                 'field_a': {'type': 'typed-dict-field', 'schema': {'type': 'list', 'items_schema': {'type': 'int'}}}
             },
-            'extra_validator': {'type': 'int'},
+            'extras_schema': {'type': 'int'},
             'extra_behavior': 'allow',
         }
     )
diff --git a/tests/validators/test_model_fields.py b/tests/validators/test_model_fields.py
index 61d0c779b..dbba463e2 100644
--- a/tests/validators/test_model_fields.py
+++ b/tests/validators/test_model_fields.py
@@ -210,9 +210,9 @@ def test_forbid_extra():
 
 
 def test_allow_extra_invalid():
-    with pytest.raises(SchemaError, match='extra_validator can only be used if extra_behavior=allow'):
+    with pytest.raises(SchemaError, match='extras_schema can only be used if extra_behavior=allow'):
         SchemaValidator(
-            {'type': 'model-fields', 'fields': {}, 'extra_validator': {'type': 'int'}, 'extra_behavior': 'ignore'}
+            {'type': 'model-fields', 'fields': {}, 'extras_schema': {'type': 'int'}, 'extra_behavior': 'ignore'}
         )
 
 
@@ -358,7 +358,7 @@ def test_validate_assignment_allow_extra_validate():
         {
             'type': 'model-fields',
             'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}},
-            'extra_validator': {'type': 'int'},
+            'extras_schema': {'type': 'int'},
             'extra_behavior': 'allow',
         }
     )
@@ -1659,19 +1659,19 @@ def test_frozen_field():
     ],
 )
 @pytest.mark.parametrize(
-    'extra_validator_kw, expected_extra_value',
-    [({}, '123'), ({'extra_validator': None}, '123'), ({'extra_validator': core_schema.int_schema()}, 123)],
-    ids=['extra_validator=unset', 'extra_validator=None', 'extra_validator=int'],
+    'extras_schema_kw, expected_extra_value',
+    [({}, '123'), ({'extras_schema': None}, '123'), ({'extras_schema': core_schema.int_schema()}, 123)],
+    ids=['extras_schema=unset', 'extras_schema=None', 'extras_schema=int'],
 )
 def test_extra_behavior_allow(
     config: Union[core_schema.CoreConfig, None],
     schema_extra_behavior_kw: Dict[str, Any],
-    extra_validator_kw: Dict[str, Any],
+    extras_schema_kw: Dict[str, Any],
     expected_extra_value: Any,
 ):
     v = SchemaValidator(
         core_schema.model_fields_schema(
-            {'f': core_schema.model_field(core_schema.str_schema())}, **schema_extra_behavior_kw, **extra_validator_kw
+            {'f': core_schema.model_field(core_schema.str_schema())}, **schema_extra_behavior_kw, **extras_schema_kw
         ),
         config=config,
     )
diff --git a/tests/validators/test_tuple.py b/tests/validators/test_tuple.py
index 9e365050f..b7f3e9720 100644
--- a/tests/validators/test_tuple.py
+++ b/tests/validators/test_tuple.py
@@ -264,7 +264,7 @@ def test_positional_empty(py_and_json: PyAndJson):
 
 
 def test_positional_empty_extra(py_and_json: PyAndJson):
-    v = py_and_json({'type': 'tuple-positional', 'items_schema': [], 'extra_schema': {'type': 'int'}})
+    v = py_and_json({'type': 'tuple-positional', 'items_schema': [], 'extras_schema': {'type': 'int'}})
     assert v.validate_test([]) == ()
     assert v.validate_python(()) == ()
     assert v.validate_test([1]) == (1,)
@@ -408,7 +408,7 @@ def test_tuple_fix_extra(input_value, expected, cache):
         {
             'type': 'tuple-positional',
             'items_schema': [{'type': 'int'}, {'type': 'str'}],
-            'extra_schema': {'type': 'str'},
+            'extras_schema': {'type': 'str'},
         }
     )
 
@@ -422,7 +422,7 @@ def test_tuple_fix_extra(input_value, expected, cache):
 
 def test_tuple_fix_extra_any():
     v = SchemaValidator(
-        {'type': 'tuple-positional', 'items_schema': [{'type': 'str'}], 'extra_schema': {'type': 'any'}}
+        {'type': 'tuple-positional', 'items_schema': [{'type': 'str'}], 'extras_schema': {'type': 'any'}}
     )
     assert v.validate_python([b'1']) == ('1',)
     assert v.validate_python([b'1', 2]) == ('1', 2)
diff --git a/tests/validators/test_typed_dict.py b/tests/validators/test_typed_dict.py
index b073ad88d..1d3b694f1 100644
--- a/tests/validators/test_typed_dict.py
+++ b/tests/validators/test_typed_dict.py
@@ -186,9 +186,9 @@ def test_forbid_extra():
 
 
 def test_allow_extra_invalid():
-    with pytest.raises(SchemaError, match='extra_validator can only be used if extra_behavior=allow'):
+    with pytest.raises(SchemaError, match='extras_schema can only be used if extra_behavior=allow'):
         SchemaValidator(
-            {'type': 'typed-dict', 'fields': {}, 'extra_validator': {'type': 'int'}, 'extra_behavior': 'ignore'}
+            {'type': 'typed-dict', 'fields': {}, 'extras_schema': {'type': 'int'}, 'extra_behavior': 'ignore'}
         )
 
 
@@ -1089,21 +1089,21 @@ def wrap_function(input_value, validator, info):
     ],
 )
 @pytest.mark.parametrize(
-    'extra_validator_kw, expected_extra_value',
-    [({}, '123'), ({'extra_validator': None}, '123'), ({'extra_validator': core_schema.int_schema()}, 123)],
-    ids=['extra_validator=unset', 'extra_validator=None', 'extra_validator=int'],
+    'extras_schema_kw, expected_extra_value',
+    [({}, '123'), ({'extras_schema': None}, '123'), ({'extras_schema': core_schema.int_schema()}, 123)],
+    ids=['extras_schema=unset', 'extras_schema=None', 'extras_schema=int'],
 )
 def test_extra_behavior_allow(
     config: Union[core_schema.CoreConfig, None],
     schema_extra_behavior_kw: Dict[str, Any],
-    extra_validator_kw: Dict[str, Any],
+    extras_schema_kw: Dict[str, Any],
     expected_extra_value: Any,
 ):
     v = SchemaValidator(
         core_schema.typed_dict_schema(
             {'f': core_schema.typed_dict_field(core_schema.str_schema())},
             **schema_extra_behavior_kw,
-            **extra_validator_kw,
+            **extras_schema_kw,
             config=config,
         )
     )
@@ -1173,7 +1173,7 @@ def validate(v, info):
 
         schema = core_schema.general_plain_validator_function(validate)
         schema = core_schema.typed_dict_schema(
-            {'f': core_schema.typed_dict_field(schema)}, extra_behavior='allow', extra_validator=schema
+            {'f': core_schema.typed_dict_field(schema)}, extra_behavior='allow', extras_schema=schema
         )
 
         # If any of the Rust validators don't implement traversal properly,
diff --git a/tests/validators/test_with_default.py b/tests/validators/test_with_default.py
index 266bd0cda..e0ebd2fb3 100644
--- a/tests/validators/test_with_default.py
+++ b/tests/validators/test_with_default.py
@@ -189,7 +189,7 @@ def test_tuple_positional_omit():
         {
             'type': 'tuple-positional',
             'items_schema': [{'type': 'int'}, {'type': 'int'}],
-            'extra_schema': {'type': 'default', 'schema': {'type': 'int'}, 'on_error': 'omit'},
+            'extras_schema': {'type': 'default', 'schema': {'type': 'int'}, 'on_error': 'omit'},
         }
     )
     assert v.validate_python((1, '2')) == (1, 2)

From 882b57fc891d0800a5c26809cfae1c505d75249a Mon Sep 17 00:00:00 2001
From: Yohan Valencia <31091198+yvalencia91@users.noreply.github.com>
Date: Wed, 23 Aug 2023 21:29:03 +0200
Subject: [PATCH 004/550] Fix max length error on conlist with type int (#902)

---
 src/input/return_enums.rs     | 56 +++++++++++++++++++++++++----------
 tests/validators/test_list.py | 10 +++++--
 2 files changed, 49 insertions(+), 17 deletions(-)

diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index d0f3ba45d..c68566b42 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -105,31 +105,54 @@ struct MaxLengthCheck<'a, INPUT> {
     max_length: Option<usize>,
     field_type: &'a str,
     input: &'a INPUT,
+    known_input_length: usize,
 }
 
 impl<'a, INPUT: Input<'a>> MaxLengthCheck<'a, INPUT> {
-    fn new(max_length: Option<usize>, field_type: &'a str, input: &'a INPUT) -> Self {
+    fn new(max_length: Option<usize>, field_type: &'a str, input: &'a INPUT, known_input_length: usize) -> Self {
         Self {
             current_length: 0,
             max_length,
             field_type,
             input,
+            known_input_length,
         }
     }
 
     fn incr(&mut self) -> ValResult<'a, ()> {
-        if let Some(max_length) = self.max_length {
-            self.current_length += 1;
-            if self.current_length > max_length {
-                return Err(ValError::new(
-                    ErrorType::TooLong {
-                        field_type: self.field_type.to_string(),
-                        max_length,
-                        actual_length: self.current_length,
-                        context: None,
-                    },
-                    self.input,
-                ));
+        match self.max_length {
+            Some(max_length) => {
+                self.current_length += 1;
+                if self.current_length > max_length {
+                    let biggest_length = if self.known_input_length > self.current_length {
+                        self.known_input_length
+                    } else {
+                        self.current_length
+                    };
+                    return Err(ValError::new(
+                        ErrorType::TooLong {
+                            field_type: self.field_type.to_string(),
+                            max_length,
+                            actual_length: biggest_length,
+                            context: None,
+                        },
+                        self.input,
+                    ));
+                }
+            }
+            None => {
+                self.current_length += 1;
+                if self.current_length > self.known_input_length {
+                    return Err(ValError::new(
+                        ErrorType::TooLong {
+                            field_type: self.field_type.to_string(),
+                            max_length: self.known_input_length,
+                            actual_length: self.current_length,
+                            context: None,
+                        },
+                        self.input,
+                    ));
+                }
             }
         }
         Ok(())
@@ -315,7 +338,7 @@ impl<'a> GenericIterable<'a> {
         let capacity = self
             .generic_len()
             .unwrap_or_else(|| max_length.unwrap_or(DEFAULT_CAPACITY));
-        let max_length_check = MaxLengthCheck::new(max_length, field_type, input);
+        let max_length_check = MaxLengthCheck::new(max_length, field_type, input, capacity);
 
         macro_rules! validate {
             ($iter:expr) => {
@@ -371,7 +394,10 @@ impl<'a> GenericIterable<'a> {
         field_type: &'static str,
         max_length: Option<usize>,
     ) -> ValResult<'a, Vec<PyObject>> {
-        let max_length_check = MaxLengthCheck::new(max_length, field_type, input);
+        let capacity = self
+            .generic_len()
+            .unwrap_or_else(|| max_length.unwrap_or(DEFAULT_CAPACITY));
+        let max_length_check = MaxLengthCheck::new(max_length, field_type, input, capacity);
 
         match self {
             GenericIterable::List(collection) => {
diff --git a/tests/validators/test_list.py b/tests/validators/test_list.py
index 4d56a725d..d3cfaa528 100644
--- a/tests/validators/test_list.py
+++ b/tests/validators/test_list.py
@@ -162,6 +162,12 @@ def test_list_error(input_value, index):
             infinite_generator(),
             Err('List should have at most 44 items after validation, not 45 [type=too_long,'),
         ),
+        (
+            {'max_length': 4, 'items_schema': {'type': 'int'}},
+            [0, 1, 2, 3, 4, 5, 6, 7, 8],
+            Err('List should have at most 4 items after validation, not 9 [type=too_long,'),
+        ),
+        ({}, infinite_generator(), Err('List should have at most 10 items after validation, not 11 [type=too_long,')),
     ],
 )
 def test_list_length_constraints(kwargs: Dict[str, Any], input_value, expected):
@@ -391,9 +397,9 @@ def f(v: int) -> int:
         {
             'type': 'too_long',
             'loc': (),
-            'msg': 'List should have at most 10 items after validation, not 11',
+            'msg': 'List should have at most 10 items after validation, not 15',
             'input': data,
-            'ctx': {'field_type': 'List', 'max_length': 10, 'actual_length': 11},
+            'ctx': {'field_type': 'List', 'max_length': 10, 'actual_length': 15},
         }
     )
 

From 34fbd845c120869c732d84b9cc5e2797be18bb92 Mon Sep 17 00:00:00 2001
From: David Hewitt <1939362+davidhewitt@users.noreply.github.com>
Date: Thu, 24 Aug 2023 22:30:45 +0100
Subject: [PATCH 005/550] snipe off some unsafe code (#922)

---
 src/errors/validation_exception.rs |  40 +++++----
 src/input/input_python.rs          |  24 +++---
 src/input/return_enums.rs          | 134 ++++++++++-------------------
 src/serializers/infer.rs           |  23 +++--
 src/serializers/ob_type.rs         |  57 ++++++------
 5 files changed, 123 insertions(+), 155 deletions(-)

diff --git a/src/errors/validation_exception.rs b/src/errors/validation_exception.rs
index daec6b910..8963c1d81 100644
--- a/src/errors/validation_exception.rs
+++ b/src/errors/validation_exception.rs
@@ -3,11 +3,10 @@ use std::fmt::{Display, Write};
 use std::str::from_utf8;
 
 use pyo3::exceptions::{PyKeyError, PyTypeError, PyValueError};
-use pyo3::ffi::Py_ssize_t;
+use pyo3::intern;
 use pyo3::once_cell::GILOnceCell;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList, PyString};
-use pyo3::{ffi, intern};
 use serde::ser::{Error, SerializeMap, SerializeSeq};
 use serde::{Serialize, Serializer};
 
@@ -173,22 +172,27 @@ impl ValidationError {
     #[pyo3(signature = (*, include_url = true, include_context = true))]
     pub fn errors(&self, py: Python, include_url: bool, include_context: bool) -> PyResult<Py<PyList>> {
         let url_prefix = get_url_prefix(py, include_url);
-        // taken approximately from the pyo3, but modified to return the error during iteration
-        // https://github.com/PyO3/pyo3/blob/a3edbf4fcd595f0e234c87d4705eb600a9779130/src/types/list.rs#L27-L55
-        unsafe {
-            let ptr = ffi::PyList_New(self.line_errors.len() as Py_ssize_t);
-
-            // We create the `Py` pointer here for two reasons:
-            // - panics if the ptr is null
-            // - its Drop cleans up the list if user code or the asserts panic.
-            let list: Py<PyList> = Py::from_owned_ptr(py, ptr);
-
-            for (index, line_error) in (0_isize..).zip(&self.line_errors) {
-                let item = line_error.as_dict(py, url_prefix, include_context, &self.error_mode)?;
-                ffi::PyList_SET_ITEM(ptr, index, item.into_ptr());
-            }
-
-            Ok(list)
+        let mut iteration_error = None;
+        let list = PyList::new(
+            py,
+            // PyList::new takes ExactSizeIterator, so if an error occurs during iteration we
+            // fill the list with None before returning the error; the list will then be thrown
+            // away safely.
+            self.line_errors.iter().map(|e| -> PyObject {
+                if iteration_error.is_some() {
+                    return py.None();
+                }
+                e.as_dict(py, url_prefix, include_context, &self.error_mode)
+                    .unwrap_or_else(|err| {
+                        iteration_error = Some(err);
+                        py.None()
+                    })
+            }),
+        );
+        if let Some(err) = iteration_error {
+            Err(err)
+        } else {
+            Ok(list.into())
         }
     }
 
diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index 5ebe9025a..b31ff4361 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -187,6 +187,8 @@ impl<'a> Input<'a> for PyAny {
             let str = py_str.to_str()?;
             serde_json::from_str(str).map_err(|e| map_json_err(self, e))
         } else if let Ok(py_byte_array) = self.downcast::<PyByteArray>() {
+            // Safety: from_slice does not run arbitrary Python code and the GIL is held so the
+            // bytes array will not be mutated while from_slice is reading it
             serde_json::from_slice(unsafe { py_byte_array.as_bytes() }).map_err(|e| map_json_err(self, e))
         } else {
             Err(ValError::new(ErrorTypeDefaults::JsonType, self))
@@ -235,13 +237,15 @@ impl<'a> Input<'a> for PyAny {
             };
             Ok(str.into())
         } else if let Ok(py_byte_array) = self.downcast::<PyByteArray>() {
-            // see https://docs.rs/pyo3/latest/pyo3/types/struct.PyByteArray.html#method.as_bytes
-            // for why this is marked unsafe
-            let str = match from_utf8(unsafe { py_byte_array.as_bytes() }) {
-                Ok(s) => s,
+            // Safety: the gil is held while from_utf8 is running so py_byte_array is not mutated,
+            // and we immediately copy the bytes into a new Python string
+            let s = match from_utf8(unsafe { py_byte_array.as_bytes() }) {
+                // Why Python not Rust? to avoid an unnecessary allocation on the Rust side, the
+                // final output needs to be Python anyway.
+                Ok(s) => PyString::new(self.py(), s),
                 Err(_) => return Err(ValError::new(ErrorTypeDefaults::StringUnicode, self)),
             };
-            Ok(str.into())
+            Ok(s.into())
         } else {
             Err(ValError::new(ErrorTypeDefaults::StringType, self))
         }
@@ -337,9 +341,8 @@ impl<'a> Input<'a> for PyAny {
         }
     }
     fn strict_float(&'a self) -> ValResult<EitherFloat<'a>> {
-        if PyFloat::is_exact_type_of(self) {
-            // Safety: self is PyFloat
-            Ok(EitherFloat::Py(unsafe { self.downcast_unchecked::<PyFloat>() }))
+        if let Ok(py_float) = self.downcast_exact::<PyFloat>() {
+            Ok(EitherFloat::Py(py_float))
         } else if let Ok(float) = self.extract::<f64>() {
             // bools are cast to floats as either 0.0 or 1.0, so check for bool type in this specific case
             if (float == 0.0 || float == 1.0) && PyBool::is_exact_type_of(self) {
@@ -353,9 +356,8 @@ impl<'a> Input<'a> for PyAny {
     }
 
     fn lax_float(&'a self) -> ValResult<EitherFloat<'a>> {
-        if PyFloat::is_exact_type_of(self) {
-            // Safety: self is PyFloat
-            Ok(EitherFloat::Py(unsafe { self.downcast_unchecked::<PyFloat>() }))
+        if let Ok(py_float) = self.downcast_exact() {
+            Ok(EitherFloat::Py(py_float))
         } else if let Some(cow_str) = maybe_as_string(self, ErrorTypeDefaults::FloatParsing)? {
             str_as_float(self, &cow_str)
         } else if let Ok(float) = self.extract::<f64>() {
diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index c68566b42..f1cfb8543 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -224,12 +224,11 @@ impl BuildSet for &PySet {
 
 impl BuildSet for &PyFrozenSet {
     fn build_add(&self, item: PyObject) -> PyResult<()> {
-        unsafe {
-            py_error_on_minusone(
-                self.py(),
-                ffi::PySet_Add(self.as_ptr(), item.to_object(self.py()).as_ptr()),
-            )
-        }
+        py_error_on_minusone(self.py(), unsafe {
+            // Safety: self.as_ptr() the _only_ pointer to the `frozenset`, and it's allowed
+            // to mutate this via the C API when nothing else can refer to it.
+            ffi::PySet_Add(self.as_ptr(), item.to_object(self.py()).as_ptr())
+        })
     }
 
     fn build_len(&self) -> usize {
@@ -492,57 +491,32 @@ impl<'py> Iterator for MappingGenericIterator<'py> {
     type Item = ValResult<'py, (&'py PyAny, &'py PyAny)>;
 
     fn next(&mut self) -> Option<Self::Item> {
-        let item = match self.iter.next() {
-            Some(Err(e)) => return Some(Err(mapping_err(e, self.iter.py(), self.input))),
-            Some(Ok(item)) => item,
-            None => return None,
-        };
-        let tuple: &PyTuple = match item.downcast() {
-            Ok(tuple) => tuple,
-            Err(_) => {
-                return Some(Err(ValError::new(
+        Some(match self.iter.next()? {
+            Ok(item) => item.extract().map_err(|_| {
+                ValError::new(
                     ErrorType::MappingType {
                         error: MAPPING_TUPLE_ERROR.into(),
                         context: None,
                     },
                     self.input,
-                )))
-            }
-        };
-        if tuple.len() != 2 {
-            return Some(Err(ValError::new(
-                ErrorType::MappingType {
-                    error: MAPPING_TUPLE_ERROR.into(),
-                    context: None,
-                },
-                self.input,
-            )));
-        };
-        #[cfg(PyPy)]
-        let key = tuple.get_item(0).unwrap();
-        #[cfg(PyPy)]
-        let value = tuple.get_item(1).unwrap();
-        #[cfg(not(PyPy))]
-        let key = unsafe { tuple.get_item_unchecked(0) };
-        #[cfg(not(PyPy))]
-        let value = unsafe { tuple.get_item_unchecked(1) };
-        Some(Ok((key, value)))
+                )
+            }),
+            Err(e) => Err(mapping_err(e, self.iter.py(), self.input)),
+        })
     }
-    // size_hint is omitted as it isn't needed
 }
 
 pub struct AttributesGenericIterator<'py> {
     object: &'py PyAny,
-    attributes: &'py PyList,
-    index: usize,
+    // PyO3 should export this type upstream
+    attributes_iterator: <&'py PyList as IntoIterator>::IntoIter,
 }
 
 impl<'py> AttributesGenericIterator<'py> {
     pub fn new(py_any: &'py PyAny) -> ValResult<'py, Self> {
         Ok(Self {
             object: py_any,
-            attributes: py_any.dir(),
-            index: 0,
+            attributes_iterator: py_any.dir().into_iter(),
         })
     }
 }
@@ -553,37 +527,31 @@ impl<'py> Iterator for AttributesGenericIterator<'py> {
     fn next(&mut self) -> Option<Self::Item> {
         // loop until we find an attribute who's name does not start with underscore,
         // or we get to the end of the list of attributes
-        while self.index < self.attributes.len() {
-            #[cfg(PyPy)]
-            let name: &PyAny = self.attributes.get_item(self.index).unwrap();
-            #[cfg(not(PyPy))]
-            let name: &PyAny = unsafe { self.attributes.get_item_unchecked(self.index) };
-            self.index += 1;
-            // from benchmarks this is 14x faster than using the python `startswith` method
-            let name_cow = match name.downcast::<PyString>() {
-                Ok(name) => name.to_string_lossy(),
-                Err(e) => return Some(Err(e.into())),
-            };
-            if !name_cow.as_ref().starts_with('_') {
-                // getattr is most likely to fail due to an exception in a @property, skip
-                if let Ok(attr) = self.object.getattr(name_cow.as_ref()) {
-                    // we don't want bound methods to be included, is there a better way to check?
-                    // ref https://stackoverflow.com/a/18955425/949890
-                    let is_bound = matches!(attr.hasattr(intern!(attr.py(), "__self__")), Ok(true));
-                    // the PyFunction::is_type_of(attr) catches `staticmethod`, but also any other function,
-                    // I think that's better than including static methods in the yielded attributes,
-                    // if someone really wants fields, they can use an explicit field, or a function to modify input
-                    #[cfg(not(PyPy))]
-                    if !is_bound && !PyFunction::is_type_of(attr) {
-                        return Some(Ok((name, attr)));
-                    }
-                    // MASSIVE HACK! PyFunction doesn't exist for PyPy,
-                    // is_instance_of::<PyFunction> crashes with a null pointer, hence this hack, see
-                    // https://github.com/pydantic/pydantic-core/pull/161#discussion_r917257635
-                    #[cfg(PyPy)]
-                    if !is_bound && attr.get_type().to_string() != "<class 'function'>" {
-                        return Some(Ok((name, attr)));
-                    }
+        let name = self.attributes_iterator.next()?;
+        // from benchmarks this is 14x faster than using the python `startswith` method
+        let name_cow = match name.downcast::<PyString>() {
+            Ok(name) => name.to_string_lossy(),
+            Err(e) => return Some(Err(e.into())),
+        };
+        if !name_cow.as_ref().starts_with('_') {
+            // getattr is most likely to fail due to an exception in a @property, skip
+            if let Ok(attr) = self.object.getattr(name_cow.as_ref()) {
+                // we don't want bound methods to be included, is there a better way to check?
+                // ref https://stackoverflow.com/a/18955425/949890
+                let is_bound = matches!(attr.hasattr(intern!(attr.py(), "__self__")), Ok(true));
+                // the PyFunction::is_type_of(attr) catches `staticmethod`, but also any other function,
+                // I think that's better than including static methods in the yielded attributes,
+                // if someone really wants fields, they can use an explicit field, or a function to modify input
+                #[cfg(not(PyPy))]
+                if !is_bound && !PyFunction::is_type_of(attr) {
+                    return Some(Ok((name, attr)));
+                }
+                // MASSIVE HACK! PyFunction doesn't exist for PyPy,
+                // is_instance_of::<PyFunction> crashes with a null pointer, hence this hack, see
+                // https://github.com/pydantic/pydantic-core/pull/161#discussion_r917257635
+                #[cfg(PyPy)]
+                if !is_bound && attr.get_type().to_string() != "<class 'function'>" {
+                    return Some(Ok((name, attr)));
                 }
             }
         }
@@ -621,12 +589,7 @@ pub enum GenericIterator {
 
 impl From<JsonArray> for GenericIterator {
     fn from(array: JsonArray) -> Self {
-        let length = array.len();
-        let json_iter = GenericJsonIterator {
-            array,
-            length,
-            index: 0,
-        };
+        let json_iter = GenericJsonIterator { array, index: 0 };
         Self::JsonArray(json_iter)
     }
 }
@@ -674,14 +637,15 @@ impl GenericPyIterator {
 #[derive(Debug, Clone)]
 pub struct GenericJsonIterator {
     array: JsonArray,
-    length: usize,
     index: usize,
 }
 
 impl GenericJsonIterator {
     pub fn next(&mut self, _py: Python) -> PyResult<Option<(&JsonInput, usize)>> {
-        if self.index < self.length {
-            let next = unsafe { self.array.get_unchecked(self.index) };
+        if self.index < self.array.len() {
+            // panic here is impossible due to bounds check above; compiler should be
+            // able to optimize it away even
+            let next = &self.array[self.index];
             let a = (next, self.index);
             self.index += 1;
             Ok(Some(a))
@@ -940,13 +904,7 @@ impl<'a> EitherFloat<'a> {
     pub fn as_f64(self) -> f64 {
         match self {
             EitherFloat::F64(f) => f,
-
-            EitherFloat::Py(f) => {
-                {
-                    // Safety: known to be a python float
-                    unsafe { ffi::PyFloat_AS_DOUBLE(f.as_ptr()) }
-                }
-            }
+            EitherFloat::Py(f) => f.value(),
         }
     }
 }
diff --git a/src/serializers/infer.rs b/src/serializers/infer.rs
index 91418bb6e..265967c57 100644
--- a/src/serializers/infer.rs
+++ b/src/serializers/infer.rs
@@ -133,8 +133,8 @@ pub(crate) fn infer_to_python_known(
                 .map(|s| s.into_py(py))?,
             ObType::Bytearray => {
                 let py_byte_array: &PyByteArray = value.downcast()?;
-                // see https://docs.rs/pyo3/latest/pyo3/types/struct.PyByteArray.html#method.as_bytes
-                // for why this is marked unsafe
+                // Safety: the GIL is held while bytes_to_string is running; it doesn't run
+                // arbitrary Python code, so py_byte_array cannot be mutated.
                 let bytes = unsafe { py_byte_array.as_bytes() };
                 extra
                     .config
@@ -428,8 +428,12 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
         }
         ObType::Bytearray => {
             let py_byte_array: &PyByteArray = value.downcast().map_err(py_err_se_err)?;
-            let bytes = unsafe { py_byte_array.as_bytes() };
-            extra.config.bytes_mode.serialize_bytes(bytes, serializer)
+            // Safety: the GIL is held while serialize_bytes is running; it doesn't run
+            // arbitrary Python code, so py_byte_array cannot be mutated.
+            extra
+                .config
+                .bytes_mode
+                .serialize_bytes(unsafe { py_byte_array.as_bytes() }, serializer)
         }
         ObType::Dict => serialize_dict!(value.downcast::<PyDict>().map_err(py_err_se_err)?),
         ObType::List => serialize_seq_filter!(PyList),
@@ -581,8 +585,15 @@ pub(crate) fn infer_json_key_known<'py>(ob_type: ObType, key: &'py PyAny, extra:
             .bytes_to_string(key.py(), key.downcast::<PyBytes>()?.as_bytes()),
         ObType::Bytearray => {
             let py_byte_array: &PyByteArray = key.downcast()?;
-            let bytes = unsafe { py_byte_array.as_bytes() };
-            extra.config.bytes_mode.bytes_to_string(key.py(), bytes)
+            // Safety: the GIL is held while serialize_bytes is running; it doesn't run
+            // arbitrary Python code, so py_byte_array cannot be mutated during the call.
+            //
+            // We copy the bytes into a new buffer immediately afterwards
+            extra
+                .config
+                .bytes_mode
+                .bytes_to_string(key.py(), unsafe { py_byte_array.as_bytes() })
+                .map(|cow| Cow::Owned(cow.into_owned()))
         }
         ObType::Datetime => {
             let py_dt: &PyDateTime = key.downcast()?;
diff --git a/src/serializers/ob_type.rs b/src/serializers/ob_type.rs
index 70afcae13..fc491f618 100644
--- a/src/serializers/ob_type.rs
+++ b/src/serializers/ob_type.rs
@@ -1,9 +1,8 @@
-use pyo3::ffi::PyTypeObject;
 use pyo3::once_cell::GILOnceCell;
 use pyo3::prelude::*;
 use pyo3::types::{
     PyBool, PyByteArray, PyBytes, PyDate, PyDateTime, PyDelta, PyDict, PyFloat, PyFrozenSet, PyInt, PyIterator, PyList,
-    PySet, PyString, PyTime, PyTuple,
+    PySet, PyString, PyTime, PyTuple, PyType,
 };
 use pyo3::{intern, AsPyPointer, PyTypeInfo};
 
@@ -100,7 +99,7 @@ impl ObTypeLookup {
     }
 
     pub fn is_type(&self, value: &PyAny, expected_ob_type: ObType) -> IsType {
-        match self.ob_type_is_expected(Some(value), value.get_type_ptr(), &expected_ob_type) {
+        match self.ob_type_is_expected(Some(value), value.get_type(), &expected_ob_type) {
             IsType::False => {
                 if expected_ob_type == self.fallback_isinstance(value) {
                     IsType::Subclass
@@ -112,12 +111,8 @@ impl ObTypeLookup {
         }
     }
 
-    fn ob_type_is_expected(
-        &self,
-        op_value: Option<&PyAny>,
-        type_ptr: *mut PyTypeObject,
-        expected_ob_type: &ObType,
-    ) -> IsType {
+    fn ob_type_is_expected(&self, op_value: Option<&PyAny>, py_type: &PyType, expected_ob_type: &ObType) -> IsType {
+        let type_ptr = py_type.as_ptr();
         let ob_type = type_ptr as usize;
         let ans = match expected_ob_type {
             ObType::None => self.none == ob_type,
@@ -168,28 +163,26 @@ impl ObTypeLookup {
             // this allows for subtypes of the supported class types,
             // if we didn't successfully confirm the type, we try again with the next base type pointer provided
             // it's not null
-            let base_type_ptr = unsafe { (*type_ptr).tp_base };
-            if base_type_ptr.is_null() {
-                IsType::False
-            } else {
-                // as bellow, we don't want to tests for dataclass etc. again, so we pass None as op_value
-                match self.ob_type_is_expected(None, base_type_ptr, expected_ob_type) {
+            match get_base_type(py_type) {
+                // as below, we don't want to tests for dataclass etc. again, so we pass None as op_value
+                Some(base_type) => match self.ob_type_is_expected(None, base_type, expected_ob_type) {
                     IsType::False => IsType::False,
                     _ => IsType::Subclass,
-                }
+                },
+                None => IsType::False,
             }
         }
     }
 
     pub fn get_type(&self, value: &PyAny) -> ObType {
-        match self.lookup_by_ob_type(Some(value), value.get_type_ptr()) {
+        match self.lookup_by_ob_type(Some(value), value.get_type()) {
             ObType::Unknown => self.fallback_isinstance(value),
             ob_type => ob_type,
         }
     }
 
-    fn lookup_by_ob_type(&self, op_value: Option<&PyAny>, type_ptr: *mut PyTypeObject) -> ObType {
-        let ob_type = type_ptr as usize;
+    fn lookup_by_ob_type(&self, op_value: Option<&PyAny>, py_type: &PyType) -> ObType {
+        let ob_type = py_type.as_ptr() as usize;
         // this should be pretty fast, but still order is a bit important, so the most common types should come first
         // thus we don't follow the order of ObType
         if ob_type == self.none {
@@ -246,7 +239,7 @@ impl ObTypeLookup {
             ObType::PydanticSerializable
         } else if is_dataclass(op_value) {
             ObType::Dataclass
-        } else if self.is_enum(op_value, type_ptr) {
+        } else if self.is_enum(op_value, py_type) {
             ObType::Enum
         } else if ob_type == self.generator_object.as_ptr() as usize || is_generator(op_value) {
             ObType::Generator
@@ -255,25 +248,19 @@ impl ObTypeLookup {
         } 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
-            let base_type_ptr = unsafe { (*type_ptr).tp_base };
-            if base_type_ptr.is_null() {
-                ObType::Unknown
-            } else {
+            match get_base_type(py_type) {
                 // we don't want to tests for dataclass etc. again, so we pass None as op_value
-                self.lookup_by_ob_type(None, base_type_ptr)
+                Some(base_type) => self.lookup_by_ob_type(None, base_type),
+                None => ObType::Unknown,
             }
         }
     }
 
-    fn is_enum(&self, op_value: Option<&PyAny>, type_ptr: *mut PyTypeObject) -> bool {
+    fn is_enum(&self, op_value: Option<&PyAny>, py_type: &PyType) -> bool {
         // only test on the type itself, not base types
         if op_value.is_some() {
-            // see https://github.com/PyO3/pyo3/issues/2905 for details
-            #[cfg(all(PyPy, not(Py_3_9)))]
-            let meta_type = unsafe { (*type_ptr).ob_type };
-            #[cfg(any(not(PyPy), Py_3_9))]
-            let meta_type = unsafe { (*type_ptr).ob_base.ob_base.ob_type };
-            meta_type as usize == self.enum_object.as_ptr() as usize
+            let meta_type = py_type.get_type();
+            meta_type.is(&self.enum_object)
         } else {
             false
         }
@@ -434,3 +421,9 @@ impl PartialEq for ObType {
         }
     }
 }
+
+fn get_base_type(py_type: &PyType) -> Option<&PyType> {
+    let base_type_ptr = unsafe { (*py_type.as_type_ptr()).tp_base };
+    // Safety: `base_type_ptr` must be a valid pointer to a Python type object, or null.
+    unsafe { py_type.py().from_borrowed_ptr_or_opt(base_type_ptr.cast()) }
+}

From b9f45f9debf1c7f5e49dd09af63f1b3c4f54475b Mon Sep 17 00:00:00 2001
From: David Montague <35119617+dmontagu@users.noreply.github.com>
Date: Mon, 28 Aug 2023 12:03:16 -0600
Subject: [PATCH 006/550] Make round trip exclude computed fields (#934)

---
 src/serializers/computed_fields.rs | 8 ++++++++
 tests/serializers/test_model.py    | 3 +++
 2 files changed, 11 insertions(+)

diff --git a/src/serializers/computed_fields.rs b/src/serializers/computed_fields.rs
index 572a35dc4..8a1f041ae 100644
--- a/src/serializers/computed_fields.rs
+++ b/src/serializers/computed_fields.rs
@@ -48,6 +48,10 @@ impl ComputedFields {
         exclude: Option<&PyAny>,
         extra: &Extra,
     ) -> PyResult<()> {
+        if extra.round_trip {
+            // Do not serialize computed fields
+            return Ok(());
+        }
         for computed_fields in &self.0 {
             computed_fields.to_python(model, output_dict, filter, include, exclude, extra)?;
         }
@@ -63,6 +67,10 @@ impl ComputedFields {
         exclude: Option<&PyAny>,
         extra: &Extra,
     ) -> Result<(), S::Error> {
+        if extra.round_trip {
+            // Do not serialize computed fields
+            return Ok(());
+        }
         for computed_field in &self.0 {
             let property_name_py = computed_field.property_name_py.as_ref(model.py());
             if let Some((next_include, next_exclude)) = filter
diff --git a/tests/serializers/test_model.py b/tests/serializers/test_model.py
index 16e213b0d..32ecd3c1a 100644
--- a/tests/serializers/test_model.py
+++ b/tests/serializers/test_model.py
@@ -570,6 +570,9 @@ def area(self) -> bytes:
     assert s.to_python(Model(width=3, height=4), mode='json') == {'width': 3, 'height': 4, 'area': '12'}
     assert s.to_json(Model(width=3, height=4)) == b'{"width":3,"height":4,"area":"12"}'
 
+    assert s.to_python(Model(width=3, height=4), round_trip=True) == {'width': 3, 'height': 4}
+    assert s.to_json(Model(width=3, height=4), round_trip=True) == b'{"width":3,"height":4}'
+
 
 def test_property_alias():
     @dataclasses.dataclass

From a23db506c16282ac7a5c0b019a7ebf413463ad15 Mon Sep 17 00:00:00 2001
From: Adrian Garcia Badaracco <1755071+adriangb@users.noreply.github.com>
Date: Tue, 29 Aug 2023 01:04:20 -0500
Subject: [PATCH 007/550] Update version to 2.7.0 (#936)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 25119d19c..d45b03f51 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -242,7 +242,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.6.3"
+version = "2.7.0"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index b16624acc..ce32d0cc5 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.6.3"
+version = "2.7.0"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From 42d48fefd8a14e1553c048b8a145eeff46f98a12 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 29 Aug 2023 08:29:47 +0100
Subject: [PATCH 008/550] Bump base64 from 0.21.2 to 0.21.3 (#933)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index d45b03f51..d26e8006c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -31,9 +31,9 @@ checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
 
 [[package]]
 name = "base64"
-version = "0.21.2"
+version = "0.21.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "604178f6c5c21f02dc555784810edfb88d34ac2c73b2eae109655649ee73ce3d"
+checksum = "414dcefbc63d77c526a76b3afcf6fbb9b5e2791c19c3aa2297733208750c6e53"
 
 [[package]]
 name = "bitflags"
diff --git a/Cargo.toml b/Cargo.toml
index ce32d0cc5..9d020750b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -39,7 +39,7 @@ ahash = "0.8.0"
 url = "2.3.1"
 # idna is already required by url, added here to be explicit
 idna = "0.4.0"
-base64 = "0.21.2"
+base64 = "0.21.3"
 num-bigint = "0.4.3"
 python3-dll-a = "0.2.7"
 uuid = "1.4.1"

From 39b4a7815fac155a9d64a9bcb80fb7149ec5b98a Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 29 Aug 2023 08:30:36 +0100
Subject: [PATCH 009/550] Bump url from 2.4.0 to 2.4.1 (#932)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index d26e8006c..36aa60b42 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -542,9 +542,9 @@ checksum = "e1766d682d402817b5ac4490b3c3002d91dfa0d22812f341609f97b08757359c"
 
 [[package]]
 name = "url"
-version = "2.4.0"
+version = "2.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50bff7831e19200a85b17131d085c25d7811bc4e186efdaf54bbd132994a88cb"
+checksum = "143b538f18257fac9cad154828a57c6bf5157e1aa604d4816b5995bf6de87ae5"
 dependencies = [
  "form_urlencoded",
  "idna",
diff --git a/Cargo.toml b/Cargo.toml
index 9d020750b..f084450dd 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -36,7 +36,7 @@ serde = { version = "1.0.185", features = ["derive"] }
 speedate = "0.12.0"
 smallvec = "1.11.0"
 ahash = "0.8.0"
-url = "2.3.1"
+url = "2.4.1"
 # idna is already required by url, added here to be explicit
 idna = "0.4.0"
 base64 = "0.21.3"

From a52d38b0a054f847c736a977658f285910e53253 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 29 Aug 2023 08:33:03 +0100
Subject: [PATCH 010/550] Bump regex from 1.9.3 to 1.9.4 (#930)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 12 ++++++------
 Cargo.toml |  2 +-
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 36aa60b42..0845c7116 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -355,9 +355,9 @@ dependencies = [
 
 [[package]]
 name = "regex"
-version = "1.9.3"
+version = "1.9.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81bc1d4caf89fac26a70747fe603c130093b53c773888797a6329091246d651a"
+checksum = "12de2eff854e5fa4b1295edd650e227e9d8fb0c9e90b12e7f36d6a6811791a29"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -367,9 +367,9 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.3.6"
+version = "0.3.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fed1ceff11a1dddaee50c9dc8e4938bd106e9d89ae372f192311e7da498e3b69"
+checksum = "49530408a136e16e5b486e883fbb6ba058e8e4e8ae6621a77b048b314336e629"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -378,9 +378,9 @@ dependencies = [
 
 [[package]]
 name = "regex-syntax"
-version = "0.7.4"
+version = "0.7.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5ea92a5b6195c6ef2a0295ea818b312502c6fc94dde986c5553242e18fd4ce2"
+checksum = "dbb5fb1acd8a1a18b3dd5be62d25485eb770e05afb408a9627d14d451bae12da"
 
 [[package]]
 name = "rustversion"
diff --git a/Cargo.toml b/Cargo.toml
index f084450dd..296258def 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -27,7 +27,7 @@ include = [
 
 [dependencies]
 pyo3 = { version = "0.19.2", features = ["generate-import-lib", "num-bigint"] }
-regex = "1.9.3"
+regex = "1.9.4"
 strum = { version = "0.25.0", features = ["derive"] }
 strum_macros = "0.25.2"
 serde_json = {version = "1.0.105", features = ["arbitrary_precision", "preserve_order"]}

From 2dfcd6b8be45a71a7584c87742b1288fe123255d Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 29 Aug 2023 08:33:28 +0100
Subject: [PATCH 011/550] Bump ruff from 0.0.285 to 0.0.286 (#928)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index 94c5c0303..d575ef749 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,5 +1,5 @@
 black==23.7.0
 griffe==0.34.0
 pyright==1.1.323
-ruff==0.0.285
+ruff==0.0.286
 mypy==1.5.1

From cf90503071226c7975bea448eceb34745da40203 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 29 Aug 2023 08:34:02 +0100
Subject: [PATCH 012/550] Bump griffe from 0.34.0 to 0.35.2 (#927)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index d575ef749..5a158d339 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,5 +1,5 @@
 black==23.7.0
-griffe==0.34.0
+griffe==0.35.2
 pyright==1.1.323
 ruff==0.0.286
 mypy==1.5.1

From 53385d3657e5e16ffcb5d7b3e1457bd86d1c8a57 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 29 Aug 2023 07:40:54 +0000
Subject: [PATCH 013/550] Bump pyright from 1.1.323 to 1.1.324 (#926)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index 5a158d339..fc4c55b3c 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,5 +1,5 @@
 black==23.7.0
 griffe==0.35.2
-pyright==1.1.323
+pyright==1.1.324
 ruff==0.0.286
 mypy==1.5.1

From 18425b00d5961840d78434bf2fdc6a9e5f4490e4 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 29 Aug 2023 07:41:21 +0000
Subject: [PATCH 014/550] Bump num-bigint from 0.4.3 to 0.4.4 (#931)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 8 ++++----
 Cargo.toml | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 0845c7116..5cb3573b2 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -168,9 +168,9 @@ dependencies = [
 
 [[package]]
 name = "num-bigint"
-version = "0.4.3"
+version = "0.4.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f93ab6289c7b344a8a9f60f88d80aa20032336fe78da341afc91c8a2341fc75f"
+checksum = "608e7659b5c3d7cba262d894801b9ec9d00de989e8a82bd4bef91d08da45cdc0"
 dependencies = [
  "autocfg",
  "num-integer",
@@ -189,9 +189,9 @@ dependencies = [
 
 [[package]]
 name = "num-traits"
-version = "0.2.15"
+version = "0.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "578ede34cf02f8924ab9447f50c28075b4d3e5b269972345e7e0372b38c6cdcd"
+checksum = "f30b0abd723be7e2ffca1272140fac1a2f084c77ec3e123c192b66af1ee9e6c2"
 dependencies = [
  "autocfg",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index 296258def..e7a533605 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -40,7 +40,7 @@ url = "2.4.1"
 # idna is already required by url, added here to be explicit
 idna = "0.4.0"
 base64 = "0.21.3"
-num-bigint = "0.4.3"
+num-bigint = "0.4.4"
 python3-dll-a = "0.2.7"
 uuid = "1.4.1"
 

From 01a1523afafd8ab5c9073633905c3792c7d06483 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 29 Aug 2023 07:41:50 +0000
Subject: [PATCH 015/550] Bump serde from 1.0.185 to 1.0.188 (#929)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 8 ++++----
 Cargo.toml | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 5cb3573b2..87a889e43 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -402,18 +402,18 @@ checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
 
 [[package]]
 name = "serde"
-version = "1.0.185"
+version = "1.0.188"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be9b6f69f1dfd54c3b568ffa45c310d6973a5e5148fd40cf515acaf38cf5bc31"
+checksum = "cf9e0fcba69a370eed61bcf2b728575f726b50b55cba78064753d708ddc7549e"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.185"
+version = "1.0.188"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc59dfdcbad1437773485e0367fea4b090a2e0a16d9ffc46af47764536a298ec"
+checksum = "4eca7ac642d82aa35b60049a6eccb4be6be75e599bd2e9adb5f875a737654af2"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/Cargo.toml b/Cargo.toml
index e7a533605..75b2bcb34 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -32,7 +32,7 @@ strum = { version = "0.25.0", features = ["derive"] }
 strum_macros = "0.25.2"
 serde_json = {version = "1.0.105", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.8"
-serde = { version = "1.0.185", features = ["derive"] }
+serde = { version = "1.0.188", features = ["derive"] }
 speedate = "0.12.0"
 smallvec = "1.11.0"
 ahash = "0.8.0"

From 9ec1036b4583d5ada15f7ac3e32fcc04a981746a Mon Sep 17 00:00:00 2001
From: Viicos <65306057+Viicos@users.noreply.github.com>
Date: Thu, 31 Aug 2023 15:37:01 +0200
Subject: [PATCH 016/550] Fix typo in `MultiHostUrl.build` docstring (#938)

---
 python/pydantic_core/_pydantic_core.pyi | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index 5aae6df8a..9b24e7076 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -631,7 +631,7 @@ class MultiHostUrl(SupportsAllComparisons):
         fragment: Optional[str] = None,
     ) -> Self:
         """
-        Build a new `MultiHostUul` instance from its component parts.
+        Build a new `MultiHostUrl` instance from its component parts.
 
         This method takes either `hosts` - a list of `MultiHostHost` typed dicts, or the individual components
         `username`, `password`, `host` and `port`.

From 04a9135a695212665017175c96f1bc7dc5007349 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 5 Sep 2023 09:42:43 +0100
Subject: [PATCH 017/550] Bump regex from 1.9.4 to 1.9.5 (#944)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 12 ++++++------
 Cargo.toml |  2 +-
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 87a889e43..4e38d8cf7 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -153,9 +153,9 @@ dependencies = [
 
 [[package]]
 name = "memchr"
-version = "2.5.0"
+version = "2.6.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2dffe52ecf27772e601905b7522cb4ef790d2cc203488bbd0e2fe85fcb74566d"
+checksum = "8f232d6ef707e1956a43342693d2a31e72989554d58299d7a88738cc95b0d35c"
 
 [[package]]
 name = "memoffset"
@@ -355,9 +355,9 @@ dependencies = [
 
 [[package]]
 name = "regex"
-version = "1.9.4"
+version = "1.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "12de2eff854e5fa4b1295edd650e227e9d8fb0c9e90b12e7f36d6a6811791a29"
+checksum = "697061221ea1b4a94a624f67d0ae2bfe4e22b8a17b6a192afb11046542cc8c47"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -367,9 +367,9 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.3.7"
+version = "0.3.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49530408a136e16e5b486e883fbb6ba058e8e4e8ae6621a77b048b314336e629"
+checksum = "c2f401f4955220693b56f8ec66ee9c78abffd8d1c4f23dc41a23839eb88f0795"
 dependencies = [
  "aho-corasick",
  "memchr",
diff --git a/Cargo.toml b/Cargo.toml
index 75b2bcb34..3f5b25e7f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -27,7 +27,7 @@ include = [
 
 [dependencies]
 pyo3 = { version = "0.19.2", features = ["generate-import-lib", "num-bigint"] }
-regex = "1.9.4"
+regex = "1.9.5"
 strum = { version = "0.25.0", features = ["derive"] }
 strum_macros = "0.25.2"
 serde_json = {version = "1.0.105", features = ["arbitrary_precision", "preserve_order"]}

From fffb1d853ccdbacbf1dee84be8c76a67178ae5e1 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 5 Sep 2023 09:43:20 +0100
Subject: [PATCH 018/550] Bump pytest from 7.4.0 to 7.4.1 (#939)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements.txt b/tests/requirements.txt
index c1d0e8a70..c8469082f 100644
--- a/tests/requirements.txt
+++ b/tests/requirements.txt
@@ -3,7 +3,7 @@ dirty-equals==0.6.0
 hypothesis==6.79.4
 # pandas doesn't offer prebuilt wheels for all versions and platforms we test in CI e.g. aarch64 musllinux
 pandas==2.0.3; python_version >= "3.9" and python_version < "3.12" and implementation_name == "cpython" and platform_machine == 'x86_64'
-pytest==7.4.0
+pytest==7.4.1
 # we run codspeed benchmarks on x86_64 CPython (i.e. native github actions architecture)
 pytest-codspeed~=2.1.0; implementation_name == "cpython" and platform_machine == 'x86_64'
 pytest-examples==0.0.10

From 7dc8946e05d73ddd68e71ee34cb6a94fa470c65f Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 5 Sep 2023 09:43:34 +0100
Subject: [PATCH 019/550] Bump ruff from 0.0.286 to 0.0.287 (#942)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index fc4c55b3c..5536a4cb8 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,5 +1,5 @@
 black==23.7.0
 griffe==0.35.2
 pyright==1.1.324
-ruff==0.0.286
+ruff==0.0.287
 mypy==1.5.1

From 8a0bc71f3ed13fd93eeaa10bf4acd0c206c13fab Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 5 Sep 2023 09:43:53 +0100
Subject: [PATCH 020/550] Bump griffe from 0.35.2 to 0.36.0 (#940)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index 5536a4cb8..1b125e5f6 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,5 +1,5 @@
 black==23.7.0
-griffe==0.35.2
+griffe==0.36.0
 pyright==1.1.324
 ruff==0.0.287
 mypy==1.5.1

From e09112a28aa6dae3e8a41ac3d1a4e9ebc10d5863 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 5 Sep 2023 08:50:55 +0000
Subject: [PATCH 021/550] Bump pyright from 1.1.324 to 1.1.325 (#941)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index 1b125e5f6..2204967c1 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,5 +1,5 @@
 black==23.7.0
 griffe==0.36.0
-pyright==1.1.324
+pyright==1.1.325
 ruff==0.0.287
 mypy==1.5.1

From 6a139753af85fc7bb6b34f26c1328994506f94ee Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 5 Sep 2023 10:15:42 +0100
Subject: [PATCH 022/550] Bump griffe from 0.35.2 to 0.36.1 (#946)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index 2204967c1..6faa2c2d2 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,5 +1,5 @@
 black==23.7.0
-griffe==0.36.0
+griffe==0.36.1
 pyright==1.1.325
 ruff==0.0.287
 mypy==1.5.1

From 2d9df49bc2c99b076cfbe87b0101f440abbd8519 Mon Sep 17 00:00:00 2001
From: Adrian Garcia Badaracco <1755071+adriangb@users.noreply.github.com>
Date: Thu, 7 Sep 2023 08:16:06 -0500
Subject: [PATCH 023/550] Update pytz (#949)

---
 tests/requirements.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements.txt b/tests/requirements.txt
index c8469082f..aad4fd52c 100644
--- a/tests/requirements.txt
+++ b/tests/requirements.txt
@@ -11,6 +11,6 @@ pytest-speed==0.3.5
 pytest-mock==3.11.1
 pytest-pretty==1.2.0
 pytest-timeout==2.1.0
-pytz==2023.3
+pytz==2023.3.post1
 # numpy doesn't offer prebuilt wheels for all versions and platforms we test in CI e.g. aarch64 musllinux
 numpy==1.25.2; python_version >= "3.9" and python_version < "3.12" and implementation_name == "cpython" and platform_machine == 'x86_64'

From 6769140dfb4cbe817567344308d3d492ef0e677e Mon Sep 17 00:00:00 2001
From: Adrian Garcia Badaracco <1755071+adriangb@users.noreply.github.com>
Date: Thu, 7 Sep 2023 08:24:08 -0500
Subject: [PATCH 024/550] Fix parsing int from large decimals (#948)

Co-authored-by: David Hewitt <1939362+davidhewitt@users.noreply.github.com>
---
 src/input/input_abstract.rs  | 12 ++++----
 src/input/input_json.rs      | 14 ++++-----
 src/input/input_python.rs    | 24 ++++++++++-----
 src/input/shared.rs          | 14 +++++++++
 src/validators/decimal.rs    | 58 +++++++++++++++++++++---------------
 tests/validators/test_int.py | 21 +++++++++++++
 6 files changed, 97 insertions(+), 46 deletions(-)

diff --git a/src/input/input_abstract.rs b/src/input/input_abstract.rs
index 80ebc059c..3e780237b 100644
--- a/src/input/input_abstract.rs
+++ b/src/input/input_abstract.rs
@@ -152,17 +152,17 @@ pub trait Input<'a>: fmt::Debug + ToPyObject {
         self.strict_float()
     }
 
-    fn validate_decimal(&'a self, strict: bool, decimal_type: &'a PyType) -> ValResult<&'a PyAny> {
+    fn validate_decimal(&'a self, strict: bool, py: Python<'a>) -> ValResult<&'a PyAny> {
         if strict {
-            self.strict_decimal(decimal_type)
+            self.strict_decimal(py)
         } else {
-            self.lax_decimal(decimal_type)
+            self.lax_decimal(py)
         }
     }
-    fn strict_decimal(&'a self, decimal_type: &'a PyType) -> ValResult<&'a PyAny>;
+    fn strict_decimal(&'a self, py: Python<'a>) -> ValResult<&'a PyAny>;
     #[cfg_attr(has_no_coverage, no_coverage)]
-    fn lax_decimal(&'a self, decimal_type: &'a PyType) -> ValResult<&'a PyAny> {
-        self.strict_decimal(decimal_type)
+    fn lax_decimal(&'a self, py: Python<'a>) -> ValResult<&'a PyAny> {
+        self.strict_decimal(py)
     }
 
     fn validate_dict(&'a self, strict: bool) -> ValResult<GenericMapping<'a>> {
diff --git a/src/input/input_json.rs b/src/input/input_json.rs
index c2da56703..86079da09 100644
--- a/src/input/input_json.rs
+++ b/src/input/input_json.rs
@@ -1,7 +1,7 @@
 use std::borrow::Cow;
 
 use pyo3::prelude::*;
-use pyo3::types::{PyDict, PyString, PyType};
+use pyo3::types::{PyDict, PyString};
 use speedate::MicrosecondsPrecisionOverflowBehavior;
 use strum::EnumMessage;
 
@@ -178,13 +178,12 @@ impl<'a> Input<'a> for JsonInput {
         }
     }
 
-    fn strict_decimal(&'a self, decimal_type: &'a PyType) -> ValResult<&'a PyAny> {
-        let py = decimal_type.py();
+    fn strict_decimal(&'a self, py: Python<'a>) -> ValResult<&'a PyAny> {
         match self {
-            JsonInput::Float(f) => create_decimal(PyString::new(py, &f.to_string()), self, decimal_type),
+            JsonInput::Float(f) => create_decimal(PyString::new(py, &f.to_string()), self, py),
 
             JsonInput::String(..) | JsonInput::Int(..) | JsonInput::Uint(..) | JsonInput::BigInt(..) => {
-                create_decimal(self.to_object(py).into_ref(py), self, decimal_type)
+                create_decimal(self.to_object(py).into_ref(py), self, py)
             }
             _ => Err(ValError::new(ErrorTypeDefaults::DecimalType, self)),
         }
@@ -439,9 +438,8 @@ impl<'a> Input<'a> for String {
         str_as_float(self, self)
     }
 
-    fn strict_decimal(&'a self, decimal_type: &'a PyType) -> ValResult<&'a PyAny> {
-        let py = decimal_type.py();
-        create_decimal(self.to_object(py).into_ref(py), self, decimal_type)
+    fn strict_decimal(&'a self, py: Python<'a>) -> ValResult<&'a PyAny> {
+        create_decimal(self.to_object(py).into_ref(py), self, py)
     }
 
     #[cfg_attr(has_no_coverage, no_coverage)]
diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index b31ff4361..3fbf20240 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -13,7 +13,7 @@ use speedate::MicrosecondsPrecisionOverflowBehavior;
 
 use crate::errors::{ErrorType, ErrorTypeDefaults, InputValue, LocItem, ValError, ValResult};
 use crate::tools::{extract_i64, safe_repr};
-use crate::validators::decimal::create_decimal;
+use crate::validators::decimal::{create_decimal, get_decimal_type};
 use crate::{ArgsKwargs, PyMultiHostUrl, PyUrl};
 
 use super::datetime::{
@@ -21,7 +21,7 @@ use super::datetime::{
     float_as_duration, float_as_time, int_as_datetime, int_as_duration, int_as_time, EitherDate, EitherDateTime,
     EitherTime,
 };
-use super::shared::{float_as_int, int_as_bool, map_json_err, str_as_bool, str_as_float, str_as_int};
+use super::shared::{decimal_as_int, float_as_int, int_as_bool, map_json_err, str_as_bool, str_as_float, str_as_int};
 use super::{
     py_string_str, EitherBytes, EitherFloat, EitherInt, EitherString, EitherTimedelta, GenericArguments,
     GenericIterable, GenericIterator, GenericMapping, Input, JsonInput, PyArgs,
@@ -324,6 +324,10 @@ impl<'a> Input<'a> for PyAny {
         } else if PyInt::is_type_of(self) {
             // force to an int to upcast to a pure python int to maintain current behaviour
             EitherInt::upcast(self)
+        } else if PyFloat::is_exact_type_of(self) {
+            float_as_int(self, self.extract::<f64>()?)
+        } else if let Ok(decimal) = self.strict_decimal(self.py()) {
+            decimal_as_int(self.py(), self, decimal)
         } else if let Ok(float) = self.extract::<f64>() {
             float_as_int(self, float)
         } else {
@@ -367,7 +371,9 @@ impl<'a> Input<'a> for PyAny {
         }
     }
 
-    fn strict_decimal(&'a self, decimal_type: &'a PyType) -> ValResult<&'a PyAny> {
+    fn strict_decimal(&'a self, py: Python<'a>) -> ValResult<&'a PyAny> {
+        let decimal_type_obj: Py<PyType> = get_decimal_type(py);
+        let decimal_type = decimal_type_obj.as_ref(py);
         // Fast path for existing decimal objects
         if self.is_exact_instance(decimal_type) {
             return Ok(self);
@@ -375,7 +381,7 @@ impl<'a> Input<'a> for PyAny {
 
         // Try subclasses of decimals, they will be upcast to Decimal
         if self.is_instance(decimal_type)? {
-            return create_decimal(self, self, decimal_type);
+            return create_decimal(self, self, py);
         }
 
         Err(ValError::new(
@@ -387,7 +393,9 @@ impl<'a> Input<'a> for PyAny {
         ))
     }
 
-    fn lax_decimal(&'a self, decimal_type: &'a PyType) -> ValResult<&'a PyAny> {
+    fn lax_decimal(&'a self, py: Python<'a>) -> ValResult<&'a PyAny> {
+        let decimal_type_obj: Py<PyType> = get_decimal_type(py);
+        let decimal_type = decimal_type_obj.as_ref(py);
         // Fast path for existing decimal objects
         if self.is_exact_instance(decimal_type) {
             return Ok(self);
@@ -395,12 +403,12 @@ impl<'a> Input<'a> for PyAny {
 
         if self.is_instance_of::<PyString>() || (self.is_instance_of::<PyInt>() && !self.is_instance_of::<PyBool>()) {
             // checking isinstance for str / int / bool is fast compared to decimal / float
-            create_decimal(self, self, decimal_type)
+            create_decimal(self, self, py)
         } else if self.is_instance(decimal_type)? {
             // upcast subclasses to decimal
-            return create_decimal(self, self, decimal_type);
+            return create_decimal(self, self, py);
         } else if self.is_instance_of::<PyFloat>() {
-            create_decimal(self.str()?, self, decimal_type)
+            create_decimal(self.str()?, self, py)
         } else {
             Err(ValError::new(ErrorTypeDefaults::DecimalType, self))
         }
diff --git a/src/input/shared.rs b/src/input/shared.rs
index bed673531..d8733bd31 100644
--- a/src/input/shared.rs
+++ b/src/input/shared.rs
@@ -1,4 +1,5 @@
 use num_bigint::BigInt;
+use pyo3::{intern, PyAny, Python};
 
 use crate::errors::{ErrorType, ErrorTypeDefaults, ValError, ValResult};
 use crate::input::EitherInt;
@@ -136,3 +137,16 @@ pub fn float_as_int<'a>(input: &'a impl Input<'a>, float: f64) -> ValResult<'a,
         Err(ValError::new(ErrorTypeDefaults::IntParsingSize, input))
     }
 }
+
+pub fn decimal_as_int<'a>(py: Python, input: &'a impl Input<'a>, decimal: &'a PyAny) -> ValResult<'a, EitherInt<'a>> {
+    if !decimal.call_method0(intern!(py, "is_finite"))?.extract::<bool>()? {
+        return Err(ValError::new(ErrorTypeDefaults::FiniteNumber, input));
+    }
+    let (numerator, denominator) = decimal
+        .call_method0(intern!(py, "as_integer_ratio"))?
+        .extract::<(&PyAny, &PyAny)>()?;
+    if denominator.extract::<i64>().map_or(true, |d| d != 1) {
+        return Err(ValError::new(ErrorTypeDefaults::IntFromFloat, input));
+    }
+    Ok(EitherInt::Py(numerator))
+}
diff --git a/src/validators/decimal.rs b/src/validators/decimal.rs
index faacf4dd3..2564e096a 100644
--- a/src/validators/decimal.rs
+++ b/src/validators/decimal.rs
@@ -1,4 +1,5 @@
 use pyo3::exceptions::{PyTypeError, PyValueError};
+use pyo3::sync::GILOnceCell;
 use pyo3::types::{IntoPyDict, PyDict, PyTuple, PyType};
 use pyo3::{intern, AsPyPointer};
 use pyo3::{prelude::*, PyTypeInfo};
@@ -13,6 +14,21 @@ use crate::tools::SchemaDict;
 
 use super::{BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
 
+static DECIMAL_TYPE: GILOnceCell<Py<PyType>> = GILOnceCell::new();
+
+pub fn get_decimal_type(py: Python) -> Py<PyType> {
+    DECIMAL_TYPE
+        .get_or_init(py, || {
+            py.import("decimal")
+                .and_then(|decimal_module| decimal_module.getattr("Decimal"))
+                .unwrap()
+                .extract::<&PyType>()
+                .unwrap()
+                .into()
+        })
+        .clone()
+}
+
 #[derive(Debug, Clone)]
 pub struct DecimalValidator {
     strict: bool,
@@ -25,7 +41,6 @@ pub struct DecimalValidator {
     gt: Option<Py<PyAny>>,
     max_digits: Option<u64>,
     decimal_places: Option<u64>,
-    decimal_type: Py<PyType>,
 }
 
 impl BuildValidator for DecimalValidator {
@@ -55,10 +70,6 @@ impl BuildValidator for DecimalValidator {
             ge: schema.get_as(intern!(py, "ge"))?,
             gt: schema.get_as(intern!(py, "gt"))?,
             max_digits,
-            decimal_type: py
-                .import(intern!(py, "decimal"))?
-                .getattr(intern!(py, "Decimal"))?
-                .extract()?,
         }
         .into())
     }
@@ -69,8 +80,7 @@ impl_py_gc_traverse!(DecimalValidator {
     le,
     lt,
     ge,
-    gt,
-    decimal_type
+    gt
 });
 
 impl Validator for DecimalValidator {
@@ -80,11 +90,7 @@ impl Validator for DecimalValidator {
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
     ) -> ValResult<'data, PyObject> {
-        let decimal = input.validate_decimal(
-            state.strict_or(self.strict),
-            // Safety: self and py both outlive this call
-            unsafe { py.from_borrowed_ptr(self.decimal_type.as_ptr()) },
-        )?;
+        let decimal = input.validate_decimal(state.strict_or(self.strict), py)?;
 
         if !self.allow_inf_nan || self.check_digits {
             if !decimal.call_method0(intern!(py, "is_finite"))?.extract()? {
@@ -244,19 +250,23 @@ impl Validator for DecimalValidator {
 pub(crate) fn create_decimal<'a>(
     arg: &'a PyAny,
     input: &'a impl Input<'a>,
-    decimal_type: &'a PyType,
+    py: Python<'a>,
 ) -> ValResult<'a, &'a PyAny> {
-    decimal_type.call1((arg,)).map_err(|e| {
-        let decimal_exception = match arg
-            .py()
-            .import("decimal")
-            .and_then(|decimal_module| decimal_module.getattr("DecimalException"))
-        {
-            Ok(decimal_exception) => decimal_exception,
-            Err(e) => return ValError::InternalErr(e),
-        };
-        handle_decimal_new_error(arg.py(), input.as_error_value(), e, decimal_exception)
-    })
+    let decimal_type_obj: Py<PyType> = get_decimal_type(py);
+    decimal_type_obj
+        .call1(py, (arg,))
+        .map_err(|e| {
+            let decimal_exception = match arg
+                .py()
+                .import("decimal")
+                .and_then(|decimal_module| decimal_module.getattr("DecimalException"))
+            {
+                Ok(decimal_exception) => decimal_exception,
+                Err(e) => return ValError::InternalErr(e),
+            };
+            handle_decimal_new_error(arg.py(), input.as_error_value(), e, decimal_exception)
+        })
+        .map(|v| v.into_ref(py))
 }
 
 fn handle_decimal_new_error<'a>(
diff --git a/tests/validators/test_int.py b/tests/validators/test_int.py
index 44a806118..43cd5bacb 100644
--- a/tests/validators/test_int.py
+++ b/tests/validators/test_int.py
@@ -58,7 +58,9 @@ def test_int_py_and_json(py_and_json: PyAndJson, input_value, expected):
     'input_value,expected',
     [
         (Decimal('1'), 1),
+        (Decimal('1' + '0' * 1_000), int('1' + '0' * 1_000)),  # a large decimal
         (Decimal('1.0'), 1),
+        (1.0, 1),
         (i64_max, i64_max),
         (str(i64_max), i64_max),
         (str(i64_max * 2), i64_max * 2),
@@ -66,6 +68,14 @@ def test_int_py_and_json(py_and_json: PyAndJson, input_value, expected):
         (-i64_max + 1, -i64_max + 1),
         (i64_max * 2, i64_max * 2),
         (-i64_max * 2, -i64_max * 2),
+        pytest.param(
+            1.00000000001,
+            Err(
+                'Input should be a valid integer, got a number with a fractional part '
+                '[type=int_from_float, input_value=1.00000000001, input_type=float]'
+            ),
+            id='decimal-remainder',
+        ),
         pytest.param(
             Decimal('1.001'),
             Err(
@@ -437,3 +447,14 @@ def test_int_subclass_constraint() -> None:
 
     with pytest.raises(ValidationError, match='Input should be greater than 0'):
         v.validate_python(IntSubclass(0))
+
+
+class FloatSubclass(float):
+    pass
+
+
+def test_float_subclass() -> None:
+    v = SchemaValidator({'type': 'int'})
+    v_lax = v.validate_python(FloatSubclass(1))
+    assert v_lax == 1
+    assert type(v_lax) == int

From f6b14cce22b1539727ed0e0a47d2c680c79c1692 Mon Sep 17 00:00:00 2001
From: David Hewitt <1939362+davidhewitt@users.noreply.github.com>
Date: Fri, 8 Sep 2023 07:00:14 +0100
Subject: [PATCH 025/550] make error "duplicate" cheaper (#950)

---
 src/errors/line_error.rs           | 31 +++++++++++------------
 src/errors/validation_exception.rs | 16 ++++++------
 src/input/input_json.rs            |  7 +++---
 src/input/parse_json.rs            | 14 ++++++-----
 src/input/return_enums.rs          |  9 +++----
 src/lazy_index_map.rs              | 40 ++++++++++++++----------------
 src/validators/function.rs         |  2 +-
 src/validators/generator.rs        |  8 +++---
 src/validators/json.rs             |  2 +-
 9 files changed, 62 insertions(+), 67 deletions(-)

diff --git a/src/errors/line_error.rs b/src/errors/line_error.rs
index c8230a27a..e5d3c7bac 100644
--- a/src/errors/line_error.rs
+++ b/src/errors/line_error.rs
@@ -62,10 +62,10 @@ impl<'a> ValError<'a> {
     }
 
     /// a bit like clone but change the lifetime to match py
-    pub fn duplicate<'py>(&self, py: Python<'py>) -> ValError<'py> {
+    pub fn into_owned(self, py: Python<'_>) -> ValError<'_> {
         match self {
-            ValError::LineErrors(errors) => errors.iter().map(|e| e.duplicate(py)).collect::<Vec<_>>().into(),
-            ValError::InternalErr(err) => ValError::InternalErr(err.clone_ref(py)),
+            ValError::LineErrors(errors) => errors.into_iter().map(|e| e.into_owned(py)).collect::<Vec<_>>().into(),
+            ValError::InternalErr(err) => ValError::InternalErr(err),
             ValError::Omit => ValError::Omit,
             ValError::UseDefault => ValError::UseDefault,
         }
@@ -129,28 +129,26 @@ impl<'a> ValLineError<'a> {
         self
     }
 
-    /// a bit like clone but change the lifetime to match py, used by ValError.duplicate above
-    pub fn duplicate<'py>(&'a self, py: Python<'py>) -> ValLineError<'py> {
+    /// a bit like clone but change the lifetime to match py, used by ValError.into_owned above
+    pub fn into_owned(self, py: Python<'_>) -> ValLineError<'_> {
         ValLineError {
-            error_type: self.error_type.clone(),
-            input_value: InputValue::<'py>::from(self.input_value.to_object(py)),
-            location: self.location.clone(),
+            error_type: self.error_type,
+            input_value: match self.input_value {
+                InputValue::PyAny(input) => InputValue::PyAny(input.to_object(py).into_ref(py)),
+                InputValue::JsonInput(input) => InputValue::JsonInput(input),
+                InputValue::String(input) => InputValue::PyAny(input.to_object(py).into_ref(py)),
+            },
+            location: self.location,
         }
     }
 }
 
 #[cfg_attr(debug_assertions, derive(Debug))]
+#[derive(Clone)]
 pub enum InputValue<'a> {
     PyAny(&'a PyAny),
-    JsonInput(&'a JsonInput),
+    JsonInput(JsonInput),
     String(&'a str),
-    PyObject(PyObject),
-}
-
-impl<'a> From<PyObject> for InputValue<'a> {
-    fn from(py_object: PyObject) -> Self {
-        Self::PyObject(py_object)
-    }
 }
 
 impl<'a> ToPyObject for InputValue<'a> {
@@ -159,7 +157,6 @@ impl<'a> ToPyObject for InputValue<'a> {
             Self::PyAny(input) => input.into_py(py),
             Self::JsonInput(input) => input.to_object(py),
             Self::String(input) => input.into_py(py),
-            Self::PyObject(py_obj) => py_obj.into_py(py),
         }
     }
 }
diff --git a/src/errors/validation_exception.rs b/src/errors/validation_exception.rs
index 8963c1d81..9dde6551c 100644
--- a/src/errors/validation_exception.rs
+++ b/src/errors/validation_exception.rs
@@ -22,7 +22,7 @@ use super::line_error::ValLineError;
 use super::location::Location;
 use super::types::{ErrorMode, ErrorType};
 use super::value_exception::PydanticCustomError;
-use super::ValError;
+use super::{InputValue, ValError};
 
 #[pyclass(extends=PyValueError, module="pydantic_core._pydantic_core")]
 #[derive(Clone)]
@@ -128,11 +128,11 @@ fn get_url_prefix(py: Python, include_url: bool) -> Option<&str> {
 }
 
 // used to convert a validation error back to ValError for wrap functions
-impl<'a> IntoPy<ValError<'a>> for ValidationError {
-    fn into_py(self, py: Python) -> ValError<'a> {
+impl ValidationError {
+    pub(crate) fn into_val_error(self, py: Python<'_>) -> ValError<'_> {
         self.line_errors
             .into_iter()
-            .map(|e| e.into_py(py))
+            .map(|e| e.into_val_line_error(py))
             .collect::<Vec<_>>()
             .into()
     }
@@ -322,13 +322,13 @@ impl<'a> IntoPy<PyLineError> for ValLineError<'a> {
     }
 }
 
-/// opposite of above, used to extract line errors from a validation error for wrap functions
-impl<'a> IntoPy<ValLineError<'a>> for PyLineError {
-    fn into_py(self, _py: Python) -> ValLineError<'a> {
+impl PyLineError {
+    /// Used to extract line errors from a validation error for wrap functions
+    fn into_val_line_error(self, py: Python<'_>) -> ValLineError<'_> {
         ValLineError {
             error_type: self.error_type,
             location: self.location,
-            input_value: self.input_value.into(),
+            input_value: InputValue::PyAny(self.input_value.into_ref(py)),
         }
     }
 }
diff --git a/src/input/input_json.rs b/src/input/input_json.rs
index 86079da09..d9cb81fe2 100644
--- a/src/input/input_json.rs
+++ b/src/input/input_json.rs
@@ -31,7 +31,8 @@ impl<'a> Input<'a> for JsonInput {
     }
 
     fn as_error_value(&'a self) -> InputValue<'a> {
-        InputValue::JsonInput(self)
+        // cloning JsonInput is cheap due to use of Arc
+        InputValue::JsonInput(self.clone())
     }
 
     fn is_none(&self) -> bool {
@@ -262,7 +263,7 @@ impl<'a> Input<'a> for JsonInput {
             JsonInput::String(s) => Ok(string_to_vec(s).into()),
             JsonInput::Object(object) => {
                 // return keys iterator to match python's behavior
-                let keys: Vec<JsonInput> = object.keys().map(|k| JsonInput::String(k.clone())).collect();
+                let keys: JsonArray = JsonArray::new(object.keys().map(|k| JsonInput::String(k.clone())).collect());
                 Ok(keys.into())
             }
             _ => Err(ValError::new(ErrorTypeDefaults::IterableType, self)),
@@ -550,5 +551,5 @@ impl<'a> Input<'a> for String {
 }
 
 fn string_to_vec(s: &str) -> JsonArray {
-    s.chars().map(|c| JsonInput::String(c.to_string())).collect()
+    JsonArray::new(s.chars().map(|c| JsonInput::String(c.to_string())).collect())
 }
diff --git a/src/input/parse_json.rs b/src/input/parse_json.rs
index 3bc2d0d46..7603eaf67 100644
--- a/src/input/parse_json.rs
+++ b/src/input/parse_json.rs
@@ -1,9 +1,11 @@
 use std::fmt;
+use std::sync::Arc;
 
 use num_bigint::BigInt;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList};
 use serde::de::{Deserialize, DeserializeSeed, Error as SerdeError, MapAccess, SeqAccess, Visitor};
+use smallvec::SmallVec;
 
 use crate::lazy_index_map::LazyIndexMap;
 
@@ -20,8 +22,8 @@ pub enum JsonInput {
     Array(JsonArray),
     Object(JsonObject),
 }
-pub type JsonArray = Vec<JsonInput>;
-pub type JsonObject = LazyIndexMap<String, JsonInput>;
+pub type JsonArray = Arc<SmallVec<[JsonInput; 8]>>;
+pub type JsonObject = Arc<LazyIndexMap<String, JsonInput>>;
 
 impl ToPyObject for JsonInput {
     fn to_object(&self, py: Python<'_>) -> PyObject {
@@ -111,13 +113,13 @@ impl<'de> Deserialize<'de> for JsonInput {
             where
                 V: SeqAccess<'de>,
             {
-                let mut vec = Vec::new();
+                let mut vec = SmallVec::new();
 
                 while let Some(elem) = visitor.next_element()? {
                     vec.push(elem);
                 }
 
-                Ok(JsonInput::Array(vec))
+                Ok(JsonInput::Array(JsonArray::new(vec)))
             }
 
             fn visit_map<V>(self, mut visitor: V) -> Result<JsonInput, V::Error>
@@ -171,9 +173,9 @@ impl<'de> Deserialize<'de> for JsonInput {
                         while let Some((key, value)) = visitor.next_entry()? {
                             values.insert(key, value);
                         }
-                        Ok(JsonInput::Object(values))
+                        Ok(JsonInput::Object(Arc::new(values)))
                     }
-                    None => Ok(JsonInput::Object(LazyIndexMap::new())),
+                    None => Ok(JsonInput::Object(Arc::new(LazyIndexMap::new()))),
                 }
             }
         }
diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index f1cfb8543..e97fe8b81 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -625,8 +625,8 @@ impl GenericPyIterator {
         }
     }
 
-    pub fn input<'a>(&'a self, py: Python<'a>) -> &'a PyAny {
-        self.obj.as_ref(py)
+    pub fn input_as_error_value<'py>(&self, py: Python<'py>) -> InputValue<'py> {
+        InputValue::PyAny(self.obj.clone_ref(py).into_ref(py))
     }
 
     pub fn index(&self) -> usize {
@@ -654,9 +654,8 @@ impl GenericJsonIterator {
         }
     }
 
-    pub fn input<'a>(&'a self, py: Python<'a>) -> &'a PyAny {
-        let input = JsonInput::Array(self.array.clone());
-        input.to_object(py).into_ref(py)
+    pub fn input_as_error_value<'py>(&self, _py: Python<'py>) -> InputValue<'py> {
+        InputValue::JsonInput(JsonInput::Array(self.array.clone()))
     }
 
     pub fn index(&self) -> usize {
diff --git a/src/lazy_index_map.rs b/src/lazy_index_map.rs
index 163421de3..c5621f877 100644
--- a/src/lazy_index_map.rs
+++ b/src/lazy_index_map.rs
@@ -1,32 +1,36 @@
 use std::borrow::Borrow;
-use std::cell::RefCell;
 use std::cmp::{Eq, PartialEq};
 use std::fmt::Debug;
 use std::hash::Hash;
 use std::slice::Iter as SliceIter;
+use std::sync::OnceLock;
 
 use ahash::AHashMap;
+use smallvec::SmallVec;
 
 #[derive(Debug, Clone, Default)]
 pub struct LazyIndexMap<K, V> {
-    vec: Vec<(K, V)>,
-    map: RefCell<Option<AHashMap<K, usize>>>,
+    vec: SmallVec<[(K, V); 8]>,
+    map: OnceLock<AHashMap<K, usize>>,
 }
 
 /// Like [IndexMap](https://docs.rs/indexmap/latest/indexmap/) but only builds the lookup map when it's needed.
 impl<K, V> LazyIndexMap<K, V>
 where
     K: Clone + Debug + Eq + Hash,
-    V: Clone + Debug,
+    V: Debug,
 {
     pub fn new() -> Self {
         Self {
-            vec: Vec::new(),
-            map: RefCell::new(None),
+            vec: SmallVec::new(),
+            map: OnceLock::new(),
         }
     }
 
     pub fn insert(&mut self, key: K, value: V) {
+        if let Some(map) = self.map.get_mut() {
+            map.insert(key.clone(), self.vec.len());
+        }
         self.vec.push((key, value));
     }
 
@@ -39,22 +43,14 @@ where
         K: Borrow<Q> + PartialEq<Q>,
         Q: Hash + Eq,
     {
-        let mut map = self.map.borrow_mut();
-        if let Some(map) = map.as_ref() {
-            map.get(key).map(|&i| &self.vec[i].1)
-        } else {
-            let mut new_map = AHashMap::with_capacity(self.vec.len());
-            let mut value = None;
-            // reverse here so the last value is the one that's returned
-            for (index, (k, v)) in self.vec.iter().enumerate().rev() {
-                if value.is_none() && k == key {
-                    value = Some(v);
-                }
-                new_map.insert(k.clone(), index);
-            }
-            *map = Some(new_map);
-            value
-        }
+        let map = self.map.get_or_init(|| {
+            self.vec
+                .iter()
+                .enumerate()
+                .map(|(index, (key, _))| (key.clone(), index))
+                .collect()
+        });
+        map.get(key).map(|&i| &self.vec[i].1)
     }
 
     pub fn keys(&self) -> impl Iterator<Item = &K> {
diff --git a/src/validators/function.rs b/src/validators/function.rs
index 8f9b25d70..fa8a0673b 100644
--- a/src/validators/function.rs
+++ b/src/validators/function.rs
@@ -504,7 +504,7 @@ pub fn convert_err<'a>(py: Python<'a>, err: PyErr, input: &'a impl Input<'a>) ->
         } else if let Ok(pydantic_error_type) = err.value(py).extract::<PydanticKnownError>() {
             pydantic_error_type.into_val_error(input)
         } else if let Ok(validation_error) = err.value(py).extract::<ValidationError>() {
-            validation_error.into_py(py)
+            validation_error.into_val_error(py)
         } else {
             py_err_string!(err.value(py), ValueError, input)
         }
diff --git a/src/validators/generator.rs b/src/validators/generator.rs
index 698504a83..1047e31bd 100644
--- a/src/validators/generator.rs
+++ b/src/validators/generator.rs
@@ -127,14 +127,14 @@ impl ValidatorIterator {
                         Some(validator) => {
                             if let Some(max_length) = max_length {
                                 if index >= max_length {
-                                    let val_error = ValError::new(
+                                    let val_error = ValError::new_custom_input(
                                         ErrorType::TooLong {
                                             field_type: "Generator".to_string(),
                                             max_length,
                                             actual_length: index + 1,
                                             context: None,
                                         },
-                                        $iter.input(py),
+                                        $iter.input_as_error_value(py),
                                     );
                                     return Err(ValidationError::from_val_error(
                                         py,
@@ -153,14 +153,14 @@ impl ValidatorIterator {
                     None => {
                         if let Some(min_length) = min_length {
                             if $iter.index() < min_length {
-                                let val_error = ValError::new(
+                                let val_error = ValError::new_custom_input(
                                     ErrorType::TooShort {
                                         field_type: "Generator".to_string(),
                                         min_length,
                                         actual_length: $iter.index(),
                                         context: None,
                                     },
-                                    $iter.input(py),
+                                    $iter.input_as_error_value(py),
                                 );
                                 return Err(ValidationError::from_val_error(
                                     py,
diff --git a/src/validators/json.rs b/src/validators/json.rs
index f99ac29ae..5eda007be 100644
--- a/src/validators/json.rs
+++ b/src/validators/json.rs
@@ -55,7 +55,7 @@ impl Validator for JsonValidator {
         match self.validator {
             Some(ref validator) => match validator.validate(py, &json_value, state) {
                 Ok(v) => Ok(v),
-                Err(err) => Err(err.duplicate(py)),
+                Err(err) => Err(err.into_owned(py)),
             },
             None => Ok(json_value.to_object(py)),
         }

From 6e9c6ebf50935236677a1c0999fafc3e949d818e Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Sun, 17 Sep 2023 08:12:53 +0200
Subject: [PATCH 026/550] Bump actions/checkout from 3 to 4 (#958)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/ci.yml       | 32 ++++++++++++++++----------------
 .github/workflows/codspeed.yml |  2 +-
 2 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 9d784a79c..0b54ac0d8 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -16,7 +16,7 @@ jobs:
     runs-on: ubuntu-20.04
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: install rust nightly
         uses: dtolnay/rust-toolchain@nightly
@@ -79,7 +79,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: install rust stable
         uses: dtolnay/rust-toolchain@stable
@@ -116,7 +116,7 @@ jobs:
 
     runs-on: ${{ matrix.os }}-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: install rust stable
         uses: dtolnay/rust-toolchain@stable
@@ -156,7 +156,7 @@ jobs:
           - 'pypy3.10'
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - name: set up python
         uses: actions/setup-python@v4
         with:
@@ -181,12 +181,12 @@ jobs:
     continue-on-error: true
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           repository: pydantic/pydantic
           path: pydantic
 
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
         with:
           path: pydantic-core
 
@@ -221,7 +221,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: install rust stable
         uses: dtolnay/rust-toolchain@stable
@@ -269,7 +269,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: install rust nightly
         uses: dtolnay/rust-toolchain@nightly
@@ -288,7 +288,7 @@ jobs:
   build-wasm-emscripten:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: set up python
         id: setup-python
@@ -351,7 +351,7 @@ jobs:
     name: build sdist
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
       - uses: PyO3/maturin-action@v1
         with:
           command: sdist
@@ -432,7 +432,7 @@ jobs:
 
     runs-on: ${{ matrix.os }}-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: set up python
         uses: actions/setup-python@v4
@@ -485,7 +485,7 @@ jobs:
 
     runs-on: ${{ matrix.os }}-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: set up python
         uses: actions/setup-python@v4
@@ -559,7 +559,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: get dist artifacts
         uses: actions/download-artifact@v3
@@ -599,7 +599,7 @@ jobs:
             distro: alpine_latest
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: get dist artifacts
         uses: actions/download-artifact@v3
@@ -646,7 +646,7 @@ jobs:
 
     runs-on: ${{ matrix.os }}-latest
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: set up python
         uses: actions/setup-python@v4
@@ -670,7 +670,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - name: set up python
         uses: actions/setup-python@v4
diff --git a/.github/workflows/codspeed.yml b/.github/workflows/codspeed.yml
index 2150ec79b..32bc83a1e 100644
--- a/.github/workflows/codspeed.yml
+++ b/.github/workflows/codspeed.yml
@@ -14,7 +14,7 @@ jobs:
     runs-on: ubuntu-latest
 
     steps:
-      - uses: actions/checkout@v3
+      - uses: actions/checkout@v4
 
       - uses: actions/setup-python@v4
         with:

From 03cecdd54fd1f3ad770944efe9991499f71042d1 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Sun, 17 Sep 2023 08:14:23 +0200
Subject: [PATCH 027/550] Bump pytest from 7.4.1 to 7.4.2 (#956)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements.txt b/tests/requirements.txt
index aad4fd52c..6ea2d16cf 100644
--- a/tests/requirements.txt
+++ b/tests/requirements.txt
@@ -3,7 +3,7 @@ dirty-equals==0.6.0
 hypothesis==6.79.4
 # pandas doesn't offer prebuilt wheels for all versions and platforms we test in CI e.g. aarch64 musllinux
 pandas==2.0.3; python_version >= "3.9" and python_version < "3.12" and implementation_name == "cpython" and platform_machine == 'x86_64'
-pytest==7.4.1
+pytest==7.4.2
 # we run codspeed benchmarks on x86_64 CPython (i.e. native github actions architecture)
 pytest-codspeed~=2.1.0; implementation_name == "cpython" and platform_machine == 'x86_64'
 pytest-examples==0.0.10

From ba3c502c681951fce325a2537c59616a2f4b8f33 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Sun, 17 Sep 2023 08:14:39 +0200
Subject: [PATCH 028/550] Bump griffe from 0.36.1 to 0.36.2 (#954)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index 6faa2c2d2..8e7b5c66c 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,5 +1,5 @@
 black==23.7.0
-griffe==0.36.1
+griffe==0.36.2
 pyright==1.1.325
 ruff==0.0.287
 mypy==1.5.1

From 1c79f979c6826bffca5ffe5c1f0ee22ea8ea4b11 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Sun, 17 Sep 2023 08:16:12 +0200
Subject: [PATCH 029/550] Bump serde_json from 1.0.105 to 1.0.106 (#951)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 4e38d8cf7..ff04e484d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -422,9 +422,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.105"
+version = "1.0.106"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "693151e1ac27563d6dbcec9dee9fbd5da8539b20fa14ad3752b2e6d363ace360"
+checksum = "2cc66a619ed80bf7a0f6b17dd063a84b88f6dea1813737cf469aef1d081142c2"
 dependencies = [
  "indexmap",
  "itoa",
diff --git a/Cargo.toml b/Cargo.toml
index 3f5b25e7f..0ab2d81bc 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -30,7 +30,7 @@ pyo3 = { version = "0.19.2", features = ["generate-import-lib", "num-bigint"] }
 regex = "1.9.5"
 strum = { version = "0.25.0", features = ["derive"] }
 strum_macros = "0.25.2"
-serde_json = {version = "1.0.105", features = ["arbitrary_precision", "preserve_order"]}
+serde_json = {version = "1.0.106", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.8"
 serde = { version = "1.0.188", features = ["derive"] }
 speedate = "0.12.0"

From 5edddd5060919fa83d03ee33d6b4749e070feb83 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Sun, 17 Sep 2023 08:16:43 +0200
Subject: [PATCH 030/550] Bump base64 from 0.21.3 to 0.21.4 (#952)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index ff04e484d..4c8b1d58f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -31,9 +31,9 @@ checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
 
 [[package]]
 name = "base64"
-version = "0.21.3"
+version = "0.21.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "414dcefbc63d77c526a76b3afcf6fbb9b5e2791c19c3aa2297733208750c6e53"
+checksum = "9ba43ea6f343b788c8764558649e08df62f86c6ef251fdaeb1ffd010a9ae50a2"
 
 [[package]]
 name = "bitflags"
diff --git a/Cargo.toml b/Cargo.toml
index 0ab2d81bc..3c7e18d4f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -39,7 +39,7 @@ ahash = "0.8.0"
 url = "2.4.1"
 # idna is already required by url, added here to be explicit
 idna = "0.4.0"
-base64 = "0.21.3"
+base64 = "0.21.4"
 num-bigint = "0.4.4"
 python3-dll-a = "0.2.7"
 uuid = "1.4.1"

From 3dfecd70d1c5612742f197b0d436bcf780840f22 Mon Sep 17 00:00:00 2001
From: David Hewitt <1939362+davidhewitt@users.noreply.github.com>
Date: Mon, 18 Sep 2023 10:14:40 +0100
Subject: [PATCH 031/550] update to coverage_attribute feature (#966)

---
 build.rs                    |  4 +--
 src/build_tools.rs          |  2 +-
 src/input/input_abstract.rs | 30 ++++++++++----------
 src/input/input_json.rs     | 56 ++++++++++++++++++-------------------
 src/input/parse_json.rs     | 10 +++----
 src/lib.rs                  |  2 +-
 src/tools.rs                |  2 +-
 7 files changed, 53 insertions(+), 53 deletions(-)

diff --git a/build.rs b/build.rs
index d27cc3b63..7f59e1f57 100644
--- a/build.rs
+++ b/build.rs
@@ -32,8 +32,8 @@ fn generate_self_schema() {
 
 fn main() {
     pyo3_build_config::use_pyo3_cfgs();
-    if let Some(true) = version_check::supports_feature("no_coverage") {
-        println!("cargo:rustc-cfg=has_no_coverage");
+    if let Some(true) = version_check::supports_feature("coverage_attribute") {
+        println!("cargo:rustc-cfg=has_coverage_attribute");
     }
     generate_self_schema();
     println!("cargo:rustc-env=PROFILE={}", std::env::var("PROFILE").unwrap());
diff --git a/src/build_tools.rs b/src/build_tools.rs
index 0c8abdf6d..d2bc7c2cd 100644
--- a/src/build_tools.rs
+++ b/src/build_tools.rs
@@ -67,7 +67,7 @@ impl fmt::Display for SchemaError {
 }
 
 impl Error for SchemaError {
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn source(&self) -> Option<&(dyn Error + 'static)> {
         None
     }
diff --git a/src/input/input_abstract.rs b/src/input/input_abstract.rs
index 3e780237b..d799da473 100644
--- a/src/input/input_abstract.rs
+++ b/src/input/input_abstract.rs
@@ -80,7 +80,7 @@ pub trait Input<'a>: fmt::Debug + ToPyObject {
         }
     }
     fn strict_str(&'a self) -> ValResult<EitherString<'a>>;
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn lax_str(&'a self) -> ValResult<EitherString<'a>> {
         self.strict_str()
     }
@@ -93,7 +93,7 @@ pub trait Input<'a>: fmt::Debug + ToPyObject {
         }
     }
     fn strict_bytes(&'a self) -> ValResult<EitherBytes<'a>>;
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn lax_bytes(&'a self) -> ValResult<EitherBytes<'a>> {
         self.strict_bytes()
     }
@@ -106,7 +106,7 @@ pub trait Input<'a>: fmt::Debug + ToPyObject {
         }
     }
     fn strict_bool(&self) -> ValResult<bool>;
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn lax_bool(&self) -> ValResult<bool> {
         self.strict_bool()
     }
@@ -119,7 +119,7 @@ pub trait Input<'a>: fmt::Debug + ToPyObject {
         }
     }
     fn strict_int(&'a self) -> ValResult<EitherInt<'a>>;
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn lax_int(&'a self) -> ValResult<EitherInt<'a>> {
         self.strict_int()
     }
@@ -147,7 +147,7 @@ pub trait Input<'a>: fmt::Debug + ToPyObject {
     }
     fn ultra_strict_float(&'a self) -> ValResult<EitherFloat<'a>>;
     fn strict_float(&'a self) -> ValResult<EitherFloat<'a>>;
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn lax_float(&'a self) -> ValResult<EitherFloat<'a>> {
         self.strict_float()
     }
@@ -160,7 +160,7 @@ pub trait Input<'a>: fmt::Debug + ToPyObject {
         }
     }
     fn strict_decimal(&'a self, py: Python<'a>) -> ValResult<&'a PyAny>;
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn lax_decimal(&'a self, py: Python<'a>) -> ValResult<&'a PyAny> {
         self.strict_decimal(py)
     }
@@ -173,7 +173,7 @@ pub trait Input<'a>: fmt::Debug + ToPyObject {
         }
     }
     fn strict_dict(&'a self) -> ValResult<GenericMapping<'a>>;
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn lax_dict(&'a self) -> ValResult<GenericMapping<'a>> {
         self.strict_dict()
     }
@@ -190,7 +190,7 @@ pub trait Input<'a>: fmt::Debug + ToPyObject {
         }
     }
     fn strict_list(&'a self) -> ValResult<GenericIterable<'a>>;
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn lax_list(&'a self) -> ValResult<GenericIterable<'a>> {
         self.strict_list()
     }
@@ -203,7 +203,7 @@ pub trait Input<'a>: fmt::Debug + ToPyObject {
         }
     }
     fn strict_tuple(&'a self) -> ValResult<GenericIterable<'a>>;
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn lax_tuple(&'a self) -> ValResult<GenericIterable<'a>> {
         self.strict_tuple()
     }
@@ -216,7 +216,7 @@ pub trait Input<'a>: fmt::Debug + ToPyObject {
         }
     }
     fn strict_set(&'a self) -> ValResult<GenericIterable<'a>>;
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn lax_set(&'a self) -> ValResult<GenericIterable<'a>> {
         self.strict_set()
     }
@@ -229,7 +229,7 @@ pub trait Input<'a>: fmt::Debug + ToPyObject {
         }
     }
     fn strict_frozenset(&'a self) -> ValResult<GenericIterable<'a>>;
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn lax_frozenset(&'a self) -> ValResult<GenericIterable<'a>> {
         self.strict_frozenset()
     }
@@ -246,7 +246,7 @@ pub trait Input<'a>: fmt::Debug + ToPyObject {
         }
     }
     fn strict_date(&self) -> ValResult<EitherDate>;
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn lax_date(&self) -> ValResult<EitherDate> {
         self.strict_date()
     }
@@ -266,7 +266,7 @@ pub trait Input<'a>: fmt::Debug + ToPyObject {
         &self,
         microseconds_overflow_behavior: speedate::MicrosecondsPrecisionOverflowBehavior,
     ) -> ValResult<EitherTime>;
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn lax_time(
         &self,
         microseconds_overflow_behavior: speedate::MicrosecondsPrecisionOverflowBehavior,
@@ -289,7 +289,7 @@ pub trait Input<'a>: fmt::Debug + ToPyObject {
         &self,
         microseconds_overflow_behavior: speedate::MicrosecondsPrecisionOverflowBehavior,
     ) -> ValResult<EitherDateTime>;
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn lax_datetime(
         &self,
         microseconds_overflow_behavior: speedate::MicrosecondsPrecisionOverflowBehavior,
@@ -312,7 +312,7 @@ pub trait Input<'a>: fmt::Debug + ToPyObject {
         &self,
         microseconds_overflow_behavior: speedate::MicrosecondsPrecisionOverflowBehavior,
     ) -> ValResult<EitherTimedelta>;
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn lax_timedelta(
         &self,
         microseconds_overflow_behavior: speedate::MicrosecondsPrecisionOverflowBehavior,
diff --git a/src/input/input_json.rs b/src/input/input_json.rs
index d9cb81fe2..d948e2493 100644
--- a/src/input/input_json.rs
+++ b/src/input/input_json.rs
@@ -21,7 +21,7 @@ use super::{
 
 impl<'a> Input<'a> for JsonInput {
     /// This is required by since JSON object keys are always strings, I don't think it can be called
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn as_loc_item(&self) -> LocItem {
         match self {
             JsonInput::Int(i) => (*i).into(),
@@ -102,7 +102,7 @@ impl<'a> Input<'a> for JsonInput {
             _ => Err(ValError::new(ErrorTypeDefaults::BytesType, self)),
         }
     }
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn strict_bytes(&'a self) -> ValResult<EitherBytes<'a>> {
         self.validate_bytes(false)
     }
@@ -196,7 +196,7 @@ impl<'a> Input<'a> for JsonInput {
             _ => Err(ValError::new(ErrorTypeDefaults::DictType, self)),
         }
     }
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn strict_dict(&'a self) -> ValResult<GenericMapping<'a>> {
         self.validate_dict(false)
     }
@@ -207,7 +207,7 @@ impl<'a> Input<'a> for JsonInput {
             _ => Err(ValError::new(ErrorTypeDefaults::ListType, self)),
         }
     }
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn strict_list(&'a self) -> ValResult<GenericIterable<'a>> {
         self.validate_list(false)
     }
@@ -219,7 +219,7 @@ impl<'a> Input<'a> for JsonInput {
             _ => Err(ValError::new(ErrorTypeDefaults::TupleType, self)),
         }
     }
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn strict_tuple(&'a self) -> ValResult<GenericIterable<'a>> {
         self.validate_tuple(false)
     }
@@ -231,7 +231,7 @@ impl<'a> Input<'a> for JsonInput {
             _ => Err(ValError::new(ErrorTypeDefaults::SetType, self)),
         }
     }
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn strict_set(&'a self) -> ValResult<GenericIterable<'a>> {
         self.validate_set(false)
     }
@@ -243,7 +243,7 @@ impl<'a> Input<'a> for JsonInput {
             _ => Err(ValError::new(ErrorTypeDefaults::FrozenSetType, self)),
         }
     }
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn strict_frozenset(&'a self) -> ValResult<GenericIterable<'a>> {
         self.validate_frozenset(false)
     }
@@ -278,7 +278,7 @@ impl<'a> Input<'a> for JsonInput {
     }
     // 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)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn strict_date(&self) -> ValResult<EitherDate> {
         self.validate_date(false)
     }
@@ -365,7 +365,7 @@ impl<'a> Input<'a> for String {
         InputValue::String(self)
     }
 
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn is_none(&self) -> bool {
         false
     }
@@ -374,12 +374,12 @@ impl<'a> Input<'a> for String {
         None
     }
 
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn validate_args(&'a self) -> ValResult<'a, GenericArguments<'a>> {
         Err(ValError::new(ErrorTypeDefaults::ArgumentsType, self))
     }
 
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn validate_dataclass_args(&'a self, class_name: &str) -> ValResult<'a, GenericArguments<'a>> {
         let class_name = class_name.to_string();
         Err(ValError::new(
@@ -405,7 +405,7 @@ impl<'a> Input<'a> for String {
     fn validate_bytes(&'a self, _strict: bool) -> ValResult<EitherBytes<'a>> {
         Ok(self.as_bytes().into())
     }
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn strict_bytes(&'a self) -> ValResult<EitherBytes<'a>> {
         self.validate_bytes(false)
     }
@@ -427,11 +427,11 @@ impl<'a> Input<'a> for String {
         }
     }
 
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn ultra_strict_float(&'a self) -> ValResult<EitherFloat<'a>> {
         self.strict_float()
     }
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn strict_float(&'a self) -> ValResult<EitherFloat<'a>> {
         Err(ValError::new(ErrorTypeDefaults::FloatType, self))
     }
@@ -443,47 +443,47 @@ impl<'a> Input<'a> for String {
         create_decimal(self.to_object(py).into_ref(py), self, py)
     }
 
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn validate_dict(&'a self, _strict: bool) -> ValResult<GenericMapping<'a>> {
         Err(ValError::new(ErrorTypeDefaults::DictType, self))
     }
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn strict_dict(&'a self) -> ValResult<GenericMapping<'a>> {
         self.validate_dict(false)
     }
 
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn validate_list(&'a self, _strict: bool) -> ValResult<GenericIterable<'a>> {
         Err(ValError::new(ErrorTypeDefaults::ListType, self))
     }
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn strict_list(&'a self) -> ValResult<GenericIterable<'a>> {
         self.validate_list(false)
     }
 
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn validate_tuple(&'a self, _strict: bool) -> ValResult<GenericIterable<'a>> {
         Err(ValError::new(ErrorTypeDefaults::TupleType, self))
     }
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn strict_tuple(&'a self) -> ValResult<GenericIterable<'a>> {
         self.validate_tuple(false)
     }
 
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn validate_set(&'a self, _strict: bool) -> ValResult<GenericIterable<'a>> {
         Err(ValError::new(ErrorTypeDefaults::SetType, self))
     }
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn strict_set(&'a self) -> ValResult<GenericIterable<'a>> {
         self.validate_set(false)
     }
 
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn validate_frozenset(&'a self, _strict: bool) -> ValResult<GenericIterable<'a>> {
         Err(ValError::new(ErrorTypeDefaults::FrozenSetType, self))
     }
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn strict_frozenset(&'a self) -> ValResult<GenericIterable<'a>> {
         self.validate_frozenset(false)
     }
@@ -499,7 +499,7 @@ impl<'a> Input<'a> for String {
     fn validate_date(&self, _strict: bool) -> ValResult<EitherDate> {
         bytes_as_date(self, self.as_bytes())
     }
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn strict_date(&self) -> ValResult<EitherDate> {
         self.validate_date(false)
     }
@@ -511,7 +511,7 @@ impl<'a> Input<'a> for String {
     ) -> ValResult<EitherTime> {
         bytes_as_time(self, self.as_bytes(), microseconds_overflow_behavior)
     }
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn strict_time(
         &self,
         microseconds_overflow_behavior: speedate::MicrosecondsPrecisionOverflowBehavior,
@@ -526,7 +526,7 @@ impl<'a> Input<'a> for String {
     ) -> ValResult<EitherDateTime> {
         bytes_as_datetime(self, self.as_bytes(), microseconds_overflow_behavior)
     }
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn strict_datetime(
         &self,
         microseconds_overflow_behavior: speedate::MicrosecondsPrecisionOverflowBehavior,
@@ -541,7 +541,7 @@ impl<'a> Input<'a> for String {
     ) -> ValResult<EitherTimedelta> {
         bytes_as_timedelta(self, self.as_bytes(), microseconds_overflow_behavior)
     }
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn strict_timedelta(
         &self,
         microseconds_overflow_behavior: speedate::MicrosecondsPrecisionOverflowBehavior,
diff --git a/src/input/parse_json.rs b/src/input/parse_json.rs
index 7603eaf67..20a107669 100644
--- a/src/input/parse_json.rs
+++ b/src/input/parse_json.rs
@@ -57,7 +57,7 @@ impl<'de> Deserialize<'de> for JsonInput {
         impl<'de> Visitor<'de> for JsonVisitor {
             type Value = JsonInput;
 
-            #[cfg_attr(has_no_coverage, no_coverage)]
+            #[cfg_attr(has_coverage_attribute, coverage(off))]
             fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
                 formatter.write_str("any valid JSON value")
             }
@@ -92,12 +92,12 @@ impl<'de> Deserialize<'de> for JsonInput {
                 Ok(JsonInput::String(value))
             }
 
-            #[cfg_attr(has_no_coverage, no_coverage)]
+            #[cfg_attr(has_coverage_attribute, coverage(off))]
             fn visit_none<E>(self) -> Result<JsonInput, E> {
                 unreachable!()
             }
 
-            #[cfg_attr(has_no_coverage, no_coverage)]
+            #[cfg_attr(has_coverage_attribute, coverage(off))]
             fn visit_some<D>(self, _: D) -> Result<JsonInput, D::Error>
             where
                 D: serde::Deserializer<'de>,
@@ -200,7 +200,7 @@ impl<'de> DeserializeSeed<'de> for KeyDeserializer {
 impl<'de> Visitor<'de> for KeyDeserializer {
     type Value = String;
 
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
         formatter.write_str("a string key")
     }
@@ -212,7 +212,7 @@ impl<'de> Visitor<'de> for KeyDeserializer {
         Ok(s.to_string())
     }
 
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn visit_string<E>(self, _: String) -> Result<Self::Value, E>
     where
         E: serde::de::Error,
diff --git a/src/lib.rs b/src/lib.rs
index 56efbc87f..cbf668b9d 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,4 +1,4 @@
-#![cfg_attr(has_no_coverage, feature(no_coverage))]
+#![cfg_attr(has_coverage_attribute, feature(coverage_attribute))]
 
 extern crate core;
 
diff --git a/src/tools.rs b/src/tools.rs
index 71f7ad60e..3c75decf1 100644
--- a/src/tools.rs
+++ b/src/tools.rs
@@ -48,7 +48,7 @@ impl<'py> SchemaDict<'py> for Option<&PyDict> {
         }
     }
 
-    #[cfg_attr(has_no_coverage, no_coverage)]
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn get_as_req<T>(&'py self, key: &PyString) -> PyResult<T>
     where
         T: FromPyObject<'py>,

From 502fb9adfa96208236f0002b9e2d2cea8c7dd3d9 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 18 Sep 2023 09:21:56 +0000
Subject: [PATCH 032/550] Update pytest-codspeed requirement from ~=2.1.0 to
 ~=2.2.0 (#953)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements.txt b/tests/requirements.txt
index 6ea2d16cf..ce5cc9f23 100644
--- a/tests/requirements.txt
+++ b/tests/requirements.txt
@@ -5,7 +5,7 @@ hypothesis==6.79.4
 pandas==2.0.3; python_version >= "3.9" and python_version < "3.12" and implementation_name == "cpython" and platform_machine == 'x86_64'
 pytest==7.4.2
 # we run codspeed benchmarks on x86_64 CPython (i.e. native github actions architecture)
-pytest-codspeed~=2.1.0; implementation_name == "cpython" and platform_machine == 'x86_64'
+pytest-codspeed~=2.2.0; implementation_name == "cpython" and platform_machine == 'x86_64'
 pytest-examples==0.0.10
 pytest-speed==0.3.5
 pytest-mock==3.11.1

From e8015318b9f5ff64a0672f84bc51231a9438f307 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 18 Sep 2023 10:34:32 +0100
Subject: [PATCH 033/550] Bump black from 23.7.0 to 23.9.1 (#955)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index 8e7b5c66c..561e352fa 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,4 +1,4 @@
-black==23.7.0
+black==23.9.1
 griffe==0.36.2
 pyright==1.1.325
 ruff==0.0.287

From 245381f981ca3e2b146886e0ffc8011540ba7f6d Mon Sep 17 00:00:00 2001
From: zakstucke <44890343+zakstucke@users.noreply.github.com>
Date: Mon, 18 Sep 2023 12:23:55 +0200
Subject: [PATCH 034/550] Implementation of __cause__ for ValidationError using
 ExceptionGroups (#780)

---
 python/pydantic_core/core_schema.py |   3 +
 src/errors/validation_exception.rs  | 101 ++++++++++++-
 src/validators/function.rs          |  18 ++-
 src/validators/generator.rs         |  29 +++-
 src/validators/mod.rs               |   5 +
 tests/requirements.txt              |   1 +
 tests/test_errors.py                | 210 ++++++++++++++++++++++++++++
 7 files changed, 355 insertions(+), 12 deletions(-)

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index 74442b44c..0b4348e81 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -61,6 +61,8 @@ class CoreConfig(TypedDict, total=False):
         ser_json_timedelta: The serialization option for `timedelta` values. Default is 'iso8601'.
         ser_json_bytes: The serialization option for `bytes` values. Default is 'utf8'.
         hide_input_in_errors: Whether to hide input data from `ValidationError` representation.
+        validation_error_cause: Whether to add user-python excs to the __cause__ of a ValidationError.
+            Requires exceptiongroup backport pre Python 3.11.
     """
 
     title: str
@@ -92,6 +94,7 @@ class CoreConfig(TypedDict, total=False):
     ser_json_bytes: Literal['utf8', 'base64']  # default: 'utf8'
     # used to hide input data from ValidationError repr
     hide_input_in_errors: bool
+    validation_error_cause: bool  # default: False
 
 
 IncExCall: TypeAlias = 'set[int | str] | dict[int | str, IncExCall] | None'
diff --git a/src/errors/validation_exception.rs b/src/errors/validation_exception.rs
index 9dde6551c..e6563f597 100644
--- a/src/errors/validation_exception.rs
+++ b/src/errors/validation_exception.rs
@@ -3,10 +3,11 @@ use std::fmt::{Display, Write};
 use std::str::from_utf8;
 
 use pyo3::exceptions::{PyKeyError, PyTypeError, PyValueError};
-use pyo3::intern;
+use pyo3::ffi;
 use pyo3::once_cell::GILOnceCell;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList, PyString};
+use pyo3::{intern, AsPyPointer};
 use serde::ser::{Error, SerializeMap, SerializeSeq};
 use serde::{Serialize, Serializer};
 
@@ -51,6 +52,7 @@ impl ValidationError {
         error: ValError,
         outer_location: Option<LocItem>,
         hide_input: bool,
+        validation_error_cause: bool,
     ) -> PyErr {
         match error {
             ValError::LineErrors(raw_errors) => {
@@ -61,9 +63,19 @@ impl ValidationError {
                         .collect(),
                     None => raw_errors.into_iter().map(|e| e.into_py(py)).collect(),
                 };
+
                 let validation_error = Self::new(line_errors, title, error_mode, hide_input);
+
                 match Py::new(py, validation_error) {
-                    Ok(err) => PyErr::from_value(err.into_ref(py)),
+                    Ok(err) => {
+                        if validation_error_cause {
+                            // Will return an import error if the backport was needed and not installed:
+                            if let Some(cause_problem) = ValidationError::maybe_add_cause(err.borrow(py), py) {
+                                return cause_problem;
+                            }
+                        }
+                        PyErr::from_value(err.as_ref(py))
+                    }
                     Err(err) => err,
                 }
             }
@@ -93,6 +105,91 @@ impl ValidationError {
     pub fn use_default_error() -> PyErr {
         py_schema_error_type!("Uncaught UseDefault error, please check your usage of `default` validators.")
     }
+
+    fn maybe_add_cause(self_: PyRef<'_, Self>, py: Python) -> Option<PyErr> {
+        let mut user_py_errs = vec![];
+        for line_error in &self_.line_errors {
+            if let ErrorType::AssertionError {
+                error: Some(err),
+                context: _,
+            }
+            | ErrorType::ValueError {
+                error: Some(err),
+                context: _,
+            } = &line_error.error_type
+            {
+                let note: PyObject = if let Location::Empty = &line_error.location {
+                    "Pydantic: cause of loc: root".into_py(py)
+                } else {
+                    format!(
+                        "Pydantic: cause of loc: {}",
+                        // Location formats with a newline at the end, hence the trim()
+                        line_error.location.to_string().trim()
+                    )
+                    .into_py(py)
+                };
+
+                // Notes only support 3.11 upwards:
+                #[cfg(Py_3_11)]
+                {
+                    // Add the location context as a note, no direct c api for this,
+                    // fine performance wise, add_note() goes directly to C: "(PyCFunction)BaseException_add_note":
+                    // https://github.com/python/cpython/blob/main/Objects/exceptions.c
+                    if err.call_method1(py, "add_note", (format!("\n{note}"),)).is_ok() {
+                        user_py_errs.push(err.clone_ref(py));
+                    }
+                }
+
+                // Pre 3.11 notes support, use a UserWarning exception instead:
+                #[cfg(not(Py_3_11))]
+                {
+                    use pyo3::exceptions::PyUserWarning;
+
+                    let wrapped = PyUserWarning::new_err((note,));
+                    wrapped.set_cause(py, Some(PyErr::from_value(err.as_ref(py))));
+                    user_py_errs.push(wrapped);
+                }
+            }
+        }
+
+        // Only add the cause if there are actually python user exceptions to show:
+        if !user_py_errs.is_empty() {
+            let title = "Pydantic User Code Exceptions";
+
+            // Native ExceptionGroup(s) only supported 3.11 and later:
+            #[cfg(Py_3_11)]
+            let cause = {
+                use pyo3::exceptions::PyBaseExceptionGroup;
+                Some(PyBaseExceptionGroup::new_err((title, user_py_errs)).into_py(py))
+            };
+
+            // Pre 3.11 ExceptionGroup support, use the python backport instead:
+            // If something's gone wrong with the backport, just don't add the cause:
+            #[cfg(not(Py_3_11))]
+            let cause = {
+                use pyo3::exceptions::PyImportError;
+                match py.import("exceptiongroup") {
+                Ok(py_mod) => match py_mod.getattr("ExceptionGroup") {
+                    Ok(group_cls) => match group_cls.call1((title, user_py_errs)) {
+                        Ok(group_instance) => Some(group_instance.into_py(py)),
+                        Err(_) => None,
+                    },
+                    Err(_) => None,
+                },
+                Err(_) => return Some(PyImportError::new_err("validation_error_cause flag requires the exceptiongroup module backport to be installed when used on Python <3.11.")),
+            }
+            };
+
+            // Set the cause to the ValidationError:
+            if let Some(cause) = cause {
+                unsafe {
+                    // PyException_SetCause _steals_ a reference to cause, so must use .into_ptr()
+                    ffi::PyException_SetCause(self_.as_ptr(), cause.into_ptr());
+                }
+            }
+        }
+        None
+    }
 }
 
 static URL_ENV_VAR: GILOnceCell<bool> = GILOnceCell::new();
diff --git a/src/validators/function.rs b/src/validators/function.rs
index fa8a0673b..206e10a0c 100644
--- a/src/validators/function.rs
+++ b/src/validators/function.rs
@@ -288,6 +288,7 @@ pub struct FunctionWrapValidator {
     field_name: Option<Py<PyString>>,
     info_arg: bool,
     hide_input_in_errors: bool,
+    validation_error_cause: bool,
 }
 
 impl BuildValidator for FunctionWrapValidator {
@@ -302,6 +303,7 @@ impl BuildValidator for FunctionWrapValidator {
         let validator = build_validator(schema.get_as_req(intern!(py, "schema"))?, config, definitions)?;
         let function_info = destructure_function_schema(schema)?;
         let hide_input_in_errors: bool = config.get_as(intern!(py, "hide_input_in_errors"))?.unwrap_or(false);
+        let validation_error_cause: bool = config.get_as(intern!(py, "validation_error_cause"))?.unwrap_or(false);
         Ok(Self {
             validator: Box::new(validator),
             func: function_info.function.clone(),
@@ -313,6 +315,7 @@ impl BuildValidator for FunctionWrapValidator {
             field_name: function_info.field_name.clone(),
             info_arg: function_info.info_arg,
             hide_input_in_errors,
+            validation_error_cause,
         }
         .into())
     }
@@ -356,6 +359,7 @@ impl Validator for FunctionWrapValidator {
                 &self.validator,
                 state,
                 self.hide_input_in_errors,
+                self.validation_error_cause,
             ),
         };
         self._validate(
@@ -381,6 +385,7 @@ impl Validator for FunctionWrapValidator {
                 &self.validator,
                 state,
                 self.hide_input_in_errors,
+                self.validation_error_cause,
             ),
             updated_field_name: field_name.to_string(),
             updated_field_value: field_value.to_object(py),
@@ -478,12 +483,12 @@ impl AssignmentValidatorCallable {
 }
 
 macro_rules! py_err_string {
-    ($error_value:expr, $type_member:ident, $input:ident) => {
+    ($py:expr, $py_err:expr, $error_value:expr, $type_member:ident, $input:ident) => {
         match $error_value.str() {
             Ok(py_string) => match py_string.to_str() {
                 Ok(_) => ValError::new(
                     ErrorType::$type_member {
-                        error: Some($error_value.into()),
+                        error: Some($py_err.into_py($py)),
                         context: None,
                     },
                     $input,
@@ -499,17 +504,18 @@ macro_rules! py_err_string {
 /// as validation errors, `TypeError` is now considered as a runtime error to catch errors in function signatures
 pub fn convert_err<'a>(py: Python<'a>, err: PyErr, input: &'a impl Input<'a>) -> ValError<'a> {
     if err.is_instance_of::<PyValueError>(py) {
-        if let Ok(pydantic_value_error) = err.value(py).extract::<PydanticCustomError>() {
+        let error_value = err.value(py);
+        if let Ok(pydantic_value_error) = error_value.extract::<PydanticCustomError>() {
             pydantic_value_error.into_val_error(input)
-        } else if let Ok(pydantic_error_type) = err.value(py).extract::<PydanticKnownError>() {
+        } else if let Ok(pydantic_error_type) = error_value.extract::<PydanticKnownError>() {
             pydantic_error_type.into_val_error(input)
         } else if let Ok(validation_error) = err.value(py).extract::<ValidationError>() {
             validation_error.into_val_error(py)
         } else {
-            py_err_string!(err.value(py), ValueError, input)
+            py_err_string!(py, err, error_value, ValueError, input)
         }
     } else if err.is_instance_of::<PyAssertionError>(py) {
-        py_err_string!(err.value(py), AssertionError, input)
+        py_err_string!(py, err, err.value(py), AssertionError, input)
     } else if err.is_instance_of::<PydanticOmit>(py) {
         ValError::Omit
     } else if err.is_instance_of::<PydanticUseDefault>(py) {
diff --git a/src/validators/generator.rs b/src/validators/generator.rs
index 1047e31bd..c52910500 100644
--- a/src/validators/generator.rs
+++ b/src/validators/generator.rs
@@ -19,6 +19,7 @@ pub struct GeneratorValidator {
     max_length: Option<usize>,
     name: String,
     hide_input_in_errors: bool,
+    validation_error_cause: bool,
 }
 
 impl BuildValidator for GeneratorValidator {
@@ -37,12 +38,16 @@ impl BuildValidator for GeneratorValidator {
         let hide_input_in_errors: bool = config
             .get_as(pyo3::intern!(schema.py(), "hide_input_in_errors"))?
             .unwrap_or(false);
+        let validation_error_cause: bool = config
+            .get_as(pyo3::intern!(schema.py(), "validation_error_cause"))?
+            .unwrap_or(false);
         Ok(Self {
             item_validator,
             name,
             min_length: schema.get_as(pyo3::intern!(schema.py(), "min_length"))?,
             max_length: schema.get_as(pyo3::intern!(schema.py(), "max_length"))?,
             hide_input_in_errors,
+            validation_error_cause,
         }
         .into())
     }
@@ -58,10 +63,16 @@ impl Validator for GeneratorValidator {
         state: &mut ValidationState,
     ) -> ValResult<'data, PyObject> {
         let iterator = input.validate_iter()?;
-        let validator = self
-            .item_validator
-            .as_ref()
-            .map(|v| InternalValidator::new(py, "ValidatorIterator", v, state, self.hide_input_in_errors));
+        let validator = self.item_validator.as_ref().map(|v| {
+            InternalValidator::new(
+                py,
+                "ValidatorIterator",
+                v,
+                state,
+                self.hide_input_in_errors,
+                self.validation_error_cause,
+            )
+        });
 
         let v_iterator = ValidatorIterator {
             iterator,
@@ -69,6 +80,7 @@ impl Validator for GeneratorValidator {
             min_length: self.min_length,
             max_length: self.max_length,
             hide_input_in_errors: self.hide_input_in_errors,
+            validation_error_cause: self.validation_error_cause,
         };
         Ok(v_iterator.into_py(py))
     }
@@ -105,6 +117,7 @@ struct ValidatorIterator {
     min_length: Option<usize>,
     max_length: Option<usize>,
     hide_input_in_errors: bool,
+    validation_error_cause: bool,
 }
 
 #[pymethods]
@@ -117,6 +130,7 @@ impl ValidatorIterator {
         let min_length = slf.min_length;
         let max_length = slf.max_length;
         let hide_input_in_errors = slf.hide_input_in_errors;
+        let validation_error_cause = slf.validation_error_cause;
         let Self {
             validator, iterator, ..
         } = &mut *slf;
@@ -143,6 +157,7 @@ impl ValidatorIterator {
                                         val_error,
                                         None,
                                         hide_input_in_errors,
+                                        validation_error_cause,
                                     ));
                                 }
                             }
@@ -169,6 +184,7 @@ impl ValidatorIterator {
                                     val_error,
                                     None,
                                     hide_input_in_errors,
+                                    validation_error_cause,
                                 ));
                             }
                         }
@@ -217,6 +233,7 @@ pub struct InternalValidator {
     recursion_guard: RecursionGuard,
     validation_mode: InputType,
     hide_input_in_errors: bool,
+    validation_error_cause: bool,
 }
 
 impl fmt::Debug for InternalValidator {
@@ -232,6 +249,7 @@ impl InternalValidator {
         validator: &CombinedValidator,
         state: &ValidationState,
         hide_input_in_errors: bool,
+        validation_error_cause: bool,
     ) -> Self {
         let extra = state.extra();
         Self {
@@ -246,6 +264,7 @@ impl InternalValidator {
             recursion_guard: state.recursion_guard.clone(),
             validation_mode: extra.mode,
             hide_input_in_errors,
+            validation_error_cause,
         }
     }
 
@@ -277,6 +296,7 @@ impl InternalValidator {
                     e,
                     outer_location,
                     self.hide_input_in_errors,
+                    self.validation_error_cause,
                 )
             })
     }
@@ -305,6 +325,7 @@ impl InternalValidator {
                 e,
                 outer_location,
                 self.hide_input_in_errors,
+                self.validation_error_cause,
             )
         })
     }
diff --git a/src/validators/mod.rs b/src/validators/mod.rs
index 5824888ec..9a9c6a185 100644
--- a/src/validators/mod.rs
+++ b/src/validators/mod.rs
@@ -107,6 +107,7 @@ pub struct SchemaValidator {
     #[pyo3(get)]
     title: PyObject,
     hide_input_in_errors: bool,
+    validation_error_cause: bool,
 }
 
 #[pymethods]
@@ -133,12 +134,14 @@ impl SchemaValidator {
             None => validator.get_name().into_py(py),
         };
         let hide_input_in_errors: bool = config.get_as(intern!(py, "hide_input_in_errors"))?.unwrap_or(false);
+        let validation_error_cause: bool = config.get_as(intern!(py, "validation_error_cause"))?.unwrap_or(false);
         Ok(Self {
             validator,
             definitions,
             schema: schema.into_py(py),
             title,
             hide_input_in_errors,
+            validation_error_cause,
         })
     }
 
@@ -329,6 +332,7 @@ impl SchemaValidator {
             error,
             None,
             self.hide_input_in_errors,
+            self.validation_error_cause,
         )
     }
 }
@@ -385,6 +389,7 @@ impl<'py> SelfValidator<'py> {
             schema: py.None(),
             title: "Self Schema".into_py(py),
             hide_input_in_errors: false,
+            validation_error_cause: false,
         })
     }
 }
diff --git a/tests/requirements.txt b/tests/requirements.txt
index ce5cc9f23..ae8b9e50d 100644
--- a/tests/requirements.txt
+++ b/tests/requirements.txt
@@ -14,3 +14,4 @@ pytest-timeout==2.1.0
 pytz==2023.3.post1
 # numpy doesn't offer prebuilt wheels for all versions and platforms we test in CI e.g. aarch64 musllinux
 numpy==1.25.2; python_version >= "3.9" and python_version < "3.12" and implementation_name == "cpython" and platform_machine == 'x86_64'
+exceptiongroup==1.1; python_version < "3.11"
diff --git a/tests/test_errors.py b/tests/test_errors.py
index 881abd508..fe71b9860 100644
--- a/tests/test_errors.py
+++ b/tests/test_errors.py
@@ -1,11 +1,15 @@
+import enum
 import re
+import sys
 from decimal import Decimal
 from typing import Any, Optional
+from unittest.mock import patch
 
 import pytest
 from dirty_equals import HasRepr, IsInstance, IsJson, IsStr
 
 from pydantic_core import (
+    CoreConfig,
     PydanticCustomError,
     PydanticKnownError,
     PydanticOmit,
@@ -517,6 +521,212 @@ def test_all_errors():
         pytest.fail('core_schema.ErrorType needs to be updated')
 
 
+@pytest.mark.skipif(sys.version_info < (3, 11), reason='This is the modern version used post 3.10.')
+def test_validation_error_cause_contents():
+    enabled_config: CoreConfig = {'validation_error_cause': True}
+
+    def multi_raise_py_error(v: Any) -> Any:
+        try:
+            raise AssertionError('Wrong')
+        except AssertionError as e:
+            raise ValueError('Oh no!') from e
+
+    s2 = SchemaValidator(core_schema.no_info_plain_validator_function(multi_raise_py_error), config=enabled_config)
+    with pytest.raises(ValidationError) as exc_info:
+        s2.validate_python('anything')
+
+    cause_group = exc_info.value.__cause__
+    assert isinstance(cause_group, BaseExceptionGroup)
+    assert len(cause_group.exceptions) == 1
+
+    cause = cause_group.exceptions[0]
+    assert cause.__notes__
+    assert cause.__notes__[-1].startswith('\nPydantic: ')
+    assert repr(cause) == repr(ValueError('Oh no!'))
+    assert cause.__traceback__ is not None
+
+    sub_cause = cause.__cause__
+    assert repr(sub_cause) == repr(AssertionError('Wrong'))
+    assert sub_cause.__cause__ is None
+    assert sub_cause.__traceback__ is not None
+
+    # Edge case: make sure a deep inner ValidationError(s) causing a validator failure doesn't cause any problems:
+    def outer_raise_py_error(v: Any) -> Any:
+        try:
+            s2.validate_python('anything')
+        except ValidationError as e:
+            raise ValueError('Sub val failure') from e
+
+    s3 = SchemaValidator(core_schema.no_info_plain_validator_function(outer_raise_py_error), config=enabled_config)
+    with pytest.raises(ValidationError) as exc_info:
+        s3.validate_python('anything')
+
+    assert isinstance(exc_info.value.__cause__, BaseExceptionGroup)
+    assert len(exc_info.value.__cause__.exceptions) == 1
+    cause = exc_info.value.__cause__.exceptions[0]
+    assert cause.__notes__ and cause.__notes__[-1].startswith('\nPydantic: ')
+    assert repr(cause) == repr(ValueError('Sub val failure'))
+    subcause = cause.__cause__
+    assert isinstance(subcause, ValidationError)
+
+    cause_group = subcause.__cause__
+    assert isinstance(cause_group, BaseExceptionGroup)
+    assert len(cause_group.exceptions) == 1
+
+    cause = cause_group.exceptions[0]
+    assert cause.__notes__
+    assert cause.__notes__[-1].startswith('\nPydantic: ')
+    assert repr(cause) == repr(ValueError('Oh no!'))
+    assert cause.__traceback__ is not None
+
+    sub_cause = cause.__cause__
+    assert repr(sub_cause) == repr(AssertionError('Wrong'))
+    assert sub_cause.__cause__ is None
+    assert sub_cause.__traceback__ is not None
+
+
+@pytest.mark.skipif(sys.version_info >= (3, 11), reason='This is the backport/legacy version used pre 3.11 only.')
+def test_validation_error_cause_contents_legacy():
+    from exceptiongroup import BaseExceptionGroup
+
+    enabled_config: CoreConfig = {'validation_error_cause': True}
+
+    def multi_raise_py_error(v: Any) -> Any:
+        try:
+            raise AssertionError('Wrong')
+        except AssertionError as e:
+            raise ValueError('Oh no!') from e
+
+    s2 = SchemaValidator(core_schema.no_info_plain_validator_function(multi_raise_py_error), config=enabled_config)
+    with pytest.raises(ValidationError) as exc_info:
+        s2.validate_python('anything')
+
+    cause_group = exc_info.value.__cause__
+    assert isinstance(cause_group, BaseExceptionGroup)
+    assert len(cause_group.exceptions) == 1
+
+    cause = cause_group.exceptions[0]
+    assert repr(cause).startswith("UserWarning('Pydantic: ")
+
+    assert cause.__cause__ is not None
+    cause = cause.__cause__
+    assert repr(cause) == repr(ValueError('Oh no!'))
+    assert cause.__traceback__ is not None
+
+    sub_cause = cause.__cause__
+    assert repr(sub_cause) == repr(AssertionError('Wrong'))
+    assert sub_cause.__cause__ is None
+    assert sub_cause.__traceback__ is not None
+
+    # Make sure a deep inner ValidationError(s) causing a validator failure doesn't cause any problems:
+    def outer_raise_py_error(v: Any) -> Any:
+        try:
+            s2.validate_python('anything')
+        except ValidationError as e:
+            raise ValueError('Sub val failure') from e
+
+    s3 = SchemaValidator(core_schema.no_info_plain_validator_function(outer_raise_py_error), config=enabled_config)
+    with pytest.raises(ValidationError) as exc_info:
+        s3.validate_python('anything')
+
+    assert isinstance(exc_info.value.__cause__, BaseExceptionGroup)
+    assert len(exc_info.value.__cause__.exceptions) == 1
+    cause = exc_info.value.__cause__.exceptions[0]
+    assert repr(cause).startswith("UserWarning('Pydantic: ")
+    assert cause.__cause__ is not None
+    cause = cause.__cause__
+    assert repr(cause) == repr(ValueError('Sub val failure'))
+    subcause = cause.__cause__
+    assert isinstance(subcause, ValidationError)
+
+    cause_group = subcause.__cause__
+    assert isinstance(cause_group, BaseExceptionGroup)
+    assert len(cause_group.exceptions) == 1
+
+    cause = cause_group.exceptions[0]
+    assert repr(cause).startswith("UserWarning('Pydantic: ")
+    assert cause.__cause__ is not None
+    cause = cause.__cause__
+    assert repr(cause) == repr(ValueError('Oh no!'))
+    assert cause.__traceback__ is not None
+
+    sub_cause = cause.__cause__
+    assert repr(sub_cause) == repr(AssertionError('Wrong'))
+    assert sub_cause.__cause__ is None
+    assert sub_cause.__traceback__ is not None
+
+
+class CauseResult(enum.Enum):
+    CAUSE = enum.auto()
+    NO_CAUSE = enum.auto()
+    IMPORT_ERROR = enum.auto()
+
+
+@pytest.mark.parametrize(
+    'desc,config,expected_result',
+    [  # Without the backport should still work after 3.10 as not needed:
+        (
+            'Enabled',
+            {'validation_error_cause': True},
+            CauseResult.CAUSE if sys.version_info >= (3, 11) else CauseResult.IMPORT_ERROR,
+        ),
+        ('Disabled specifically', {'validation_error_cause': False}, CauseResult.NO_CAUSE),
+        ('Disabled implicitly', {}, CauseResult.NO_CAUSE),
+    ],
+)
+def test_validation_error_cause_config_variants(desc: str, config: CoreConfig, expected_result: CauseResult):
+    # Simulate the package being missing:
+    with patch.dict('sys.modules', {'exceptiongroup': None}):
+
+        def singular_raise_py_error(v: Any) -> Any:
+            raise ValueError('Oh no!')
+
+        s = SchemaValidator(core_schema.no_info_plain_validator_function(singular_raise_py_error), config=config)
+
+        if expected_result is CauseResult.IMPORT_ERROR:
+            # Confirm error message contains "requires the exceptiongroup module" in the middle of the string:
+            with pytest.raises(ImportError, match='requires the exceptiongroup module'):
+                s.validate_python('anything')
+        elif expected_result is CauseResult.CAUSE:
+            with pytest.raises(ValidationError) as exc_info:
+                s.validate_python('anything')
+            assert exc_info.value.__cause__ is not None
+            assert hasattr(exc_info.value.__cause__, 'exceptions')
+            assert len(exc_info.value.__cause__.exceptions) == 1
+            assert repr(exc_info.value.__cause__.exceptions[0]) == repr(ValueError('Oh no!'))
+        elif expected_result is CauseResult.NO_CAUSE:
+            with pytest.raises(ValidationError) as exc_info:
+                s.validate_python('anything')
+            assert exc_info.value.__cause__ is None
+        else:
+            raise AssertionError('Unhandled result: {}'.format(expected_result))
+
+
+def test_validation_error_cause_traceback_preserved():
+    """Makes sure historic bug of traceback being lost is fixed."""
+
+    enabled_config: CoreConfig = {'validation_error_cause': True}
+
+    def singular_raise_py_error(v: Any) -> Any:
+        raise ValueError('Oh no!')
+
+    s1 = SchemaValidator(core_schema.no_info_plain_validator_function(singular_raise_py_error), config=enabled_config)
+    with pytest.raises(ValidationError) as exc_info:
+        s1.validate_python('anything')
+
+    base_errs = getattr(exc_info.value.__cause__, 'exceptions', [])
+    assert len(base_errs) == 1
+    base_err = base_errs[0]
+
+    # Get to the root error:
+    cause = base_err
+    while cause.__cause__ is not None:
+        cause = cause.__cause__
+
+    # Should still have a traceback:
+    assert cause.__traceback__ is not None
+
+
 class BadRepr:
     def __repr__(self):
         raise RuntimeError('bad repr')

From e4eed14b7b8af6f71f3bce7b4ff2f3f034191d55 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 18 Sep 2023 13:03:32 +0100
Subject: [PATCH 035/550] Bump pyright from 1.1.325 to 1.1.327 (#970)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index 561e352fa..eb8321437 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,5 +1,5 @@
 black==23.9.1
 griffe==0.36.2
-pyright==1.1.325
+pyright==1.1.327
 ruff==0.0.287
 mypy==1.5.1

From a107c96a00f87154c4da2cf60d4ba9462a87339f Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 18 Sep 2023 12:07:28 +0000
Subject: [PATCH 036/550] Bump serde_json from 1.0.106 to 1.0.107 (#971)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 4c8b1d58f..2986812aa 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -422,9 +422,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.106"
+version = "1.0.107"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2cc66a619ed80bf7a0f6b17dd063a84b88f6dea1813737cf469aef1d081142c2"
+checksum = "6b420ce6e3d8bd882e9b243c6eed35dbc9a6110c9769e74b584e0d68d1f20c65"
 dependencies = [
  "indexmap",
  "itoa",
diff --git a/Cargo.toml b/Cargo.toml
index 3c7e18d4f..75fc7ae17 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -30,7 +30,7 @@ pyo3 = { version = "0.19.2", features = ["generate-import-lib", "num-bigint"] }
 regex = "1.9.5"
 strum = { version = "0.25.0", features = ["derive"] }
 strum_macros = "0.25.2"
-serde_json = {version = "1.0.106", features = ["arbitrary_precision", "preserve_order"]}
+serde_json = {version = "1.0.107", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.8"
 serde = { version = "1.0.188", features = ["derive"] }
 speedate = "0.12.0"

From 1d102381b04dd53e61665d84281161fc351ffbee Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 18 Sep 2023 12:10:10 +0000
Subject: [PATCH 037/550] Bump ruff from 0.0.287 to 0.0.290 (#968)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index eb8321437..ff8f85657 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,5 +1,5 @@
 black==23.9.1
 griffe==0.36.2
 pyright==1.1.327
-ruff==0.0.287
+ruff==0.0.290
 mypy==1.5.1

From a17e9b632eb25e67a0b668a33cfd6dc79b6392db Mon Sep 17 00:00:00 2001
From: Adrian Garcia Badaracco <1755071+adriangb@users.noreply.github.com>
Date: Mon, 18 Sep 2023 15:27:43 -0500
Subject: [PATCH 038/550] Populate defs from defs schema (#972)

Co-authored-by: David Hewitt <1939362+davidhewitt@users.noreply.github.com>
---
 .github/workflows/ci.yml                      |   2 +-
 Cargo.lock                                    |   2 +-
 Cargo.toml                                    |   2 +-
 generate_self_schema.py                       |  41 +-
 python/pydantic_core/core_schema.py           |   9 +-
 src/definitions.rs                            |   3 +-
 src/serializers/shared.rs                     |   8 -
 .../type_serializers/definitions.rs           |  15 +-
 src/validators/definitions.rs                 |   7 +-
 src/validators/mod.rs                         |   8 -
 tests/benchmarks/complete_schema.py           |  34 +-
 tests/benchmarks/test_micro_benchmarks.py     |  44 +-
 tests/serializers/test_definitions.py         |  27 +-
 .../serializers/test_definitions_recursive.py | 144 ++---
 tests/test.rs                                 |  47 +-
 tests/test_build.py                           |   1 +
 tests/test_garbage_collection.py              |  30 +-
 tests/test_hypothesis.py                      |  30 +-
 tests/test_json.py                            |  27 +-
 tests/test_schema_functions.py                |   8 +-
 tests/test_typing.py                          |  34 +-
 tests/validators/test_definitions.py          |  28 +-
 .../validators/test_definitions_recursive.py  | 586 +++++++++---------
 tests/validators/test_tagged_union.py         |  31 +-
 tests/validators/test_union.py                |  17 +-
 25 files changed, 607 insertions(+), 578 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 0b54ac0d8..85174fa41 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -207,7 +207,7 @@ jobs:
         run: |
           pip install pdm maturin
           pdm venv create --with-pip
-          pdm install -G testing
+          pdm install -G testing -G email
           pdm run pip install maturin
           pdm run bash -c 'cd ../pydantic-core && make build-dev'
         working-directory: pydantic
diff --git a/Cargo.lock b/Cargo.lock
index 2986812aa..55224a954 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -242,7 +242,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.7.0"
+version = "2.8.0"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index 75fc7ae17..a4dfda154 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.7.0"
+version = "2.8.0"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"
diff --git a/generate_self_schema.py b/generate_self_schema.py
index a745471d8..2c190bbad 100644
--- a/generate_self_schema.py
+++ b/generate_self_schema.py
@@ -14,7 +14,7 @@
 from pathlib import Path
 from typing import TYPE_CHECKING, Any, Dict, ForwardRef, List, Set, Type, Union
 
-from typing_extensions import get_args, get_origin, is_typeddict
+from typing_extensions import TypedDict, get_args, get_origin, is_typeddict
 
 TypingUnionType = Type[Union[str, int]]
 
@@ -45,13 +45,13 @@
 schema_ref_validator = {'type': 'definition-ref', 'schema_ref': 'root-schema'}
 
 
-def get_schema(obj) -> core_schema.CoreSchema:
+def get_schema(obj: Any, definitions: dict[str, core_schema.CoreSchema]) -> core_schema.CoreSchema:
     if isinstance(obj, str):
         return {'type': obj}
     elif obj in (datetime, timedelta, date, time, bool, int, float, str, decimal.Decimal):
         return {'type': obj.__name__.lower()}
     elif is_typeddict(obj):
-        return type_dict_schema(obj)
+        return type_dict_schema(obj, definitions)
     elif obj == Any or obj == type:
         return {'type': 'any'}
     if isinstance(obj, type) and issubclass(obj, core_schema.Protocol):
@@ -60,7 +60,7 @@ def get_schema(obj) -> core_schema.CoreSchema:
     origin = get_origin(obj)
     assert origin is not None, f'origin cannot be None, obj={obj}, you probably need to fix generate_self_schema.py'
     if origin is Union or origin is TypesUnionType:
-        return union_schema(obj)
+        return union_schema(obj, definitions)
     elif obj is Callable or origin is Callable:
         return {'type': 'callable'}
     elif origin is core_schema.Literal:
@@ -68,14 +68,14 @@ def get_schema(obj) -> core_schema.CoreSchema:
         assert expected, f'literal "expected" cannot be empty, obj={obj}'
         return {'type': 'literal', 'expected': expected}
     elif issubclass(origin, List):
-        return {'type': 'list', 'items_schema': get_schema(obj.__args__[0])}
+        return {'type': 'list', 'items_schema': get_schema(obj.__args__[0], definitions)}
     elif issubclass(origin, Set):
-        return {'type': 'set', 'items_schema': get_schema(obj.__args__[0])}
+        return {'type': 'set', 'items_schema': get_schema(obj.__args__[0], definitions)}
     elif issubclass(origin, Dict):
         return {
             'type': 'dict',
-            'keys_schema': get_schema(obj.__args__[0]),
-            'values_schema': get_schema(obj.__args__[1]),
+            'keys_schema': get_schema(obj.__args__[0], definitions),
+            'values_schema': get_schema(obj.__args__[1], definitions),
         }
     elif issubclass(origin, Type):
         # can't really use 'is-instance' since this is used for the class_ parameter of 'is-instance' validators
@@ -107,7 +107,9 @@ def tagged_union(std_union_schema: Dict[str, Any], discriminator_key: str, ref:
 defined_ser_schema = False
 
 
-def type_dict_schema(typed_dict) -> dict[str, Any]:  # noqa: C901
+def type_dict_schema(  # noqa: C901
+    typed_dict: type[TypedDict], definitions: dict[str, core_schema.CoreSchema]
+) -> dict[str, Any]:
     global defined_ser_schema
 
     required_keys = getattr(typed_dict, '__required_keys__', set())
@@ -154,13 +156,14 @@ def type_dict_schema(typed_dict) -> dict[str, Any]:  # noqa: C901
                 required = True
                 field_type = field_type.__args__[0]
 
-            schema = get_schema(field_type)
+            schema = get_schema(field_type, definitions)
             if fr_arg == 'SerSchema':
                 if defined_ser_schema:
                     schema = {'type': 'definition-ref', 'schema_ref': 'ser-schema'}
                 else:
                     defined_ser_schema = True
-                    schema = tagged_union(schema, 'type', 'ser-schema')
+                    definitions['ser-schema'] = tagged_union(schema, 'type', 'ser-schema')
+                    schema = {'type': 'definition-ref', 'schema_ref': 'ser-schema'}
             elif fr_arg.endswith('SerSchema'):
                 schema = tagged_union(schema, 'type')
 
@@ -172,8 +175,8 @@ def type_dict_schema(typed_dict) -> dict[str, Any]:  # noqa: C901
     return {'type': 'typed-dict', 'fields': fields, 'extra_behavior': 'forbid'}
 
 
-def union_schema(union_type: UnionType) -> core_schema.UnionSchema | core_schema.DefinitionReferenceSchema:
-    return {'type': 'union', 'choices': [get_schema(arg) for arg in union_type.__args__]}
+def union_schema(union_type: UnionType, definitions) -> core_schema.UnionSchema | core_schema.DefinitionReferenceSchema:
+    return {'type': 'union', 'choices': [get_schema(arg, definitions) for arg in union_type.__args__]}
 
 
 def all_literal_values(type_: type[core_schema.Literal]) -> list[any]:
@@ -196,16 +199,24 @@ def main() -> None:
     schema_union = core_schema.CoreSchema
     assert get_origin(schema_union) is Union, 'expected core_schema.CoreSchema to be a Union'
 
+    definitions: dict[str, core_schema.CoreSchema] = {}
+
     choices = {}
     for s in schema_union.__args__:
         type_ = s.__annotations__['type']
         m = re.search(r"Literal\['(.+?)']", type_.__forward_arg__)
         assert m, f'Unknown schema type: {type_}'
         key = m.group(1)
-        value = get_schema(s)
+        value = get_schema(s, definitions)
         choices[key] = value
 
-    schema = {'type': 'tagged-union', 'ref': 'root-schema', 'discriminator': 'type', 'choices': choices}
+    schema = core_schema.definitions_schema(
+        schema=core_schema.definition_reference_schema(schema_ref='root-schema'),
+        definitions=[
+            core_schema.tagged_union_schema(choices, discriminator='type', ref='root-schema'),
+            *definitions.values(),
+        ],
+    )
     python_code = (
         f'# this file is auto-generated by generate_self_schema.py, DO NOT edit manually\nself_schema = {schema}\n'
     )
diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index 0b4348e81..db0b1bd54 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -3772,9 +3772,14 @@ def definition_reference_schema(
     from pydantic_core import SchemaValidator, core_schema
 
     schema_definition = core_schema.definition_reference_schema('list-schema')
-    schema = core_schema.list_schema(items_schema=schema_definition, ref='list-schema')
+    schema = core_schema.definitions_schema(
+        schema=schema_definition,
+        definitions=[
+            core_schema.list_schema(items_schema=schema_definition, ref='list-schema'),
+        ],
+    )
     v = SchemaValidator(schema)
-    assert v.validate_python([[]]) == [[]]
+    assert v.validate_python([()]) == [[]]
     ```
 
     Args:
diff --git a/src/definitions.rs b/src/definitions.rs
index 44360c83f..0d01fd2ae 100644
--- a/src/definitions.rs
+++ b/src/definitions.rs
@@ -82,7 +82,8 @@ impl<T: Clone + std::fmt::Debug> DefinitionsBuilder<T> {
     }
 
     /// Retrieve an item definition using a ReferenceId
-    /// Will raise an error if the definition for that reference does not yet exist
+    /// If the definition doesn't yet exist (as happens in recursive types) then we create it
+    /// At the end (in finish()) we check that there are no undefined definitions
     pub fn get_definition(&self, reference_id: ReferenceId) -> PyResult<&T> {
         let (reference, def) = match self.definitions.iter().find(|(_, def)| def.id == reference_id) {
             Some(v) => v,
diff --git a/src/serializers/shared.rs b/src/serializers/shared.rs
index 0c97ee635..7c24ff6db 100644
--- a/src/serializers/shared.rs
+++ b/src/serializers/shared.rs
@@ -21,7 +21,6 @@ use super::errors::se_err_py_err;
 use super::extra::Extra;
 use super::infer::infer_json_key;
 use super::ob_type::{IsType, ObType};
-use super::type_serializers::definitions::DefinitionRefSerializer;
 
 pub(crate) trait BuildSerializer: Sized {
     const EXPECTED_TYPE: &'static str;
@@ -207,13 +206,6 @@ impl BuildSerializer for CombinedSerializer {
         config: Option<&PyDict>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
-        let py: Python = schema.py();
-        if let Some(schema_ref) = schema.get_as::<String>(intern!(py, "ref"))? {
-            let inner_ser = Self::_build(schema, config, definitions)?;
-            let ser_id = definitions.add_definition(schema_ref, inner_ser)?;
-            return Ok(DefinitionRefSerializer::from_id(ser_id));
-        }
-
         Self::_build(schema, config, definitions)
     }
 }
diff --git a/src/serializers/type_serializers/definitions.rs b/src/serializers/type_serializers/definitions.rs
index 4d2a0371c..19d6e75ed 100644
--- a/src/serializers/type_serializers/definitions.rs
+++ b/src/serializers/type_serializers/definitions.rs
@@ -25,9 +25,12 @@ impl BuildSerializer for DefinitionsSerializerBuilder {
 
         let schema_definitions: &PyList = schema.get_as_req(intern!(py, "definitions"))?;
 
-        for schema_def in schema_definitions {
-            CombinedSerializer::build(schema_def.downcast()?, config, definitions)?;
-            // no need to store the serializer here, it has already been stored in definitions if necessary
+        for schema_definition in schema_definitions {
+            let reference = schema_definition
+                .extract::<&PyDict>()?
+                .get_as_req::<String>(intern!(py, "ref"))?;
+            let serializer = CombinedSerializer::build(schema_definition.downcast()?, config, definitions)?;
+            definitions.add_definition(reference, serializer)?;
         }
 
         let inner_schema: &PyDict = schema.get_as_req(intern!(py, "schema"))?;
@@ -40,12 +43,6 @@ pub struct DefinitionRefSerializer {
     serializer_id: usize,
 }
 
-impl DefinitionRefSerializer {
-    pub fn from_id(serializer_id: usize) -> CombinedSerializer {
-        Self { serializer_id }.into()
-    }
-}
-
 impl BuildSerializer for DefinitionRefSerializer {
     const EXPECTED_TYPE: &'static str = "definition-ref";
 
diff --git a/src/validators/definitions.rs b/src/validators/definitions.rs
index 0dfc80475..3a35fce4c 100644
--- a/src/validators/definitions.rs
+++ b/src/validators/definitions.rs
@@ -25,8 +25,11 @@ impl BuildValidator for DefinitionsValidatorBuilder {
         let schema_definitions: &PyList = schema.get_as_req(intern!(py, "definitions"))?;
 
         for schema_definition in schema_definitions {
-            build_validator(schema_definition, config, definitions)?;
-            // no need to store the validator here, it has already been stored in definitions if necessary
+            let reference = schema_definition
+                .extract::<&PyDict>()?
+                .get_as_req::<String>(intern!(py, "ref"))?;
+            let validator = build_validator(schema_definition, config, definitions)?;
+            definitions.add_definition(reference, validator)?;
         }
 
         let inner_schema: &PyAny = schema.get_as_req(intern!(py, "schema"))?;
diff --git a/src/validators/mod.rs b/src/validators/mod.rs
index 9a9c6a185..9440f1527 100644
--- a/src/validators/mod.rs
+++ b/src/validators/mod.rs
@@ -60,7 +60,6 @@ mod with_default;
 
 pub use with_default::DefaultType;
 
-use self::definitions::DefinitionRefValidator;
 pub use self::validation_state::ValidationState;
 
 #[pyclass(module = "pydantic_core._pydantic_core", name = "Some")]
@@ -413,13 +412,6 @@ fn build_specific_validator<'a, T: BuildValidator>(
     config: Option<&'a PyDict>,
     definitions: &mut DefinitionsBuilder<CombinedValidator>,
 ) -> PyResult<CombinedValidator> {
-    let py = schema_dict.py();
-    if let Some(schema_ref) = schema_dict.get_as::<String>(intern!(py, "ref"))? {
-        let inner_val = T::build(schema_dict, config, definitions)?;
-        let validator_id = definitions.add_definition(schema_ref, inner_val)?;
-        return Ok(DefinitionRefValidator::new(validator_id).into());
-    }
-
     T::build(schema_dict, config, definitions)
         .map_err(|err| py_schema_error_type!("Error building \"{}\" validator:\n  {}", val_type, err))
 }
diff --git a/tests/benchmarks/complete_schema.py b/tests/benchmarks/complete_schema.py
index 69a27277b..d4eff16b2 100644
--- a/tests/benchmarks/complete_schema.py
+++ b/tests/benchmarks/complete_schema.py
@@ -191,22 +191,28 @@ def wrap_function(input_value, validator, info):
                 'field_recursive': {
                     'type': 'model-field',
                     'schema': {
-                        'ref': 'Branch',
-                        'type': 'typed-dict',
-                        'fields': {
-                            'name': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
-                            'sub_branch': {
-                                'type': 'typed-dict-field',
-                                'schema': {
-                                    'type': 'default',
-                                    'schema': {
-                                        'type': 'nullable',
-                                        'schema': {'type': 'definition-ref', 'schema_ref': 'Branch'},
+                        'type': 'definitions',
+                        'schema': {'type': 'definition-ref', 'schema_ref': 'Branch'},
+                        'definitions': [
+                            {
+                                'type': 'typed-dict',
+                                'fields': {
+                                    'name': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
+                                    'sub_branch': {
+                                        'type': 'typed-dict-field',
+                                        'schema': {
+                                            'type': 'default',
+                                            'schema': {
+                                                'type': 'nullable',
+                                                'schema': {'type': 'definition-ref', 'schema_ref': 'Branch'},
+                                            },
+                                            'default': None,
+                                        },
                                     },
-                                    'default': None,
                                 },
-                            },
-                        },
+                                'ref': 'Branch',
+                            }
+                        ],
                     },
                 },
             },
diff --git a/tests/benchmarks/test_micro_benchmarks.py b/tests/benchmarks/test_micro_benchmarks.py
index 6c9de2fb2..7e6799a74 100644
--- a/tests/benchmarks/test_micro_benchmarks.py
+++ b/tests/benchmarks/test_micro_benchmarks.py
@@ -298,28 +298,28 @@ class CoreBranch:
         __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__'
 
     v = SchemaValidator(
-        {
-            'ref': 'Branch',
-            'type': 'model',
-            'cls': CoreBranch,
-            'schema': {
-                'type': 'model-fields',
-                'fields': {
-                    'width': {'type': 'model-field', 'schema': {'type': 'int'}},
-                    'branch': {
-                        'type': 'model-field',
-                        'schema': {
-                            'type': 'default',
-                            'schema': {
-                                'type': 'nullable',
-                                'schema': {'type': 'definition-ref', 'schema_ref': 'Branch'},
-                            },
-                            'default': None,
-                        },
-                    },
-                },
-            },
-        }
+        core_schema.definitions_schema(
+            core_schema.definition_reference_schema(schema_ref='Branch'),
+            [
+                core_schema.model_schema(
+                    CoreBranch,
+                    core_schema.model_fields_schema(
+                        {
+                            'width': core_schema.model_field(core_schema.int_schema()),
+                            'branch': core_schema.model_field(
+                                core_schema.with_default_schema(
+                                    core_schema.nullable_schema(
+                                        core_schema.definition_reference_schema(schema_ref='Branch')
+                                    ),
+                                    default=None,
+                                )
+                            ),
+                        }
+                    ),
+                    ref='Branch',
+                )
+            ],
+        )
     )
     benchmark(v.validate_python, definition_model_data)
 
diff --git a/tests/serializers/test_definitions.py b/tests/serializers/test_definitions.py
index b52e1e27f..61b1e9cf7 100644
--- a/tests/serializers/test_definitions.py
+++ b/tests/serializers/test_definitions.py
@@ -42,9 +42,12 @@ def test_repeated_ref():
         SchemaSerializer(
             core_schema.tuple_positional_schema(
                 [
-                    core_schema.int_schema(ref='foobar'),
-                    core_schema.definition_reference_schema('foobar'),
-                    core_schema.int_schema(ref='foobar'),
+                    core_schema.definitions_schema(
+                        core_schema.definition_reference_schema('foobar'), [core_schema.int_schema(ref='foobar')]
+                    ),
+                    core_schema.definitions_schema(
+                        core_schema.definition_reference_schema('foobar'), [core_schema.int_schema(ref='foobar')]
+                    ),
                 ]
             )
         )
@@ -53,14 +56,16 @@ def test_repeated_ref():
 def test_repeat_after():
     with pytest.raises(SchemaError, match='SchemaError: Duplicate ref: `foobar`'):
         SchemaSerializer(
-            core_schema.tuple_positional_schema(
-                [
-                    core_schema.definitions_schema(
-                        core_schema.list_schema(core_schema.definition_reference_schema('foobar')),
-                        [core_schema.int_schema(ref='foobar')],
-                    ),
-                    core_schema.int_schema(ref='foobar'),
-                ]
+            core_schema.definitions_schema(
+                core_schema.tuple_positional_schema(
+                    [
+                        core_schema.definitions_schema(
+                            core_schema.definition_reference_schema('foobar'), [core_schema.int_schema(ref='foobar')]
+                        ),
+                        core_schema.definition_reference_schema('foobar'),
+                    ]
+                ),
+                [core_schema.int_schema(ref='foobar')],
             )
         )
 
diff --git a/tests/serializers/test_definitions_recursive.py b/tests/serializers/test_definitions_recursive.py
index 8d5a80065..014af35c0 100644
--- a/tests/serializers/test_definitions_recursive.py
+++ b/tests/serializers/test_definitions_recursive.py
@@ -1,21 +1,24 @@
 import pytest
 
-from pydantic_core import SchemaSerializer
+from pydantic_core import SchemaSerializer, core_schema
 
 
 def test_branch_nullable():
     s = SchemaSerializer(
-        {
-            'type': 'typed-dict',
-            'ref': 'Branch',
-            'fields': {
-                'name': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
-                'sub_branch': {
-                    'type': 'typed-dict-field',
-                    'schema': {'type': 'nullable', 'schema': {'type': 'definition-ref', 'schema_ref': 'Branch'}},
-                },
-            },
-        }
+        core_schema.definitions_schema(
+            core_schema.definition_reference_schema('Branch'),
+            [
+                core_schema.typed_dict_schema(
+                    {
+                        'name': core_schema.typed_dict_field(core_schema.str_schema()),
+                        'sub_branch': core_schema.typed_dict_field(
+                            core_schema.nullable_schema(core_schema.definition_reference_schema('Branch'))
+                        ),
+                    },
+                    ref='Branch',
+                )
+            ],
+        )
     )
     assert s.to_python({'name': 'root', 'sub_branch': {'name': 'branch', 'sub_branch': None}}) == {
         'name': 'root',
@@ -29,17 +32,20 @@ def test_branch_nullable():
 
 def test_cyclic_recursion():
     s = SchemaSerializer(
-        {
-            'type': 'typed-dict',
-            'ref': 'Branch',
-            'fields': {
-                'name': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
-                'sub_branch': {
-                    'type': 'typed-dict-field',
-                    'schema': {'type': 'nullable', 'schema': {'type': 'definition-ref', 'schema_ref': 'Branch'}},
-                },
-            },
-        }
+        core_schema.definitions_schema(
+            core_schema.definition_reference_schema('Branch'),
+            [
+                core_schema.typed_dict_schema(
+                    {
+                        'name': core_schema.typed_dict_field(core_schema.str_schema()),
+                        'sub_branch': core_schema.typed_dict_field(
+                            core_schema.nullable_schema(core_schema.definition_reference_schema('Branch'))
+                        ),
+                    },
+                    ref='Branch',
+                )
+            ],
+        )
     )
     v = {'name': 'root'}
     v['sub_branch'] = v
@@ -53,24 +59,24 @@ def test_cyclic_recursion():
 
 def test_custom_ser():
     s = SchemaSerializer(
-        {
-            'type': 'typed-dict',
-            'ref': 'Branch',
-            'fields': {
-                'name': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
-                'sub_branch': {
-                    'type': 'typed-dict-field',
-                    'schema': {
-                        'type': 'nullable',
-                        'schema': {
-                            'type': 'definition-ref',
-                            'schema_ref': 'Branch',
-                            'serialization': {'type': 'to-string', 'when_used': 'always'},
-                        },
+        core_schema.definitions_schema(
+            core_schema.definition_reference_schema('Branch'),
+            [
+                core_schema.typed_dict_schema(
+                    {
+                        'name': core_schema.typed_dict_field(core_schema.str_schema()),
+                        'sub_branch': core_schema.typed_dict_field(
+                            core_schema.nullable_schema(
+                                core_schema.definition_reference_schema(
+                                    'Branch', serialization=core_schema.to_string_ser_schema(when_used='always')
+                                )
+                            )
+                        ),
                     },
-                },
-            },
-        }
+                    ref='Branch',
+                )
+            ],
+        )
     )
     assert s.to_python({'name': 'root', 'sub_branch': {'name': 'branch', 'sub_branch': None}}) == {
         'name': 'root',
@@ -80,43 +86,39 @@ def test_custom_ser():
 
 def test_recursive_function():
     s = SchemaSerializer(
-        {
-            'type': 'typed-dict',
-            'fields': {
-                'root': {'type': 'typed-dict-field', 'schema': {'type': 'definition-ref', 'schema_ref': 'my_ref'}}
-            },
-            'ref': 'my_ref',
-            'serialization': {'type': 'function-wrap', 'info_arg': True, 'function': lambda x, _1, _2: x},
-        }
+        core_schema.definitions_schema(
+            core_schema.definition_reference_schema('my_ref'),
+            [
+                core_schema.typed_dict_schema(
+                    {'root': core_schema.typed_dict_field(core_schema.definition_reference_schema('my_ref'))},
+                    ref='my_ref',
+                    serialization=core_schema.wrap_serializer_function_ser_schema(function=lambda x, _handler: x),
+                )
+            ],
+        )
     )
     assert s.to_python({'root': {'root': {}}}) == {'root': {'root': {}}}
 
 
 def test_recursive_function_deeper_ref():
     s = SchemaSerializer(
-        {
-            'type': 'typed-dict',
-            'fields': {
-                'a': {
-                    'type': 'typed-dict-field',
-                    'schema': {
-                        'type': 'typed-dict',
-                        'ref': 'my_ref',
-                        'fields': {
-                            'b': {
-                                'type': 'typed-dict-field',
-                                'schema': {'type': 'definition-ref', 'schema_ref': 'my_ref'},
-                            }
-                        },
-                    },
-                }
-            },
-            'serialization': {
-                'type': 'function-wrap',
-                'is_field_serializer': False,
-                'info_arg': True,
-                'function': lambda x, _1, _2: x,
+        core_schema.typed_dict_schema(
+            {
+                'a': core_schema.typed_dict_field(
+                    core_schema.definitions_schema(
+                        core_schema.definition_reference_schema('my_ref'),
+                        [
+                            core_schema.typed_dict_schema(
+                                {'b': core_schema.typed_dict_field(core_schema.definition_reference_schema('my_ref'))},
+                                ref='my_ref',
+                            )
+                        ],
+                    )
+                )
             },
-        }
+            serialization=core_schema.wrap_serializer_function_ser_schema(
+                function=lambda x, _handler: x, is_field_serializer=False
+            ),
+        )
     )
     assert s.to_python({'a': {'b': {'b': {}}}}) == {'a': {'b': {'b': {}}}}
diff --git a/tests/test.rs b/tests/test.rs
index fc3456eec..9b2fb99b5 100644
--- a/tests/test.rs
+++ b/tests/test.rs
@@ -7,22 +7,43 @@ mod tests {
     #[test]
     fn test_build_schema_serializer() {
         Python::with_gil(|py| {
+            // 'type': 'typed-dict',
+            //     'fields': {
+            //         'root': {
+            //             'type': 'typed-dict-field',
+            //             'schema': {
+            //                 'type': 'definition-ref',
+            //                 'schema_ref': 'C-ref',
+            //             },
+            //         },
+            //     },
+            //     'ref': 'C-ref',
+            //     'serialization': {
+            //         'type': 'function-wrap',
+            //         'function': lambda: None,
+            //     },
             let code = r#"{
-                'type': 'typed-dict',
-                'fields': {
-                    'root': {
-                        'type': 'typed-dict-field',
-                        'schema': {
-                            'type': 'definition-ref',
-                            'schema_ref': 'C-ref',
+                'type': 'definitions',
+                'schema': {'type': 'definition-ref', 'schema_ref': 'C-ref'},
+                'definitions': [
+                    {
+                        'type': 'typed-dict',
+                        'fields': {
+                            'root': {
+                                'type': 'typed-dict-field',
+                                'schema': {
+                                    'type': 'definition-ref',
+                                    'schema_ref': 'C-ref',
+                                }
+                            },
+                        },
+                        'ref': 'C-ref',
+                        'serialization': {
+                            'type': 'function-wrap',
+                            'function': lambda: None,
                         },
                     },
-                },
-                'ref': 'C-ref',
-                'serialization': {
-                    'type': 'function-wrap',
-                    'function': lambda: None,
-                },
+                ]
             }"#;
             let schema: &PyDict = py.eval(code, None, None).unwrap().extract().unwrap();
             SchemaSerializer::py_new(py, schema, None).unwrap();
diff --git a/tests/test_build.py b/tests/test_build.py
index 7cc0b69af..095eb6887 100644
--- a/tests/test_build.py
+++ b/tests/test_build.py
@@ -61,6 +61,7 @@ def test_pickle(pickle_protocol: int) -> None:
     assert repr(v1) == repr(v2)
 
 
+@pytest.mark.skip
 def test_schema_definition_error():
     schema = {'type': 'union', 'choices': []}
     schema['choices'].append({'type': 'nullable', 'schema': schema})
diff --git a/tests/test_garbage_collection.py b/tests/test_garbage_collection.py
index 9dec6e9ea..d848c91ea 100644
--- a/tests/test_garbage_collection.py
+++ b/tests/test_garbage_collection.py
@@ -7,6 +7,16 @@
 
 from pydantic_core import SchemaSerializer, SchemaValidator, core_schema
 
+GC_TEST_SCHEMA_INNER = core_schema.definitions_schema(
+    core_schema.definition_reference_schema(schema_ref='model'),
+    [
+        core_schema.typed_dict_schema(
+            {'x': core_schema.typed_dict_field(core_schema.definition_reference_schema(schema_ref='model'))},
+            ref='model',
+        )
+    ],
+)
+
 
 @pytest.mark.xfail(
     condition=platform.python_implementation() == 'PyPy', reason='https://foss.heptapod.net/pypy/pypy/-/issues/3899'
@@ -17,15 +27,7 @@ class BaseModel:
         __schema__: SchemaSerializer
 
         def __init_subclass__(cls) -> None:
-            cls.__schema__ = SchemaSerializer(
-                core_schema.model_schema(
-                    cls,
-                    core_schema.typed_dict_schema(
-                        {'x': core_schema.typed_dict_field(core_schema.definition_reference_schema('model'))}
-                    ),
-                    ref='model',
-                )
-            )
+            cls.__schema__ = SchemaSerializer(core_schema.model_schema(cls, GC_TEST_SCHEMA_INNER))
 
     cache: 'WeakValueDictionary[int, Any]' = WeakValueDictionary()
 
@@ -54,15 +56,7 @@ class BaseModel:
         __validator__: SchemaValidator
 
         def __init_subclass__(cls) -> None:
-            cls.__validator__ = SchemaValidator(
-                core_schema.model_schema(
-                    cls,
-                    core_schema.typed_dict_schema(
-                        {'x': core_schema.typed_dict_field(core_schema.definition_reference_schema('model'))}
-                    ),
-                    ref='model',
-                )
-            )
+            cls.__validator__ = SchemaValidator(core_schema.model_schema(cls, GC_TEST_SCHEMA_INNER))
 
     cache: 'WeakValueDictionary[int, Any]' = WeakValueDictionary()
 
diff --git a/tests/test_hypothesis.py b/tests/test_hypothesis.py
index e925d56b7..ea0d67f0d 100644
--- a/tests/test_hypothesis.py
+++ b/tests/test_hypothesis.py
@@ -10,6 +10,7 @@
 from typing_extensions import TypedDict
 
 from pydantic_core import SchemaSerializer, SchemaValidator, ValidationError
+from pydantic_core import core_schema as cs
 
 
 @pytest.fixture(scope='module')
@@ -58,21 +59,22 @@ def test_datetime_binary(datetime_schema, data):
 @pytest.fixture(scope='module')
 def definition_schema():
     return SchemaValidator(
-        {
-            'type': 'typed-dict',
-            'ref': 'Branch',
-            'fields': {
-                'name': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
-                'sub_branch': {
-                    'type': 'typed-dict-field',
-                    'schema': {
-                        'type': 'default',
-                        'schema': {'type': 'nullable', 'schema': {'type': 'definition-ref', 'schema_ref': 'Branch'}},
-                        'default': None,
+        cs.definitions_schema(
+            cs.definition_reference_schema('Branch'),
+            [
+                cs.typed_dict_schema(
+                    {
+                        'name': cs.typed_dict_field(cs.str_schema()),
+                        'sub_branch': cs.typed_dict_field(
+                            cs.with_default_schema(
+                                cs.nullable_schema(cs.definition_reference_schema('Branch')), default=None
+                            )
+                        ),
                     },
-                },
-            },
-        }
+                    ref='Branch',
+                )
+            ],
+        )
     )
 
 
diff --git a/tests/test_json.py b/tests/test_json.py
index 272fb5dcb..9bba05c14 100644
--- a/tests/test_json.py
+++ b/tests/test_json.py
@@ -254,18 +254,23 @@ def __init__(self, my_foo: int, my_inners: List['Foobar']):
 
     # force a recursive model to ensure we exercise the transfer of definitions from the loaded
     # serializer
-    c = core_schema.model_schema(
-        Foobar,
-        core_schema.typed_dict_schema(
-            {
-                'my_foo': core_schema.typed_dict_field(core_schema.int_schema(), serialization_alias='myFoo'),
-                'my_inners': core_schema.typed_dict_field(
-                    core_schema.list_schema(core_schema.definition_reference_schema('foobar')),
-                    serialization_alias='myInners',
+    c = core_schema.definitions_schema(
+        core_schema.definition_reference_schema(schema_ref='foobar'),
+        [
+            core_schema.model_schema(
+                Foobar,
+                core_schema.typed_dict_schema(
+                    {
+                        'my_foo': core_schema.typed_dict_field(core_schema.int_schema(), serialization_alias='myFoo'),
+                        'my_inners': core_schema.typed_dict_field(
+                            core_schema.list_schema(core_schema.definition_reference_schema('foobar')),
+                            serialization_alias='myInners',
+                        ),
+                    }
                 ),
-            }
-        ),
-        ref='foobar',
+                ref='foobar',
+            )
+        ],
     )
     v = SchemaValidator(c)
     s = SchemaSerializer(c)
diff --git a/tests/test_schema_functions.py b/tests/test_schema_functions.py
index 512a1977d..c119ca567 100644
--- a/tests/test_schema_functions.py
+++ b/tests/test_schema_functions.py
@@ -255,8 +255,12 @@ def args(*args, **kwargs):
     (core_schema.is_subclass_schema, args(MyModel), {'type': 'is-subclass', 'cls': MyModel}),
     (
         core_schema.definitions_schema,
-        args({'type': 'int'}, [{'type': 'int'}]),
-        {'type': 'definitions', 'schema': {'type': 'int'}, 'definitions': [{'type': 'int'}]},
+        args({'type': 'definition-ref', 'schema_ref': 'an-int'}, [{'type': 'int', 'ref': 'an-int'}]),
+        {
+            'type': 'definitions',
+            'schema': {'type': 'definition-ref', 'schema_ref': 'an-int'},
+            'definitions': [{'type': 'int', 'ref': 'an-int'}],
+        },
     ),
     (core_schema.definition_reference_schema, args('foo'), {'type': 'definition-ref', 'schema_ref': 'foo'}),
     (
diff --git a/tests/test_typing.py b/tests/test_typing.py
index ea51029a4..55c3732e8 100644
--- a/tests/test_typing.py
+++ b/tests/test_typing.py
@@ -118,22 +118,28 @@ def test_schema_typing() -> None:
     schema: CoreSchema = {'type': 'function-plain', 'function': {'type': 'general', 'function': validator}}
     SchemaValidator(schema)
     schema: CoreSchema = {
-        'ref': 'Branch',
-        'type': 'typed-dict',
-        'fields': {
-            'name': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
-            'sub_branch': {
-                'type': 'typed-dict-field',
-                'schema': {
-                    'type': 'default',
-                    'schema': {
-                        'type': 'union',
-                        'choices': [{'type': 'none'}, {'type': 'definition-ref', 'schema_ref': 'Branch'}],
+        'type': 'definitions',
+        'schema': {'type': 'definition-ref', 'schema_ref': 'Branch'},
+        'definitions': [
+            {
+                'type': 'typed-dict',
+                'fields': {
+                    'name': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
+                    'sub_branch': {
+                        'type': 'typed-dict-field',
+                        'schema': {
+                            'type': 'default',
+                            'schema': {
+                                'type': 'nullable',
+                                'schema': {'type': 'definition-ref', 'schema_ref': 'Branch'},
+                            },
+                            'default': None,
+                        },
                     },
-                    'default': None,
                 },
-            },
-        },
+                'ref': 'Branch',
+            }
+        ],
     }
     SchemaValidator(schema)
     schema: CoreSchema = {'type': 'date', 'le': date.today()}
diff --git a/tests/validators/test_definitions.py b/tests/validators/test_definitions.py
index bff170890..b6ac5d133 100644
--- a/tests/validators/test_definitions.py
+++ b/tests/validators/test_definitions.py
@@ -78,10 +78,12 @@ def test_repeated_ref():
         SchemaValidator(
             core_schema.tuple_positional_schema(
                 [
-                    core_schema.int_schema(ref='foobar'),
-                    # the definition has to be used for it to go into slots/reusable and therefore trigger the error
-                    core_schema.definition_reference_schema('foobar'),
-                    core_schema.int_schema(ref='foobar'),
+                    core_schema.definitions_schema(
+                        core_schema.definition_reference_schema('foobar'), [core_schema.int_schema(ref='foobar')]
+                    ),
+                    core_schema.definitions_schema(
+                        core_schema.definition_reference_schema('foobar'), [core_schema.int_schema(ref='foobar')]
+                    ),
                 ]
             )
         )
@@ -90,14 +92,16 @@ def test_repeated_ref():
 def test_repeat_after():
     with pytest.raises(SchemaError, match='SchemaError: Duplicate ref: `foobar`'):
         SchemaValidator(
-            core_schema.tuple_positional_schema(
-                [
-                    core_schema.definitions_schema(
-                        core_schema.list_schema(core_schema.definition_reference_schema('foobar')),
-                        [core_schema.int_schema(ref='foobar')],
-                    ),
-                    core_schema.int_schema(ref='foobar'),
-                ]
+            core_schema.definitions_schema(
+                core_schema.tuple_positional_schema(
+                    [
+                        core_schema.definitions_schema(
+                            core_schema.definition_reference_schema('foobar'), [core_schema.int_schema(ref='foobar')]
+                        ),
+                        core_schema.definition_reference_schema('foobar'),
+                    ]
+                ),
+                [core_schema.int_schema(ref='foobar')],
             )
         )
 
diff --git a/tests/validators/test_definitions_recursive.py b/tests/validators/test_definitions_recursive.py
index 06ee6c460..f23999cfa 100644
--- a/tests/validators/test_definitions_recursive.py
+++ b/tests/validators/test_definitions_recursive.py
@@ -13,39 +13,6 @@
 
 
 def test_branch_nullable():
-    v = SchemaValidator(
-        {
-            'type': 'typed-dict',
-            'ref': 'Branch',
-            'fields': {
-                'name': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
-                'sub_branch': {
-                    'type': 'typed-dict-field',
-                    'schema': {
-                        'type': 'default',
-                        'schema': {'type': 'nullable', 'schema': {'type': 'definition-ref', 'schema_ref': 'Branch'}},
-                        'default': None,
-                    },
-                },
-            },
-        }
-    )
-
-    assert v.validate_python({'name': 'root'}) == {'name': 'root', 'sub_branch': None}
-    assert plain_repr(v).startswith(
-        'SchemaValidator(title="typed-dict",validator=DefinitionRef(DefinitionRefValidator{'
-    )
-    assert ',definitions=[TypedDict(TypedDictValidator{' in plain_repr(v)
-
-    assert v.validate_python({'name': 'root', 'sub_branch': {'name': 'b1'}}) == (
-        {'name': 'root', 'sub_branch': {'name': 'b1', 'sub_branch': None}}
-    )
-    assert v.validate_python({'name': 'root', 'sub_branch': {'name': 'b1', 'sub_branch': {'name': 'b2'}}}) == (
-        {'name': 'root', 'sub_branch': {'name': 'b1', 'sub_branch': {'name': 'b2', 'sub_branch': None}}}
-    )
-
-
-def test_branch_nullable_definitions():
     v = SchemaValidator(
         core_schema.definitions_schema(
             {'type': 'definition-ref', 'schema_ref': 'Branch'},
@@ -99,24 +66,25 @@ def test_unused_ref():
 
 def test_nullable_error():
     v = SchemaValidator(
-        {
-            'ref': 'Branch',
-            'type': 'typed-dict',
-            'fields': {
-                'width': {'type': 'typed-dict-field', 'schema': {'type': 'int'}},
-                'sub_branch': {
-                    'type': 'typed-dict-field',
-                    'schema': {
-                        'type': 'default',
-                        'schema': {
-                            'type': 'union',
-                            'choices': [{'type': 'none'}, {'type': 'definition-ref', 'schema_ref': 'Branch'}],
-                        },
-                        'default': None,
+        core_schema.definitions_schema(
+            core_schema.definition_reference_schema('Branch'),
+            [
+                core_schema.typed_dict_schema(
+                    {
+                        'width': core_schema.typed_dict_field(core_schema.int_schema()),
+                        'sub_branch': core_schema.typed_dict_field(
+                            core_schema.with_default_schema(
+                                core_schema.union_schema(
+                                    [core_schema.none_schema(), core_schema.definition_reference_schema('Branch')]
+                                ),
+                                default=None,
+                            )
+                        ),
                     },
-                },
-            },
-        }
+                    ref='Branch',
+                )
+            ],
+        )
     )
     assert v.validate_python({'width': 123, 'sub_branch': {'width': 321}}) == (
         {'width': 123, 'sub_branch': {'width': 321, 'sub_branch': None}}
@@ -141,24 +109,23 @@ def test_nullable_error():
 
 def test_list():
     v = SchemaValidator(
-        {
-            'type': 'typed-dict',
-            'ref': 'BranchList',
-            'fields': {
-                'width': {'type': 'typed-dict-field', 'schema': {'type': 'int'}},
-                'branches': {
-                    'type': 'typed-dict-field',
-                    'schema': {
-                        'type': 'default',
-                        'schema': {
-                            'type': 'list',
-                            'items_schema': {'type': 'definition-ref', 'schema_ref': 'BranchList'},
-                        },
-                        'default': None,
+        core_schema.definitions_schema(
+            core_schema.definition_reference_schema('BranchList'),
+            [
+                core_schema.typed_dict_schema(
+                    {
+                        'width': core_schema.typed_dict_field(core_schema.int_schema()),
+                        'branches': core_schema.typed_dict_field(
+                            core_schema.with_default_schema(
+                                core_schema.list_schema(core_schema.definition_reference_schema('BranchList')),
+                                default=None,
+                            )
+                        ),
                     },
-                },
-            },
-        }
+                    ref='BranchList',
+                )
+            ],
+        )
     )
     assert v.validate_python({'width': 1, 'branches': [{'width': 2}, {'width': 3, 'branches': [{'width': 4}]}]}) == (
         {
@@ -183,45 +150,37 @@ class Bar:
     """
 
     v = SchemaValidator(
-        {
-            'ref': 'Foo',
-            'type': 'typed-dict',
-            'fields': {
-                'height': {'type': 'typed-dict-field', 'schema': {'type': 'int'}},
-                'bar': {
-                    'type': 'typed-dict-field',
-                    'schema': {
-                        'ref': 'Bar',
-                        'type': 'typed-dict',
-                        'fields': {
-                            'width': {'type': 'typed-dict-field', 'schema': {'type': 'int'}},
-                            'bars': {
-                                'type': 'typed-dict-field',
-                                'schema': {
-                                    'type': 'default',
-                                    'schema': {
-                                        'type': 'list',
-                                        'items_schema': {'type': 'definition-ref', 'schema_ref': 'Bar'},
-                                    },
-                                    'default': None,
-                                },
-                            },
-                            'foo': {
-                                'type': 'typed-dict-field',
-                                'schema': {
-                                    'type': 'default',
-                                    'schema': {
-                                        'type': 'union',
-                                        'choices': [{'type': 'none'}, {'type': 'definition-ref', 'schema_ref': 'Foo'}],
-                                    },
-                                    'default': None,
-                                },
-                            },
-                        },
+        core_schema.definitions_schema(
+            core_schema.definition_reference_schema('Foo'),
+            [
+                core_schema.typed_dict_schema(
+                    {
+                        'height': core_schema.typed_dict_field(core_schema.int_schema()),
+                        'bar': core_schema.typed_dict_field(core_schema.definition_reference_schema('Bar')),
                     },
-                },
-            },
-        }
+                    ref='Foo',
+                ),
+                core_schema.typed_dict_schema(
+                    {
+                        'width': core_schema.typed_dict_field(core_schema.int_schema()),
+                        'bars': core_schema.typed_dict_field(
+                            core_schema.with_default_schema(
+                                core_schema.list_schema(core_schema.definition_reference_schema('Bar')), default=None
+                            )
+                        ),
+                        'foo': core_schema.typed_dict_field(
+                            core_schema.with_default_schema(
+                                core_schema.union_schema(
+                                    [core_schema.none_schema(), core_schema.definition_reference_schema('Foo')]
+                                ),
+                                default=None,
+                            )
+                        ),
+                    },
+                    ref='Bar',
+                ),
+            ],
+        )
     )
     v.validate_python(
         {
@@ -244,28 +203,28 @@ class Branch:
         branch: Optional['Branch']
 
     v = SchemaValidator(
-        {
-            'type': 'model',
-            'ref': 'Branch',
-            'cls': Branch,
-            'schema': {
-                'type': 'model-fields',
-                'fields': {
-                    'width': {'type': 'model-field', 'schema': {'type': 'int'}},
-                    'branch': {
-                        'type': 'model-field',
-                        'schema': {
-                            'type': 'default',
-                            'schema': {
-                                'type': 'union',
-                                'choices': [{'type': 'none'}, {'type': 'definition-ref', 'schema_ref': 'Branch'}],
-                            },
-                            'default': None,
-                        },
-                    },
-                },
-            },
-        }
+        core_schema.definitions_schema(
+            core_schema.definition_reference_schema('Branch'),
+            [
+                core_schema.model_schema(
+                    Branch,
+                    core_schema.model_fields_schema(
+                        {
+                            'width': core_schema.model_field(core_schema.int_schema()),
+                            'branch': core_schema.model_field(
+                                core_schema.with_default_schema(
+                                    core_schema.union_schema(
+                                        [core_schema.none_schema(), core_schema.definition_reference_schema('Branch')]
+                                    ),
+                                    default=None,
+                                )
+                            ),
+                        }
+                    ),
+                    ref='Branch',
+                )
+            ],
+        )
     )
     m1: Branch = v.validate_python({'width': '1'})
     assert isinstance(m1, Branch)
@@ -311,20 +270,19 @@ def test_invalid_schema():
 
 def test_outside_parent():
     v = SchemaValidator(
-        {
-            'type': 'typed-dict',
-            'fields': {
-                'tuple1': {
-                    'type': 'typed-dict-field',
-                    'schema': {
-                        'type': 'tuple-positional',
-                        'items_schema': [{'type': 'int'}, {'type': 'int'}, {'type': 'str'}],
-                        'ref': 'tuple-iis',
-                    },
-                },
-                'tuple2': {'type': 'typed-dict-field', 'schema': {'type': 'definition-ref', 'schema_ref': 'tuple-iis'}},
-            },
-        }
+        core_schema.definitions_schema(
+            core_schema.typed_dict_schema(
+                {
+                    'tuple1': core_schema.typed_dict_field(core_schema.definition_reference_schema('tuple-iis')),
+                    'tuple2': core_schema.typed_dict_field(core_schema.definition_reference_schema('tuple-iis')),
+                }
+            ),
+            [
+                core_schema.tuple_positional_schema(
+                    [core_schema.int_schema(), core_schema.int_schema(), core_schema.str_schema()], ref='tuple-iis'
+                )
+            ],
+        )
     )
 
     assert v.validate_python({'tuple1': [1, '1', 'frog'], 'tuple2': [2, '2', 'toad']}) == {
@@ -335,21 +293,23 @@ def test_outside_parent():
 
 def test_recursion_branch():
     v = SchemaValidator(
-        {
-            'type': 'typed-dict',
-            'ref': 'Branch',
-            'fields': {
-                'name': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
-                'branch': {
-                    'type': 'typed-dict-field',
-                    'schema': {
-                        'type': 'default',
-                        'schema': {'type': 'nullable', 'schema': {'type': 'definition-ref', 'schema_ref': 'Branch'}},
-                        'default': None,
+        core_schema.definitions_schema(
+            core_schema.definition_reference_schema('Branch'),
+            [
+                core_schema.typed_dict_schema(
+                    {
+                        'name': core_schema.typed_dict_field(core_schema.str_schema()),
+                        'branch': core_schema.typed_dict_field(
+                            core_schema.with_default_schema(
+                                core_schema.nullable_schema(core_schema.definition_reference_schema('Branch')),
+                                default=None,
+                            )
+                        ),
                     },
-                },
-            },
-        },
+                    ref='Branch',
+                )
+            ],
+        ),
         {'from_attributes': True},
     )
     assert ',definitions=[TypedDict(TypedDictValidator{' in plain_repr(v)
@@ -377,21 +337,23 @@ def test_recursion_branch():
 
 def test_recursion_branch_from_attributes():
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'ref': 'Branch',
-            'fields': {
-                'name': {'type': 'model-field', 'schema': {'type': 'str'}},
-                'branch': {
-                    'type': 'model-field',
-                    'schema': {
-                        'type': 'default',
-                        'schema': {'type': 'nullable', 'schema': {'type': 'definition-ref', 'schema_ref': 'Branch'}},
-                        'default': None,
+        core_schema.definitions_schema(
+            core_schema.definition_reference_schema('Branch'),
+            [
+                core_schema.model_fields_schema(
+                    {
+                        'name': core_schema.model_field(core_schema.str_schema()),
+                        'branch': core_schema.model_field(
+                            core_schema.with_default_schema(
+                                core_schema.nullable_schema(core_schema.definition_reference_schema('Branch')),
+                                default=None,
+                            )
+                        ),
                     },
-                },
-            },
-        },
+                    ref='Branch',
+                )
+            ],
+        ),
         {'from_attributes': True},
     )
 
@@ -424,7 +386,10 @@ def test_recursion_branch_from_attributes():
 
 def test_definition_list():
     v = SchemaValidator(
-        {'type': 'list', 'ref': 'the-list', 'items_schema': {'type': 'definition-ref', 'schema_ref': 'the-list'}}
+        core_schema.definitions_schema(
+            core_schema.definition_reference_schema('the-list'),
+            [core_schema.list_schema(core_schema.definition_reference_schema('the-list'), ref='the-list')],
+        )
     )
     assert ',definitions=[List(ListValidator{' in plain_repr(v)
     assert v.validate_python([]) == []
@@ -448,30 +413,27 @@ def test_definition_list():
 @pytest.fixture(scope='module')
 def multiple_tuple_schema() -> SchemaValidator:
     return SchemaValidator(
-        {
-            'type': 'typed-dict',
-            'fields': {
-                'f1': {
-                    'type': 'typed-dict-field',
-                    'schema': {
-                        'type': 'tuple-positional',
-                        'items_schema': [
-                            {'type': 'int'},
-                            {'type': 'nullable', 'schema': {'type': 'definition-ref', 'schema_ref': 't'}},
-                        ],
-                        'ref': 't',
-                    },
-                },
-                'f2': {
-                    'type': 'typed-dict-field',
-                    'schema': {
-                        'type': 'default',
-                        'schema': {'type': 'nullable', 'schema': {'type': 'definition-ref', 'schema_ref': 't'}},
-                        'default': None,
-                    },
-                },
-            },
-        }
+        core_schema.definitions_schema(
+            core_schema.typed_dict_schema(
+                {
+                    'f1': core_schema.typed_dict_field(core_schema.definition_reference_schema('t')),
+                    'f2': core_schema.typed_dict_field(
+                        core_schema.with_default_schema(
+                            core_schema.nullable_schema(core_schema.definition_reference_schema('t')), default=None
+                        )
+                    ),
+                }
+            ),
+            [
+                core_schema.tuple_positional_schema(
+                    [
+                        core_schema.int_schema(),
+                        core_schema.nullable_schema(core_schema.definition_reference_schema('t')),
+                    ],
+                    ref='t',
+                )
+            ],
+        )
     )
 
 
@@ -554,18 +516,21 @@ def wrap_func(input_value, validator, info):
         return validator(input_value) + (42,)
 
     v = SchemaValidator(
-        {
-            'type': 'function-wrap',
-            'ref': 'wrapper',
-            'function': {'type': 'general', 'function': wrap_func},
-            'schema': {
-                'type': 'tuple-positional',
-                'items_schema': [
-                    {'type': 'int'},
-                    {'type': 'nullable', 'schema': {'type': 'definition-ref', 'schema_ref': 'wrapper'}},
-                ],
-            },
-        }
+        core_schema.definitions_schema(
+            core_schema.definition_reference_schema('wrapper'),
+            [
+                core_schema.general_wrap_validator_function(
+                    wrap_func,
+                    core_schema.tuple_positional_schema(
+                        [
+                            core_schema.int_schema(),
+                            core_schema.nullable_schema(core_schema.definition_reference_schema('wrapper')),
+                        ]
+                    ),
+                    ref='wrapper',
+                )
+            ],
+        )
     )
     assert v.validate_python((1, None)) == (1, None, 42)
     assert v.validate_python((1, (2, (3, None)))) == (1, (2, (3, None, 42), 42), 42)
@@ -585,19 +550,19 @@ def wrap_func(input_value, validator, info):
 
 def test_union_ref_strictness():
     v = SchemaValidator(
-        {
-            'fields': {
-                'a': {'type': 'typed-dict-field', 'schema': {'type': 'int', 'ref': 'int-type'}},
-                'b': {
-                    'type': 'typed-dict-field',
-                    'schema': {
-                        'type': 'union',
-                        'choices': [{'type': 'definition-ref', 'schema_ref': 'int-type'}, {'type': 'str'}],
-                    },
-                },
-            },
-            'type': 'typed-dict',
-        }
+        core_schema.definitions_schema(
+            core_schema.typed_dict_schema(
+                {
+                    'a': core_schema.typed_dict_field(core_schema.definition_reference_schema('int-type')),
+                    'b': core_schema.typed_dict_field(
+                        core_schema.union_schema(
+                            [core_schema.definition_reference_schema('int-type'), core_schema.str_schema()]
+                        )
+                    ),
+                }
+            ),
+            [core_schema.int_schema(ref='int-type')],
+        )
     )
     assert v.validate_python({'a': 1, 'b': '2'}) == {'a': 1, 'b': '2'}
     assert v.validate_python({'a': 1, 'b': 2}) == {'a': 1, 'b': 2}
@@ -613,16 +578,19 @@ def test_union_ref_strictness():
 
 def test_union_container_strictness():
     v = SchemaValidator(
-        {
-            'fields': {
-                'b': {
-                    'type': 'typed-dict-field',
-                    'schema': {'type': 'union', 'choices': [{'type': 'int', 'ref': 'int-type'}, {'type': 'str'}]},
-                },
-                'a': {'type': 'typed-dict-field', 'schema': {'type': 'definition-ref', 'schema_ref': 'int-type'}},
-            },
-            'type': 'typed-dict',
-        }
+        core_schema.definitions_schema(
+            core_schema.typed_dict_schema(
+                {
+                    'b': core_schema.typed_dict_field(
+                        core_schema.union_schema(
+                            [core_schema.definition_reference_schema('int-type'), core_schema.str_schema()]
+                        )
+                    ),
+                    'a': core_schema.typed_dict_field(core_schema.definition_reference_schema('int-type')),
+                }
+            ),
+            [core_schema.int_schema(ref='int-type')],
+        )
     )
     assert v.validate_python({'a': 1, 'b': '2'}) == {'a': 1, 'b': '2'}
     assert v.validate_python({'a': 1, 'b': 2}) == {'a': 1, 'b': 2}
@@ -639,26 +607,25 @@ def test_union_container_strictness():
 @pytest.mark.parametrize('strict', [True, False], ids=lambda s: f'strict={s}')
 def test_union_cycle(strict: bool):
     s = SchemaValidator(
-        {
-            'choices': [
-                {
-                    'fields': {
-                        'foobar': {
-                            'type': 'typed-dict-field',
-                            'schema': {
-                                'items_schema': {'schema_ref': 'root-schema', 'type': 'definition-ref'},
-                                'type': 'list',
-                            },
-                        }
-                    },
-                    'type': 'typed-dict',
-                }
+        core_schema.definitions_schema(
+            core_schema.definition_reference_schema('root-schema'),
+            [
+                core_schema.union_schema(
+                    [
+                        core_schema.typed_dict_schema(
+                            {
+                                'foobar': core_schema.typed_dict_field(
+                                    core_schema.list_schema(core_schema.definition_reference_schema('root-schema'))
+                                )
+                            }
+                        )
+                    ],
+                    auto_collapse=False,
+                    strict=strict,
+                    ref='root-schema',
+                )
             ],
-            'auto_collapse': False,
-            'strict': strict,
-            'ref': 'root-schema',
-            'type': 'union',
-        }
+        )
     )
 
     data = {'foobar': []}
@@ -681,18 +648,20 @@ def f(input_value, info):
         return input_value + ' Changed'
 
     v = SchemaValidator(
-        {
-            'choices': [
-                {
-                    'type': 'function-after',
-                    'function': {'type': 'general', 'function': f},
-                    'schema': {'schema_ref': 'root-schema', 'type': 'definition-ref'},
-                },
-                {'type': 'int'},
+        core_schema.definitions_schema(
+            core_schema.definition_reference_schema('root-schema'),
+            [
+                core_schema.union_schema(
+                    [
+                        core_schema.general_after_validator_function(
+                            f, core_schema.definition_reference_schema('root-schema')
+                        ),
+                        core_schema.int_schema(),
+                    ],
+                    ref='root-schema',
+                )
             ],
-            'ref': 'root-schema',
-            'type': 'union',
-        }
+        )
     )
 
     assert v.validate_python(123) == 123
@@ -727,19 +696,21 @@ def f(input_value, info):
         return f'f-{int(count) + 1}'
 
     v = SchemaValidator(
-        {
-            'choices': [
-                {
-                    'type': 'function-before',
-                    'function': {'type': 'general', 'function': f},
-                    'schema': {'schema_ref': 'root-schema', 'type': 'definition-ref'},
-                }
+        core_schema.definitions_schema(
+            core_schema.definition_reference_schema('root-schema'),
+            [
+                core_schema.union_schema(
+                    [
+                        core_schema.general_before_validator_function(
+                            f, core_schema.definition_reference_schema('root-schema')
+                        )
+                    ],
+                    auto_collapse=False,
+                    strict=strict,
+                    ref='root-schema',
+                )
             ],
-            'auto_collapse': False,
-            'strict': strict,
-            'ref': 'root-schema',
-            'type': 'union',
-        }
+        )
     )
 
     with pytest.raises(ValidationError) as exc_info:
@@ -758,23 +729,21 @@ def f(input_value, info):
 def test_many_uses_of_ref():
     # check we can safely exceed RECURSION_GUARD_LIMIT without upsetting the recursion guard
     v = SchemaValidator(
-        {
-            'type': 'typed-dict',
-            'ref': 'Branch',
-            'fields': {
-                'name': {
-                    'type': 'typed-dict-field',
-                    'schema': {'type': 'str', 'max_length': 8, 'ref': 'limited-string'},
-                },
-                'other_names': {
-                    'type': 'typed-dict-field',
-                    'schema': {
-                        'type': 'list',
-                        'items_schema': {'type': 'definition-ref', 'schema_ref': 'limited-string'},
+        core_schema.definitions_schema(
+            core_schema.definition_reference_schema('Branch'),
+            [
+                core_schema.typed_dict_schema(
+                    {
+                        'name': core_schema.typed_dict_field(core_schema.definition_reference_schema('limited-string')),
+                        'other_names': core_schema.typed_dict_field(
+                            core_schema.list_schema(core_schema.definition_reference_schema('limited-string'))
+                        ),
                     },
-                },
-            },
-        }
+                    ref='Branch',
+                ),
+                core_schema.str_schema(max_length=8, ref='limited-string'),
+            ],
+        )
     )
 
     assert v.validate_python({'name': 'Anne', 'other_names': ['Bob', 'Charlie']}) == {
@@ -812,7 +781,8 @@ def test_error_inside_definition_wrapper():
             }
         )
     assert str(exc_info.value) == (
-        'Field "sub_branch":\n'
+        'Error building "typed-dict" validator:\n'
+        '  SchemaError: Field "sub_branch":\n'
         '  SchemaError: Error building "default" validator:\n'
         "  SchemaError: 'default' and 'default_factory' cannot be used together"
     )
@@ -820,7 +790,7 @@ def test_error_inside_definition_wrapper():
 
 def test_recursive_definitions_schema(pydantic_version) -> None:
     s = core_schema.definitions_schema(
-        core_schema.definition_reference_schema(schema_ref='a'),
+        core_schema.definition_reference_schema('a'),
         [
             core_schema.typed_dict_schema(
                 {
@@ -861,7 +831,7 @@ def test_recursive_definitions_schema(pydantic_version) -> None:
 
 def test_unsorted_definitions_schema() -> None:
     s = core_schema.definitions_schema(
-        core_schema.definition_reference_schema(schema_ref='td'),
+        core_schema.definition_reference_schema('td'),
         [
             core_schema.typed_dict_schema(
                 {'x': core_schema.typed_dict_field(core_schema.definition_reference_schema('int'))}, ref='td'
@@ -883,22 +853,28 @@ def test_validate_assignment(pydantic_version) -> None:
     class Model:
         x: List['Model']
 
-    schema = core_schema.dataclass_schema(
-        Model,
-        core_schema.dataclass_args_schema(
-            'Model',
-            [
-                core_schema.dataclass_field(
-                    name='x',
-                    schema=core_schema.list_schema(core_schema.definition_reference_schema('model')),
-                    kw_only=False,
-                )
-            ],
-        ),
-        ['x'],
-        ref='model',
-        config=core_schema.CoreConfig(revalidate_instances='always'),
+    schema = core_schema.definitions_schema(
+        core_schema.definition_reference_schema('model'),
+        [
+            core_schema.dataclass_schema(
+                Model,
+                core_schema.dataclass_args_schema(
+                    'Model',
+                    [
+                        core_schema.dataclass_field(
+                            name='x',
+                            schema=core_schema.list_schema(core_schema.definition_reference_schema('model')),
+                            kw_only=False,
+                        )
+                    ],
+                ),
+                ['x'],
+                ref='model',
+                config=core_schema.CoreConfig(revalidate_instances='always'),
+            )
+        ],
     )
+
     v = SchemaValidator(schema)
 
     data = [Model(x=[Model(x=[])])]
diff --git a/tests/validators/test_tagged_union.py b/tests/validators/test_tagged_union.py
index e2fac95af..3061b2c34 100644
--- a/tests/validators/test_tagged_union.py
+++ b/tests/validators/test_tagged_union.py
@@ -3,7 +3,7 @@
 import pytest
 from dirty_equals import IsAnyStr
 
-from pydantic_core import SchemaValidator, ValidationError
+from pydantic_core import CoreConfig, SchemaValidator, ValidationError, core_schema
 
 from ..conftest import Err, PyAndJson
 from .test_typed_dict import Cls
@@ -495,23 +495,20 @@ def test_from_attributes():
 
 def test_use_ref():
     v = SchemaValidator(
-        {
-            'type': 'tagged-union',
-            'discriminator': 'foobar',
-            'choices': {
-                'apple': {
-                    'type': 'typed-dict',
-                    'ref': 'apple',
-                    'fields': {'a': {'type': 'typed-dict-field', 'schema': {'type': 'str'}}},
-                },
-                'apple2': {'type': 'definition-ref', 'schema_ref': 'apple'},
-                'banana': {
-                    'type': 'typed-dict',
-                    'fields': {'b': {'type': 'typed-dict-field', 'schema': {'type': 'str'}}},
+        core_schema.definitions_schema(
+            core_schema.tagged_union_schema(
+                discriminator='foobar',
+                choices={
+                    'apple': core_schema.definition_reference_schema('apple'),
+                    'apple2': core_schema.definition_reference_schema('apple'),
+                    'banana': core_schema.typed_dict_schema(
+                        {'b': core_schema.typed_dict_field(core_schema.str_schema())}
+                    ),
                 },
-            },
-        },
-        {'from_attributes': True},
+            ),
+            [core_schema.typed_dict_schema({'a': core_schema.typed_dict_field(core_schema.str_schema())}, ref='apple')],
+        ),
+        config=CoreConfig(from_attributes=True),
     )
     assert v.validate_python({'foobar': 'apple', 'a': 'apple'}) == {'a': 'apple'}
     assert v.validate_python({'foobar': 'apple2', 'a': 'apple'}) == {'a': 'apple'}
diff --git a/tests/validators/test_union.py b/tests/validators/test_union.py
index d4ceb4b9f..7e0f608f1 100644
--- a/tests/validators/test_union.py
+++ b/tests/validators/test_union.py
@@ -396,14 +396,19 @@ def test_no_strict_check():
 
 def test_strict_reference():
     v = SchemaValidator(
-        core_schema.tuple_positional_schema(
+        core_schema.definitions_schema(
+            core_schema.definition_reference_schema(schema_ref='tuple-ref'),
             [
-                core_schema.float_schema(),
-                core_schema.union_schema(
-                    [core_schema.int_schema(), core_schema.definition_reference_schema('tuple-ref')]
-                ),
+                core_schema.tuple_positional_schema(
+                    [
+                        core_schema.float_schema(),
+                        core_schema.union_schema(
+                            [core_schema.int_schema(), core_schema.definition_reference_schema('tuple-ref')]
+                        ),
+                    ],
+                    ref='tuple-ref',
+                )
             ],
-            ref='tuple-ref',
         )
     )
     assert 'strict_required:true' in plain_repr(v)

From fb7b50133a8bbf1bf5fcd5dabd94b62f2b58ff6a Mon Sep 17 00:00:00 2001
From: David Hewitt <1939362+davidhewitt@users.noreply.github.com>
Date: Tue, 19 Sep 2023 09:37:26 +0100
Subject: [PATCH 039/550] fix function-after validator changing validation mode
 to Python (#967)

---
 src/validators/function.rs        | 12 ++++++------
 tests/validators/test_function.py | 19 +++++++++++++++++++
 2 files changed, 25 insertions(+), 6 deletions(-)

diff --git a/src/validators/function.rs b/src/validators/function.rs
index 206e10a0c..9f8fe75a7 100644
--- a/src/validators/function.rs
+++ b/src/validators/function.rs
@@ -100,7 +100,7 @@ macro_rules! impl_validator {
                 state: &mut ValidationState<'_>,
             ) -> ValResult<'data, PyObject> {
                 let validate = |v, s: &mut ValidationState<'_>| self.validator.validate(py, v, s);
-                self._validate(validate, py, input.to_object(py).into_ref(py), state)
+                self._validate(validate, py, input, state)
             }
             fn validate_assignment<'data>(
                 &self,
@@ -158,7 +158,7 @@ impl FunctionBeforeValidator {
         &'s self,
         call: impl FnOnce(&'data PyAny, &mut ValidationState<'_>) -> ValResult<'data, PyObject>,
         py: Python<'data>,
-        input: &'data PyAny,
+        input: &'data impl Input<'data>,
         state: &'s mut ValidationState<'_>,
     ) -> ValResult<'data, PyObject> {
         let r = if self.info_arg {
@@ -187,11 +187,11 @@ pub struct FunctionAfterValidator {
 impl_build!(FunctionAfterValidator, "function-after");
 
 impl FunctionAfterValidator {
-    fn _validate<'s, 'data>(
+    fn _validate<'s, 'data, I: Input<'data>>(
         &'s self,
-        call: impl FnOnce(&'data PyAny, &mut ValidationState<'_>) -> ValResult<'data, PyObject>,
+        call: impl FnOnce(&'data I, &mut ValidationState<'_>) -> ValResult<'data, PyObject>,
         py: Python<'data>,
-        input: &'data PyAny,
+        input: &'data I,
         state: &mut ValidationState<'_>,
     ) -> ValResult<'data, PyObject> {
         let v = call(input, state)?;
@@ -326,7 +326,7 @@ impl FunctionWrapValidator {
         &'s self,
         handler: &'s PyAny,
         py: Python<'data>,
-        input: &'data PyAny,
+        input: &'data impl Input<'data>,
         state: &mut ValidationState,
     ) -> ValResult<'data, PyObject> {
         let r = if self.info_arg {
diff --git a/tests/validators/test_function.py b/tests/validators/test_function.py
index a4f9737f7..07710be41 100644
--- a/tests/validators/test_function.py
+++ b/tests/validators/test_function.py
@@ -1,3 +1,4 @@
+import datetime
 import platform
 import re
 from copy import deepcopy
@@ -971,3 +972,21 @@ def __repr__(self) -> str:
         'ValidationInfo(config=None, context=None)',
         "FieldValidationInfo(config=None, context=None, field_name='x')",
     ]
+
+
+def test_function_after_doesnt_change_mode() -> None:
+    # https://github.com/pydantic/pydantic/issues/7468 - function-after was
+    # incorrectly forcing Python validation mode
+
+    def identity(v):
+        return v
+
+    schema = core_schema.no_info_after_validator_function(identity, core_schema.date_schema(strict=True))
+    v = SchemaValidator(schema)
+
+    # this input should be valid JSON input, but isn't valid Python input, so
+    # the following tests will pass if the after_validator is not
+    # forcing the mode to Python
+    assert v.validate_json(b'"2000-01-01"') == datetime.date(2000, 1, 1)
+    with pytest.raises(ValidationError):
+        v.validate_python(b'"2000-01-01"')

From 367a67aaa17c2e0a4daf086250c265f2a61ee499 Mon Sep 17 00:00:00 2001
From: Samuel Colvin <s@muelcolvin.com>
Date: Tue, 19 Sep 2023 16:42:09 +0100
Subject: [PATCH 040/550] implementing `validate_strings` (#883)

Co-authored-by: David Hewitt <1939362+davidhewitt@users.noreply.github.com>
---
 python/pydantic_core/_pydantic_core.pyi |  29 ++-
 src/build_tools.rs                      |   5 +-
 src/errors/mod.rs                       |   2 +-
 src/errors/types.rs                     |  41 ++---
 src/errors/validation_exception.rs      |  47 +++--
 src/errors/value_exception.rs           |   5 +-
 src/input/input_abstract.rs             |  37 +++-
 src/input/input_json.rs                 | 127 ++++---------
 src/input/input_python.rs               |  15 +-
 src/input/input_string.rs               | 229 ++++++++++++++++++++++++
 src/input/mod.rs                        |   8 +-
 src/input/return_enums.rs               |  35 ++++
 src/input/shared.rs                     |   8 +-
 src/lookup_key.rs                       |  39 +++-
 src/validators/arguments.rs             |   1 +
 src/validators/dataclass.rs             |  52 ++++--
 src/validators/dict.rs                  |  24 ++-
 src/validators/function.rs              |   2 +-
 src/validators/generator.rs             |  16 +-
 src/validators/json_or_python.rs        |   4 +-
 src/validators/mod.rs                   |  52 ++++--
 src/validators/model_fields.rs          |  61 ++++---
 src/validators/typed_dict.rs            |  67 ++++---
 src/validators/union.rs                 |   3 +-
 src/validators/validation_state.rs      |   1 +
 tests/conftest.py                       |   3 +
 tests/test_validate_strings.py          | 121 +++++++++++++
 tests/validators/test_bool.py           |   3 +-
 tests/validators/test_float.py          |   3 +-
 tests/validators/test_int.py            |   3 +-
 tests/validators/test_json.py           |  13 +-
 31 files changed, 777 insertions(+), 279 deletions(-)
 create mode 100644 src/input/input_string.rs
 create mode 100644 tests/test_validate_strings.py

diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index 9b24e7076..be2b64793 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -52,6 +52,8 @@ _recursion_limit: int
 
 _T = TypeVar('_T', default=Any, covariant=True)
 
+_StringInput: TypeAlias = 'dict[str, _StringInput]'
+
 @final
 class Some(Generic[_T]):
     """
@@ -168,6 +170,29 @@ class SchemaValidator:
             ValidationError: If validation fails or if the JSON data is invalid.
             Exception: Other error types maybe raised if internal errors occur.
 
+        Returns:
+            The validated Python object.
+        """
+    def validate_strings(
+        self, input: _StringInput, *, strict: bool | None = None, context: 'dict[str, Any] | None' = None
+    ) -> Any:
+        """
+        Validate a string against the schema and return the validated Python object.
+
+        This is similar to `validate_json` but applies to scenarios where the input will be a string but not
+        JSON data, e.g. URL fragments, query parameters, etc.
+
+        Arguments:
+            input: The input as a string, or bytes/bytearray if `strict=False`.
+            strict: Whether to validate the object in strict mode.
+                If `None`, the value of [`CoreConfig.strict`][pydantic_core.core_schema.CoreConfig] is used.
+            context: The context to use for validation, this is passed to functional validators as
+                [`info.context`][pydantic_core.core_schema.ValidationInfo.context].
+
+        Raises:
+            ValidationError: If validation fails or if the JSON data is invalid.
+            Exception: Other error types maybe raised if internal errors occur.
+
         Returns:
             The validated Python object.
         """
@@ -680,7 +705,7 @@ class ValidationError(ValueError):
     def from_exception_data(
         title: str,
         line_errors: list[InitErrorDetails],
-        error_mode: Literal['python', 'json'] = 'python',
+        input_type: Literal['python', 'json'] = 'python',
         hide_input: bool = False,
     ) -> ValidationError:
         """
@@ -693,7 +718,7 @@ class ValidationError(ValueError):
             title: The title of the error, as used in the heading of `str(validation_error)`
             line_errors: A list of [`InitErrorDetails`][pydantic_core.InitErrorDetails] which contain information
                 about errors that occurred during validation.
-            error_mode: Whether the error is for a Python object or JSON.
+            input_type: Whether the error is for a Python object or JSON.
             hide_input: Whether to hide the input value in the error message.
         """
     @property
diff --git a/src/build_tools.rs b/src/build_tools.rs
index d2bc7c2cd..47fa569ac 100644
--- a/src/build_tools.rs
+++ b/src/build_tools.rs
@@ -6,7 +6,8 @@ use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList, PyString};
 use pyo3::{intern, FromPyObject, PyErrArguments};
 
-use crate::errors::{ErrorMode, ValError};
+use crate::errors::ValError;
+use crate::input::InputType;
 use crate::tools::SchemaDict;
 use crate::ValidationError;
 
@@ -86,7 +87,7 @@ impl SchemaError {
             ValError::LineErrors(raw_errors) => {
                 let line_errors = raw_errors.into_iter().map(|e| e.into_py(py)).collect();
                 let validation_error =
-                    ValidationError::new(line_errors, "Schema".to_object(py), ErrorMode::Python, false);
+                    ValidationError::new(line_errors, "Schema".to_object(py), InputType::Python, false);
                 let schema_error = SchemaError(SchemaErrorEnum::ValidationError(validation_error));
                 match Py::new(py, schema_error) {
                     Ok(err) => PyErr::from_value(err.into_ref(py)),
diff --git a/src/errors/mod.rs b/src/errors/mod.rs
index ed10049de..6a253197f 100644
--- a/src/errors/mod.rs
+++ b/src/errors/mod.rs
@@ -8,7 +8,7 @@ mod value_exception;
 
 pub use self::line_error::{InputValue, ValError, ValLineError, ValResult};
 pub use self::location::LocItem;
-pub use self::types::{list_all_errors, ErrorMode, ErrorType, ErrorTypeDefaults, Number};
+pub use self::types::{list_all_errors, ErrorType, ErrorTypeDefaults, Number};
 pub use self::validation_exception::ValidationError;
 pub use self::value_exception::{PydanticCustomError, PydanticKnownError, PydanticOmit, PydanticUseDefault};
 
diff --git a/src/errors/types.rs b/src/errors/types.rs
index d7e1051b7..da4d5fdd7 100644
--- a/src/errors/types.rs
+++ b/src/errors/types.rs
@@ -2,37 +2,20 @@ use std::any::type_name;
 use std::borrow::Cow;
 use std::fmt;
 
-use ahash::AHashMap;
-use num_bigint::BigInt;
-use pyo3::exceptions::{PyKeyError, PyTypeError, PyValueError};
+use pyo3::exceptions::{PyKeyError, PyTypeError};
 use pyo3::once_cell::GILOnceCell;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList};
 
-use crate::input::Int;
-use crate::tools::{extract_i64, py_err, py_error_type};
+use ahash::AHashMap;
+use num_bigint::BigInt;
 use strum::{Display, EnumMessage, IntoEnumIterator};
 use strum_macros::EnumIter;
 
-use super::PydanticCustomError;
-
-#[derive(Clone, Debug)]
-pub enum ErrorMode {
-    Python,
-    Json,
-}
-
-impl TryFrom<&str> for ErrorMode {
-    type Error = PyErr;
+use crate::input::{InputType, Int};
+use crate::tools::{extract_i64, py_err, py_error_type};
 
-    fn try_from(error_mode: &str) -> PyResult<Self> {
-        match error_mode {
-            "python" => Ok(Self::Python),
-            "json" => Ok(Self::Json),
-            s => py_err!(PyValueError; "Invalid error mode: {}", s),
-        }
-    }
-}
+use super::PydanticCustomError;
 
 #[pyfunction]
 pub fn list_all_errors(py: Python) -> PyResult<&PyList> {
@@ -45,12 +28,12 @@ pub fn list_all_errors(py: Python) -> PyResult<&PyList> {
             d.set_item("message_template_python", message_template_python)?;
             d.set_item(
                 "example_message_python",
-                error_type.render_message(py, &ErrorMode::Python)?,
+                error_type.render_message(py, InputType::Python)?,
             )?;
             let message_template_json = error_type.message_template_json();
             if message_template_python != message_template_json {
                 d.set_item("message_template_json", message_template_json)?;
-                d.set_item("example_message_json", error_type.render_message(py, &ErrorMode::Json)?)?;
+                d.set_item("example_message_json", error_type.render_message(py, InputType::Json)?)?;
             }
             d.set_item("example_context", error_type.py_dict(py)?)?;
             errors.push(d);
@@ -623,10 +606,10 @@ impl ErrorType {
         }
     }
 
-    pub fn render_message(&self, py: Python, error_mode: &ErrorMode) -> PyResult<String> {
-        let tmpl = match error_mode {
-            ErrorMode::Python => self.message_template_python(),
-            ErrorMode::Json => self.message_template_json(),
+    pub fn render_message(&self, py: Python, input_type: InputType) -> PyResult<String> {
+        let tmpl = match input_type {
+            InputType::Python => self.message_template_python(),
+            _ => self.message_template_json(),
         };
         match self {
             Self::NoSuchAttribute { attribute, .. } => render!(tmpl, attribute),
diff --git a/src/errors/validation_exception.rs b/src/errors/validation_exception.rs
index e6563f597..d0977001a 100644
--- a/src/errors/validation_exception.rs
+++ b/src/errors/validation_exception.rs
@@ -16,12 +16,13 @@ use serde_json::ser::PrettyFormatter;
 use crate::build_tools::py_schema_error_type;
 use crate::errors::LocItem;
 use crate::get_pydantic_version;
+use crate::input::InputType;
 use crate::serializers::{SerMode, SerializationState};
 use crate::tools::{safe_repr, SchemaDict};
 
 use super::line_error::ValLineError;
 use super::location::Location;
-use super::types::{ErrorMode, ErrorType};
+use super::types::ErrorType;
 use super::value_exception::PydanticCustomError;
 use super::{InputValue, ValError};
 
@@ -31,16 +32,16 @@ use super::{InputValue, ValError};
 pub struct ValidationError {
     line_errors: Vec<PyLineError>,
     title: PyObject,
-    error_mode: ErrorMode,
+    input_type: InputType,
     hide_input: bool,
 }
 
 impl ValidationError {
-    pub fn new(line_errors: Vec<PyLineError>, title: PyObject, error_mode: ErrorMode, hide_input: bool) -> Self {
+    pub fn new(line_errors: Vec<PyLineError>, title: PyObject, input_type: InputType, hide_input: bool) -> Self {
         Self {
             line_errors,
             title,
-            error_mode,
+            input_type,
             hide_input,
         }
     }
@@ -48,7 +49,7 @@ impl ValidationError {
     pub fn from_val_error(
         py: Python,
         title: PyObject,
-        error_mode: ErrorMode,
+        input_type: InputType,
         error: ValError,
         outer_location: Option<LocItem>,
         hide_input: bool,
@@ -63,9 +64,7 @@ impl ValidationError {
                         .collect(),
                     None => raw_errors.into_iter().map(|e| e.into_py(py)).collect(),
                 };
-
-                let validation_error = Self::new(line_errors, title, error_mode, hide_input);
-
+                let validation_error = Self::new(line_errors, title, input_type, hide_input);
                 match Py::new(py, validation_error) {
                     Ok(err) => {
                         if validation_error_cause {
@@ -87,7 +86,7 @@ impl ValidationError {
 
     pub fn display(&self, py: Python, prefix_override: Option<&'static str>, hide_input: bool) -> String {
         let url_prefix = get_url_prefix(py, include_url_env(py));
-        let line_errors = pretty_py_line_errors(py, &self.error_mode, self.line_errors.iter(), url_prefix, hide_input);
+        let line_errors = pretty_py_line_errors(py, self.input_type, self.line_errors.iter(), url_prefix, hide_input);
         if let Some(prefix) = prefix_override {
             format!("{prefix}\n{line_errors}")
         } else {
@@ -238,12 +237,12 @@ impl ValidationError {
 #[pymethods]
 impl ValidationError {
     #[staticmethod]
-    #[pyo3(signature = (title, line_errors, error_mode="python", hide_input=false))]
+    #[pyo3(signature = (title, line_errors, input_type="python", hide_input=false))]
     fn from_exception_data(
         py: Python,
         title: PyObject,
         line_errors: &PyList,
-        error_mode: &str,
+        input_type: &str,
         hide_input: bool,
     ) -> PyResult<Py<Self>> {
         Py::new(
@@ -251,7 +250,7 @@ impl ValidationError {
             Self {
                 line_errors: line_errors.iter().map(PyLineError::try_from).collect::<PyResult<_>>()?,
                 title,
-                error_mode: ErrorMode::try_from(error_mode)?,
+                input_type: InputType::try_from(input_type)?,
                 hide_input,
             },
         )
@@ -279,7 +278,7 @@ impl ValidationError {
                 if iteration_error.is_some() {
                     return py.None();
                 }
-                e.as_dict(py, url_prefix, include_context, &self.error_mode)
+                e.as_dict(py, url_prefix, include_context, self.input_type)
                     .unwrap_or_else(|err| {
                         iteration_error = Some(err);
                         py.None()
@@ -309,7 +308,7 @@ impl ValidationError {
             url_prefix: get_url_prefix(py, include_url),
             include_context,
             extra: &extra,
-            error_mode: &self.error_mode,
+            input_type: &self.input_type,
         };
 
         let writer: Vec<u8> = Vec::with_capacity(self.line_errors.len() * 200);
@@ -387,13 +386,13 @@ macro_rules! truncate_input_value {
 
 pub fn pretty_py_line_errors<'a>(
     py: Python,
-    error_mode: &ErrorMode,
+    input_type: InputType,
     line_errors_iter: impl Iterator<Item = &'a PyLineError>,
     url_prefix: Option<&str>,
     hide_input: bool,
 ) -> String {
     line_errors_iter
-        .map(|i| i.pretty(py, error_mode, url_prefix, hide_input))
+        .map(|i| i.pretty(py, input_type, url_prefix, hide_input))
         .collect::<Result<Vec<_>, _>>()
         .unwrap_or_else(|err| vec![format!("[error formatting line errors: {err}]")])
         .join("\n")
@@ -477,12 +476,12 @@ impl PyLineError {
         py: Python,
         url_prefix: Option<&str>,
         include_context: bool,
-        error_mode: &ErrorMode,
+        input_type: InputType,
     ) -> PyResult<PyObject> {
         let dict = PyDict::new(py);
         dict.set_item("type", self.error_type.type_string())?;
         dict.set_item("loc", self.location.to_object(py))?;
-        dict.set_item("msg", self.error_type.render_message(py, error_mode)?)?;
+        dict.set_item("msg", self.error_type.render_message(py, input_type)?)?;
         dict.set_item("input", &self.input_value)?;
         if include_context {
             if let Some(context) = self.error_type.py_dict(py)? {
@@ -505,14 +504,14 @@ impl PyLineError {
     fn pretty(
         &self,
         py: Python,
-        error_mode: &ErrorMode,
+        input_type: InputType,
         url_prefix: Option<&str>,
         hide_input: bool,
     ) -> Result<String, fmt::Error> {
         let mut output = String::with_capacity(200);
         write!(output, "{}", self.location)?;
 
-        let message = match self.error_type.render_message(py, error_mode) {
+        let message = match self.error_type.render_message(py, input_type) {
             Ok(message) => message,
             Err(err) => format!("(error rendering message: {err})"),
         };
@@ -565,7 +564,7 @@ struct ValidationErrorSerializer<'py> {
     url_prefix: Option<&'py str>,
     include_context: bool,
     extra: &'py crate::serializers::Extra<'py>,
-    error_mode: &'py ErrorMode,
+    input_type: &'py InputType,
 }
 
 impl<'py> Serialize for ValidationErrorSerializer<'py> {
@@ -581,7 +580,7 @@ impl<'py> Serialize for ValidationErrorSerializer<'py> {
                 url_prefix: self.url_prefix,
                 include_context: self.include_context,
                 extra: self.extra,
-                error_mode: self.error_mode,
+                input_type: self.input_type,
             };
             seq.serialize_element(&line_s)?;
         }
@@ -595,7 +594,7 @@ struct PyLineErrorSerializer<'py> {
     url_prefix: Option<&'py str>,
     include_context: bool,
     extra: &'py crate::serializers::Extra<'py>,
-    error_mode: &'py ErrorMode,
+    input_type: &'py InputType,
 }
 
 impl<'py> Serialize for PyLineErrorSerializer<'py> {
@@ -620,7 +619,7 @@ impl<'py> Serialize for PyLineErrorSerializer<'py> {
         let msg = self
             .line_error
             .error_type
-            .render_message(py, self.error_mode)
+            .render_message(py, *self.input_type)
             .map_err(py_err_json::<S>)?;
         map.serialize_entry("msg", &msg)?;
 
diff --git a/src/errors/value_exception.rs b/src/errors/value_exception.rs
index d0c08bf5f..f7d877b30 100644
--- a/src/errors/value_exception.rs
+++ b/src/errors/value_exception.rs
@@ -1,9 +1,8 @@
-use crate::errors::ErrorMode;
 use pyo3::exceptions::{PyException, PyValueError};
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyString};
 
-use crate::input::Input;
+use crate::input::{Input, InputType};
 use crate::tools::extract_i64;
 
 use super::{ErrorType, ValError};
@@ -164,7 +163,7 @@ impl PydanticKnownError {
     }
 
     pub fn message(&self, py: Python) -> PyResult<String> {
-        self.error_type.render_message(py, &ErrorMode::Python)
+        self.error_type.render_message(py, InputType::Python)
     }
 
     fn __str__(&self, py: Python) -> PyResult<String> {
diff --git a/src/input/input_abstract.rs b/src/input/input_abstract.rs
index d799da473..f4a760a45 100644
--- a/src/input/input_abstract.rs
+++ b/src/input/input_abstract.rs
@@ -1,9 +1,11 @@
 use std::fmt;
 
+use pyo3::exceptions::PyValueError;
 use pyo3::types::{PyDict, PyType};
 use pyo3::{intern, prelude::*};
 
 use crate::errors::{InputValue, LocItem, ValResult};
+use crate::tools::py_err;
 use crate::{PyMultiHostUrl, PyUrl};
 
 use super::datetime::{EitherDate, EitherDateTime, EitherTime, EitherTimedelta};
@@ -14,6 +16,7 @@ use super::{EitherFloat, GenericArguments, GenericIterable, GenericIterator, Gen
 pub enum InputType {
     Python,
     Json,
+    String,
 }
 
 impl IntoPy<PyObject> for InputType {
@@ -21,6 +24,20 @@ impl IntoPy<PyObject> for InputType {
         match self {
             Self::Json => intern!(py, "json").into(),
             Self::Python => intern!(py, "python").into(),
+            Self::String => intern!(py, "string").into(),
+        }
+    }
+}
+
+impl TryFrom<&str> for InputType {
+    type Error = PyErr;
+
+    fn try_from(error_mode: &str) -> PyResult<Self> {
+        match error_mode {
+            "python" => Ok(Self::Python),
+            "json" => Ok(Self::Json),
+            "string" => Ok(Self::String),
+            s => py_err!(PyValueError; "Invalid error mode: {}", s),
         }
     }
 }
@@ -38,7 +55,9 @@ pub trait Input<'a>: fmt::Debug + ToPyObject {
         None
     }
 
-    fn is_none(&self) -> bool;
+    fn is_none(&self) -> bool {
+        false
+    }
 
     fn input_is_instance(&self, _class: &PyType) -> Option<&PyAny> {
         None
@@ -320,3 +339,19 @@ pub trait Input<'a>: fmt::Debug + ToPyObject {
         self.strict_timedelta(microseconds_overflow_behavior)
     }
 }
+
+/// The problem to solve here is that iterating a `StringMapping` returns an owned
+/// `StringMapping`, but all the other iterators return references. By introducing
+/// this trait we abstract over whether the return value from the iterator is owned
+/// or borrowed; all we care about is that we can borrow it again with `borrow_input`
+/// for some lifetime 'a.
+///
+/// This lifetime `'a` is shorter than the original lifetime `'data` of the input,
+/// which is only a problem in error branches. To resolve we have to call `into_owned`
+/// to extend out the lifetime to match the original input.
+pub trait BorrowInput {
+    type Input<'a>: Input<'a>
+    where
+        Self: 'a;
+    fn borrow_input(&self) -> &Self::Input<'_>;
+}
diff --git a/src/input/input_json.rs b/src/input/input_json.rs
index d948e2493..07f3554e6 100644
--- a/src/input/input_json.rs
+++ b/src/input/input_json.rs
@@ -12,11 +12,10 @@ use super::datetime::{
     bytes_as_date, bytes_as_datetime, bytes_as_time, bytes_as_timedelta, float_as_datetime, float_as_duration,
     float_as_time, int_as_datetime, int_as_duration, int_as_time, EitherDate, EitherDateTime, EitherTime,
 };
-use super::parse_json::JsonArray;
-use super::shared::{float_as_int, int_as_bool, map_json_err, str_as_bool, str_as_float, str_as_int};
+use super::shared::{float_as_int, int_as_bool, map_json_err, str_as_bool, str_as_float, str_as_int, string_to_vec};
 use super::{
-    EitherBytes, EitherFloat, EitherInt, EitherString, EitherTimedelta, GenericArguments, GenericIterable,
-    GenericIterator, GenericMapping, Input, JsonArgs, JsonInput,
+    BorrowInput, EitherBytes, EitherFloat, EitherInt, EitherString, EitherTimedelta, GenericArguments, GenericIterable,
+    GenericIterator, GenericMapping, Input, JsonArgs, JsonArray, JsonInput,
 };
 
 impl<'a> Input<'a> for JsonInput {
@@ -355,6 +354,15 @@ impl<'a> Input<'a> for JsonInput {
     }
 }
 
+impl BorrowInput for &'_ JsonInput {
+    type Input<'a> = JsonInput where Self: 'a;
+    fn borrow_input(&self) -> &Self::Input<'_> {
+        self
+    }
+}
+
+/// TODO: it would be good to get JsonInput and StringMapping string variants to go through this
+/// implementation
 /// Required for Dict keys so the string can behave like an Input
 impl<'a> Input<'a> for String {
     fn as_loc_item(&self) -> LocItem {
@@ -365,11 +373,6 @@ impl<'a> Input<'a> for String {
         InputValue::String(self)
     }
 
-    #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn is_none(&self) -> bool {
-        false
-    }
-
     fn as_kwargs(&'a self, _py: Python<'a>) -> Option<&'a PyDict> {
         None
     }
@@ -395,47 +398,29 @@ impl<'a> Input<'a> for String {
         serde_json::from_str(self.as_str()).map_err(|e| map_json_err(self, e))
     }
 
-    fn validate_str(&'a self, _strict: bool) -> ValResult<EitherString<'a>> {
-        Ok(self.as_str().into())
-    }
     fn strict_str(&'a self) -> ValResult<EitherString<'a>> {
-        self.validate_str(false)
+        Ok(self.as_str().into())
     }
 
-    fn validate_bytes(&'a self, _strict: bool) -> ValResult<EitherBytes<'a>> {
-        Ok(self.as_bytes().into())
-    }
-    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn strict_bytes(&'a self) -> ValResult<EitherBytes<'a>> {
-        self.validate_bytes(false)
+        Ok(self.as_bytes().into())
     }
 
     fn strict_bool(&self) -> ValResult<bool> {
-        Err(ValError::new(ErrorTypeDefaults::BoolType, self))
-    }
-    fn lax_bool(&self) -> ValResult<bool> {
         str_as_bool(self, self)
     }
 
     fn strict_int(&'a self) -> ValResult<EitherInt<'a>> {
-        Err(ValError::new(ErrorTypeDefaults::IntType, self))
-    }
-    fn lax_int(&'a self) -> ValResult<EitherInt<'a>> {
         match self.parse() {
             Ok(i) => Ok(EitherInt::I64(i)),
             Err(_) => Err(ValError::new(ErrorTypeDefaults::IntParsing, self)),
         }
     }
 
-    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn ultra_strict_float(&'a self) -> ValResult<EitherFloat<'a>> {
         self.strict_float()
     }
-    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn strict_float(&'a self) -> ValResult<EitherFloat<'a>> {
-        Err(ValError::new(ErrorTypeDefaults::FloatType, self))
-    }
-    fn lax_float(&'a self) -> ValResult<EitherFloat<'a>> {
         str_as_float(self, self)
     }
 
@@ -443,49 +428,29 @@ impl<'a> Input<'a> for String {
         create_decimal(self.to_object(py).into_ref(py), self, py)
     }
 
-    #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn validate_dict(&'a self, _strict: bool) -> ValResult<GenericMapping<'a>> {
-        Err(ValError::new(ErrorTypeDefaults::DictType, self))
-    }
     #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn strict_dict(&'a self) -> ValResult<GenericMapping<'a>> {
-        self.validate_dict(false)
+        Err(ValError::new(ErrorTypeDefaults::DictType, self))
     }
 
-    #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn validate_list(&'a self, _strict: bool) -> ValResult<GenericIterable<'a>> {
-        Err(ValError::new(ErrorTypeDefaults::ListType, self))
-    }
     #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn strict_list(&'a self) -> ValResult<GenericIterable<'a>> {
-        self.validate_list(false)
+        Err(ValError::new(ErrorTypeDefaults::ListType, self))
     }
 
-    #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn validate_tuple(&'a self, _strict: bool) -> ValResult<GenericIterable<'a>> {
-        Err(ValError::new(ErrorTypeDefaults::TupleType, self))
-    }
     #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn strict_tuple(&'a self) -> ValResult<GenericIterable<'a>> {
-        self.validate_tuple(false)
+        Err(ValError::new(ErrorTypeDefaults::TupleType, self))
     }
 
-    #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn validate_set(&'a self, _strict: bool) -> ValResult<GenericIterable<'a>> {
-        Err(ValError::new(ErrorTypeDefaults::SetType, self))
-    }
     #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn strict_set(&'a self) -> ValResult<GenericIterable<'a>> {
-        self.validate_set(false)
+        Err(ValError::new(ErrorTypeDefaults::SetType, self))
     }
 
-    #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn validate_frozenset(&'a self, _strict: bool) -> ValResult<GenericIterable<'a>> {
-        Err(ValError::new(ErrorTypeDefaults::FrozenSetType, self))
-    }
     #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn strict_frozenset(&'a self) -> ValResult<GenericIterable<'a>> {
-        self.validate_frozenset(false)
+        Err(ValError::new(ErrorTypeDefaults::FrozenSetType, self))
     }
 
     fn extract_generic_iterable(&'a self) -> ValResult<GenericIterable<'a>> {
@@ -496,60 +461,42 @@ impl<'a> Input<'a> for String {
         Ok(string_to_vec(self).into())
     }
 
-    fn validate_date(&self, _strict: bool) -> ValResult<EitherDate> {
-        bytes_as_date(self, self.as_bytes())
-    }
-    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn strict_date(&self) -> ValResult<EitherDate> {
-        self.validate_date(false)
+        bytes_as_date(self, self.as_bytes())
     }
 
-    fn validate_time(
-        &self,
-        _strict: bool,
-        microseconds_overflow_behavior: speedate::MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<EitherTime> {
-        bytes_as_time(self, self.as_bytes(), microseconds_overflow_behavior)
-    }
-    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn strict_time(
         &self,
-        microseconds_overflow_behavior: speedate::MicrosecondsPrecisionOverflowBehavior,
+        microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
     ) -> ValResult<EitherTime> {
-        self.validate_time(false, microseconds_overflow_behavior)
+        bytes_as_time(self, self.as_bytes(), microseconds_overflow_behavior)
     }
 
-    fn validate_datetime(
-        &self,
-        _strict: bool,
-        microseconds_overflow_behavior: speedate::MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<EitherDateTime> {
-        bytes_as_datetime(self, self.as_bytes(), microseconds_overflow_behavior)
-    }
-    #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn strict_datetime(
         &self,
-        microseconds_overflow_behavior: speedate::MicrosecondsPrecisionOverflowBehavior,
+        microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
     ) -> ValResult<EitherDateTime> {
-        self.validate_datetime(false, microseconds_overflow_behavior)
+        bytes_as_datetime(self, self.as_bytes(), microseconds_overflow_behavior)
     }
 
-    fn validate_timedelta(
+    fn strict_timedelta(
         &self,
-        _strict: bool,
-        microseconds_overflow_behavior: speedate::MicrosecondsPrecisionOverflowBehavior,
+        microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
     ) -> ValResult<EitherTimedelta> {
         bytes_as_timedelta(self, self.as_bytes(), microseconds_overflow_behavior)
     }
-    #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn strict_timedelta(
-        &self,
-        microseconds_overflow_behavior: speedate::MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<EitherTimedelta> {
-        self.validate_timedelta(false, microseconds_overflow_behavior)
+}
+
+impl BorrowInput for &'_ String {
+    type Input<'a> = String where Self: 'a;
+    fn borrow_input(&self) -> &Self::Input<'_> {
+        self
     }
 }
 
-fn string_to_vec(s: &str) -> JsonArray {
-    JsonArray::new(s.chars().map(|c| JsonInput::String(c.to_string())).collect())
+impl BorrowInput for String {
+    type Input<'a> = String where Self: 'a;
+    fn borrow_input(&self) -> &Self::Input<'_> {
+        self
+    }
 }
diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index 3fbf20240..9e5fd1d1f 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -23,7 +23,7 @@ use super::datetime::{
 };
 use super::shared::{decimal_as_int, float_as_int, int_as_bool, map_json_err, str_as_bool, str_as_float, str_as_int};
 use super::{
-    py_string_str, EitherBytes, EitherFloat, EitherInt, EitherString, EitherTimedelta, GenericArguments,
+    py_string_str, BorrowInput, EitherBytes, EitherFloat, EitherInt, EitherString, EitherTimedelta, GenericArguments,
     GenericIterable, GenericIterator, GenericMapping, Input, JsonInput, PyArgs,
 };
 
@@ -184,7 +184,7 @@ impl<'a> Input<'a> for PyAny {
         if let Ok(py_bytes) = self.downcast::<PyBytes>() {
             serde_json::from_slice(py_bytes.as_bytes()).map_err(|e| map_json_err(self, e))
         } else if let Ok(py_str) = self.downcast::<PyString>() {
-            let str = py_str.to_str()?;
+            let str = py_string_str(py_str)?;
             serde_json::from_str(str).map_err(|e| map_json_err(self, e))
         } else if let Ok(py_byte_array) = self.downcast::<PyByteArray>() {
             // Safety: from_slice does not run arbitrary Python code and the GIL is held so the
@@ -196,7 +196,7 @@ impl<'a> Input<'a> for PyAny {
     }
 
     fn strict_str(&'a self) -> ValResult<EitherString<'a>> {
-        if let Ok(py_str) = <PyString as PyTryFrom>::try_from_exact(self) {
+        if let Ok(py_str) = PyString::try_from_exact(self) {
             Ok(py_str.into())
         } else if let Ok(py_str) = self.downcast::<PyString>() {
             // force to a rust string to make sure behavior is consistent whether or not we go via a
@@ -208,7 +208,7 @@ impl<'a> Input<'a> for PyAny {
     }
 
     fn exact_str(&'a self) -> ValResult<EitherString<'a>> {
-        if let Ok(py_str) = <PyString as PyTryFrom>::try_from_exact(self) {
+        if let Ok(py_str) = PyString::try_from_exact(self) {
             Ok(EitherString::Py(py_str))
         } else {
             Err(ValError::new(ErrorTypeDefaults::IntType, self))
@@ -710,6 +710,13 @@ impl<'a> Input<'a> for PyAny {
     }
 }
 
+impl BorrowInput for &'_ PyAny {
+    type Input<'a> = PyAny where Self: 'a;
+    fn borrow_input(&self) -> &Self::Input<'_> {
+        self
+    }
+}
+
 /// Best effort check of whether it's likely to make sense to inspect obj for attributes and iterate over it
 /// with `obj.dir()`
 fn from_attributes_applicable(obj: &PyAny) -> bool {
diff --git a/src/input/input_string.rs b/src/input/input_string.rs
new file mode 100644
index 000000000..72a32d897
--- /dev/null
+++ b/src/input/input_string.rs
@@ -0,0 +1,229 @@
+use pyo3::prelude::*;
+use pyo3::types::{PyDict, PyString};
+
+use speedate::MicrosecondsPrecisionOverflowBehavior;
+
+use crate::errors::{ErrorTypeDefaults, InputValue, LocItem, ValError, ValResult};
+use crate::input::py_string_str;
+use crate::tools::safe_repr;
+use crate::validators::decimal::create_decimal;
+
+use super::datetime::{
+    bytes_as_date, bytes_as_datetime, bytes_as_time, bytes_as_timedelta, EitherDate, EitherDateTime, EitherTime,
+};
+use super::shared::{map_json_err, str_as_bool, str_as_float};
+use super::{
+    BorrowInput, EitherBytes, EitherFloat, EitherInt, EitherString, EitherTimedelta, GenericArguments, GenericIterable,
+    GenericIterator, GenericMapping, Input, JsonInput,
+};
+
+#[derive(Debug)]
+pub enum StringMapping<'py> {
+    String(&'py PyString),
+    Mapping(&'py PyDict),
+}
+
+impl<'py> ToPyObject for StringMapping<'py> {
+    fn to_object(&self, py: Python<'_>) -> PyObject {
+        match self {
+            Self::String(s) => s.to_object(py),
+            Self::Mapping(d) => d.to_object(py),
+        }
+    }
+}
+
+impl<'py> StringMapping<'py> {
+    pub fn new_key(py_key: &'py PyAny) -> ValResult<'py, StringMapping> {
+        if let Ok(py_str) = py_key.downcast::<PyString>() {
+            Ok(Self::String(py_str))
+        } else {
+            Err(ValError::new(ErrorTypeDefaults::StringType, py_key))
+        }
+    }
+
+    pub fn new_value(py_value: &'py PyAny) -> ValResult<'py, Self> {
+        if let Ok(py_str) = py_value.downcast::<PyString>() {
+            Ok(Self::String(py_str))
+        } else if let Ok(value) = py_value.downcast::<PyDict>() {
+            Ok(Self::Mapping(value))
+        } else {
+            Err(ValError::new(ErrorTypeDefaults::StringType, py_value))
+        }
+    }
+}
+
+impl<'a> Input<'a> for StringMapping<'a> {
+    fn as_loc_item(&self) -> LocItem {
+        match self {
+            Self::String(s) => s.to_string_lossy().as_ref().into(),
+            Self::Mapping(d) => safe_repr(d).to_string().into(),
+        }
+    }
+
+    fn as_error_value(&'a self) -> InputValue<'a> {
+        match self {
+            Self::String(s) => s.as_error_value(),
+            Self::Mapping(d) => InputValue::PyAny(d),
+        }
+    }
+
+    fn as_kwargs(&'a self, _py: Python<'a>) -> Option<&'a PyDict> {
+        None
+    }
+
+    fn validate_args(&'a self) -> ValResult<'a, GenericArguments<'a>> {
+        // do we want to support this?
+        Err(ValError::new(ErrorTypeDefaults::ArgumentsType, self))
+    }
+
+    fn validate_dataclass_args(&'a self, _dataclass_name: &str) -> ValResult<'a, GenericArguments<'a>> {
+        match self {
+            StringMapping::String(_) => Err(ValError::new(ErrorTypeDefaults::ArgumentsType, self)),
+            StringMapping::Mapping(m) => Ok(GenericArguments::StringMapping(m)),
+        }
+    }
+
+    fn parse_json(&'a self) -> ValResult<'a, JsonInput> {
+        match self {
+            Self::String(s) => {
+                let str = py_string_str(s)?;
+                serde_json::from_str(str).map_err(|e| map_json_err(self, e))
+            }
+            Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::JsonType, self)),
+        }
+    }
+
+    fn strict_str(&'a self) -> ValResult<EitherString<'a>> {
+        match self {
+            Self::String(s) => Ok((*s).into()),
+            Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::StringType, self)),
+        }
+    }
+
+    fn strict_bytes(&'a self) -> ValResult<EitherBytes<'a>> {
+        match self {
+            Self::String(s) => py_string_str(s).map(|b| b.as_bytes().into()),
+            Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::BytesType, self)),
+        }
+    }
+
+    fn lax_bytes(&'a self) -> ValResult<EitherBytes<'a>> {
+        match self {
+            Self::String(s) => {
+                let str = py_string_str(s)?;
+                Ok(str.as_bytes().into())
+            }
+            Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::BytesType, self)),
+        }
+    }
+
+    fn strict_bool(&self) -> ValResult<bool> {
+        match self {
+            Self::String(s) => str_as_bool(self, py_string_str(s)?),
+            Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::BoolType, self)),
+        }
+    }
+
+    fn strict_int(&'a self) -> ValResult<EitherInt<'a>> {
+        match self {
+            Self::String(s) => match py_string_str(s)?.parse() {
+                Ok(i) => Ok(EitherInt::I64(i)),
+                Err(_) => Err(ValError::new(ErrorTypeDefaults::IntParsing, self)),
+            },
+            Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::IntType, self)),
+        }
+    }
+
+    fn ultra_strict_float(&'a self) -> ValResult<EitherFloat<'a>> {
+        self.strict_float()
+    }
+
+    fn strict_float(&'a self) -> ValResult<EitherFloat<'a>> {
+        match self {
+            Self::String(s) => str_as_float(self, py_string_str(s)?),
+            Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::FloatType, self)),
+        }
+    }
+
+    fn strict_decimal(&'a self, py: Python<'a>) -> ValResult<&'a PyAny> {
+        match self {
+            Self::String(s) => create_decimal(s, self, py),
+            Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::DecimalType, self)),
+        }
+    }
+
+    fn strict_dict(&'a self) -> ValResult<GenericMapping<'a>> {
+        match self {
+            Self::String(_) => Err(ValError::new(ErrorTypeDefaults::DictType, self)),
+            Self::Mapping(d) => Ok(GenericMapping::StringMapping(d)),
+        }
+    }
+
+    fn strict_list(&'a self) -> ValResult<GenericIterable<'a>> {
+        Err(ValError::new(ErrorTypeDefaults::ListType, self))
+    }
+
+    fn strict_tuple(&'a self) -> ValResult<GenericIterable<'a>> {
+        Err(ValError::new(ErrorTypeDefaults::TupleType, self))
+    }
+
+    fn strict_set(&'a self) -> ValResult<GenericIterable<'a>> {
+        Err(ValError::new(ErrorTypeDefaults::SetType, self))
+    }
+
+    fn strict_frozenset(&'a self) -> ValResult<GenericIterable<'a>> {
+        Err(ValError::new(ErrorTypeDefaults::FrozenSetType, self))
+    }
+
+    fn extract_generic_iterable(&'a self) -> ValResult<GenericIterable<'a>> {
+        Err(ValError::new(ErrorTypeDefaults::IterableType, self))
+    }
+
+    fn validate_iter(&self) -> ValResult<GenericIterator> {
+        Err(ValError::new(ErrorTypeDefaults::IterableType, self))
+    }
+
+    fn strict_date(&self) -> ValResult<EitherDate> {
+        match self {
+            Self::String(s) => bytes_as_date(self, py_string_str(s)?.as_bytes()),
+            Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::DateType, self)),
+        }
+    }
+
+    fn strict_time(
+        &self,
+        microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
+    ) -> ValResult<EitherTime> {
+        match self {
+            Self::String(s) => bytes_as_time(self, py_string_str(s)?.as_bytes(), microseconds_overflow_behavior),
+            Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::TimeType, self)),
+        }
+    }
+
+    fn strict_datetime(
+        &self,
+        microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
+    ) -> ValResult<EitherDateTime> {
+        match self {
+            Self::String(s) => bytes_as_datetime(self, py_string_str(s)?.as_bytes(), microseconds_overflow_behavior),
+            Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::DatetimeType, self)),
+        }
+    }
+
+    fn strict_timedelta(
+        &self,
+        microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
+    ) -> ValResult<EitherTimedelta> {
+        match self {
+            Self::String(s) => bytes_as_timedelta(self, py_string_str(s)?.as_bytes(), microseconds_overflow_behavior),
+            Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::TimeDeltaType, self)),
+        }
+    }
+}
+
+impl BorrowInput for StringMapping<'_> {
+    type Input<'a> = StringMapping<'a> where Self: 'a;
+    fn borrow_input(&self) -> &Self::Input<'_> {
+        self
+    }
+}
diff --git a/src/input/mod.rs b/src/input/mod.rs
index c15f54b2a..22d774a8c 100644
--- a/src/input/mod.rs
+++ b/src/input/mod.rs
@@ -6,6 +6,7 @@ mod datetime;
 mod input_abstract;
 mod input_json;
 mod input_python;
+mod input_string;
 mod parse_json;
 mod return_enums;
 mod shared;
@@ -15,12 +16,13 @@ pub(crate) use datetime::{
     duration_as_pytimedelta, pydate_as_date, pydatetime_as_datetime, pytime_as_time, EitherDate, EitherDateTime,
     EitherTime, EitherTimedelta,
 };
-pub(crate) use input_abstract::{Input, InputType};
-pub(crate) use parse_json::{JsonInput, JsonObject};
+pub(crate) use input_abstract::{BorrowInput, Input, InputType};
+pub(crate) use input_string::StringMapping;
+pub(crate) use parse_json::{JsonArray, JsonInput, JsonObject};
 pub(crate) use return_enums::{
     py_string_str, AttributesGenericIterator, DictGenericIterator, EitherBytes, EitherFloat, EitherInt, EitherString,
     GenericArguments, GenericIterable, GenericIterator, GenericMapping, Int, JsonArgs, JsonObjectGenericIterator,
-    MappingGenericIterator, PyArgs,
+    MappingGenericIterator, PyArgs, StringMappingGenericIterator,
 };
 
 // Defined here as it's not exported by pyo3
diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index e97fe8b81..56f86f580 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -25,6 +25,7 @@ use crate::errors::{py_err_string, ErrorType, ErrorTypeDefaults, InputValue, Val
 use crate::tools::py_err;
 use crate::validators::{CombinedValidator, ValidationState, Validator};
 
+use super::input_string::StringMapping;
 use super::parse_json::{JsonArray, JsonInput, JsonObject};
 use super::{py_error_on_minusone, Input};
 
@@ -429,6 +430,7 @@ impl<'a> GenericIterable<'a> {
 pub enum GenericMapping<'a> {
     PyDict(&'a PyDict),
     PyMapping(&'a PyMapping),
+    StringMapping(&'a PyDict),
     PyGetAttr(&'a PyAny, Option<&'a PyDict>),
     JsonObject(&'a JsonObject),
 }
@@ -506,6 +508,38 @@ impl<'py> Iterator for MappingGenericIterator<'py> {
     }
 }
 
+pub struct StringMappingGenericIterator<'py> {
+    dict_iter: PyDictIterator<'py>,
+}
+
+impl<'py> StringMappingGenericIterator<'py> {
+    pub fn new(dict: &'py PyDict) -> ValResult<'py, Self> {
+        Ok(Self { dict_iter: dict.iter() })
+    }
+}
+
+impl<'py> Iterator for StringMappingGenericIterator<'py> {
+    // key (the first member of the tuple could be a simple String)
+    type Item = ValResult<'py, (StringMapping<'py>, StringMapping<'py>)>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        match self.dict_iter.next() {
+            Some((py_key, py_value)) => {
+                let key = match StringMapping::new_key(py_key) {
+                    Ok(key) => key,
+                    Err(e) => return Some(Err(e)),
+                };
+                let value = match StringMapping::new_value(py_value) {
+                    Ok(value) => value,
+                    Err(e) => return Some(Err(e)),
+                };
+                Some(Ok((key, value)))
+            }
+            None => None,
+        }
+    }
+}
+
 pub struct AttributesGenericIterator<'py> {
     object: &'py PyAny,
     // PyO3 should export this type upstream
@@ -691,6 +725,7 @@ impl<'a> JsonArgs<'a> {
 pub enum GenericArguments<'a> {
     Py(PyArgs<'a>),
     Json(JsonArgs<'a>),
+    StringMapping(&'a PyDict),
 }
 
 impl<'a> From<PyArgs<'a>> for GenericArguments<'a> {
diff --git a/src/input/shared.rs b/src/input/shared.rs
index d8733bd31..1a8e2b61c 100644
--- a/src/input/shared.rs
+++ b/src/input/shared.rs
@@ -2,9 +2,9 @@ use num_bigint::BigInt;
 use pyo3::{intern, PyAny, Python};
 
 use crate::errors::{ErrorType, ErrorTypeDefaults, ValError, ValResult};
-use crate::input::EitherInt;
 
-use super::{EitherFloat, Input};
+use super::parse_json::{JsonArray, JsonInput};
+use super::{EitherFloat, EitherInt, Input};
 
 pub fn map_json_err<'a>(input: &'a impl Input<'a>, error: serde_json::Error) -> ValError<'a> {
     ValError::new(
@@ -150,3 +150,7 @@ pub fn decimal_as_int<'a>(py: Python, input: &'a impl Input<'a>, decimal: &'a Py
     }
     Ok(EitherInt::Py(numerator))
 }
+
+pub fn string_to_vec(s: &str) -> JsonArray {
+    JsonArray::new(s.chars().map(|c| JsonInput::String(c.to_string())).collect())
+}
diff --git a/src/lookup_key.rs b/src/lookup_key.rs
index 49915e3b4..36190c069 100644
--- a/src/lookup_key.rs
+++ b/src/lookup_key.rs
@@ -6,8 +6,8 @@ use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList, PyMapping, PyString};
 
 use crate::build_tools::py_schema_err;
-use crate::errors::{ErrorType, ValLineError};
-use crate::input::{Input, JsonInput, JsonObject};
+use crate::errors::{py_err_string, ErrorType, ValError, ValLineError, ValResult};
+use crate::input::{Input, JsonInput, JsonObject, StringMapping};
 use crate::tools::{extract_i64, py_err};
 
 /// Used for getting items from python dicts, python objects, or JSON objects, in different ways
@@ -109,7 +109,7 @@ impl LookupKey {
     pub fn py_get_dict_item<'data, 's>(
         &'s self,
         dict: &'data PyDict,
-    ) -> PyResult<Option<(&'s LookupPath, &'data PyAny)>> {
+    ) -> ValResult<'data, Option<(&'s LookupPath, &'data PyAny)>> {
         match self {
             Self::Simple { py_key, path, .. } => match dict.get_item(py_key) {
                 Some(value) => Ok(Some((path, value))),
@@ -143,10 +143,22 @@ impl LookupKey {
         }
     }
 
+    pub fn py_get_string_mapping_item<'data, 's>(
+        &'s self,
+        dict: &'data PyDict,
+    ) -> ValResult<'data, Option<(&'s LookupPath, StringMapping<'data>)>> {
+        if let Some((path, py_any)) = self.py_get_dict_item(dict)? {
+            let value = StringMapping::new_value(py_any)?;
+            Ok(Some((path, value)))
+        } else {
+            Ok(None)
+        }
+    }
+
     pub fn py_get_mapping_item<'data, 's>(
         &'s self,
         dict: &'data PyMapping,
-    ) -> PyResult<Option<(&'s LookupPath, &'data PyAny)>> {
+    ) -> ValResult<'data, Option<(&'s LookupPath, &'data PyAny)>> {
         match self {
             Self::Simple { py_key, path, .. } => match dict.get_item(py_key) {
                 Ok(value) => Ok(Some((path, value))),
@@ -184,6 +196,23 @@ impl LookupKey {
         &'s self,
         obj: &'data PyAny,
         kwargs: Option<&'data PyDict>,
+    ) -> ValResult<'data, Option<(&'s LookupPath, &'data PyAny)>> {
+        match self._py_get_attr(obj, kwargs) {
+            Ok(v) => Ok(v),
+            Err(err) => {
+                let error = py_err_string(obj.py(), err);
+                Err(ValError::new(
+                    ErrorType::GetAttributeError { error, context: None },
+                    obj,
+                ))
+            }
+        }
+    }
+
+    pub fn _py_get_attr<'data, 's>(
+        &'s self,
+        obj: &'data PyAny,
+        kwargs: Option<&'data PyDict>,
     ) -> PyResult<Option<(&'s LookupPath, &'data PyAny)>> {
         if let Some(dict) = kwargs {
             if let Ok(Some(item)) = self.py_get_dict_item(dict) {
@@ -235,7 +264,7 @@ impl LookupKey {
     pub fn json_get<'data, 's>(
         &'s self,
         dict: &'data JsonObject,
-    ) -> PyResult<Option<(&'s LookupPath, &'data JsonInput)>> {
+    ) -> ValResult<'data, Option<(&'s LookupPath, &'data JsonInput)>> {
         match self {
             Self::Simple { key, path, .. } => match dict.get(key) {
                 Some(value) => Ok(Some((path, value))),
diff --git a/src/validators/arguments.rs b/src/validators/arguments.rs
index e75ff310a..2c0fe4a0a 100644
--- a/src/validators/arguments.rs
+++ b/src/validators/arguments.rs
@@ -323,6 +323,7 @@ impl Validator for ArgumentsValidator {
         match args {
             GenericArguments::Py(a) => process!(a, py_get_dict_item, py_get, py_slice),
             GenericArguments::Json(a) => process!(a, json_get, json_get, json_slice),
+            GenericArguments::StringMapping(_) => unimplemented!(),
         }
         if !errors.is_empty() {
             Err(ValError::LineErrors(errors))
diff --git a/src/validators/dataclass.rs b/src/validators/dataclass.rs
index 7b7be282e..117596b9f 100644
--- a/src/validators/dataclass.rs
+++ b/src/validators/dataclass.rs
@@ -8,7 +8,7 @@ use ahash::AHashSet;
 use crate::build_tools::py_schema_err;
 use crate::build_tools::{is_strict, schema_or_config_same, ExtraBehavior};
 use crate::errors::{ErrorType, ErrorTypeDefaults, ValError, ValLineError, ValResult};
-use crate::input::{GenericArguments, Input};
+use crate::input::{BorrowInput, GenericArguments, Input};
 use crate::lookup_key::LookupKey;
 use crate::tools::SchemaDict;
 use crate::validators::function::convert_err;
@@ -188,15 +188,21 @@ impl Validator for DataclassArgsValidator {
                                     kw_value = Some((lookup_path, value));
                                 }
                             }
+                            let kw_value = kw_value
+                                .as_ref()
+                                .map(|(path, value)| (path, value.borrow_input()));
 
                             match (pos_value, kw_value) {
                                 // found both positional and keyword arguments, error
                                 (Some(_), Some((_, kw_value))) => {
-                                    errors.push(ValLineError::new_with_loc(
-                                        ErrorTypeDefaults::MultipleArgumentValues,
-                                        kw_value,
-                                        field.name.clone(),
-                                    ));
+                                    errors.push(
+                                        ValLineError::new_with_loc(
+                                            ErrorTypeDefaults::MultipleArgumentValues,
+                                            kw_value,
+                                            field.name.clone(),
+                                        )
+                                        .into_owned(py),
+                                    );
                                 }
                                 // found a positional argument, validate it
                                 (Some(pos_value), None) => match field.validator.validate(py, pos_value, state) {
@@ -216,10 +222,12 @@ impl Validator for DataclassArgsValidator {
                                         Ok(value) => set_item!(field, value),
                                         Err(ValError::LineErrors(line_errors)) => {
                                             errors.extend(line_errors.into_iter().map(|err| {
-                                                lookup_path.apply_error_loc(err, self.loc_by_alias, &field.name)
+                                                lookup_path
+                                                    .apply_error_loc(err, self.loc_by_alias, &field.name)
+                                                    .into_owned(py)
                                             }));
                                         }
-                                        Err(err) => return Err(err),
+                                        Err(err) => return Err(err.into_owned(py)),
                                     }
                                 }
                                 // found neither, check if there is a default value, otherwise error
@@ -267,11 +275,14 @@ impl Validator for DataclassArgsValidator {
                                                 // Unknown / extra field
                                                 match self.extra_behavior {
                                                     ExtraBehavior::Forbid => {
-                                                        errors.push(ValLineError::new_with_loc(
-                                                            ErrorTypeDefaults::UnexpectedKeywordArgument,
-                                                            value,
-                                                            raw_key.as_loc_item(),
-                                                        ));
+                                                        errors.push(
+                                                            ValLineError::new_with_loc(
+                                                                ErrorTypeDefaults::UnexpectedKeywordArgument,
+                                                                value,
+                                                                raw_key.as_loc_item(),
+                                                            )
+                                                            .into_owned(py),
+                                                        );
                                                     }
                                                     ExtraBehavior::Ignore => {}
                                                     ExtraBehavior::Allow => {
@@ -310,9 +321,24 @@ impl Validator for DataclassArgsValidator {
                         }
                     }};
                 }
+
                 match args {
                     GenericArguments::Py(a) => process!(a, py_get_dict_item, py_get, py_slice),
                     GenericArguments::Json(a) => process!(a, json_get, json_get, json_slice),
+                    GenericArguments::StringMapping(a) => {
+                        // StringMapping cannot pass positional args, so wrap the PyDict
+                        // in a type with guaranteed empty args array for sake of the process
+                        // macro
+                        struct StringMappingArgs<'a> {
+                            args: Option<&'a PyTuple>,
+                            kwargs: Option<&'a PyDict>,
+                        }
+                        let a = StringMappingArgs {
+                            args: None,
+                            kwargs: Some(a),
+                        };
+                        process!(a, py_get_string_mapping_item, py_get, py_slice);
+                    }
                 }
                 Ok(())
             },
diff --git a/src/validators/dict.rs b/src/validators/dict.rs
index 6a52b7f79..dc8f03937 100644
--- a/src/validators/dict.rs
+++ b/src/validators/dict.rs
@@ -4,7 +4,11 @@ use pyo3::types::PyDict;
 
 use crate::build_tools::is_strict;
 use crate::errors::{ValError, ValLineError, ValResult};
-use crate::input::{DictGenericIterator, GenericMapping, Input, JsonObjectGenericIterator, MappingGenericIterator};
+use crate::input::BorrowInput;
+use crate::input::{
+    DictGenericIterator, GenericMapping, Input, JsonObjectGenericIterator, MappingGenericIterator,
+    StringMappingGenericIterator,
+};
 
 use crate::tools::SchemaDict;
 
@@ -78,6 +82,9 @@ impl Validator for DictValidator {
             GenericMapping::PyMapping(mapping) => {
                 self.validate_generic_mapping(py, input, MappingGenericIterator::new(mapping)?, state)
             }
+            GenericMapping::StringMapping(dict) => {
+                self.validate_generic_mapping(py, input, StringMappingGenericIterator::new(dict)?, state)
+            }
             GenericMapping::PyGetAttr(_, _) => unreachable!(),
             GenericMapping::JsonObject(json_object) => {
                 self.validate_generic_mapping(py, input, JsonObjectGenericIterator::new(json_object)?, state)
@@ -113,9 +120,7 @@ impl DictValidator {
         &'s self,
         py: Python<'data>,
         input: &'data impl Input<'data>,
-        mapping_iter: impl Iterator<
-            Item = ValResult<'data, (&'data (impl Input<'data> + 'data), &'data (impl Input<'data> + 'data))>,
-        >,
+        mapping_iter: impl Iterator<Item = ValResult<'data, (impl BorrowInput + 'data, impl BorrowInput + 'data)>>,
         state: &mut ValidationState,
     ) -> ValResult<'data, PyObject> {
         let output = PyDict::new(py);
@@ -125,6 +130,8 @@ impl DictValidator {
         let value_validator = self.value_validator.as_ref();
         for item_result in mapping_iter {
             let (key, value) = item_result?;
+            let key = key.borrow_input();
+            let value = value.borrow_input();
             let output_key = match key_validator.validate(py, key, state) {
                 Ok(value) => Some(value),
                 Err(ValError::LineErrors(line_errors)) => {
@@ -132,24 +139,25 @@ impl DictValidator {
                         // these are added in reverse order so [key] is shunted along by the second call
                         errors.push(
                             err.with_outer_location("[key]".into())
-                                .with_outer_location(key.as_loc_item()),
+                                .with_outer_location(key.as_loc_item())
+                                .into_owned(py),
                         );
                     }
                     None
                 }
                 Err(ValError::Omit) => continue,
-                Err(err) => return Err(err),
+                Err(err) => return Err(err.into_owned(py)),
             };
             let output_value = match value_validator.validate(py, value, state) {
                 Ok(value) => Some(value),
                 Err(ValError::LineErrors(line_errors)) => {
                     for err in line_errors {
-                        errors.push(err.with_outer_location(key.as_loc_item()));
+                        errors.push(err.with_outer_location(key.as_loc_item()).into_owned(py));
                     }
                     None
                 }
                 Err(ValError::Omit) => continue,
-                Err(err) => return Err(err),
+                Err(err) => return Err(err.into_owned(py)),
             };
             if let (Some(key), Some(value)) = (output_key, output_value) {
                 output.set_item(key, value)?;
diff --git a/src/validators/function.rs b/src/validators/function.rs
index 9f8fe75a7..6334a5e16 100644
--- a/src/validators/function.rs
+++ b/src/validators/function.rs
@@ -544,7 +544,7 @@ impl ValidationInfo {
             context: extra.context.map(Into::into),
             field_name,
             data: extra.data.map(Into::into),
-            mode: extra.mode,
+            mode: extra.input_type,
         }
     }
 }
diff --git a/src/validators/generator.rs b/src/validators/generator.rs
index c52910500..bf6d009e1 100644
--- a/src/validators/generator.rs
+++ b/src/validators/generator.rs
@@ -3,7 +3,7 @@ use std::fmt;
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
 
-use crate::errors::{ErrorMode, ErrorType, LocItem, ValError, ValResult};
+use crate::errors::{ErrorType, LocItem, ValError, ValResult};
 use crate::input::{GenericIterator, Input};
 use crate::recursion_guard::RecursionGuard;
 use crate::tools::SchemaDict;
@@ -153,7 +153,7 @@ impl ValidatorIterator {
                                     return Err(ValidationError::from_val_error(
                                         py,
                                         "ValidatorIterator".to_object(py),
-                                        ErrorMode::Python,
+                                        InputType::Python,
                                         val_error,
                                         None,
                                         hide_input_in_errors,
@@ -180,7 +180,7 @@ impl ValidatorIterator {
                                 return Err(ValidationError::from_val_error(
                                     py,
                                     "ValidatorIterator".to_object(py),
-                                    ErrorMode::Python,
+                                    InputType::Python,
                                     val_error,
                                     None,
                                     hide_input_in_errors,
@@ -262,7 +262,7 @@ impl InternalValidator {
             context: extra.context.map(|d| d.into_py(py)),
             self_instance: extra.self_instance.map(|d| d.into_py(py)),
             recursion_guard: state.recursion_guard.clone(),
-            validation_mode: extra.mode,
+            validation_mode: extra.input_type,
             hide_input_in_errors,
             validation_error_cause,
         }
@@ -277,7 +277,7 @@ impl InternalValidator {
         outer_location: Option<LocItem>,
     ) -> PyResult<PyObject> {
         let extra = Extra {
-            mode: self.validation_mode,
+            input_type: self.validation_mode,
             data: self.data.as_ref().map(|data| data.as_ref(py)),
             strict: self.strict,
             ultra_strict: false,
@@ -292,7 +292,7 @@ impl InternalValidator {
                 ValidationError::from_val_error(
                     py,
                     self.name.to_object(py),
-                    ErrorMode::Python,
+                    InputType::Python,
                     e,
                     outer_location,
                     self.hide_input_in_errors,
@@ -308,7 +308,7 @@ impl InternalValidator {
         outer_location: Option<LocItem>,
     ) -> PyResult<PyObject> {
         let extra = Extra {
-            mode: self.validation_mode,
+            input_type: self.validation_mode,
             data: self.data.as_ref().map(|data| data.as_ref(py)),
             strict: self.strict,
             ultra_strict: false,
@@ -321,7 +321,7 @@ impl InternalValidator {
             ValidationError::from_val_error(
                 py,
                 self.name.to_object(py),
-                ErrorMode::Python,
+                InputType::Python,
                 e,
                 outer_location,
                 self.hide_input_in_errors,
diff --git a/src/validators/json_or_python.rs b/src/validators/json_or_python.rs
index e62620027..828532fe5 100644
--- a/src/validators/json_or_python.rs
+++ b/src/validators/json_or_python.rs
@@ -57,9 +57,9 @@ impl Validator for JsonOrPython {
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
     ) -> ValResult<'data, PyObject> {
-        match state.extra().mode {
+        match state.extra().input_type {
             InputType::Python => self.python.validate(py, input, state),
-            InputType::Json => self.json.validate(py, input, state),
+            _ => self.json.validate(py, input, state),
         }
     }
 
diff --git a/src/validators/mod.rs b/src/validators/mod.rs
index 9440f1527..de98eb583 100644
--- a/src/validators/mod.rs
+++ b/src/validators/mod.rs
@@ -10,8 +10,8 @@ use pyo3::{intern, PyTraverseError, PyVisit};
 
 use crate::build_tools::{py_schema_err, py_schema_error_type, SchemaError};
 use crate::definitions::DefinitionsBuilder;
-use crate::errors::{ErrorMode, LocItem, ValError, ValResult, ValidationError};
-use crate::input::{Input, InputType};
+use crate::errors::{LocItem, ValError, ValResult, ValidationError};
+use crate::input::{Input, InputType, StringMapping};
 use crate::py_gc::PyGcTraverse;
 use crate::recursion_guard::RecursionGuard;
 use crate::tools::SchemaDict;
@@ -170,7 +170,7 @@ impl SchemaValidator {
             self_instance,
             &mut RecursionGuard::default(),
         )
-        .map_err(|e| self.prepare_validation_err(py, e, ErrorMode::Python))
+        .map_err(|e| self.prepare_validation_err(py, e, InputType::Python))
     }
 
     #[pyo3(signature = (input, *, strict=None, from_attributes=None, context=None, self_instance=None))]
@@ -223,8 +223,26 @@ impl SchemaValidator {
                     self_instance,
                     recursion_guard,
                 )
-                .map_err(|e| self.prepare_validation_err(py, e, ErrorMode::Json)),
-            Err(err) => Err(self.prepare_validation_err(py, err, ErrorMode::Json)),
+                .map_err(|e| self.prepare_validation_err(py, e, InputType::Json)),
+            Err(err) => Err(self.prepare_validation_err(py, err, InputType::Json)),
+        }
+    }
+
+    #[pyo3(signature = (input, *, strict=None, context=None))]
+    pub fn validate_strings(
+        &self,
+        py: Python,
+        input: &PyAny,
+        strict: Option<bool>,
+        context: Option<&PyAny>,
+    ) -> PyResult<PyObject> {
+        let t = InputType::String;
+        let string_mapping = StringMapping::new_value(input).map_err(|e| self.prepare_validation_err(py, e, t))?;
+
+        let recursion_guard = &mut RecursionGuard::default();
+        match self._validate(py, &string_mapping, t, strict, None, context, None, recursion_guard) {
+            Ok(r) => Ok(r),
+            Err(e) => Err(self.prepare_validation_err(py, e, t)),
         }
     }
 
@@ -241,7 +259,7 @@ impl SchemaValidator {
         context: Option<&PyAny>,
     ) -> PyResult<PyObject> {
         let extra = Extra {
-            mode: InputType::Python,
+            input_type: InputType::Python,
             data: None,
             strict,
             from_attributes,
@@ -254,13 +272,13 @@ impl SchemaValidator {
         let mut state = ValidationState::new(extra, &self.definitions, guard);
         self.validator
             .validate_assignment(py, obj, field_name, field_value, &mut state)
-            .map_err(|e| self.prepare_validation_err(py, e, ErrorMode::Python))
+            .map_err(|e| self.prepare_validation_err(py, e, InputType::Python))
     }
 
     #[pyo3(signature = (*, strict=None, context=None))]
     pub fn get_default_value(&self, py: Python, strict: Option<bool>, context: Option<&PyAny>) -> PyResult<PyObject> {
         let extra = Extra {
-            mode: InputType::Python,
+            input_type: InputType::Python,
             data: None,
             strict,
             from_attributes: None,
@@ -276,7 +294,7 @@ impl SchemaValidator {
                 Some(v) => Ok(PySome::new(v).into_py(py)),
                 None => Ok(py.None().into_py(py)),
             },
-            Err(e) => Err(self.prepare_validation_err(py, e, ErrorMode::Python)),
+            Err(e) => Err(self.prepare_validation_err(py, e, InputType::Python)),
         }
     }
 
@@ -305,7 +323,7 @@ impl SchemaValidator {
         &'data self,
         py: Python<'data>,
         input: &'data impl Input<'data>,
-        mode: InputType,
+        input_type: InputType,
         strict: Option<bool>,
         from_attributes: Option<bool>,
         context: Option<&'data PyAny>,
@@ -316,18 +334,18 @@ impl SchemaValidator {
         's: 'data,
     {
         let mut state = ValidationState::new(
-            Extra::new(strict, from_attributes, context, self_instance, mode),
+            Extra::new(strict, from_attributes, context, self_instance, input_type),
             &self.definitions,
             recursion_guard,
         );
         self.validator.validate(py, input, &mut state)
     }
 
-    fn prepare_validation_err(&self, py: Python, error: ValError, error_mode: ErrorMode) -> PyErr {
+    fn prepare_validation_err(&self, py: Python, error: ValError, input_type: InputType) -> PyErr {
         ValidationError::from_val_error(
             py,
             self.title.clone_ref(py),
-            error_mode,
+            input_type,
             error,
             None,
             self.hide_input_in_errors,
@@ -533,7 +551,7 @@ pub fn build_validator<'a>(
 #[derive(Debug)]
 pub struct Extra<'a> {
     /// Validation mode
-    pub mode: InputType,
+    pub input_type: InputType,
     /// This is used as the `data` kwargs to validator functions
     pub data: Option<&'a PyDict>,
     /// whether we're in strict or lax mode
@@ -554,10 +572,10 @@ impl<'a> Extra<'a> {
         from_attributes: Option<bool>,
         context: Option<&'a PyAny>,
         self_instance: Option<&'a PyAny>,
-        mode: InputType,
+        input_type: InputType,
     ) -> Self {
         Extra {
-            mode,
+            input_type,
             data: None,
             strict,
             ultra_strict: false,
@@ -571,7 +589,7 @@ impl<'a> Extra<'a> {
 impl<'a> Extra<'a> {
     pub fn as_strict(&self, ultra_strict: bool) -> Self {
         Self {
-            mode: self.mode,
+            input_type: self.input_type,
             data: self.data,
             strict: Some(true),
             ultra_strict,
diff --git a/src/validators/model_fields.rs b/src/validators/model_fields.rs
index 29e9522f2..f2654c33e 100644
--- a/src/validators/model_fields.rs
+++ b/src/validators/model_fields.rs
@@ -7,10 +7,10 @@ use ahash::AHashSet;
 
 use crate::build_tools::py_schema_err;
 use crate::build_tools::{is_strict, schema_or_config_same, ExtraBehavior};
-use crate::errors::{py_err_string, ErrorType, ErrorTypeDefaults, ValError, ValLineError, ValResult};
+use crate::errors::{ErrorType, ErrorTypeDefaults, ValError, ValLineError, ValResult};
 use crate::input::{
-    AttributesGenericIterator, DictGenericIterator, GenericMapping, Input, JsonObjectGenericIterator,
-    MappingGenericIterator,
+    AttributesGenericIterator, BorrowInput, DictGenericIterator, GenericMapping, Input, JsonObjectGenericIterator,
+    MappingGenericIterator, StringMappingGenericIterator,
 };
 use crate::lookup_key::LookupKey;
 use crate::tools::SchemaDict;
@@ -180,17 +180,13 @@ impl Validator for ModelFieldsValidator {
                     for field in &self.fields {
                         let op_key_value = match field.lookup_key.$get_method($dict $(, $kwargs )? ) {
                             Ok(v) => v,
-                            Err(err) => {
-                                errors.push(ValLineError::new_with_loc(
-                                    ErrorType::GetAttributeError {
-                                        error: py_err_string(py, err),
-                                        context: None,
-                                    },
-                                    input,
-                                    field.name.clone(),
-                                ));
+                            Err(ValError::LineErrors(line_errors)) => {
+                                for err in line_errors {
+                                    errors.push(err.with_outer_location(field.name.as_loc_item()));
+                                }
                                 continue;
                             }
+                            Err(err) => return ControlFlow::Break(err),
                         };
                         if let Some((lookup_path, value)) = op_key_value {
                             if let Some(ref mut used_keys) = used_keys {
@@ -198,10 +194,7 @@ impl Validator for ModelFieldsValidator {
                                 // extra logic either way
                                 used_keys.insert(lookup_path.first_key());
                             }
-                            match field
-                                .validator
-                                .validate(py, value, state)
-                            {
+                            match field.validator.validate(py, value.borrow_input(), state) {
                                 Ok(value) => {
                                     control_flow!(model_dict.set_item(&field.name_py, value))?;
                                     fields_set_vec.push(field.name_py.clone_ref(py));
@@ -209,10 +202,13 @@ impl Validator for ModelFieldsValidator {
                                 Err(ValError::Omit) => continue,
                                 Err(ValError::LineErrors(line_errors)) => {
                                     for err in line_errors {
-                                        errors.push(lookup_path.apply_error_loc(err, self.loc_by_alias, &field.name));
+                                        errors.push(
+                                            lookup_path.apply_error_loc(err, self.loc_by_alias, &field.name)
+                                            .into_owned(py)
+                                        );
                                     }
                                 }
-                                Err(err) => return ControlFlow::Break(err),
+                                Err(err) => return ControlFlow::Break(err.into_owned(py)),
                             }
                             continue;
                         } else if let Some(value) = control_flow!(field.validator.default_value(py, Some(field.name.as_str()), state))? {
@@ -242,25 +238,31 @@ impl Validator for ModelFieldsValidator {
                                 for err in line_errors {
                                     errors.push(
                                         err.with_outer_location(raw_key.as_loc_item())
-                                            .with_type(ErrorTypeDefaults::InvalidKey),
+                                            .with_type(ErrorTypeDefaults::InvalidKey)
+                                            .into_owned(py)
                                     );
                                 }
                                 continue;
                             }
-                            Err(err) => return Err(err),
+                            Err(err) => return Err(err.into_owned(py)),
                         };
-                        if used_keys.contains(either_str.as_cow()?.as_ref()) {
+                        let cow = either_str.as_cow().map_err(|err| err.into_owned(py))?;
+                        if used_keys.contains(cow.as_ref()) {
                             continue;
                         }
 
+                        let value = value.borrow_input();
                         // Unknown / extra field
                         match self.extra_behavior {
                             ExtraBehavior::Forbid => {
-                                errors.push(ValLineError::new_with_loc(
-                                    ErrorTypeDefaults::ExtraForbidden,
-                                    value,
-                                    raw_key.as_loc_item(),
-                                ));
+                                errors.push(
+                                    ValLineError::new_with_loc(
+                                        ErrorTypeDefaults::ExtraForbidden,
+                                        value,
+                                        raw_key.as_loc_item(),
+                                    )
+                                    .into_owned(py)
+                                );
                             }
                             ExtraBehavior::Ignore => {}
                             ExtraBehavior::Allow => {
@@ -273,10 +275,10 @@ impl Validator for ModelFieldsValidator {
                                         }
                                         Err(ValError::LineErrors(line_errors)) => {
                                             for err in line_errors {
-                                                errors.push(err.with_outer_location(raw_key.as_loc_item()));
+                                                errors.push(err.with_outer_location(raw_key.as_loc_item()).into_owned(py));
                                             }
                                         }
-                                        Err(err) => return Err(err),
+                                        Err(err) => return Err(err.into_owned(py)),
                                     }
                                 } else {
                                     model_extra_dict.set_item(py_key, value.to_object(py))?;
@@ -293,8 +295,9 @@ impl Validator for ModelFieldsValidator {
         }
         match dict {
             GenericMapping::PyDict(d) => process!(d, py_get_dict_item, DictGenericIterator),
-            GenericMapping::PyGetAttr(d, kwargs) => process!(d, py_get_attr, AttributesGenericIterator, kwargs),
             GenericMapping::PyMapping(d) => process!(d, py_get_mapping_item, MappingGenericIterator),
+            GenericMapping::StringMapping(d) => process!(d, py_get_string_mapping_item, StringMappingGenericIterator),
+            GenericMapping::PyGetAttr(d, kwargs) => process!(d, py_get_attr, AttributesGenericIterator, kwargs),
             GenericMapping::JsonObject(d) => process!(d, json_get, JsonObjectGenericIterator),
         }
 
diff --git a/src/validators/typed_dict.rs b/src/validators/typed_dict.rs
index a095a52f1..56e4a8225 100644
--- a/src/validators/typed_dict.rs
+++ b/src/validators/typed_dict.rs
@@ -1,3 +1,5 @@
+use std::ops::ControlFlow;
+
 use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyString};
@@ -6,10 +8,10 @@ use ahash::AHashSet;
 
 use crate::build_tools::py_schema_err;
 use crate::build_tools::{is_strict, schema_or_config, schema_or_config_same, ExtraBehavior};
-use crate::errors::{py_err_string, ErrorType, ErrorTypeDefaults, ValError, ValLineError, ValResult};
+use crate::errors::{ErrorTypeDefaults, ValError, ValLineError, ValResult};
 use crate::input::{
-    AttributesGenericIterator, DictGenericIterator, GenericMapping, Input, JsonObjectGenericIterator,
-    MappingGenericIterator,
+    AttributesGenericIterator, BorrowInput, DictGenericIterator, GenericMapping, Input, JsonObjectGenericIterator,
+    MappingGenericIterator, StringMappingGenericIterator,
 };
 use crate::lookup_key::LookupKey;
 use crate::tools::SchemaDict;
@@ -18,8 +20,6 @@ use super::{
     build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, Extra, ValidationState, Validator,
 };
 
-use std::ops::ControlFlow;
-
 #[derive(Debug, Clone)]
 struct TypedDictField {
     name: String,
@@ -181,17 +181,13 @@ impl Validator for TypedDictValidator {
                     for field in &self.fields {
                         let op_key_value = match field.lookup_key.$get_method($dict $(, $kwargs )? ) {
                             Ok(v) => v,
-                            Err(err) => {
-                                errors.push(ValLineError::new_with_loc(
-                                    ErrorType::GetAttributeError {
-                                        error: py_err_string(py, err),
-                                        context: None,
-                                    },
-                                    input,
-                                    field.name.clone(),
-                                ));
+                            Err(ValError::LineErrors(line_errors)) => {
+                                for err in line_errors {
+                                    errors.push(err.with_outer_location(field.name.as_loc_item()));
+                                }
                                 continue;
                             }
+                            Err(err) => return ControlFlow::Break(err),
                         };
                         if let Some((lookup_path, value)) = op_key_value {
                             if let Some(ref mut used_keys) = used_keys {
@@ -199,17 +195,21 @@ impl Validator for TypedDictValidator {
                                 // extra logic either way
                                 used_keys.insert(lookup_path.first_key());
                             }
-                            match field.validator.validate(py, value, state) {
+                            match field.validator.validate(py, value.borrow_input(), state) {
                                 Ok(value) => {
                                     control_flow!(output_dict.set_item(&field.name_py, value))?;
                                 }
                                 Err(ValError::Omit) => continue,
                                 Err(ValError::LineErrors(line_errors)) => {
                                     for err in line_errors {
-                                        errors.push(lookup_path.apply_error_loc(err, self.loc_by_alias, &field.name));
+                                        errors.push(
+                                            lookup_path
+                                            .apply_error_loc(err, self.loc_by_alias, &field.name)
+                                            .into_owned(py)
+                                        );
                                     }
                                 }
-                                Err(err) => return ControlFlow::Break(err),
+                                Err(err) => return ControlFlow::Break(err.into_owned(py)),
                             }
                             continue;
                         } else if let Some(value) = control_flow!(field.validator.default_value(py, Some(field.name.as_str()), state))? {
@@ -238,25 +238,31 @@ impl Validator for TypedDictValidator {
                                 for err in line_errors {
                                     errors.push(
                                         err.with_outer_location(raw_key.as_loc_item())
-                                            .with_type(ErrorTypeDefaults::InvalidKey),
+                                            .with_type(ErrorTypeDefaults::InvalidKey)
+                                            .into_owned(py)
                                     );
                                 }
                                 continue;
                             }
-                            Err(err) => return Err(err),
+                            Err(err) => return Err(err.into_owned(py)),
                         };
-                        if used_keys.contains(either_str.as_cow()?.as_ref()) {
+                        let cow = either_str.as_cow().map_err(|err| err.into_owned(py))?;
+                        if used_keys.contains(cow.as_ref()) {
                             continue;
                         }
 
+                        let value = value.borrow_input();
                         // Unknown / extra field
                         match self.extra_behavior {
                             ExtraBehavior::Forbid => {
-                                errors.push(ValLineError::new_with_loc(
-                                    ErrorTypeDefaults::ExtraForbidden,
-                                    value,
-                                    raw_key.as_loc_item(),
-                                ));
+                                errors.push(
+                                    ValLineError::new_with_loc(
+                                        ErrorTypeDefaults::ExtraForbidden,
+                                        value,
+                                        raw_key.as_loc_item(),
+                                    )
+                                    .into_owned(py)
+                                );
                             }
                             ExtraBehavior::Ignore => {}
                             ExtraBehavior::Allow => {
@@ -268,10 +274,14 @@ impl Validator for TypedDictValidator {
                                         }
                                         Err(ValError::LineErrors(line_errors)) => {
                                             for err in line_errors {
-                                                errors.push(err.with_outer_location(raw_key.as_loc_item()));
+                                                errors.push(
+                                                    err
+                                                    .with_outer_location(raw_key.as_loc_item())
+                                                    .into_owned(py)
+                                                );
                                             }
                                         }
-                                        Err(err) => return Err(err),
+                                        Err(err) => return Err(err.into_owned(py)),
                                     }
                                 } else {
                                     output_dict.set_item(py_key, value.to_object(py))?;
@@ -284,8 +294,9 @@ impl Validator for TypedDictValidator {
         }
         match dict {
             GenericMapping::PyDict(d) => process!(d, py_get_dict_item, DictGenericIterator),
-            GenericMapping::PyGetAttr(d, kwargs) => process!(d, py_get_attr, AttributesGenericIterator, kwargs),
             GenericMapping::PyMapping(d) => process!(d, py_get_mapping_item, MappingGenericIterator),
+            GenericMapping::StringMapping(d) => process!(d, py_get_string_mapping_item, StringMappingGenericIterator),
+            GenericMapping::PyGetAttr(d, kwargs) => process!(d, py_get_attr, AttributesGenericIterator, kwargs),
             GenericMapping::JsonObject(d) => process!(d, json_get, JsonObjectGenericIterator),
         }
 
diff --git a/src/validators/union.rs b/src/validators/union.rs
index 385a1f49d..4d3b0bd78 100644
--- a/src/validators/union.rs
+++ b/src/validators/union.rs
@@ -455,8 +455,9 @@ impl Validator for TaggedUnionValidator {
                 let dict = input.validate_model_fields(self.strict, from_attributes)?;
                 let tag = match dict {
                     GenericMapping::PyDict(dict) => find_validator!(py_get_dict_item, dict),
-                    GenericMapping::PyGetAttr(obj, kwargs) => find_validator!(py_get_attr, obj, kwargs),
                     GenericMapping::PyMapping(mapping) => find_validator!(py_get_mapping_item, mapping),
+                    GenericMapping::StringMapping(d) => find_validator!(py_get_dict_item, d),
+                    GenericMapping::PyGetAttr(obj, kwargs) => find_validator!(py_get_attr, obj, kwargs),
                     GenericMapping::JsonObject(mapping) => find_validator!(json_get, mapping),
                 }?;
                 self.find_call_validator(py, tag, input, state)
diff --git a/src/validators/validation_state.rs b/src/validators/validation_state.rs
index 75d6dae66..6cf5ce313 100644
--- a/src/validators/validation_state.rs
+++ b/src/validators/validation_state.rs
@@ -44,6 +44,7 @@ impl<'a> ValidationState<'a> {
         &'state mut self,
         f: impl FnOnce(&mut Extra<'a>),
     ) -> ValidationStateWithReboundExtra<'state, 'a> {
+        #[allow(clippy::unnecessary_struct_initialization)]
         let old_extra = Extra { ..self.extra };
         f(&mut self.extra);
         ValidationStateWithReboundExtra { state: self, old_extra }
diff --git a/tests/conftest.py b/tests/conftest.py
index a5f5cc344..a83c49472 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -59,6 +59,9 @@ def __init__(
     def validate_python(self, py_input, strict: bool | None = None, context: Any = None):
         return self.validator.validate_python(py_input, strict=strict, context=context)
 
+    def validate_json(self, json_str: str, strict: bool | None = None, context: Any = None):
+        return self.validator.validate_json(json_str, strict=strict, context=context)
+
     def validate_test(self, py_input, strict: bool | None = None, context: Any = None):
         if self.validator_type == 'json':
             return self.validator.validate_json(
diff --git a/tests/test_validate_strings.py b/tests/test_validate_strings.py
new file mode 100644
index 000000000..0e0350d0b
--- /dev/null
+++ b/tests/test_validate_strings.py
@@ -0,0 +1,121 @@
+import dataclasses
+import re
+from datetime import date, datetime
+
+import pytest
+
+from pydantic_core import SchemaValidator, ValidationError, core_schema
+
+from .conftest import Err
+
+
+def test_bool():
+    v = SchemaValidator(core_schema.bool_schema())
+
+    assert v.validate_strings('true') is True
+    assert v.validate_strings('true', strict=True) is True
+    assert v.validate_strings('false') is False
+
+
+@pytest.mark.parametrize(
+    'schema,input_value,expected,strict',
+    [
+        (core_schema.int_schema(), '1', 1, False),
+        (core_schema.int_schema(), '1', 1, True),
+        (core_schema.int_schema(), 'xxx', Err('type=int_parsing'), True),
+        (core_schema.float_schema(), '1.1', 1.1, False),
+        (core_schema.float_schema(), '1.10', 1.1, False),
+        (core_schema.float_schema(), '1.1', 1.1, True),
+        (core_schema.float_schema(), '1.10', 1.1, True),
+        (core_schema.date_schema(), '2017-01-01', date(2017, 1, 1), False),
+        (core_schema.date_schema(), '2017-01-01', date(2017, 1, 1), True),
+        (core_schema.datetime_schema(), '2017-01-01T12:13:14.567', datetime(2017, 1, 1, 12, 13, 14, 567_000), False),
+        (core_schema.datetime_schema(), '2017-01-01T12:13:14.567', datetime(2017, 1, 1, 12, 13, 14, 567_000), True),
+        (core_schema.date_schema(), '2017-01-01T12:13:14.567', Err('type=date_from_datetime_inexact'), False),
+        (core_schema.date_schema(), '2017-01-01T12:13:14.567', Err('type=date_parsing'), True),
+        (core_schema.date_schema(), '2017-01-01T00:00:00', date(2017, 1, 1), False),
+        (core_schema.date_schema(), '2017-01-01T00:00:00', Err('type=date_parsing'), True),
+    ],
+    ids=repr,
+)
+def test_validate_strings(schema, input_value, expected, strict):
+    v = SchemaValidator(schema)
+    if isinstance(expected, Err):
+        with pytest.raises(ValidationError, match=re.escape(expected.message)):
+            v.validate_strings(input_value, strict=strict)
+    else:
+        assert v.validate_strings(input_value, strict=strict) == expected
+
+
+def test_dict():
+    v = SchemaValidator(core_schema.dict_schema(core_schema.int_schema(), core_schema.date_schema()))
+
+    assert v.validate_strings({'1': '2017-01-01', '2': '2017-01-02'}) == {1: date(2017, 1, 1), 2: date(2017, 1, 2)}
+    assert v.validate_strings({'1': '2017-01-01', '2': '2017-01-02'}, strict=True) == {
+        1: date(2017, 1, 1),
+        2: date(2017, 1, 2),
+    }
+
+
+def test_model():
+    class MyModel:
+        # this is not required, but it avoids `__pydantic_fields_set__` being included in `__dict__`
+        __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__'
+        field_a: int
+        field_b: date
+
+    v = SchemaValidator(
+        core_schema.model_schema(
+            MyModel,
+            core_schema.model_fields_schema(
+                {
+                    'field_a': core_schema.model_field(core_schema.int_schema()),
+                    'field_b': core_schema.model_field(core_schema.date_schema()),
+                }
+            ),
+        )
+    )
+    m2 = v.validate_strings({'field_a': '1', 'field_b': '2017-01-01'})
+    assert m2.__dict__ == {'field_a': 1, 'field_b': date(2017, 1, 1)}
+    m2 = v.validate_strings({'field_a': '1', 'field_b': '2017-01-01'}, strict=True)
+    assert m2.__dict__ == {'field_a': 1, 'field_b': date(2017, 1, 1)}
+
+
+def test_dataclass():
+    @dataclasses.dataclass
+    class MyDataClass:
+        field_a: int
+        field_b: date
+
+    v = SchemaValidator(
+        core_schema.dataclass_schema(
+            MyDataClass,
+            core_schema.dataclass_args_schema(
+                'MyDataClass',
+                [
+                    core_schema.dataclass_field('field_a', core_schema.int_schema()),
+                    core_schema.dataclass_field('field_b', core_schema.date_schema()),
+                ],
+            ),
+            ['field_a', 'field_b'],
+        )
+    )
+    m2 = v.validate_strings({'field_a': '1', 'field_b': '2017-01-01'})
+    assert m2.__dict__ == {'field_a': 1, 'field_b': date(2017, 1, 1)}
+    m2 = v.validate_strings({'field_a': '1', 'field_b': '2017-01-01'}, strict=True)
+    assert m2.__dict__ == {'field_a': 1, 'field_b': date(2017, 1, 1)}
+
+
+def test_typed_dict():
+    v = SchemaValidator(
+        core_schema.typed_dict_schema(
+            {
+                'field_a': core_schema.typed_dict_field(core_schema.int_schema()),
+                'field_b': core_schema.typed_dict_field(core_schema.date_schema()),
+            }
+        )
+    )
+    m2 = v.validate_strings({'field_a': '1', 'field_b': '2017-01-01'})
+    assert m2 == {'field_a': 1, 'field_b': date(2017, 1, 1)}
+    m2 = v.validate_strings({'field_a': '1', 'field_b': '2017-01-01'}, strict=True)
+    assert m2 == {'field_a': 1, 'field_b': date(2017, 1, 1)}
diff --git a/tests/validators/test_bool.py b/tests/validators/test_bool.py
index 714c07ffe..e71d41cb1 100644
--- a/tests/validators/test_bool.py
+++ b/tests/validators/test_bool.py
@@ -88,7 +88,8 @@ def test_bool_key(py_and_json: PyAndJson):
     assert v.validate_test({'true': 1, 'off': 2}) == {True: 1, False: 2}
     assert v.validate_test({'true': 1, 'off': 2}, strict=False) == {True: 1, False: 2}
     with pytest.raises(ValidationError, match='Input should be a valid boolean'):
-        v.validate_test({'true': 1, 'off': 2}, strict=True)
+        v.validate_python({'true': 1, 'off': 2}, strict=True)
+    assert v.validate_json('{"true": 1, "off": 2}', strict=True) == {True: 1, False: 2}
 
 
 def test_validate_assignment_not_supported() -> None:
diff --git a/tests/validators/test_float.py b/tests/validators/test_float.py
index 80b96eacd..74f0024ca 100644
--- a/tests/validators/test_float.py
+++ b/tests/validators/test_float.py
@@ -215,7 +215,8 @@ def test_float_key(py_and_json: PyAndJson):
     assert v.validate_test({'1': 1, '2': 2}) == {1: 1, 2: 2}
     assert v.validate_test({'1.5': 1, '2.4': 2}) == {1.5: 1, 2.4: 2}
     with pytest.raises(ValidationError, match='Input should be a valid number'):
-        v.validate_test({'1.5': 1, '2.5': 2}, strict=True)
+        v.validate_python({'1.5': 1, '2.5': 2}, strict=True)
+    assert v.validate_json('{"1.5": 1, "2.5": 2}', strict=True) == {1.5: 1, 2.5: 2}
 
 
 @pytest.mark.parametrize(
diff --git a/tests/validators/test_int.py b/tests/validators/test_int.py
index 43cd5bacb..8d5850dc8 100644
--- a/tests/validators/test_int.py
+++ b/tests/validators/test_int.py
@@ -402,7 +402,8 @@ def test_int_key(py_and_json: PyAndJson):
     v = py_and_json({'type': 'dict', 'keys_schema': {'type': 'int'}, 'values_schema': {'type': 'int'}})
     assert v.validate_test({'1': 1, '2': 2}) == {1: 1, 2: 2}
     with pytest.raises(ValidationError, match='Input should be a valid integer'):
-        v.validate_test({'1': 1, '2': 2}, strict=True)
+        v.validate_python({'1': 1, '2': 2}, strict=True)
+    assert v.validate_json('{"1": 1, "2": 2}', strict=True) == {1: 1, 2: 2}
 
 
 def test_string_as_int_with_underscores() -> None:
diff --git a/tests/validators/test_json.py b/tests/validators/test_json.py
index 83ddca172..d8666d335 100644
--- a/tests/validators/test_json.py
+++ b/tests/validators/test_json.py
@@ -50,26 +50,33 @@ def test_any(py_and_json: PyAndJson, input_value, expected):
     [
         ('{"a": 1}', {'a': 1}),
         (b'{"a": 1}', {'a': 1}),
+        (
+            '🐈 Hello \ud800World',
+            Err(
+                'Input should be a valid string, unable to parse raw data as a unicode string '
+                "[type=string_unicode, input_value='🐈 Hello \\ud800World', input_type=str]"
+            ),
+        ),
         (bytearray(b'{"a": 1}'), {'a': 1}),
         (
             'xx',
             Err(
                 'Invalid JSON: expected value at line 1 column 1 '
-                "[type=json_invalid, input_value='xx', input_type=str"
+                "[type=json_invalid, input_value='xx', input_type=str]"
             ),
         ),
         (
             b'xx',
             Err(
                 'Invalid JSON: expected value at line 1 column 1 '
-                "[type=json_invalid, input_value=b'xx', input_type=bytes"
+                "[type=json_invalid, input_value=b'xx', input_type=bytes]"
             ),
         ),
         (
             bytearray(b'xx'),
             Err(
                 'Invalid JSON: expected value at line 1 column 1 '
-                "[type=json_invalid, input_value=bytearray(b'xx'), input_type=bytearray"
+                "[type=json_invalid, input_value=bytearray(b'xx'), input_type=bytearray]"
             ),
         ),
     ],

From bed050bcd41ed23e302835f5e1ba415db44fa9c1 Mon Sep 17 00:00:00 2001
From: Adrian Garcia Badaracco <1755071+adriangb@users.noreply.github.com>
Date: Wed, 20 Sep 2023 03:15:31 -0400
Subject: [PATCH 041/550] Fix serialization of model subclasses via unions when
 definition referneces are used (#977)

---
 src/serializers/shared.rs                     |  4 +-
 src/serializers/type_serializers/dataclass.rs |  4 +-
 .../type_serializers/definitions.rs           |  6 ++
 src/serializers/type_serializers/model.rs     |  4 +-
 src/serializers/type_serializers/nullable.rs  |  6 +-
 src/serializers/type_serializers/union.rs     | 14 +++--
 .../type_serializers/with_default.rs          |  6 +-
 tests/serializers/test_union.py               | 55 ++++++++++++++++++-
 8 files changed, 80 insertions(+), 19 deletions(-)

diff --git a/src/serializers/shared.rs b/src/serializers/shared.rs
index 7c24ff6db..b9b0c1fe1 100644
--- a/src/serializers/shared.rs
+++ b/src/serializers/shared.rs
@@ -13,7 +13,7 @@ use serde_json::ser::PrettyFormatter;
 
 use crate::build_tools::py_schema_err;
 use crate::build_tools::py_schema_error_type;
-use crate::definitions::DefinitionsBuilder;
+use crate::definitions::{Definitions, DefinitionsBuilder};
 use crate::py_gc::PyGcTraverse;
 use crate::tools::{py_err, SchemaDict};
 
@@ -293,7 +293,7 @@ pub(crate) trait TypeSerializer: Send + Sync + Clone + Debug {
     fn get_name(&self) -> &str;
 
     /// Used by union serializers to decide if it's worth trying again while allowing subclasses
-    fn retry_with_lax_check(&self) -> bool {
+    fn retry_with_lax_check(&self, _definitions: &Definitions<CombinedSerializer>) -> bool {
         false
     }
 
diff --git a/src/serializers/type_serializers/dataclass.rs b/src/serializers/type_serializers/dataclass.rs
index 787e267dd..124f962ad 100644
--- a/src/serializers/type_serializers/dataclass.rs
+++ b/src/serializers/type_serializers/dataclass.rs
@@ -6,7 +6,7 @@ use std::borrow::Cow;
 use ahash::AHashMap;
 
 use crate::build_tools::{py_schema_error_type, ExtraBehavior};
-use crate::definitions::DefinitionsBuilder;
+use crate::definitions::{Definitions, DefinitionsBuilder};
 use crate::tools::SchemaDict;
 
 use super::{
@@ -179,7 +179,7 @@ impl TypeSerializer for DataclassSerializer {
         &self.name
     }
 
-    fn retry_with_lax_check(&self) -> bool {
+    fn retry_with_lax_check(&self, _definitions: &Definitions<CombinedSerializer>) -> bool {
         true
     }
 }
diff --git a/src/serializers/type_serializers/definitions.rs b/src/serializers/type_serializers/definitions.rs
index 19d6e75ed..4614bbc56 100644
--- a/src/serializers/type_serializers/definitions.rs
+++ b/src/serializers/type_serializers/definitions.rs
@@ -4,6 +4,7 @@ use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList};
 
+use crate::definitions::Definitions;
 use crate::definitions::DefinitionsBuilder;
 
 use crate::tools::SchemaDict;
@@ -96,4 +97,9 @@ impl TypeSerializer for DefinitionRefSerializer {
     fn get_name(&self) -> &str {
         Self::EXPECTED_TYPE
     }
+
+    fn retry_with_lax_check(&self, definitions: &Definitions<CombinedSerializer>) -> bool {
+        let comb_serializer = definitions.get(self.serializer_id).unwrap();
+        comb_serializer.retry_with_lax_check(definitions)
+    }
 }
diff --git a/src/serializers/type_serializers/model.rs b/src/serializers/type_serializers/model.rs
index 8a2eeb4e1..c5b252fbf 100644
--- a/src/serializers/type_serializers/model.rs
+++ b/src/serializers/type_serializers/model.rs
@@ -13,7 +13,7 @@ use super::{
 };
 use crate::build_tools::py_schema_err;
 use crate::build_tools::{py_schema_error_type, ExtraBehavior};
-use crate::definitions::DefinitionsBuilder;
+use crate::definitions::{Definitions, DefinitionsBuilder};
 use crate::serializers::errors::PydanticSerializationUnexpectedValue;
 use crate::tools::SchemaDict;
 
@@ -228,7 +228,7 @@ impl TypeSerializer for ModelSerializer {
         &self.name
     }
 
-    fn retry_with_lax_check(&self) -> bool {
+    fn retry_with_lax_check(&self, _definitions: &Definitions<CombinedSerializer>) -> bool {
         true
     }
 }
diff --git a/src/serializers/type_serializers/nullable.rs b/src/serializers/type_serializers/nullable.rs
index 23349ec81..837d6c5f1 100644
--- a/src/serializers/type_serializers/nullable.rs
+++ b/src/serializers/type_serializers/nullable.rs
@@ -4,7 +4,7 @@ use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
 
-use crate::definitions::DefinitionsBuilder;
+use crate::definitions::{Definitions, DefinitionsBuilder};
 use crate::tools::SchemaDict;
 
 use super::{infer_json_key_known, BuildSerializer, CombinedSerializer, Extra, IsType, ObType, TypeSerializer};
@@ -75,7 +75,7 @@ impl TypeSerializer for NullableSerializer {
         Self::EXPECTED_TYPE
     }
 
-    fn retry_with_lax_check(&self) -> bool {
-        self.serializer.retry_with_lax_check()
+    fn retry_with_lax_check(&self, definitions: &Definitions<CombinedSerializer>) -> bool {
+        self.serializer.retry_with_lax_check(definitions)
     }
 }
diff --git a/src/serializers/type_serializers/union.rs b/src/serializers/type_serializers/union.rs
index d9b185017..70818959e 100644
--- a/src/serializers/type_serializers/union.rs
+++ b/src/serializers/type_serializers/union.rs
@@ -4,7 +4,7 @@ use pyo3::types::{PyDict, PyList, PyTuple};
 use std::borrow::Cow;
 
 use crate::build_tools::py_schema_err;
-use crate::definitions::DefinitionsBuilder;
+use crate::definitions::{Definitions, DefinitionsBuilder};
 use crate::tools::SchemaDict;
 use crate::PydanticSerializationUnexpectedValue;
 
@@ -87,7 +87,7 @@ impl TypeSerializer for UnionSerializer {
                 },
             }
         }
-        if self.retry_with_lax_check() {
+        if self.retry_with_lax_check(extra.definitions) {
             new_extra.check = SerCheck::Lax;
             for comb_serializer in &self.choices {
                 match comb_serializer.to_python(value, include, exclude, &new_extra) {
@@ -116,7 +116,7 @@ impl TypeSerializer for UnionSerializer {
                 },
             }
         }
-        if self.retry_with_lax_check() {
+        if self.retry_with_lax_check(extra.definitions) {
             new_extra.check = SerCheck::Lax;
             for comb_serializer in &self.choices {
                 match comb_serializer.json_key(key, &new_extra) {
@@ -153,7 +153,7 @@ impl TypeSerializer for UnionSerializer {
                 },
             }
         }
-        if self.retry_with_lax_check() {
+        if self.retry_with_lax_check(extra.definitions) {
             new_extra.check = SerCheck::Lax;
             for comb_serializer in &self.choices {
                 match comb_serializer.to_python(value, include, exclude, &new_extra) {
@@ -174,8 +174,10 @@ impl TypeSerializer for UnionSerializer {
         &self.name
     }
 
-    fn retry_with_lax_check(&self) -> bool {
-        self.choices.iter().any(TypeSerializer::retry_with_lax_check)
+    fn retry_with_lax_check(&self, definitions: &Definitions<CombinedSerializer>) -> bool {
+        self.choices
+            .iter()
+            .any(|choice| choice.retry_with_lax_check(definitions))
     }
 }
 
diff --git a/src/serializers/type_serializers/with_default.rs b/src/serializers/type_serializers/with_default.rs
index d20c273a1..148c05052 100644
--- a/src/serializers/type_serializers/with_default.rs
+++ b/src/serializers/type_serializers/with_default.rs
@@ -4,7 +4,7 @@ use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
 
-use crate::definitions::DefinitionsBuilder;
+use crate::definitions::{Definitions, DefinitionsBuilder};
 use crate::tools::SchemaDict;
 use crate::validators::DefaultType;
 
@@ -67,8 +67,8 @@ impl TypeSerializer for WithDefaultSerializer {
         Self::EXPECTED_TYPE
     }
 
-    fn retry_with_lax_check(&self) -> bool {
-        self.serializer.retry_with_lax_check()
+    fn retry_with_lax_check(&self, definitions: &Definitions<CombinedSerializer>) -> bool {
+        self.serializer.retry_with_lax_check(definitions)
     }
 
     fn get_default(&self, py: Python) -> PyResult<Option<PyObject>> {
diff --git a/tests/serializers/test_union.py b/tests/serializers/test_union.py
index c59996669..f81e33a6b 100644
--- a/tests/serializers/test_union.py
+++ b/tests/serializers/test_union.py
@@ -1,7 +1,7 @@
 import dataclasses
 import json
 import re
-from typing import Union
+from typing import Any, ClassVar, Union
 
 import pytest
 from typing_extensions import Literal
@@ -401,3 +401,56 @@ class Model(BaseModel):
 
     assert s.to_python(m) == {'value': data, 'value_types_reversed': data}
     assert s.to_json(m) == f'{{"value":{json_value},"value_types_reversed":{json_value}}}'.encode()
+
+
+def test_union_serializes_model_subclass_from_definition() -> None:
+    class BaseModel:
+        __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__'
+
+        def __init__(self, **kwargs: Any):
+            for key, value in kwargs.items():
+                setattr(self, key, value)
+
+    class User(BaseModel):
+        name: str
+
+    class DBUser(User):
+        password: str
+        __pydantic_serializer__: ClassVar[SchemaSerializer]
+
+    DBUser.__pydantic_serializer__ = SchemaSerializer(
+        core_schema.model_schema(
+            DBUser,
+            core_schema.model_fields_schema(
+                {
+                    'name': core_schema.model_field(core_schema.str_schema()),
+                    'password': core_schema.model_field(core_schema.str_schema()),
+                }
+            ),
+        )
+    )
+
+    class Item(BaseModel):
+        price: float
+
+    s = SchemaSerializer(
+        core_schema.definitions_schema(
+            core_schema.union_schema(
+                [core_schema.definition_reference_schema('User'), core_schema.definition_reference_schema('Item')]
+            ),
+            [
+                core_schema.model_schema(
+                    User,
+                    core_schema.model_fields_schema({'name': core_schema.model_field(core_schema.str_schema())}),
+                    ref='User',
+                ),
+                core_schema.model_schema(
+                    Item,
+                    core_schema.model_fields_schema({'price': core_schema.model_field(core_schema.float_schema())}),
+                    ref='Item',
+                ),
+            ],
+        )
+    )
+
+    assert s.to_python(DBUser(name='John', password='secret')) == {'name': 'John'}

From 157a64389de6bf58f0ae990ec1f7fe55237b8009 Mon Sep 17 00:00:00 2001
From: Serge Matveenko <lig@pydantic.dev>
Date: Wed, 20 Sep 2023 14:26:19 +0200
Subject: [PATCH 042/550] =?UTF-8?q?=E2=9C=A8=20Implement=20optional=20`num?=
 =?UTF-8?q?ber`=20to=20`str`=20coercion=20(#975)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: David Hewitt <1939362+davidhewitt@users.noreply.github.com>
---
 python/pydantic_core/core_schema.py |  2 ++
 src/input/input_abstract.rs         |  6 ++--
 src/input/input_json.rs             |  6 +++-
 src/input/input_python.rs           | 11 ++++++-
 src/input/return_enums.rs           |  6 ++++
 src/validators/string.rs            | 13 ++++++--
 src/validators/url.rs               |  4 +--
 tests/validators/test_function.py   | 10 +++++--
 tests/validators/test_string.py     | 46 ++++++++++++++++++++++++++++-
 tests/validators/test_union.py      |  5 +++-
 10 files changed, 96 insertions(+), 13 deletions(-)

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index db0b1bd54..6c44f034e 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -63,6 +63,7 @@ class CoreConfig(TypedDict, total=False):
         hide_input_in_errors: Whether to hide input data from `ValidationError` representation.
         validation_error_cause: Whether to add user-python excs to the __cause__ of a ValidationError.
             Requires exceptiongroup backport pre Python 3.11.
+        coerce_numbers_to_str: Whether to enable coercion of any `Number` type to `str` (not applicable in `strict` mode).
     """
 
     title: str
@@ -95,6 +96,7 @@ class CoreConfig(TypedDict, total=False):
     # used to hide input data from ValidationError repr
     hide_input_in_errors: bool
     validation_error_cause: bool  # default: False
+    coerce_numbers_to_str: bool  # default: False
 
 
 IncExCall: TypeAlias = 'set[int | str] | dict[int | str, IncExCall] | None'
diff --git a/src/input/input_abstract.rs b/src/input/input_abstract.rs
index f4a760a45..655ba24b9 100644
--- a/src/input/input_abstract.rs
+++ b/src/input/input_abstract.rs
@@ -91,16 +91,16 @@ pub trait Input<'a>: fmt::Debug + ToPyObject {
 
     fn parse_json(&'a self) -> ValResult<'a, JsonInput>;
 
-    fn validate_str(&'a self, strict: bool) -> ValResult<EitherString<'a>> {
+    fn validate_str(&'a self, strict: bool, coerce_numbers_to_str: bool) -> ValResult<EitherString<'a>> {
         if strict {
             self.strict_str()
         } else {
-            self.lax_str()
+            self.lax_str(coerce_numbers_to_str)
         }
     }
     fn strict_str(&'a self) -> ValResult<EitherString<'a>>;
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn lax_str(&'a self) -> ValResult<EitherString<'a>> {
+    fn lax_str(&'a self, _coerce_numbers_to_str: bool) -> ValResult<EitherString<'a>> {
         self.strict_str()
     }
 
diff --git a/src/input/input_json.rs b/src/input/input_json.rs
index 07f3554e6..e375f5755 100644
--- a/src/input/input_json.rs
+++ b/src/input/input_json.rs
@@ -88,9 +88,13 @@ impl<'a> Input<'a> for JsonInput {
             _ => Err(ValError::new(ErrorTypeDefaults::StringType, self)),
         }
     }
-    fn lax_str(&'a self) -> ValResult<EitherString<'a>> {
+    fn lax_str(&'a self, coerce_numbers_to_str: bool) -> ValResult<EitherString<'a>> {
         match self {
             JsonInput::String(s) => Ok(s.as_str().into()),
+            JsonInput::BigInt(v) if coerce_numbers_to_str => Ok(v.to_string().into()),
+            JsonInput::Float(v) if coerce_numbers_to_str => Ok(v.to_string().into()),
+            JsonInput::Int(v) if coerce_numbers_to_str => Ok(v.to_string().into()),
+            JsonInput::Uint(v) if coerce_numbers_to_str => Ok(v.to_string().into()),
             _ => Err(ValError::new(ErrorTypeDefaults::StringType, self)),
         }
     }
diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index 9e5fd1d1f..cf84c5517 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -223,7 +223,7 @@ impl<'a> Input<'a> for PyAny {
         }
     }
 
-    fn lax_str(&'a self) -> ValResult<EitherString<'a>> {
+    fn lax_str(&'a self, coerce_numbers_to_str: bool) -> ValResult<EitherString<'a>> {
         if let Ok(py_str) = <PyString as PyTryFrom>::try_from_exact(self) {
             Ok(py_str.into())
         } else if let Ok(py_str) = self.downcast::<PyString>() {
@@ -246,6 +246,15 @@ impl<'a> Input<'a> for PyAny {
                 Err(_) => return Err(ValError::new(ErrorTypeDefaults::StringUnicode, self)),
             };
             Ok(s.into())
+        } else if coerce_numbers_to_str && {
+            let py = self.py();
+            let decimal_type: Py<PyType> = get_decimal_type(py);
+
+            self.is_instance_of::<PyInt>()
+                || self.is_instance_of::<PyFloat>()
+                || self.is_instance(decimal_type.as_ref(py)).unwrap_or_default()
+        } {
+            Ok(self.str()?.into())
         } else {
             Err(ValError::new(ErrorTypeDefaults::StringType, self))
         }
diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index 56f86f580..d7d5a7f3b 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -768,6 +768,12 @@ impl<'a> From<&'a str> for EitherString<'a> {
     }
 }
 
+impl<'a> From<String> for EitherString<'a> {
+    fn from(data: String) -> Self {
+        Self::Cow(Cow::Owned(data))
+    }
+}
+
 impl<'a> From<&'a PyString> for EitherString<'a> {
     fn from(date: &'a PyString) -> Self {
         Self::Py(date)
diff --git a/src/validators/string.rs b/src/validators/string.rs
index 7b1a75a6d..0b4ec4a7b 100644
--- a/src/validators/string.rs
+++ b/src/validators/string.rs
@@ -13,6 +13,7 @@ use super::{BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationSta
 #[derive(Debug, Clone)]
 pub struct StrValidator {
     strict: bool,
+    coerce_numbers_to_str: bool,
 }
 
 impl BuildValidator for StrValidator {
@@ -30,6 +31,7 @@ impl BuildValidator for StrValidator {
         } else {
             Ok(Self {
                 strict: con_str_validator.strict,
+                coerce_numbers_to_str: con_str_validator.coerce_numbers_to_str,
             }
             .into())
         }
@@ -45,7 +47,7 @@ impl Validator for StrValidator {
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
     ) -> ValResult<'data, PyObject> {
-        let either_str = input.validate_str(state.strict_or(self.strict))?;
+        let either_str = input.validate_str(state.strict_or(self.strict), self.coerce_numbers_to_str)?;
         Ok(either_str.into_py(py))
     }
 
@@ -76,6 +78,7 @@ pub struct StrConstrainedValidator {
     strip_whitespace: bool,
     to_lower: bool,
     to_upper: bool,
+    coerce_numbers_to_str: bool,
 }
 
 impl_py_gc_traverse!(StrConstrainedValidator {});
@@ -87,7 +90,7 @@ impl Validator for StrConstrainedValidator {
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
     ) -> ValResult<'data, PyObject> {
-        let either_str = input.validate_str(state.strict_or(self.strict))?;
+        let either_str = input.validate_str(state.strict_or(self.strict), self.coerce_numbers_to_str)?;
         let cow = either_str.as_cow()?;
         let mut str = cow.as_ref();
         if self.strip_whitespace {
@@ -188,6 +191,11 @@ impl StrConstrainedValidator {
         let to_upper: bool =
             schema_or_config(schema, config, intern!(py, "to_upper"), intern!(py, "str_to_upper"))?.unwrap_or(false);
 
+        let coerce_numbers_to_str = config
+            .and_then(|c| c.get_item("coerce_numbers_to_str"))
+            .and_then(|v| v.is_true().ok())
+            .unwrap_or(false);
+
         Ok(Self {
             strict: is_strict(schema, config)?,
             pattern,
@@ -196,6 +204,7 @@ impl StrConstrainedValidator {
             strip_whitespace,
             to_lower,
             to_upper,
+            coerce_numbers_to_str,
         })
     }
 
diff --git a/src/validators/url.rs b/src/validators/url.rs
index a261d5e03..0afc76e59 100644
--- a/src/validators/url.rs
+++ b/src/validators/url.rs
@@ -111,7 +111,7 @@ impl Validator for UrlValidator {
 
 impl UrlValidator {
     fn get_url<'s, 'data>(&'s self, input: &'data impl Input<'data>, strict: bool) -> ValResult<'data, Url> {
-        match input.validate_str(strict) {
+        match input.validate_str(strict, false) {
             Ok(either_str) => {
                 let cow = either_str.as_cow()?;
                 let url_str = cow.as_ref();
@@ -251,7 +251,7 @@ impl Validator for MultiHostUrlValidator {
 
 impl MultiHostUrlValidator {
     fn get_url<'s, 'data>(&'s self, input: &'data impl Input<'data>, strict: bool) -> ValResult<'data, PyMultiHostUrl> {
-        match input.validate_str(strict) {
+        match input.validate_str(strict, false) {
             Ok(either_str) => {
                 let cow = either_str.as_cow()?;
                 let url_str = cow.as_ref();
diff --git a/tests/validators/test_function.py b/tests/validators/test_function.py
index 07710be41..1a63c27a3 100644
--- a/tests/validators/test_function.py
+++ b/tests/validators/test_function.py
@@ -201,7 +201,10 @@ def f(input_value, validator, info):
         {'type': 'function-wrap', 'function': {'type': 'general', 'function': f}, 'schema': {'type': 'str'}}
     )
 
-    assert v.validate_python('input value') == 'ValidatorCallable(Str(StrValidator{strict:false}))'
+    assert (
+        v.validate_python('input value')
+        == 'ValidatorCallable(Str(StrValidator{strict:false,coerce_numbers_to_str:false}))'
+    )
 
 
 def test_function_wrap_str():
@@ -212,7 +215,10 @@ def f(input_value, validator, info):
         {'type': 'function-wrap', 'function': {'type': 'general', 'function': f}, 'schema': {'type': 'str'}}
     )
 
-    assert v.validate_python('input value') == 'ValidatorCallable(Str(StrValidator{strict:false}))'
+    assert (
+        v.validate_python('input value')
+        == 'ValidatorCallable(Str(StrValidator{strict:false,coerce_numbers_to_str:false}))'
+    )
 
 
 def test_function_wrap_not_callable():
diff --git a/tests/validators/test_string.py b/tests/validators/test_string.py
index 8eae0ab65..0cff9eb95 100644
--- a/tests/validators/test_string.py
+++ b/tests/validators/test_string.py
@@ -1,5 +1,6 @@
 import re
 from decimal import Decimal
+from numbers import Number
 from typing import Any, Dict, Union
 
 import pytest
@@ -201,7 +202,10 @@ def test_regex_error():
 
 def test_default_validator():
     v = SchemaValidator(core_schema.str_schema(strict=True, to_lower=False), {'str_strip_whitespace': False})
-    assert plain_repr(v) == 'SchemaValidator(title="str",validator=Str(StrValidator{strict:true}),definitions=[])'
+    assert (
+        plain_repr(v)
+        == 'SchemaValidator(title="str",validator=Str(StrValidator{strict:true,coerce_numbers_to_str:false}),definitions=[])'
+    )
 
 
 @pytest.fixture(scope='session', name='FruitEnum')
@@ -253,3 +257,43 @@ class StrSubclass(str):
 
     assert not isinstance(v.validate_python(StrSubclass('')), StrSubclass)
     assert not isinstance(v.validate_python(StrSubclass(''), strict=True), StrSubclass)
+
+
+def test_coerce_numbers_to_str_disabled_in_strict_mode() -> None:
+    config = core_schema.CoreConfig(coerce_numbers_to_str=True)
+
+    v = SchemaValidator(core_schema.str_schema(strict=True), config)
+    with pytest.raises(ValidationError):
+        v.validate_python(42)
+    with pytest.raises(ValidationError):
+        v.validate_json('42')
+
+
+@pytest.mark.parametrize(
+    ('number', 'expected_str'),
+    [
+        pytest.param(42, '42', id='42'),
+        pytest.param(42.0, '42.0', id='42.0'),
+        pytest.param(Decimal('42.0'), '42.0', id="Decimal('42.0')"),
+    ],
+)
+def test_coerce_numbers_to_str(number: Number, expected_str: str) -> None:
+    config = core_schema.CoreConfig(coerce_numbers_to_str=True)
+
+    v = SchemaValidator(core_schema.str_schema(), config)
+    assert v.validate_python(number) == expected_str
+
+
+@pytest.mark.parametrize(
+    ('number', 'expected_str'),
+    [
+        pytest.param('42', '42', id='42'),
+        pytest.param('42.0', '42', id='42.0'),
+        pytest.param('42.13', '42.13', id='42.13'),
+    ],
+)
+def test_coerce_numbers_to_str_from_json(number: str, expected_str: str) -> None:
+    config = core_schema.CoreConfig(coerce_numbers_to_str=True)
+
+    v = SchemaValidator(core_schema.str_schema(), config)
+    assert v.validate_json(number) == expected_str
diff --git a/tests/validators/test_union.py b/tests/validators/test_union.py
index 7e0f608f1..05072b806 100644
--- a/tests/validators/test_union.py
+++ b/tests/validators/test_union.py
@@ -256,7 +256,10 @@ def test_empty_choices():
 
 def test_one_choice():
     v = SchemaValidator({'type': 'union', 'choices': [{'type': 'str'}]})
-    assert plain_repr(v) == 'SchemaValidator(title="str",validator=Str(StrValidator{strict:false}),definitions=[])'
+    assert (
+        plain_repr(v)
+        == 'SchemaValidator(title="str",validator=Str(StrValidator{strict:false,coerce_numbers_to_str:false}),definitions=[])'
+    )
     assert v.validate_python('hello') == 'hello'
 
 

From 621fb035f24e243a45f3e17aaeef2d9afc31a7de Mon Sep 17 00:00:00 2001
From: sydney-runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Wed, 20 Sep 2023 09:42:26 -0500
Subject: [PATCH 043/550] Add support for hiding input in errors and json
 (#973)

Co-authored-by: David Hewitt <1939362+davidhewitt@users.noreply.github.com>
---
 python/pydantic_core/_pydantic_core.pyi | 15 +++++++--
 src/build_tools.rs                      |  2 +-
 src/errors/validation_exception.rs      | 45 ++++++++++++++++---------
 tests/test_errors.py                    | 18 ++++++++++
 4 files changed, 61 insertions(+), 19 deletions(-)

diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index be2b64793..ca0104b9d 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -731,18 +731,28 @@ class ValidationError(ValueError):
         Returns:
             The number of errors in the validation error.
         """
-    def errors(self, *, include_url: bool = True, include_context: bool = True) -> list[ErrorDetails]:
+    def errors(
+        self, *, include_url: bool = True, include_context: bool = True, include_input: bool = True
+    ) -> list[ErrorDetails]:
         """
         Details about each error in the validation error.
 
         Args:
             include_url: Whether to include a URL to documentation on the error each error.
             include_context: Whether to include the context of each error.
+            include_input: Whether to include the input value of each error.
 
         Returns:
             A list of [`ErrorDetails`][pydantic_core.ErrorDetails] for each error in the validation error.
         """
-    def json(self, *, indent: int | None = None, include_url: bool = True, include_context: bool = True) -> str:
+    def json(
+        self,
+        *,
+        indent: int | None = None,
+        include_url: bool = True,
+        include_context: bool = True,
+        include_input: bool = True,
+    ) -> str:
         """
         Same as [`errors()`][pydantic_core.ValidationError.errors] but returns a JSON string.
 
@@ -750,6 +760,7 @@ class ValidationError(ValueError):
             indent: The number of spaces to indent the JSON by, or `None` for no indentation - compact JSON.
             include_url: Whether to include a URL to documentation on the error each error.
             include_context: Whether to include the context of each error.
+            include_input: Whether to include the input value of each error.
 
         Returns:
             a JSON string.
diff --git a/src/build_tools.rs b/src/build_tools.rs
index 47fa569ac..c242f97a3 100644
--- a/src/build_tools.rs
+++ b/src/build_tools.rs
@@ -125,7 +125,7 @@ impl SchemaError {
     fn errors(&self, py: Python) -> PyResult<Py<PyList>> {
         match &self.0 {
             SchemaErrorEnum::Message(_) => Ok(PyList::empty(py).into_py(py)),
-            SchemaErrorEnum::ValidationError(error) => error.errors(py, false, false),
+            SchemaErrorEnum::ValidationError(error) => error.errors(py, false, false, true),
         }
     }
 
diff --git a/src/errors/validation_exception.rs b/src/errors/validation_exception.rs
index d0977001a..09154d8ac 100644
--- a/src/errors/validation_exception.rs
+++ b/src/errors/validation_exception.rs
@@ -265,8 +265,14 @@ impl ValidationError {
         self.line_errors.len()
     }
 
-    #[pyo3(signature = (*, include_url = true, include_context = true))]
-    pub fn errors(&self, py: Python, include_url: bool, include_context: bool) -> PyResult<Py<PyList>> {
+    #[pyo3(signature = (*, include_url = true, include_context = true, include_input = true))]
+    pub fn errors(
+        &self,
+        py: Python,
+        include_url: bool,
+        include_context: bool,
+        include_input: bool,
+    ) -> PyResult<Py<PyList>> {
         let url_prefix = get_url_prefix(py, include_url);
         let mut iteration_error = None;
         let list = PyList::new(
@@ -278,7 +284,7 @@ impl ValidationError {
                 if iteration_error.is_some() {
                     return py.None();
                 }
-                e.as_dict(py, url_prefix, include_context, self.input_type)
+                e.as_dict(py, url_prefix, include_context, self.input_type, include_input)
                     .unwrap_or_else(|err| {
                         iteration_error = Some(err);
                         py.None()
@@ -292,13 +298,14 @@ impl ValidationError {
         }
     }
 
-    #[pyo3(signature = (*, indent = None, include_url = true, include_context = true))]
+    #[pyo3(signature = (*, indent = None, include_url = true, include_context = true, include_input = true))]
     pub fn json<'py>(
         &self,
         py: Python<'py>,
         indent: Option<usize>,
         include_url: bool,
         include_context: bool,
+        include_input: bool,
     ) -> PyResult<&'py PyString> {
         let state = SerializationState::new("iso8601", "utf8")?;
         let extra = state.extra(py, &SerMode::Json, true, false, false, true, None);
@@ -307,6 +314,7 @@ impl ValidationError {
             line_errors: &self.line_errors,
             url_prefix: get_url_prefix(py, include_url),
             include_context,
+            include_input,
             extra: &extra,
             input_type: &self.input_type,
         };
@@ -477,12 +485,15 @@ impl PyLineError {
         url_prefix: Option<&str>,
         include_context: bool,
         input_type: InputType,
+        include_input: bool,
     ) -> PyResult<PyObject> {
         let dict = PyDict::new(py);
         dict.set_item("type", self.error_type.type_string())?;
         dict.set_item("loc", self.location.to_object(py))?;
         dict.set_item("msg", self.error_type.render_message(py, input_type)?)?;
-        dict.set_item("input", &self.input_value)?;
+        if include_input {
+            dict.set_item("input", &self.input_value)?;
+        }
         if include_context {
             if let Some(context) = self.error_type.py_dict(py)? {
                 dict.set_item("ctx", context)?;
@@ -563,6 +574,7 @@ struct ValidationErrorSerializer<'py> {
     line_errors: &'py [PyLineError],
     url_prefix: Option<&'py str>,
     include_context: bool,
+    include_input: bool,
     extra: &'py crate::serializers::Extra<'py>,
     input_type: &'py InputType,
 }
@@ -579,6 +591,7 @@ impl<'py> Serialize for ValidationErrorSerializer<'py> {
                 line_error,
                 url_prefix: self.url_prefix,
                 include_context: self.include_context,
+                include_input: self.include_input,
                 extra: self.extra,
                 input_type: self.input_type,
             };
@@ -593,6 +606,7 @@ struct PyLineErrorSerializer<'py> {
     line_error: &'py PyLineError,
     url_prefix: Option<&'py str>,
     include_context: bool,
+    include_input: bool,
     extra: &'py crate::serializers::Extra<'py>,
     input_type: &'py InputType,
 }
@@ -603,13 +617,10 @@ impl<'py> Serialize for PyLineErrorSerializer<'py> {
         S: Serializer,
     {
         let py = self.py;
-        let mut size = 4;
-        if self.url_prefix.is_some() {
-            size += 1;
-        }
-        if self.include_context {
-            size += 1;
-        }
+        let size = 3 + [self.url_prefix.is_some(), self.include_context, self.include_input]
+            .into_iter()
+            .filter(|b| *b)
+            .count();
         let mut map = serializer.serialize_map(Some(size))?;
 
         map.serialize_entry("type", &self.line_error.error_type.type_string())?;
@@ -623,10 +634,12 @@ impl<'py> Serialize for PyLineErrorSerializer<'py> {
             .map_err(py_err_json::<S>)?;
         map.serialize_entry("msg", &msg)?;
 
-        map.serialize_entry(
-            "input",
-            &self.extra.serialize_infer(self.line_error.input_value.as_ref(py)),
-        )?;
+        if self.include_input {
+            map.serialize_entry(
+                "input",
+                &self.extra.serialize_infer(self.line_error.input_value.as_ref(py)),
+            )?;
+        }
 
         if self.include_context {
             if let Some(context) = self.line_error.error_type.py_dict(py).map_err(py_err_json::<S>)? {
diff --git a/tests/test_errors.py b/tests/test_errors.py
index fe71b9860..15d2c78af 100644
--- a/tests/test_errors.py
+++ b/tests/test_errors.py
@@ -1070,3 +1070,21 @@ def test_loc_with_dots(pydantic_version):
         "[type=int_parsing, input_value='x', input_type=str]\n"
         f'    For further information visit https://errors.pydantic.dev/{pydantic_version}/v/int_parsing'
     )
+
+
+def test_hide_input_in_error() -> None:
+    s = SchemaValidator({'type': 'int'})
+    with pytest.raises(ValidationError) as exc_info:
+        s.validate_python('definitely not an int')
+
+    for error in exc_info.value.errors(include_input=False):
+        assert 'input' not in error
+
+
+def test_hide_input_in_json() -> None:
+    s = SchemaValidator({'type': 'int'})
+    with pytest.raises(ValidationError) as exc_info:
+        s.validate_python('definitely not an int')
+
+    for error in exc_info.value.errors(include_input=False):
+        assert 'input' not in error

From 0f9a5c9569b04a787275410bf5d8764f194c3bca Mon Sep 17 00:00:00 2001
From: Serge Matveenko <lig@pydantic.dev>
Date: Wed, 20 Sep 2023 16:48:01 +0200
Subject: [PATCH 044/550] =?UTF-8?q?=F0=9F=94=96=20Bump=20version=20to=202.?=
 =?UTF-8?q?9.0=20(#979)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 55224a954..1027b8597 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -242,7 +242,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.8.0"
+version = "2.9.0"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index a4dfda154..9e193b3d4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.8.0"
+version = "2.9.0"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From b8d3b95ac27759db8df8def65b100b03db19eb31 Mon Sep 17 00:00:00 2001
From: David Hewitt <1939362+davidhewitt@users.noreply.github.com>
Date: Wed, 20 Sep 2023 16:03:02 +0100
Subject: [PATCH 045/550] use `TypedDict` from `typing_extensions` on <3.12
 (#978)

---
 python/pydantic_core/core_schema.py | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index 6c44f034e..3abf393b8 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -11,15 +11,20 @@
 from decimal import Decimal
 from typing import TYPE_CHECKING, Any, Callable, Dict, Hashable, List, Set, Tuple, Type, Union
 
+if sys.version_info < (3, 12):
+    from typing_extensions import TypedDict
+else:
+    from typing import TypedDict
+
 if sys.version_info < (3, 11):
     from typing_extensions import Protocol, Required, TypeAlias
 else:
     from typing import Protocol, Required, TypeAlias
 
 if sys.version_info < (3, 9):
-    from typing_extensions import Literal, TypedDict
+    from typing_extensions import Literal
 else:
-    from typing import Literal, TypedDict
+    from typing import Literal
 
 if TYPE_CHECKING:
     from pydantic_core import PydanticUndefined

From 4c84ed877c6806a9cca6649756160619a79c7e70 Mon Sep 17 00:00:00 2001
From: David Hewitt <1939362+davidhewitt@users.noreply.github.com>
Date: Thu, 21 Sep 2023 14:22:20 +0100
Subject: [PATCH 046/550] add switch to change regex engine from Rust to Python
 (#983)

---
 python/pydantic_core/core_schema.py | 10 ++++
 src/validators/string.rs            | 62 ++++++++++++++++++++++---
 tests/validators/test_string.py     | 71 +++++++++++++++++++++++------
 3 files changed, 123 insertions(+), 20 deletions(-)

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index 3abf393b8..718bdf969 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -69,6 +69,7 @@ class CoreConfig(TypedDict, total=False):
         validation_error_cause: Whether to add user-python excs to the __cause__ of a ValidationError.
             Requires exceptiongroup backport pre Python 3.11.
         coerce_numbers_to_str: Whether to enable coercion of any `Number` type to `str` (not applicable in `strict` mode).
+        regex_engine: The regex engine to use for regex pattern validation. Default is 'rust-regex'. See `StringSchema`.
     """
 
     title: str
@@ -752,6 +753,7 @@ class StringSchema(TypedDict, total=False):
     strip_whitespace: bool
     to_lower: bool
     to_upper: bool
+    regex_engine: Literal['rust-regex', 'python-re']  # default: 'rust-regex'
     strict: bool
     ref: str
     metadata: Any
@@ -766,6 +768,7 @@ def str_schema(
     strip_whitespace: bool | None = None,
     to_lower: bool | None = None,
     to_upper: bool | None = None,
+    regex_engine: Literal['rust-regex', 'python-re'] | None = None,
     strict: bool | None = None,
     ref: str | None = None,
     metadata: Any = None,
@@ -789,6 +792,12 @@ def str_schema(
         strip_whitespace: Whether to strip whitespace from the value
         to_lower: Whether to convert the value to lowercase
         to_upper: Whether to convert the value to uppercase
+        regex_engine: The regex engine to use for pattern validation. Default is 'rust-regex'.
+            - `rust-regex` uses the [`regex`](https://docs.rs/regex) Rust
+              crate, which is non-backtracking and therefore more DDoS
+              resistant, but does not support all regex features.
+            - `python-re` use the [`re`](https://docs.python.org/3/library/re.html) module,
+              which supports all regex features, but may be slower.
         strict: Whether the value should be a string or a value that can be converted to a string
         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
@@ -802,6 +811,7 @@ def str_schema(
         strip_whitespace=strip_whitespace,
         to_lower=to_lower,
         to_upper=to_upper,
+        regex_engine=regex_engine,
         strict=strict,
         ref=ref,
         metadata=metadata,
diff --git a/src/validators/string.rs b/src/validators/string.rs
index 0b4ec4a7b..d997dcf85 100644
--- a/src/validators/string.rs
+++ b/src/validators/string.rs
@@ -72,7 +72,7 @@ impl Validator for StrValidator {
 #[derive(Debug, Clone, Default)]
 pub struct StrConstrainedValidator {
     strict: bool,
-    pattern: Option<Regex>,
+    pattern: Option<Pattern>,
     max_length: Option<usize>,
     min_length: Option<usize>,
     strip_whitespace: bool,
@@ -126,10 +126,10 @@ impl Validator for StrConstrainedValidator {
         }
 
         if let Some(pattern) = &self.pattern {
-            if !pattern.is_match(str) {
+            if !pattern.is_match(py, str)? {
                 return Err(ValError::new(
                     ErrorType::StringPatternMismatch {
-                        pattern: pattern.to_string(),
+                        pattern: pattern.pattern.clone(),
                         context: None,
                     },
                     input,
@@ -170,10 +170,16 @@ impl Validator for StrConstrainedValidator {
 impl StrConstrainedValidator {
     fn build(schema: &PyDict, config: Option<&PyDict>) -> PyResult<Self> {
         let py = schema.py();
-        let pattern = match schema.get_as(intern!(py, "pattern"))? {
-            Some(s) => Some(Regex::new(s).map_err(|e| py_schema_error_type!("{}", e))?),
-            None => None,
-        };
+
+        let pattern = schema
+            .get_as(intern!(py, "pattern"))?
+            .map(|s| {
+                let regex_engine =
+                    schema_or_config(schema, config, intern!(py, "regex_engine"), intern!(py, "regex_engine"))?
+                        .unwrap_or(RegexEngine::RUST_REGEX);
+                Pattern::compile(py, s, regex_engine)
+            })
+            .transpose()?;
         let min_length: Option<usize> =
             schema_or_config(schema, config, intern!(py, "min_length"), intern!(py, "str_min_length"))?;
         let max_length: Option<usize> =
@@ -219,3 +225,45 @@ impl StrConstrainedValidator {
             || self.to_upper
     }
 }
+
+#[derive(Debug, Clone)]
+struct Pattern {
+    pattern: String,
+    engine: RegexEngine,
+}
+
+#[derive(Debug, Clone)]
+enum RegexEngine {
+    RustRegex(Regex),
+    PythonRe(PyObject),
+}
+
+impl RegexEngine {
+    const RUST_REGEX: &str = "rust-regex";
+    const PYTHON_RE: &str = "python-re";
+}
+
+impl Pattern {
+    fn compile(py: Python<'_>, pattern: String, engine: &str) -> PyResult<Self> {
+        let engine = match engine {
+            RegexEngine::RUST_REGEX => {
+                RegexEngine::RustRegex(Regex::new(&pattern).map_err(|e| py_schema_error_type!("{}", e))?)
+            }
+            RegexEngine::PYTHON_RE => {
+                let re_compile = py.import(intern!(py, "re"))?.getattr(intern!(py, "compile"))?;
+                RegexEngine::PythonRe(re_compile.call1((&pattern,))?.into())
+            }
+            _ => return Err(py_schema_error_type!("Invalid regex engine: {}", engine)),
+        };
+        Ok(Self { pattern, engine })
+    }
+
+    fn is_match(&self, py: Python<'_>, target: &str) -> PyResult<bool> {
+        match &self.engine {
+            RegexEngine::RustRegex(regex) => Ok(regex.is_match(target)),
+            RegexEngine::PythonRe(py_regex) => {
+                Ok(!py_regex.call_method1(py, intern!(py, "match"), (target,))?.is_none(py))
+            }
+        }
+    }
+}
diff --git a/tests/validators/test_string.py b/tests/validators/test_string.py
index 0cff9eb95..acb145a58 100644
--- a/tests/validators/test_string.py
+++ b/tests/validators/test_string.py
@@ -167,7 +167,8 @@ def test_str_constrained_config():
         v.validate_python('test long')
 
 
-def test_invalid_regex():
+@pytest.mark.parametrize('engine', [None, 'rust-regex', 'python-re'])
+def test_invalid_regex(engine):
     # TODO uncomment and fix once #150 is done
     # with pytest.raises(SchemaError) as exc_info:
     #     SchemaValidator({'type': 'str', 'pattern': 123})
@@ -175,18 +176,25 @@ def test_invalid_regex():
     #     'Error building "str" validator:\n  TypeError: \'int\' object cannot be converted to \'PyString\''
     # )
     with pytest.raises(SchemaError) as exc_info:
-        SchemaValidator({'type': 'str', 'pattern': '(abc'})
-    assert exc_info.value.args[0] == (
-        'Error building "str" validator:\n'
-        '  SchemaError: regex parse error:\n'
-        '    (abc\n'
-        '    ^\n'
-        'error: unclosed group'
-    )
-
-
-def test_regex_error():
-    v = SchemaValidator({'type': 'str', 'pattern': '11'})
+        SchemaValidator(core_schema.str_schema(pattern='(abc', regex_engine=engine))
+
+    if engine is None or engine == 'rust-regex':
+        assert exc_info.value.args[0] == (
+            'Error building "str" validator:\n'
+            '  SchemaError: regex parse error:\n'
+            '    (abc\n'
+            '    ^\n'
+            'error: unclosed group'
+        )
+    elif engine == 'python-re':
+        assert exc_info.value.args[0] == (
+            'Error building "str" validator:\n  error: missing ), unterminated subpattern at position 0'
+        )
+
+
+@pytest.mark.parametrize('engine', [None, 'rust-regex', 'python-re'])
+def test_regex_error(engine):
+    v = SchemaValidator(core_schema.str_schema(pattern='11', regex_engine=engine))
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python('12')
     assert exc_info.value.errors(include_url=False) == [
@@ -297,3 +305,40 @@ def test_coerce_numbers_to_str_from_json(number: str, expected_str: str) -> None
 
     v = SchemaValidator(core_schema.str_schema(), config)
     assert v.validate_json(number) == expected_str
+
+
+@pytest.mark.parametrize('mode', (None, 'schema', 'config'))
+def test_backtracking_regex_rust_unsupported(mode) -> None:
+    pattern = r'r(#*)".*?"\1'
+
+    with pytest.raises(SchemaError) as exc_info:
+        if mode is None:
+            # rust-regex is the default
+            SchemaValidator(core_schema.str_schema(pattern=pattern))
+        elif mode == 'schema':
+            SchemaValidator(core_schema.str_schema(pattern=pattern, regex_engine='rust-regex'))
+        elif mode == 'config':
+            SchemaValidator(core_schema.str_schema(pattern=pattern), core_schema.CoreConfig(regex_engine='rust-regex'))
+
+    assert exc_info.value.args[0] == (
+        'Error building \"str\" validator:\n'
+        '  SchemaError: regex parse error:\n'
+        '    r(#*)\".*?\"\\1\n'
+        '              ^^\n'
+        'error: backreferences are not supported'
+    )
+
+
+@pytest.mark.parametrize('mode', ('schema', 'config'))
+def test_backtracking_regex_python(mode) -> None:
+    pattern = r'r(#*)".*?"\1'
+
+    if mode == 'schema':
+        v = SchemaValidator(core_schema.str_schema(pattern=pattern, regex_engine='python-re'))
+    elif mode == 'config':
+        v = SchemaValidator(core_schema.str_schema(pattern=pattern), core_schema.CoreConfig(regex_engine='python-re'))
+    assert v.validate_python('r""') == 'r""'
+    assert v.validate_python('r#""#') == 'r#""#'
+    with pytest.raises(ValidationError):
+        # not a valid match for the pattern
+        v.validate_python('r#"#')

From 33a7cc0727bef0d5a0a293e0662dfd81af35658f Mon Sep 17 00:00:00 2001
From: Samuel Colvin <s@muelcolvin.com>
Date: Thu, 21 Sep 2023 15:16:19 +0100
Subject: [PATCH 047/550] =?UTF-8?q?=F0=9F=90=9B=20Fix=20handling=20of=20`U?=
 =?UTF-8?q?UID`=20values=20having=20`UUID.version=3DNone`=20(#981)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Co-authored-by: Serge Matveenko <lig@pydantic.dev>
Co-authored-by: David Hewitt <1939362+davidhewitt@users.noreply.github.com>
---
 src/validators/uuid.rs        | 14 ++++++++------
 tests/validators/test_uuid.py | 18 +++++++++++++++++-
 2 files changed, 25 insertions(+), 7 deletions(-)

diff --git a/src/validators/uuid.rs b/src/validators/uuid.rs
index 6467cc406..ca924ce66 100644
--- a/src/validators/uuid.rs
+++ b/src/validators/uuid.rs
@@ -59,7 +59,7 @@ impl From<u8> for Version {
 #[derive(Debug, Clone)]
 pub struct UuidValidator {
     strict: bool,
-    version: Option<Version>,
+    version: Option<usize>,
 }
 
 impl BuildValidator for UuidValidator {
@@ -71,10 +71,11 @@ impl BuildValidator for UuidValidator {
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
+        // Note(lig): let's keep this conversion through the Version enum just for the sake of validation
         let version = schema.get_as::<u8>(intern!(py, "version"))?.map(Version::from);
         Ok(Self {
             strict: is_strict(schema, config)?,
-            version,
+            version: version.map(usize::from),
         }
         .into())
     }
@@ -92,9 +93,11 @@ impl Validator for UuidValidator {
         let class = get_uuid_type(py)?;
         if let Some(py_input) = input.input_is_instance(class) {
             if let Some(expected_version) = self.version {
-                let py_input_version: usize = py_input.getattr(intern!(py, "version"))?.extract()?;
-                let expected_version = usize::from(expected_version);
-                if expected_version != py_input_version {
+                let py_input_version: Option<usize> = py_input.getattr(intern!(py, "version"))?.extract()?;
+                if !match py_input_version {
+                    Some(py_input_version) => py_input_version == expected_version,
+                    None => false,
+                } {
                     return Err(ValError::new(
                         ErrorType::UuidVersion {
                             expected_version,
@@ -179,7 +182,6 @@ impl UuidValidator {
 
         if let Some(expected_version) = self.version {
             let v1 = uuid.get_version_num();
-            let expected_version = usize::from(expected_version);
             if v1 != expected_version {
                 return Err(ValError::new(
                     ErrorType::UuidVersion {
diff --git a/tests/validators/test_uuid.py b/tests/validators/test_uuid.py
index 4ecd7feff..9afe2d2b8 100644
--- a/tests/validators/test_uuid.py
+++ b/tests/validators/test_uuid.py
@@ -23,6 +23,7 @@
         ('6ba7b810-9dad-11d1-80b4-00c04fd430c8', UUID('6ba7b810-9dad-11d1-80b4-00c04fd430c8')),
         ('886313e1-3b8a-5372-9b90-0c9aee199e5d', UUID('886313e1-3b8a-5372-9b90-0c9aee199e5d')),
         ('c0a8f9a8-aa5e-482b-a067-9cb3a51f5c11', UUID('c0a8f9a8-aa5e-482b-a067-9cb3a51f5c11')),
+        ('00000000-8000-4000-8000-000000000000', UUID('00000000-8000-4000-8000-000000000000')),
         (b'\x12\x34\x56\x78' * 4, UUID('12345678-1234-5678-1234-567812345678')),
         (b'\x00\x00\x00\x00' * 4, UUID('00000000-0000-0000-0000-000000000000')),
         (b'ebcdab58-6eb8-46fb-a190-d07a33e9eac8', UUID('ebcdab58-6eb8-46fb-a190-d07a33e9eac8')),
@@ -118,6 +119,16 @@ def test_uuid_strict(input_value, expected):
         (UUID('0e7ac198-9acd-4c0c-b4b4-761974bf71d7'), 4, UUID('0e7ac198-9acd-4c0c-b4b4-761974bf71d7')),
         ('0e7ac198-9acd-4c0c-b4b4-761974bf71d7', 4, UUID('0e7ac198-9acd-4c0c-b4b4-761974bf71d7')),
         (UUID('0e7ac198-9acd-4c0c-b4b4-761974bf71d7'), 4, UUID('0e7ac198-9acd-4c0c-b4b4-761974bf71d7')),
+        # Cases from pydantic#7355 and pydantic#7537
+        # `UUID.version` makes sense for RFC 4122 UUIDs only. For non RFC 4122 UUIDs Python uses `UUID.version=None`
+        ('00000000-8000-4000-8000-000000000000', 4, UUID('00000000-8000-4000-8000-000000000000')),
+        (UUID('00000000-8000-4000-8000-000000000000'), 4, UUID('00000000-8000-4000-8000-000000000000')),
+        ('00000000-7fff-4000-7fff-000000000000', None, UUID('00000000-7fff-4000-7fff-000000000000')),
+        (UUID('00000000-7fff-4000-7fff-000000000000'), None, UUID('00000000-7fff-4000-7fff-000000000000')),
+        (UUID('00000000-7fff-4000-7fff-000000000000'), 4, Err('UUID version 4 expected')),
+        ('b34b6755-f49c-3bd2-6f06-131a708c2bf3', None, UUID('b34b6755-f49c-3bd2-6f06-131a708c2bf3')),
+        (UUID('b34b6755-f49c-3bd2-6f06-131a708c2bf3'), None, UUID('b34b6755-f49c-3bd2-6f06-131a708c2bf3')),
+        (UUID('b34b6755-f49c-3bd2-6f06-131a708c2bf3'), 4, Err('UUID version 4 expected')),
         # Invalid UUIDs
         ('a6cc5730-2261-11ee-9c43-2eb5a363657c', 5, Err('UUID version 5 expected')),
         (UUID('a6cc5730-2261-11ee-9c43-2eb5a363657c'), 5, Err('UUID version 5 expected')),
@@ -130,7 +141,12 @@ def test_uuid_strict(input_value, expected):
     ],
 )
 def test_uuid_version(input_value, version, expected):
-    v = SchemaValidator({'type': 'uuid', 'version': version})
+    schema = {'type': 'uuid'}
+    if version is not None:
+        schema['version'] = version
+
+    v = SchemaValidator(schema)
+
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value)

From 916d9092fb99d61dea12d17bede18e39fa6719e8 Mon Sep 17 00:00:00 2001
From: David Hewitt <1939362+davidhewitt@users.noreply.github.com>
Date: Thu, 21 Sep 2023 15:50:24 +0100
Subject: [PATCH 048/550] Add `validate_core_schema` function and remove
 validation from `SchemaValidator` and `SchemaSerializer` constructors (#982)

Co-authored-by: Adrian Garcia Badaracco <1755071+adriangb@users.noreply.github.com>
---
 benches/main.rs                             |  8 +++++---
 python/pydantic_core/__init__.py            |  2 ++
 python/pydantic_core/_pydantic_core.pyi     |  9 +++++++++
 src/lib.rs                                  |  3 ++-
 src/serializers/mod.rs                      |  5 +----
 src/validators/mod.rs                       |  9 ++++++---
 src/validators/string.rs                    |  4 ++--
 tests/benchmarks/test_complete_benchmark.py | 20 ++++++++++----------
 tests/conftest.py                           |  4 ++--
 tests/serializers/test_definitions.py       |  4 ++--
 tests/serializers/test_dict.py              |  6 ++++--
 tests/serializers/test_list_tuple.py        | 10 ++++++----
 tests/serializers/test_misc.py              |  4 ++--
 tests/test.rs                               |  4 ++--
 tests/test_build.py                         | 18 +++++++++---------
 tests/validators/test_custom_error.py       |  4 ++--
 tests/validators/test_date.py               | 18 ++++++++++--------
 tests/validators/test_datetime.py           | 10 +++++-----
 tests/validators/test_decimal.py            |  6 ++++--
 tests/validators/test_definitions.py        |  4 ++--
 tests/validators/test_function.py           |  8 ++++----
 tests/validators/test_model_fields.py       | 16 +++++++++-------
 tests/validators/test_time.py               |  7 +++----
 tests/validators/test_timedelta.py          |  7 +++----
 tests/validators/test_typed_dict.py         | 18 ++++++++++--------
 tests/validators/test_union.py              |  4 ++--
 26 files changed, 118 insertions(+), 94 deletions(-)

diff --git a/benches/main.rs b/benches/main.rs
index d5ab30479..8e020e269 100644
--- a/benches/main.rs
+++ b/benches/main.rs
@@ -7,10 +7,11 @@ use test::{black_box, Bencher};
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyString};
 
-use _pydantic_core::SchemaValidator;
+use _pydantic_core::{validate_core_schema, SchemaValidator};
 
 fn build_schema_validator_with_globals(py: Python, code: &str, globals: Option<&PyDict>) -> SchemaValidator {
-    let schema: &PyDict = py.eval(code, globals, None).unwrap().extract().unwrap();
+    let mut schema: &PyDict = py.eval(code, globals, None).unwrap().extract().unwrap();
+    schema = validate_core_schema(py, schema).unwrap().extract().unwrap();
     SchemaValidator::py_new(py, schema, None).unwrap()
 }
 
@@ -444,7 +445,8 @@ fn complete_model(bench: &mut Bencher) {
         sys_path.call_method1("append", ("./tests/benchmarks/",)).unwrap();
 
         let complete_schema = py.import("complete_schema").unwrap();
-        let schema = complete_schema.call_method0("schema").unwrap();
+        let mut schema = complete_schema.call_method0("schema").unwrap();
+        schema = validate_core_schema(py, schema).unwrap().extract().unwrap();
         let validator = SchemaValidator::py_new(py, schema, None).unwrap();
 
         let input = complete_schema.call_method0("input_data_lax").unwrap();
diff --git a/python/pydantic_core/__init__.py b/python/pydantic_core/__init__.py
index a916f43d8..a46a77b7d 100644
--- a/python/pydantic_core/__init__.py
+++ b/python/pydantic_core/__init__.py
@@ -24,6 +24,7 @@
     __version__,
     to_json,
     to_jsonable_python,
+    validate_core_schema,
 )
 from .core_schema import CoreConfig, CoreSchema, CoreSchemaType, ErrorType
 
@@ -63,6 +64,7 @@
     'TzInfo',
     'to_json',
     'to_jsonable_python',
+    'validate_core_schema',
 ]
 
 
diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index ca0104b9d..82e6e3015 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -44,6 +44,7 @@ __all__ = [
     'to_jsonable_python',
     'list_all_errors',
     'TzInfo',
+    'validate_core_schema',
 ]
 __version__: str
 build_profile: str
@@ -836,3 +837,11 @@ class TzInfo(datetime.tzinfo):
     def dst(self, _dt: datetime.datetime | None) -> datetime.timedelta: ...
     def fromutc(self, dt: datetime.datetime) -> datetime.datetime: ...
     def __deepcopy__(self, _memo: dict[Any, Any]) -> 'TzInfo': ...
+
+def validate_core_schema(schema: CoreSchema) -> CoreSchema:
+    """Validate a CoreSchema
+    This currently uses lax mode for validation (i.e. will coerce strings to dates and such)
+    but may use strict mode in the future.
+    We may also remove this function altogether, do not rely on it being present if you are
+    using pydantic-core directly.
+    """
diff --git a/src/lib.rs b/src/lib.rs
index cbf668b9d..b241cdb8a 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -34,7 +34,7 @@ pub use errors::{
 pub use serializers::{
     to_json, to_jsonable_python, PydanticSerializationError, PydanticSerializationUnexpectedValue, SchemaSerializer,
 };
-pub use validators::{PySome, SchemaValidator};
+pub use validators::{validate_core_schema, PySome, SchemaValidator};
 
 pub fn get_pydantic_core_version() -> &'static str {
     static PYDANTIC_CORE_VERSION: OnceLock<String> = OnceLock::new();
@@ -97,5 +97,6 @@ fn _pydantic_core(py: Python, m: &PyModule) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(to_json, m)?)?;
     m.add_function(wrap_pyfunction!(to_jsonable_python, m)?)?;
     m.add_function(wrap_pyfunction!(list_all_errors, m)?)?;
+    m.add_function(wrap_pyfunction!(validate_core_schema, m)?)?;
     Ok(())
 }
diff --git a/src/serializers/mod.rs b/src/serializers/mod.rs
index 29a54fe05..6dbc076fe 100644
--- a/src/serializers/mod.rs
+++ b/src/serializers/mod.rs
@@ -7,7 +7,6 @@ use pyo3::{PyTraverseError, PyVisit};
 
 use crate::definitions::DefinitionsBuilder;
 use crate::py_gc::PyGcTraverse;
-use crate::validators::SelfValidator;
 
 use config::SerializationConfig;
 pub use errors::{PydanticSerializationError, PydanticSerializationUnexpectedValue};
@@ -73,9 +72,7 @@ impl SchemaSerializer {
 #[pymethods]
 impl SchemaSerializer {
     #[new]
-    pub fn py_new(py: Python, schema: &PyDict, config: Option<&PyDict>) -> PyResult<Self> {
-        let self_validator = SelfValidator::new(py)?;
-        let schema = self_validator.validate_schema(py, schema)?;
+    pub fn py_new(schema: &PyDict, config: Option<&PyDict>) -> PyResult<Self> {
         let mut definitions_builder = DefinitionsBuilder::new();
 
         let serializer = CombinedSerializer::build(schema.downcast()?, config, &mut definitions_builder)?;
diff --git a/src/validators/mod.rs b/src/validators/mod.rs
index de98eb583..c7ce0b9e9 100644
--- a/src/validators/mod.rs
+++ b/src/validators/mod.rs
@@ -113,9 +113,6 @@ pub struct SchemaValidator {
 impl SchemaValidator {
     #[new]
     pub fn py_new(py: Python, schema: &PyAny, config: Option<&PyDict>) -> PyResult<Self> {
-        let self_validator = SelfValidator::new(py)?;
-        let schema = self_validator.validate_schema(py, schema)?;
-
         let mut definitions_builder = DefinitionsBuilder::new();
 
         let mut validator = build_validator(schema, config, &mut definitions_builder)?;
@@ -411,6 +408,12 @@ impl<'py> SelfValidator<'py> {
     }
 }
 
+#[pyfunction]
+pub fn validate_core_schema<'a>(py: Python<'a>, schema: &'a PyAny) -> PyResult<&'a PyAny> {
+    let self_validator = SelfValidator::new(py)?;
+    self_validator.validate_schema(py, schema)
+}
+
 pub trait BuildValidator: Sized {
     const EXPECTED_TYPE: &'static str;
 
diff --git a/src/validators/string.rs b/src/validators/string.rs
index d997dcf85..6b646224d 100644
--- a/src/validators/string.rs
+++ b/src/validators/string.rs
@@ -239,8 +239,8 @@ enum RegexEngine {
 }
 
 impl RegexEngine {
-    const RUST_REGEX: &str = "rust-regex";
-    const PYTHON_RE: &str = "python-re";
+    const RUST_REGEX: &'static str = "rust-regex";
+    const PYTHON_RE: &'static str = "python-re";
 }
 
 impl Pattern {
diff --git a/tests/benchmarks/test_complete_benchmark.py b/tests/benchmarks/test_complete_benchmark.py
index 8ed07d37c..57fb7645c 100644
--- a/tests/benchmarks/test_complete_benchmark.py
+++ b/tests/benchmarks/test_complete_benchmark.py
@@ -8,7 +8,7 @@
 
 import pytest
 
-from pydantic_core import SchemaValidator, ValidationError
+from pydantic_core import SchemaValidator, ValidationError, validate_core_schema
 
 from .complete_schema import input_data_lax, input_data_strict, input_data_wrong, schema
 
@@ -16,7 +16,7 @@
 def test_complete_valid():
     lax_schema = schema()
     cls = lax_schema['cls']
-    lax_validator = SchemaValidator(lax_schema)
+    lax_validator = SchemaValidator(validate_core_schema(lax_schema))
     output = lax_validator.validate_python(input_data_lax())
     assert isinstance(output, cls)
     assert len(output.__pydantic_fields_set__) == 41
@@ -73,14 +73,14 @@ def test_complete_valid():
         },
     }
 
-    strict_validator = SchemaValidator(schema(strict=True))
+    strict_validator = SchemaValidator(validate_core_schema(schema(strict=True)))
     output2 = strict_validator.validate_python(input_data_strict())
     assert output_dict == output2.__dict__
 
 
 def test_complete_invalid():
     lax_schema = schema()
-    lax_validator = SchemaValidator(lax_schema)
+    lax_validator = SchemaValidator(validate_core_schema(lax_schema))
     with pytest.raises(ValidationError) as exc_info:
         lax_validator.validate_python(input_data_wrong())
     assert len(exc_info.value.errors(include_url=False)) == 739
@@ -88,19 +88,19 @@ def test_complete_invalid():
 
 @pytest.mark.benchmark(group='complete')
 def test_complete_core_lax(benchmark):
-    v = SchemaValidator(schema())
+    v = SchemaValidator(validate_core_schema(schema()))
     benchmark(v.validate_python, input_data_lax())
 
 
 @pytest.mark.benchmark(group='complete')
 def test_complete_core_strict(benchmark):
-    v = SchemaValidator(schema(strict=True))
+    v = SchemaValidator(validate_core_schema(schema(strict=True)))
     benchmark(v.validate_python, input_data_strict())
 
 
 @pytest.mark.benchmark(group='complete-wrong')
 def test_complete_core_error(benchmark):
-    v = SchemaValidator(schema())
+    v = SchemaValidator(validate_core_schema(schema()))
     data = input_data_wrong()
 
     @benchmark
@@ -115,7 +115,7 @@ def f():
 
 @pytest.mark.benchmark(group='complete-wrong')
 def test_complete_core_isinstance(benchmark):
-    v = SchemaValidator(schema())
+    v = SchemaValidator(validate_core_schema(schema()))
     data = input_data_wrong()
     assert v.isinstance_python(data) is False
 
@@ -135,7 +135,7 @@ def default_json_encoder(obj):
 
 @pytest.mark.benchmark(group='complete-json')
 def test_complete_core_json(benchmark):
-    v = SchemaValidator(schema())
+    v = SchemaValidator(validate_core_schema(schema()))
     json_data = json.dumps(input_data_lax(), default=default_json_encoder)
     benchmark(v.validate_json, json_data)
 
@@ -143,4 +143,4 @@ def test_complete_core_json(benchmark):
 @pytest.mark.benchmark(group='build')
 def test_build_schema(benchmark):
     lax_schema = schema()
-    benchmark(SchemaValidator, lax_schema)
+    benchmark(lambda s: SchemaValidator(validate_core_schema(s)), lax_schema)
diff --git a/tests/conftest.py b/tests/conftest.py
index a83c49472..bdf59a73c 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -13,7 +13,7 @@
 import pytest
 from typing_extensions import Literal
 
-from pydantic_core import ArgsKwargs, SchemaValidator, ValidationError
+from pydantic_core import ArgsKwargs, SchemaValidator, ValidationError, validate_core_schema
 from pydantic_core.core_schema import CoreConfig
 
 __all__ = 'Err', 'PyAndJson', 'plain_repr', 'infinite_generator'
@@ -53,7 +53,7 @@ class PyAndJsonValidator:
     def __init__(
         self, schema, config: CoreConfig | None = None, *, validator_type: Literal['json', 'python'] | None = None
     ):
-        self.validator = SchemaValidator(schema, config)
+        self.validator = SchemaValidator(validate_core_schema(schema), config)
         self.validator_type = validator_type
 
     def validate_python(self, py_input, strict: bool | None = None, context: Any = None):
diff --git a/tests/serializers/test_definitions.py b/tests/serializers/test_definitions.py
index 61b1e9cf7..2da4d353d 100644
--- a/tests/serializers/test_definitions.py
+++ b/tests/serializers/test_definitions.py
@@ -1,6 +1,6 @@
 import pytest
 
-from pydantic_core import SchemaError, SchemaSerializer, core_schema
+from pydantic_core import SchemaError, SchemaSerializer, core_schema, validate_core_schema
 
 
 def test_custom_ser():
@@ -25,7 +25,7 @@ def test_ignored_def():
 
 def test_def_error():
     with pytest.raises(SchemaError) as exc_info:
-        SchemaSerializer(
+        validate_core_schema(
             core_schema.definitions_schema(
                 core_schema.list_schema(core_schema.definition_reference_schema('foobar')),
                 [core_schema.int_schema(ref='foobar'), {'type': 'wrong'}],
diff --git a/tests/serializers/test_dict.py b/tests/serializers/test_dict.py
index ed627830d..cc1b56091 100644
--- a/tests/serializers/test_dict.py
+++ b/tests/serializers/test_dict.py
@@ -3,7 +3,7 @@
 import pytest
 from dirty_equals import IsStrictDict
 
-from pydantic_core import SchemaError, SchemaSerializer, core_schema
+from pydantic_core import SchemaError, SchemaSerializer, core_schema, validate_core_schema
 
 
 def test_dict_str_int():
@@ -155,4 +155,6 @@ def test_filter_runtime_int():
 )
 def test_include_error(include_value, error_msg):
     with pytest.raises(SchemaError, match=error_msg):
-        SchemaSerializer(core_schema.dict_schema(serialization=core_schema.filter_dict_schema(include=include_value)))
+        validate_core_schema(
+            core_schema.dict_schema(serialization=core_schema.filter_dict_schema(include=include_value))
+        )
diff --git a/tests/serializers/test_list_tuple.py b/tests/serializers/test_list_tuple.py
index 9149941e1..c695bbcc4 100644
--- a/tests/serializers/test_list_tuple.py
+++ b/tests/serializers/test_list_tuple.py
@@ -4,7 +4,7 @@
 
 import pytest
 
-from pydantic_core import SchemaError, SchemaSerializer, core_schema
+from pydantic_core import SchemaError, SchemaSerializer, core_schema, validate_core_schema
 
 
 def test_list_any():
@@ -144,8 +144,10 @@ def test_exclude(schema_func, seq_f):
 @pytest.mark.parametrize('include,exclude', [({1, 3, 5}, {5, 6}), ([1, 3, 5], [5, 6])])
 def test_filter(include, exclude):
     v = SchemaSerializer(
-        core_schema.list_schema(
-            core_schema.any_schema(), serialization=core_schema.filter_seq_schema(include=include, exclude=exclude)
+        validate_core_schema(
+            core_schema.list_schema(
+                core_schema.any_schema(), serialization=core_schema.filter_seq_schema(include=include, exclude=exclude)
+            )
         )
     )
     assert v.to_python([0, 1, 2, 3, 4, 5, 6, 7]) == [1, 3]
@@ -186,7 +188,7 @@ class RemovedContains(ImplicitContains):
 @pytest.mark.parametrize('schema_func', [core_schema.list_schema, core_schema.tuple_variable_schema])
 def test_include_error(schema_func, include_value, error_msg):
     with pytest.raises(SchemaError, match=error_msg):
-        SchemaSerializer(
+        validate_core_schema(
             schema_func(core_schema.any_schema(), serialization=core_schema.filter_seq_schema(include=include_value))
         )
 
diff --git a/tests/serializers/test_misc.py b/tests/serializers/test_misc.py
index ec9f97cb3..7753f1948 100644
--- a/tests/serializers/test_misc.py
+++ b/tests/serializers/test_misc.py
@@ -1,6 +1,6 @@
 import pytest
 
-from pydantic_core import SchemaError, SchemaSerializer, core_schema
+from pydantic_core import SchemaError, core_schema, validate_core_schema
 
 
 @pytest.mark.parametrize(
@@ -12,4 +12,4 @@
 )
 def test_invalid_ser_schema(ser_schema, msg):
     with pytest.raises(SchemaError, match=msg):
-        SchemaSerializer(core_schema.any_schema(serialization=ser_schema))
+        validate_core_schema(core_schema.any_schema(serialization=ser_schema))
diff --git a/tests/test.rs b/tests/test.rs
index 9b2fb99b5..526b30e5e 100644
--- a/tests/test.rs
+++ b/tests/test.rs
@@ -46,7 +46,7 @@ mod tests {
                 ]
             }"#;
             let schema: &PyDict = py.eval(code, None, None).unwrap().extract().unwrap();
-            SchemaSerializer::py_new(py, schema, None).unwrap();
+            SchemaSerializer::py_new(schema, None).unwrap();
         });
     }
 
@@ -77,7 +77,7 @@ a = A()
             py.run(code, None, Some(locals)).unwrap();
             let a: &PyAny = locals.get_item("a").unwrap().extract().unwrap();
             let schema: &PyDict = locals.get_item("schema").unwrap().extract().unwrap();
-            let serialized: Vec<u8> = SchemaSerializer::py_new(py, schema, None)
+            let serialized: Vec<u8> = SchemaSerializer::py_new(schema, None)
                 .unwrap()
                 .to_json(py, a, None, None, None, true, false, false, false, false, true, None)
                 .unwrap()
diff --git a/tests/test_build.py b/tests/test_build.py
index 095eb6887..b81179de1 100644
--- a/tests/test_build.py
+++ b/tests/test_build.py
@@ -2,23 +2,23 @@
 
 import pytest
 
-from pydantic_core import SchemaError, SchemaValidator
+from pydantic_core import SchemaError, SchemaValidator, validate_core_schema
 from pydantic_core import core_schema as cs
 
 
 def test_build_error_type():
     with pytest.raises(SchemaError, match="Input tag 'foobar' found using 'type' does not match any of the"):
-        SchemaValidator({'type': 'foobar', 'title': 'TestModel'})
+        validate_core_schema({'type': 'foobar', 'title': 'TestModel'})
 
 
 def test_build_error_internal():
     with pytest.raises(SchemaError, match='Input should be a valid integer, unable to parse string as an integer'):
-        SchemaValidator({'type': 'str', 'min_length': 'xxx', 'title': 'TestModel'})
+        validate_core_schema({'type': 'str', 'min_length': 'xxx', 'title': 'TestModel'})
 
 
 def test_build_error_deep():
     with pytest.raises(SchemaError, match='Input should be a valid integer, unable to parse string as an integer'):
-        SchemaValidator(
+        validate_core_schema(
             {
                 'title': 'MyTestModel',
                 'type': 'typed-dict',
@@ -34,7 +34,7 @@ def test_schema_as_string():
 
 def test_schema_wrong_type(pydantic_version):
     with pytest.raises(SchemaError) as exc_info:
-        SchemaValidator(1)
+        validate_core_schema(1)
     assert str(exc_info.value) == (
         'Invalid Schema:\n  Input should be a valid dictionary or object to'
         ' extract fields from [type=model_attributes_type, input_value=1, input_type=int]\n'
@@ -66,7 +66,7 @@ def test_schema_definition_error():
     schema = {'type': 'union', 'choices': []}
     schema['choices'].append({'type': 'nullable', 'schema': schema})
     with pytest.raises(SchemaError, match='Recursion error - cyclic reference detected'):
-        SchemaValidator(schema)
+        validate_core_schema(schema)
 
 
 def test_not_schema_definition_error():
@@ -83,17 +83,17 @@ def test_not_schema_definition_error():
 
 def test_no_type():
     with pytest.raises(SchemaError, match="Unable to extract tag using discriminator 'type'"):
-        SchemaValidator({})
+        validate_core_schema({})
 
 
 def test_wrong_type():
     with pytest.raises(SchemaError, match="Input tag 'unknown' found using 'type' does not match any of the"):
-        SchemaValidator({'type': 'unknown'})
+        validate_core_schema({'type': 'unknown'})
 
 
 def test_function_no_mode():
     with pytest.raises(SchemaError, match="Input tag 'function' found using 'type' does not match any of the"):
-        SchemaValidator({'type': 'function'})
+        validate_core_schema({'type': 'function'})
 
 
 def test_try_self_schema_discriminator():
diff --git a/tests/validators/test_custom_error.py b/tests/validators/test_custom_error.py
index 4c787ad0f..f2a6e45b5 100644
--- a/tests/validators/test_custom_error.py
+++ b/tests/validators/test_custom_error.py
@@ -1,6 +1,6 @@
 import pytest
 
-from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema
+from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema, validate_core_schema
 
 from ..conftest import PyAndJson
 
@@ -33,7 +33,7 @@ def test_custom_error_type(py_and_json: PyAndJson):
 
 def test_custom_error_error():
     with pytest.raises(SchemaError, match=r'custom_error_type\s+Field required \[type=missing'):
-        SchemaValidator({'type': 'custom-error', 'schema': {'type': 'int'}})
+        validate_core_schema({'type': 'custom-error', 'schema': {'type': 'int'}})
 
 
 def test_custom_error_invalid():
diff --git a/tests/validators/test_date.py b/tests/validators/test_date.py
index 616771bf0..5ddde4884 100644
--- a/tests/validators/test_date.py
+++ b/tests/validators/test_date.py
@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import re
 from datetime import date, datetime, time, timedelta, timezone
 from decimal import Decimal
@@ -5,7 +7,7 @@
 
 import pytest
 
-from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema
+from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema, validate_core_schema
 
 from ..conftest import Err, PyAndJson
 
@@ -183,9 +185,9 @@ def test_date_strict_json_ctx():
             '2000-01-02',
             Err('Input should be less than or equal to 2000-01-01 [type=less_than_equal,'),
         ),
-        ({'lt': '2000-01-01'}, '1999-12-31', date(1999, 12, 31)),
-        ({'lt': '2000-01-01'}, '2000-01-01', Err('Input should be less than 2000-01-01 [type=less_than,')),
-        ({'ge': '2000-01-01'}, '2000-01-01', date(2000, 1, 1)),
+        ({'lt': date(2000, 1, 1)}, '1999-12-31', date(1999, 12, 31)),
+        ({'lt': date(2000, 1, 1)}, '2000-01-01', Err('Input should be less than 2000-01-01 [type=less_than,')),
+        ({'ge': date(2000, 1, 1)}, '2000-01-01', date(2000, 1, 1)),
         (
             {'ge': date(2000, 1, 1)},
             '1999-12-31',
@@ -195,8 +197,8 @@ def test_date_strict_json_ctx():
         ({'gt': date(2000, 1, 1)}, '2000-01-01', Err('Input should be greater than 2000-01-01 [type=greater_than,')),
     ],
 )
-def test_date_kwargs(kwargs: Dict[str, Any], input_value, expected):
-    v = SchemaValidator({'type': 'date', **kwargs})
+def test_date_kwargs(kwargs: Dict[str, Any], input_value: date, expected: Err | date):
+    v = SchemaValidator({'type': 'date', **kwargs})  # type: ignore
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value)
@@ -207,7 +209,7 @@ def test_date_kwargs(kwargs: Dict[str, Any], input_value, expected):
 
 def test_invalid_constraint():
     with pytest.raises(SchemaError, match=r'date\.gt\n  Input should be a valid date or datetime'):
-        SchemaValidator({'type': 'date', 'gt': 'foobar'})
+        validate_core_schema({'type': 'date', 'gt': 'foobar'})
 
 
 def test_dict_py():
@@ -288,4 +290,4 @@ def test_date_past_future_today():
 
 def test_offset_too_large():
     with pytest.raises(SchemaError, match=r'Input should be less than 86400 \[type=less_than,'):
-        SchemaValidator(core_schema.date_schema(now_op='past', now_utc_offset=24 * 3600))
+        validate_core_schema(core_schema.date_schema(now_op='past', now_utc_offset=24 * 3600))
diff --git a/tests/validators/test_datetime.py b/tests/validators/test_datetime.py
index 41044e23f..df04d1631 100644
--- a/tests/validators/test_datetime.py
+++ b/tests/validators/test_datetime.py
@@ -10,7 +10,7 @@
 import pytest
 import pytz
 
-from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema
+from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema, validate_core_schema
 
 from ..conftest import Err, PyAndJson
 
@@ -284,7 +284,7 @@ def test_union():
 
 def test_invalid_constraint():
     with pytest.raises(SchemaError, match=r'datetime\.gt\n  Input should be a valid datetime'):
-        SchemaValidator({'type': 'datetime', 'gt': 'foobar'})
+        validate_core_schema({'type': 'datetime', 'gt': 'foobar'})
 
 
 @pytest.mark.parametrize(
@@ -387,7 +387,7 @@ def test_mock_utc_offset_8_hours(mocker):
 
 def test_offset_too_large():
     with pytest.raises(SchemaError, match=r'Input should be greater than -86400 \[type=greater_than,'):
-        SchemaValidator(core_schema.datetime_schema(now_op='past', now_utc_offset=-24 * 3600))
+        validate_core_schema(core_schema.datetime_schema(now_op='past', now_utc_offset=-24 * 3600))
 
 
 def test_raises_schema_error_for_unknown_constraint_kind():
@@ -395,7 +395,7 @@ def test_raises_schema_error_for_unknown_constraint_kind():
         SchemaError,
         match=(r'Input should be \'aware\' or \'naive\' \[type=literal_error, input_value=\'foo\', input_type=str\]'),
     ):
-        SchemaValidator({'type': 'datetime', 'tz_constraint': 'foo'})
+        validate_core_schema({'type': 'datetime', 'tz_constraint': 'foo'})
 
 
 def test_aware():
@@ -477,7 +477,7 @@ def test_tz_constraint_too_high():
 
 def test_tz_constraint_wrong():
     with pytest.raises(SchemaError, match="Input should be 'aware' or 'naive"):
-        SchemaValidator(core_schema.datetime_schema(tz_constraint='wrong'))
+        validate_core_schema(core_schema.datetime_schema(tz_constraint='wrong'))
 
 
 def test_tz_pickle() -> None:
diff --git a/tests/validators/test_decimal.py b/tests/validators/test_decimal.py
index d871877c8..376a9816a 100644
--- a/tests/validators/test_decimal.py
+++ b/tests/validators/test_decimal.py
@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import json
 import math
 import re
@@ -184,8 +186,8 @@ def test_decimal_kwargs(py_and_json: PyAndJson, kwargs: Dict[str, Any], input_va
     ],
     ids=repr,
 )
-def test_decimal_multiple_of(py_and_json: PyAndJson, multiple_of, input_value, error):
-    v = py_and_json({'type': 'decimal', 'multiple_of': multiple_of})
+def test_decimal_multiple_of(py_and_json: PyAndJson, multiple_of: float, input_value: float, error: Err | None):
+    v = py_and_json({'type': 'decimal', 'multiple_of': Decimal(str(multiple_of))})
     if error:
         with pytest.raises(ValidationError, match=re.escape(error.message)):
             v.validate_test(input_value)
diff --git a/tests/validators/test_definitions.py b/tests/validators/test_definitions.py
index b6ac5d133..d742da5dd 100644
--- a/tests/validators/test_definitions.py
+++ b/tests/validators/test_definitions.py
@@ -1,6 +1,6 @@
 import pytest
 
-from pydantic_core import SchemaError, SchemaValidator, core_schema
+from pydantic_core import SchemaError, SchemaValidator, core_schema, validate_core_schema
 
 from ..conftest import plain_repr
 
@@ -47,7 +47,7 @@ def test_check_ref_used_ignores_metadata():
 
 def test_def_error():
     with pytest.raises(SchemaError) as exc_info:
-        SchemaValidator(
+        validate_core_schema(
             core_schema.definitions_schema(
                 core_schema.list_schema(core_schema.definition_reference_schema('foobar')),
                 [core_schema.int_schema(ref='foobar'), {'type': 'wrong'}],
diff --git a/tests/validators/test_function.py b/tests/validators/test_function.py
index 1a63c27a3..1b35a9c25 100644
--- a/tests/validators/test_function.py
+++ b/tests/validators/test_function.py
@@ -7,7 +7,7 @@
 import pytest
 from dirty_equals import HasRepr
 
-from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema
+from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema, validate_core_schema
 
 from ..conftest import plain_repr
 
@@ -223,12 +223,12 @@ def f(input_value, validator, info):
 
 def test_function_wrap_not_callable():
     with pytest.raises(SchemaError, match='function-wrap.function.typed-dict.function\n  Input should be callable'):
-        SchemaValidator(
+        validate_core_schema(
             {'type': 'function-wrap', 'function': {'type': 'general', 'function': []}, 'schema': {'type': 'str'}}
         )
 
     with pytest.raises(SchemaError, match='function-wrap.function\n  Field required'):
-        SchemaValidator({'type': 'function-wrap', 'schema': {'type': 'str'}})
+        validate_core_schema({'type': 'function-wrap', 'schema': {'type': 'str'}})
 
 
 def test_wrap_error():
@@ -450,7 +450,7 @@ def f(input_value):
 
 def test_plain_with_schema():
     with pytest.raises(SchemaError, match='function-plain.schema\n  Extra inputs are not permitted'):
-        SchemaValidator(
+        validate_core_schema(
             {
                 'type': 'function-plain',
                 'function': {'type': 'general', 'function': lambda x: x},
diff --git a/tests/validators/test_model_fields.py b/tests/validators/test_model_fields.py
index dbba463e2..05201759a 100644
--- a/tests/validators/test_model_fields.py
+++ b/tests/validators/test_model_fields.py
@@ -8,7 +8,7 @@
 import pytest
 from dirty_equals import FunctionCheck, HasRepr, IsStr
 
-from pydantic_core import CoreConfig, SchemaError, SchemaValidator, ValidationError, core_schema
+from pydantic_core import CoreConfig, SchemaError, SchemaValidator, ValidationError, core_schema, validate_core_schema
 
 from ..conftest import Err, PyAndJson
 
@@ -430,7 +430,7 @@ def test_json_error():
 
 def test_missing_schema_key():
     with pytest.raises(SchemaError, match='model-fields.fields.x.schema\n  Field required'):
-        SchemaValidator({'type': 'model-fields', 'fields': {'x': {'type': 'str'}}})
+        validate_core_schema({'type': 'model-fields', 'fields': {'x': {'type': 'str'}}})
 
 
 def test_fields_required_by_default():
@@ -734,10 +734,12 @@ def test_paths_allow_by_name(py_and_json: PyAndJson, input_value):
 def test_alias_build_error(alias_schema, error):
     with pytest.raises(SchemaError, match=error):
         SchemaValidator(
-            {
-                'type': 'model-fields',
-                'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'int'}, **alias_schema}},
-            }
+            validate_core_schema(
+                {
+                    'type': 'model-fields',
+                    'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'int'}, **alias_schema}},
+                }
+            )
         )
 
 
@@ -1491,7 +1493,7 @@ def test_bad_default_factory(default_factory, error_message):
 class TestOnError:
     def test_on_error_bad_name(self):
         with pytest.raises(SchemaError, match="Input should be 'raise', 'omit' or 'default'"):
-            SchemaValidator(
+            validate_core_schema(
                 {
                     'type': 'model-fields',
                     'fields': {
diff --git a/tests/validators/test_time.py b/tests/validators/test_time.py
index 29c45dc80..360cda644 100644
--- a/tests/validators/test_time.py
+++ b/tests/validators/test_time.py
@@ -5,7 +5,7 @@
 
 import pytest
 
-from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema
+from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema, validate_core_schema
 
 from ..conftest import Err, PyAndJson
 
@@ -156,7 +156,6 @@ def test_time_strict_json(input_value, expected):
         ({'ge': time(1)}, '00:59', Err('Input should be greater than or equal to 01:00:00')),
         ({'gt': time(12, 13, 14, 123_456)}, '12:13:14.123457', time(12, 13, 14, 123_457)),
         ({'gt': time(12, 13, 14, 123_456)}, '12:13:14.123456', Err('Input should be greater than 12:13:14.123456')),
-        ({'gt': '12:13:14.123456'}, '12:13:14.123456', Err('Input should be greater than 12:13:14.123456')),
     ],
 )
 def test_time_kwargs(kwargs: Dict[str, Any], input_value, expected):
@@ -192,7 +191,7 @@ def test_time_bound_ctx():
 
 def test_invalid_constraint():
     with pytest.raises(SchemaError, match='Input should be in a valid time format'):
-        SchemaValidator({'type': 'time', 'gt': 'foobar'})
+        validate_core_schema({'type': 'time', 'gt': 'foobar'})
 
 
 def test_dict_py():
@@ -294,4 +293,4 @@ def test_tz_constraint_too_high():
 
 def test_tz_constraint_wrong():
     with pytest.raises(SchemaError, match="Input should be 'aware' or 'naive"):
-        SchemaValidator(core_schema.time_schema(tz_constraint='wrong'))
+        validate_core_schema(core_schema.time_schema(tz_constraint='wrong'))
diff --git a/tests/validators/test_timedelta.py b/tests/validators/test_timedelta.py
index 2bceebf85..3af2a0857 100644
--- a/tests/validators/test_timedelta.py
+++ b/tests/validators/test_timedelta.py
@@ -5,7 +5,7 @@
 
 import pytest
 
-from pydantic_core import SchemaError, SchemaValidator, ValidationError
+from pydantic_core import SchemaError, SchemaValidator, ValidationError, validate_core_schema
 
 from ..conftest import Err, PyAndJson
 
@@ -143,7 +143,6 @@ def test_timedelta_strict_json(input_value, expected):
         ({'ge': timedelta(days=3)}, 'P3D', timedelta(days=3)),
         ({'ge': timedelta(days=3)}, 'P2DT1H', Err('Input should be greater than or equal to 3 days')),
         ({'gt': timedelta(days=3)}, 'P3DT1H', timedelta(days=3, hours=1)),
-        ({'gt': 'P3D'}, 'P2DT1H', Err('Input should be greater than 3 days')),
         ({'le': timedelta(seconds=-86400.123)}, '-PT86400.123S', timedelta(seconds=-86400.123)),
         ({'le': timedelta(seconds=-86400.123)}, '-PT86400.124S', timedelta(seconds=-86400.124)),
         (
@@ -197,10 +196,10 @@ def test_timedelta_kwargs_strict():
 
 def test_invalid_constraint():
     with pytest.raises(SchemaError, match='timedelta.gt\n  Input should be a valid timedelta, invalid digit in'):
-        SchemaValidator({'type': 'timedelta', 'gt': 'foobar'})
+        validate_core_schema({'type': 'timedelta', 'gt': 'foobar'})
 
     with pytest.raises(SchemaError, match='timedelta.le\n  Input should be a valid timedelta, invalid digit in'):
-        SchemaValidator({'type': 'timedelta', 'le': 'foobar'})
+        validate_core_schema({'type': 'timedelta', 'le': 'foobar'})
 
 
 def test_dict_py():
diff --git a/tests/validators/test_typed_dict.py b/tests/validators/test_typed_dict.py
index 1d3b694f1..67cf97d97 100644
--- a/tests/validators/test_typed_dict.py
+++ b/tests/validators/test_typed_dict.py
@@ -8,7 +8,7 @@
 import pytest
 from dirty_equals import FunctionCheck
 
-from pydantic_core import CoreConfig, SchemaError, SchemaValidator, ValidationError, core_schema
+from pydantic_core import CoreConfig, SchemaError, SchemaValidator, ValidationError, core_schema, validate_core_schema
 
 from ..conftest import Err, PyAndJson
 
@@ -194,7 +194,7 @@ def test_allow_extra_invalid():
 
 def test_allow_extra_wrong():
     with pytest.raises(SchemaError, match="Input should be 'allow', 'forbid' or 'ignore'"):
-        SchemaValidator({'type': 'typed-dict', 'fields': {}, 'config': {'extra_fields_behavior': 'wrong'}})
+        validate_core_schema({'type': 'typed-dict', 'fields': {}, 'config': {'extra_fields_behavior': 'wrong'}})
 
 
 def test_str_config():
@@ -235,7 +235,7 @@ def test_json_error():
 
 def test_missing_schema_key():
     with pytest.raises(SchemaError, match='typed-dict.fields.x.schema\n  Field required'):
-        SchemaValidator({'type': 'typed-dict', 'fields': {'x': {'type': 'str'}}})
+        validate_core_schema({'type': 'typed-dict', 'fields': {'x': {'type': 'str'}}})
 
 
 def test_fields_required_by_default():
@@ -629,10 +629,12 @@ def test_paths_allow_by_name(py_and_json: PyAndJson, input_value):
 def test_alias_build_error(alias_schema, error):
     with pytest.raises(SchemaError, match=error):
         SchemaValidator(
-            {
-                'type': 'typed-dict',
-                'fields': {'field_a': {'type': 'typed-dict-field', 'schema': {'type': 'int'}, **alias_schema}},
-            }
+            validate_core_schema(
+                {
+                    'type': 'typed-dict',
+                    'fields': {'field_a': {'type': 'typed-dict-field', 'schema': {'type': 'int'}, **alias_schema}},
+                }
+            )
         )
 
 
@@ -899,7 +901,7 @@ def test_bad_default_factory(default_factory, error_message):
 class TestOnError:
     def test_on_error_bad_name(self):
         with pytest.raises(SchemaError, match="Input should be 'raise', 'omit' or 'default'"):
-            SchemaValidator(
+            validate_core_schema(
                 {
                     'type': 'typed-dict',
                     'fields': {
diff --git a/tests/validators/test_union.py b/tests/validators/test_union.py
index 05072b806..ad51fb447 100644
--- a/tests/validators/test_union.py
+++ b/tests/validators/test_union.py
@@ -1,7 +1,7 @@
 import pytest
 from dirty_equals import IsFloat, IsInt
 
-from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema
+from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema, validate_core_schema
 
 from ..conftest import plain_repr
 
@@ -234,7 +234,7 @@ def test_union_list_bool_int():
 
 def test_no_choices(pydantic_version):
     with pytest.raises(SchemaError) as exc_info:
-        SchemaValidator({'type': 'union'})
+        validate_core_schema({'type': 'union'})
 
     assert str(exc_info.value) == (
         'Invalid Schema:\n'

From 0a3f2b218c588bc8b9757f055dc9f2e255155b52 Mon Sep 17 00:00:00 2001
From: Adrian Garcia Badaracco <1755071+adriangb@users.noreply.github.com>
Date: Thu, 21 Sep 2023 10:03:39 -0500
Subject: [PATCH 049/550] add strict flag to validate_core_schema (#984)

---
 benches/main.rs                         |  4 ++--
 python/pydantic_core/_pydantic_core.pyi |  2 +-
 src/validators/mod.rs                   | 10 +++++-----
 3 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/benches/main.rs b/benches/main.rs
index 8e020e269..9d46131d1 100644
--- a/benches/main.rs
+++ b/benches/main.rs
@@ -11,7 +11,7 @@ use _pydantic_core::{validate_core_schema, SchemaValidator};
 
 fn build_schema_validator_with_globals(py: Python, code: &str, globals: Option<&PyDict>) -> SchemaValidator {
     let mut schema: &PyDict = py.eval(code, globals, None).unwrap().extract().unwrap();
-    schema = validate_core_schema(py, schema).unwrap().extract().unwrap();
+    schema = validate_core_schema(py, schema, None).unwrap().extract().unwrap();
     SchemaValidator::py_new(py, schema, None).unwrap()
 }
 
@@ -446,7 +446,7 @@ fn complete_model(bench: &mut Bencher) {
 
         let complete_schema = py.import("complete_schema").unwrap();
         let mut schema = complete_schema.call_method0("schema").unwrap();
-        schema = validate_core_schema(py, schema).unwrap().extract().unwrap();
+        schema = validate_core_schema(py, schema, None).unwrap().extract().unwrap();
         let validator = SchemaValidator::py_new(py, schema, None).unwrap();
 
         let input = complete_schema.call_method0("input_data_lax").unwrap();
diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index 82e6e3015..8ed3092a9 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -838,7 +838,7 @@ class TzInfo(datetime.tzinfo):
     def fromutc(self, dt: datetime.datetime) -> datetime.datetime: ...
     def __deepcopy__(self, _memo: dict[Any, Any]) -> 'TzInfo': ...
 
-def validate_core_schema(schema: CoreSchema) -> CoreSchema:
+def validate_core_schema(schema: CoreSchema, *, strict: bool | None = None) -> CoreSchema:
     """Validate a CoreSchema
     This currently uses lax mode for validation (i.e. will coerce strings to dates and such)
     but may use strict mode in the future.
diff --git a/src/validators/mod.rs b/src/validators/mod.rs
index c7ce0b9e9..4ee677663 100644
--- a/src/validators/mod.rs
+++ b/src/validators/mod.rs
@@ -367,10 +367,10 @@ impl<'py> SelfValidator<'py> {
         Ok(Self { validator })
     }
 
-    pub fn validate_schema(&self, py: Python<'py>, schema: &'py PyAny) -> PyResult<&'py PyAny> {
+    pub fn validate_schema(&self, py: Python<'py>, schema: &'py PyAny, strict: Option<bool>) -> PyResult<&'py PyAny> {
         let mut recursion_guard = RecursionGuard::default();
         let mut state = ValidationState::new(
-            Extra::new(None, None, None, None, InputType::Python),
+            Extra::new(strict, None, None, None, InputType::Python),
             &self.validator.definitions,
             &mut recursion_guard,
         );
@@ -408,10 +408,10 @@ impl<'py> SelfValidator<'py> {
     }
 }
 
-#[pyfunction]
-pub fn validate_core_schema<'a>(py: Python<'a>, schema: &'a PyAny) -> PyResult<&'a PyAny> {
+#[pyfunction(signature = (schema, *, strict = None))]
+pub fn validate_core_schema<'a>(py: Python<'a>, schema: &'a PyAny, strict: Option<bool>) -> PyResult<&'a PyAny> {
     let self_validator = SelfValidator::new(py)?;
-    self_validator.validate_schema(py, schema)
+    self_validator.validate_schema(py, schema, strict)
 }
 
 pub trait BuildValidator: Sized {

From 91746c9565c43739c7a8f392209bb6d1aeb06d8a Mon Sep 17 00:00:00 2001
From: Samuel Colvin <s@muelcolvin.com>
Date: Thu, 21 Sep 2023 17:18:39 +0100
Subject: [PATCH 050/550] make `field_name` and `data` available on
 `ValidationInfo` (#980)

---
 Cargo.lock                                    |   2 +-
 Cargo.toml                                    |   2 +-
 python/pydantic_core/core_schema.py           | 407 +++++++-----------
 src/validators/function.rs                    |  69 +--
 tests/benchmarks/complete_schema.py           |   8 +-
 tests/benchmarks/test_micro_benchmarks.py     |  29 +-
 tests/serializers/test_functions.py           |   4 +-
 tests/serializers/test_other.py               |  10 +-
 tests/test_errors.py                          |  52 +--
 tests/test_isinstance.py                      |   2 +-
 tests/test_misc.py                            |  10 +
 tests/test_schema_functions.py                |  20 +-
 tests/test_typing.py                          |   8 +-
 tests/test_validation_context.py              |  56 +--
 tests/validators/test_arguments.py            |   2 +-
 tests/validators/test_chain.py                |  30 +-
 tests/validators/test_dataclasses.py          |  71 +--
 .../validators/test_definitions_recursive.py  |   6 +-
 tests/validators/test_function.py             | 196 ++++-----
 tests/validators/test_list.py                 |  12 +-
 tests/validators/test_model.py                |  44 +-
 tests/validators/test_model_fields.py         |   6 +-
 tests/validators/test_model_init.py           |  24 +-
 tests/validators/test_model_root.py           |  10 +-
 tests/validators/test_nullable.py             |   2 +-
 tests/validators/test_typed_dict.py           |   4 +-
 tests/validators/test_with_default.py         |   2 +-
 27 files changed, 445 insertions(+), 643 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 1027b8597..d70598ad8 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -242,7 +242,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.9.0"
+version = "2.10.0"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index 9e193b3d4..154d310de 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.9.0"
+version = "2.10.0"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"
diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index 718bdf969..2d7061ffd 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -6,11 +6,14 @@
 from __future__ import annotations as _annotations
 
 import sys
+import warnings
 from collections.abc import Mapping
 from datetime import date, datetime, time, timedelta
 from decimal import Decimal
 from typing import TYPE_CHECKING, Any, Callable, Dict, Hashable, List, Set, Tuple, Type, Union
 
+from typing_extensions import deprecated
+
 if sys.version_info < (3, 12):
     from typing_extensions import TypedDict
 else:
@@ -177,19 +180,13 @@ def mode(self) -> Literal['python', 'json']:
         """The type of input data we are currently validating"""
         ...
 
-
-class FieldValidationInfo(ValidationInfo, Protocol):
-    """
-    Argument passed to model field validation functions.
-    """
-
     @property
     def data(self) -> Dict[str, Any]:
-        """All of the fields and data being validated for this model."""
+        """The data being validated for this model."""
         ...
 
     @property
-    def field_name(self) -> str:
+    def field_name(self) -> str | None:
         """
         The name of the current field being validated if this validator is
         attached to a model field.
@@ -1744,25 +1741,16 @@ class NoInfoValidatorFunctionSchema(TypedDict):
 
 
 # (__input_value: Any, __info: ValidationInfo) -> Any
-GeneralValidatorFunction = Callable[[Any, ValidationInfo], Any]
-
+WithInfoValidatorFunction = Callable[[Any, ValidationInfo], Any]
 
-class GeneralValidatorFunctionSchema(TypedDict):
-    type: Literal['general']
-    function: GeneralValidatorFunction
 
-
-# (__input_value: Any, __info: FieldValidationInfo) -> Any
-FieldValidatorFunction = Callable[[Any, FieldValidationInfo], Any]
-
-
-class FieldValidatorFunctionSchema(TypedDict):
-    type: Literal['field']
-    function: FieldValidatorFunction
+class WithInfoValidatorFunctionSchema(TypedDict, total=False):
+    type: Required[Literal['with-info']]
+    function: Required[WithInfoValidatorFunction]
     field_name: str
 
 
-ValidationFunction = Union[NoInfoValidatorFunctionSchema, FieldValidatorFunctionSchema, GeneralValidatorFunctionSchema]
+ValidationFunction = Union[NoInfoValidatorFunctionSchema, WithInfoValidatorFunctionSchema]
 
 
 class _ValidatorFunctionSchema(TypedDict, total=False):
@@ -1786,7 +1774,7 @@ def no_info_before_validator_function(
     serialization: SerSchema | None = None,
 ) -> BeforeValidatorFunctionSchema:
     """
-    Returns a schema that calls a validator function before validating, no info is provided, e.g.:
+    Returns a schema that calls a validator function before validating, no `info` argument is provided, e.g.:
 
     ```py
     from pydantic_core import SchemaValidator, core_schema
@@ -1820,29 +1808,29 @@ def fn(v: bytes) -> str:
     )
 
 
-def field_before_validator_function(
-    function: FieldValidatorFunction,
-    field_name: str,
+def with_info_before_validator_function(
+    function: WithInfoValidatorFunction,
     schema: CoreSchema,
     *,
+    field_name: str | None = None,
     ref: str | None = None,
     metadata: Any = None,
     serialization: SerSchema | None = None,
 ) -> BeforeValidatorFunctionSchema:
     """
-    Returns a schema that calls a validator function before validating the function is called with information
-    about the field being validated, e.g.:
+    Returns a schema that calls a validator function before validation, the function is called with
+    an `info` argument, e.g.:
 
     ```py
     from pydantic_core import SchemaValidator, core_schema
 
-    def fn(v: bytes, info: core_schema.FieldValidationInfo) -> str:
+    def fn(v: bytes, info: core_schema.ValidationInfo) -> str:
         assert info.data is not None
         assert info.field_name is not None
         return v.decode() + 'world'
 
-    func_schema = core_schema.field_before_validator_function(
-        function=fn, field_name='a', schema=core_schema.str_schema()
+    func_schema = core_schema.with_info_before_validator_function(
+        function=fn, schema=core_schema.str_schema(), field_name='a'
     )
     schema = core_schema.typed_dict_schema({'a': core_schema.typed_dict_field(func_schema)})
 
@@ -1860,51 +1848,7 @@ def fn(v: bytes, info: core_schema.FieldValidationInfo) -> str:
     """
     return _dict_not_none(
         type='function-before',
-        function={'type': 'field', 'function': function, 'field_name': field_name},
-        schema=schema,
-        ref=ref,
-        metadata=metadata,
-        serialization=serialization,
-    )
-
-
-def general_before_validator_function(
-    function: GeneralValidatorFunction,
-    schema: CoreSchema,
-    *,
-    ref: str | None = None,
-    metadata: Any = None,
-    serialization: SerSchema | None = None,
-) -> BeforeValidatorFunctionSchema:
-    """
-    Returns a schema that calls a validator function before validating the provided schema, e.g.:
-
-    ```py
-    from typing import Any
-    from pydantic_core import SchemaValidator, core_schema
-
-    def fn(v: Any, info: core_schema.ValidationInfo) -> str:
-        v_str = str(v)
-        assert 'hello' in v_str
-        return v_str + 'world'
-
-    schema = core_schema.general_before_validator_function(
-        function=fn, schema=core_schema.str_schema()
-    )
-    v = SchemaValidator(schema)
-    assert v.validate_python(b'hello ') == "b'hello 'world"
-    ```
-
-    Args:
-        function: The validator function to call
-        schema: The schema to validate the output of the validator function
-        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
-        serialization: Custom serialization schema
-    """
-    return _dict_not_none(
-        type='function-before',
-        function={'type': 'general', 'function': function},
+        function=_dict_not_none(type='with-info', function=function, field_name=field_name),
         schema=schema,
         ref=ref,
         metadata=metadata,
@@ -1925,7 +1869,7 @@ def no_info_after_validator_function(
     serialization: SerSchema | None = None,
 ) -> AfterValidatorFunctionSchema:
     """
-    Returns a schema that calls a validator function after validating, no info is provided, e.g.:
+    Returns a schema that calls a validator function after validating, no `info` argument is provided, e.g.:
 
     ```py
     from pydantic_core import SchemaValidator, core_schema
@@ -1957,29 +1901,29 @@ def fn(v: str) -> str:
     )
 
 
-def field_after_validator_function(
-    function: FieldValidatorFunction,
-    field_name: str,
+def with_info_after_validator_function(
+    function: WithInfoValidatorFunction,
     schema: CoreSchema,
     *,
+    field_name: str | None = None,
     ref: str | None = None,
     metadata: Any = None,
     serialization: SerSchema | None = None,
 ) -> AfterValidatorFunctionSchema:
     """
-    Returns a schema that calls a validator function after validating the function is called with information
-    about the field being validated, e.g.:
+    Returns a schema that calls a validator function after validation, the function is called with
+    an `info` argument, e.g.:
 
     ```py
     from pydantic_core import SchemaValidator, core_schema
 
-    def fn(v: str, info: core_schema.FieldValidationInfo) -> str:
+    def fn(v: str, info: core_schema.ValidationInfo) -> str:
         assert info.data is not None
         assert info.field_name is not None
         return v + 'world'
 
-    func_schema = core_schema.field_after_validator_function(
-        function=fn, field_name='a', schema=core_schema.str_schema()
+    func_schema = core_schema.with_info_after_validator_function(
+        function=fn, schema=core_schema.str_schema(), field_name='a'
     )
     schema = core_schema.typed_dict_schema({'a': core_schema.typed_dict_field(func_schema)})
 
@@ -1989,57 +1933,15 @@ def fn(v: str, info: core_schema.FieldValidationInfo) -> str:
 
     Args:
         function: The validator function to call after the schema is validated
-        field_name: The name of the field
-        schema: The schema to validate before the validator function
-        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
-        serialization: Custom serialization schema
-    """
-    return _dict_not_none(
-        type='function-after',
-        function={'type': 'field', 'function': function, 'field_name': field_name},
-        schema=schema,
-        ref=ref,
-        metadata=metadata,
-        serialization=serialization,
-    )
-
-
-def general_after_validator_function(
-    function: GeneralValidatorFunction,
-    schema: CoreSchema,
-    *,
-    ref: str | None = None,
-    metadata: Any = None,
-    serialization: SerSchema | None = None,
-) -> AfterValidatorFunctionSchema:
-    """
-    Returns a schema that calls a validator function after validating the provided schema, e.g.:
-
-    ```py
-    from pydantic_core import SchemaValidator, core_schema
-
-    def fn(v: str, info: core_schema.ValidationInfo) -> str:
-        assert 'hello' in v
-        return v + 'world'
-
-    schema = core_schema.general_after_validator_function(
-        schema=core_schema.str_schema(), function=fn
-    )
-    v = SchemaValidator(schema)
-    assert v.validate_python('hello ') == 'hello world'
-    ```
-
-    Args:
         schema: The schema to validate before the validator function
-        function: The validator function to call after the schema is validated
+        field_name: The name of the field this validators is applied to, if any
         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
         serialization: Custom serialization schema
     """
     return _dict_not_none(
         type='function-after',
-        function={'type': 'general', 'function': function},
+        function=_dict_not_none(type='with-info', function=function, field_name=field_name),
         schema=schema,
         ref=ref,
         metadata=metadata,
@@ -2062,27 +1964,16 @@ class NoInfoWrapValidatorFunctionSchema(TypedDict):
 
 
 # (__input_value: Any, __validator: ValidatorFunctionWrapHandler, __info: ValidationInfo) -> Any
-GeneralWrapValidatorFunction = Callable[[Any, ValidatorFunctionWrapHandler, ValidationInfo], Any]
-
-
-class GeneralWrapValidatorFunctionSchema(TypedDict):
-    type: Literal['general']
-    function: GeneralWrapValidatorFunction
+WithInfoWrapValidatorFunction = Callable[[Any, ValidatorFunctionWrapHandler, ValidationInfo], Any]
 
 
-# (__input_value: Any, __validator: ValidatorFunctionWrapHandler, __info: FieldValidationInfo) -> Any
-FieldWrapValidatorFunction = Callable[[Any, ValidatorFunctionWrapHandler, FieldValidationInfo], Any]
-
-
-class FieldWrapValidatorFunctionSchema(TypedDict):
-    type: Literal['field']
-    function: FieldWrapValidatorFunction
+class WithInfoWrapValidatorFunctionSchema(TypedDict, total=False):
+    type: Required[Literal['with-info']]
+    function: Required[WithInfoWrapValidatorFunction]
     field_name: str
 
 
-WrapValidatorFunction = Union[
-    NoInfoWrapValidatorFunctionSchema, GeneralWrapValidatorFunctionSchema, FieldWrapValidatorFunctionSchema
-]
+WrapValidatorFunction = Union[NoInfoWrapValidatorFunctionSchema, WithInfoWrapValidatorFunctionSchema]
 
 
 class WrapValidatorFunctionSchema(TypedDict, total=False):
@@ -2105,7 +1996,7 @@ def no_info_wrap_validator_function(
     """
     Returns a schema which calls a function with a `validator` callable argument which can
     optionally be used to call inner validation with the function logic, this is much like the
-    "onion" implementation of middleware in many popular web frameworks, no info argument is passed, e.g.:
+    "onion" implementation of middleware in many popular web frameworks, no `info` argument is passed, e.g.:
 
     ```py
     from pydantic_core import SchemaValidator, core_schema
@@ -2140,10 +2031,11 @@ def fn(
     )
 
 
-def general_wrap_validator_function(
-    function: GeneralWrapValidatorFunction,
+def with_info_wrap_validator_function(
+    function: WithInfoWrapValidatorFunction,
     schema: CoreSchema,
     *,
+    field_name: str | None = None,
     ref: str | None = None,
     metadata: Any = None,
     serialization: SerSchema | None = None,
@@ -2151,7 +2043,7 @@ def general_wrap_validator_function(
     """
     Returns a schema which calls a function with a `validator` callable argument which can
     optionally be used to call inner validation with the function logic, this is much like the
-    "onion" implementation of middleware in many popular web frameworks, general info is also passed, e.g.:
+    "onion" implementation of middleware in many popular web frameworks, an `info` argument is also passed, e.g.:
 
     ```py
     from pydantic_core import SchemaValidator, core_schema
@@ -2163,7 +2055,7 @@ def fn(
     ) -> str:
         return validator(input_value=v) + 'world'
 
-    schema = core_schema.general_wrap_validator_function(
+    schema = core_schema.with_info_wrap_validator_function(
         function=fn, schema=core_schema.str_schema()
     )
     v = SchemaValidator(schema)
@@ -2173,67 +2065,14 @@ def fn(
     Args:
         function: The validator function to call
         schema: The schema to validate the output of the validator function
+        field_name: The name of the field this validators is applied to, if any
         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
         serialization: Custom serialization schema
     """
     return _dict_not_none(
         type='function-wrap',
-        function={'type': 'general', 'function': function},
-        schema=schema,
-        ref=ref,
-        metadata=metadata,
-        serialization=serialization,
-    )
-
-
-def field_wrap_validator_function(
-    function: FieldWrapValidatorFunction,
-    field_name: str,
-    schema: CoreSchema,
-    *,
-    ref: str | None = None,
-    metadata: Any = None,
-    serialization: SerSchema | None = None,
-) -> WrapValidatorFunctionSchema:
-    """
-    Returns a schema applicable to **fields**
-    which calls a function with a `validator` callable argument which can
-    optionally be used to call inner validation with the function logic, this is much like the
-    "onion" implementation of middleware in many popular web frameworks, field info is passed, e.g.:
-
-    ```py
-    from pydantic_core import SchemaValidator, core_schema
-
-    def fn(
-        v: bytes,
-        validator: core_schema.ValidatorFunctionWrapHandler,
-        info: core_schema.FieldValidationInfo,
-    ) -> str:
-        assert info.data is not None
-        assert info.field_name is not None
-        return validator(v) + 'world'
-
-    func_schema = core_schema.field_wrap_validator_function(
-        function=fn, field_name='a', schema=core_schema.str_schema()
-    )
-    schema = core_schema.typed_dict_schema({'a': core_schema.typed_dict_field(func_schema)})
-
-    v = SchemaValidator(schema)
-    assert v.validate_python({'a': b'hello '}) == {'a': 'hello world'}
-    ```
-
-    Args:
-        function: The validator function to call
-        field_name: The name of the field
-        schema: The schema to validate the output of the validator function
-        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
-        serialization: Custom serialization schema
-    """
-    return _dict_not_none(
-        type='function-wrap',
-        function={'type': 'field', 'function': function, 'field_name': field_name},
+        function=_dict_not_none(type='with-info', function=function, field_name=field_name),
         schema=schema,
         ref=ref,
         metadata=metadata,
@@ -2257,7 +2096,7 @@ def no_info_plain_validator_function(
     serialization: SerSchema | None = None,
 ) -> PlainValidatorFunctionSchema:
     """
-    Returns a schema that uses the provided function for validation, no info is passed, e.g.:
+    Returns a schema that uses the provided function for validation, no `info` argument is passed, e.g.:
 
     ```py
     from pydantic_core import SchemaValidator, core_schema
@@ -2286,15 +2125,16 @@ def fn(v: str) -> str:
     )
 
 
-def general_plain_validator_function(
-    function: GeneralValidatorFunction,
+def with_info_plain_validator_function(
+    function: WithInfoValidatorFunction,
     *,
+    field_name: str | None = None,
     ref: str | None = None,
     metadata: Any = None,
     serialization: SerSchema | None = None,
 ) -> PlainValidatorFunctionSchema:
     """
-    Returns a schema that uses the provided function for validation, e.g.:
+    Returns a schema that uses the provided function for validation, an `info` argument is passed, e.g.:
 
     ```py
     from pydantic_core import SchemaValidator, core_schema
@@ -2303,63 +2143,21 @@ def fn(v: str, info: core_schema.ValidationInfo) -> str:
         assert 'hello' in v
         return v + 'world'
 
-    schema = core_schema.general_plain_validator_function(function=fn)
+    schema = core_schema.with_info_plain_validator_function(function=fn)
     v = SchemaValidator(schema)
     assert v.validate_python('hello ') == 'hello world'
     ```
 
     Args:
         function: The validator function to call
+        field_name: The name of the field this validators is applied to, if any
         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
         serialization: Custom serialization schema
     """
     return _dict_not_none(
         type='function-plain',
-        function={'type': 'general', 'function': function},
-        ref=ref,
-        metadata=metadata,
-        serialization=serialization,
-    )
-
-
-def field_plain_validator_function(
-    function: FieldValidatorFunction,
-    field_name: str,
-    *,
-    ref: str | None = None,
-    metadata: Any = None,
-    serialization: SerSchema | None = None,
-) -> PlainValidatorFunctionSchema:
-    """
-    Returns a schema that uses the provided function for validation, e.g.:
-
-    ```py
-    from typing import Any
-    from pydantic_core import SchemaValidator, core_schema
-
-    def fn(v: Any, info: core_schema.FieldValidationInfo) -> str:
-        assert info.data is not None
-        assert info.field_name is not None
-        return str(v) + 'world'
-
-    func_schema = core_schema.field_plain_validator_function(function=fn, field_name='a')
-    schema = core_schema.typed_dict_schema({'a': core_schema.typed_dict_field(func_schema)})
-
-    v = SchemaValidator(schema)
-    assert v.validate_python({'a': 'hello '}) == {'a': 'hello world'}
-    ```
-
-    Args:
-        function: The validator function to call
-        field_name: The name of the field
-        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
-        serialization: Custom serialization schema
-    """
-    return _dict_not_none(
-        type='function-plain',
-        function={'type': 'field', 'function': function, 'field_name': field_name},
+        function=_dict_not_none(type='with-info', function=function, field_name=field_name),
         ref=ref,
         metadata=metadata,
         serialization=serialization,
@@ -2659,7 +2457,7 @@ def fn(v: str, info: core_schema.ValidationInfo) -> str:
         assert 'hello' in v
         return v + ' world'
 
-    fn_schema = core_schema.general_plain_validator_function(function=fn)
+    fn_schema = core_schema.with_info_plain_validator_function(function=fn)
     schema = core_schema.chain_schema(
         [fn_schema, fn_schema, fn_schema, core_schema.str_schema()]
     )
@@ -4023,3 +3821,102 @@ def definition_reference_schema(
 
 def _dict_not_none(**kwargs: Any) -> Any:
     return {k: v for k, v in kwargs.items() if v is not None}
+
+
+###############################################################################
+# All this stuff is deprecated by #980 and will be removed eventually
+# They're kept because some code external code will be using them
+
+
+@deprecated('`field_before_validator_function` is deprecated, use `with_info_before_validator_function` instead.')
+def field_before_validator_function(function: WithInfoValidatorFunction, field_name: str, schema: CoreSchema, **kwargs):
+    warnings.warn(
+        '`field_before_validator_function` is deprecated, use `with_info_before_validator_function` instead.',
+        DeprecationWarning,
+    )
+    return with_info_before_validator_function(function, schema, field_name=field_name, **kwargs)
+
+
+@deprecated('`general_before_validator_function` is deprecated, use `with_info_before_validator_function` instead.')
+def general_before_validator_function(*args, **kwargs):
+    warnings.warn(
+        '`general_before_validator_function` is deprecated, use `with_info_before_validator_function` instead.',
+        DeprecationWarning,
+    )
+    return with_info_before_validator_function(*args, **kwargs)
+
+
+@deprecated('`field_after_validator_function` is deprecated, use `with_info_after_validator_function` instead.')
+def field_after_validator_function(function: WithInfoValidatorFunction, field_name: str, schema: CoreSchema, **kwargs):
+    warnings.warn(
+        '`field_after_validator_function` is deprecated, use `with_info_after_validator_function` instead.',
+        DeprecationWarning,
+    )
+    return with_info_after_validator_function(function, schema, field_name=field_name, **kwargs)
+
+
+@deprecated('`general_after_validator_function` is deprecated, use `with_info_after_validator_function` instead.')
+def general_after_validator_function(*args, **kwargs):
+    warnings.warn(
+        '`with_info_after_validator_function` is deprecated, use `with_info_after_validator_function` instead.',
+        DeprecationWarning,
+    )
+    return with_info_after_validator_function(*args, **kwargs)
+
+
+@deprecated('`field_wrap_validator_function` is deprecated, use `with_info_wrap_validator_function` instead.')
+def field_wrap_validator_function(
+    function: WithInfoWrapValidatorFunction, field_name: str, schema: CoreSchema, **kwargs
+):
+    warnings.warn(
+        '`field_wrap_validator_function` is deprecated, use `with_info_wrap_validator_function` instead.',
+        DeprecationWarning,
+    )
+    return with_info_wrap_validator_function(function, schema, field_name=field_name, **kwargs)
+
+
+@deprecated('`general_wrap_validator_function` is deprecated, use `with_info_wrap_validator_function` instead.')
+def general_wrap_validator_function(*args, **kwargs):
+    warnings.warn(
+        '`general_wrap_validator_function` is deprecated, use `with_info_wrap_validator_function` instead.',
+        DeprecationWarning,
+    )
+    return with_info_wrap_validator_function(*args, **kwargs)
+
+
+@deprecated('`field_plain_validator_function` is deprecated, use `with_info_plain_validator_function` instead.')
+def field_plain_validator_function(function: WithInfoValidatorFunction, field_name: str, **kwargs):
+    warnings.warn(
+        '`field_plain_validator_function` is deprecated, use `with_info_plain_validator_function` instead.',
+        DeprecationWarning,
+    )
+    return with_info_plain_validator_function(function, field_name=field_name, **kwargs)
+
+
+@deprecated('`general_plain_validator_function` is deprecated, use `with_info_plain_validator_function` instead.')
+def general_plain_validator_function(*args, **kwargs):
+    warnings.warn(
+        '`general_plain_validator_function` is deprecated, use `with_info_plain_validator_function` instead.',
+        DeprecationWarning,
+    )
+    return with_info_plain_validator_function(*args, **kwargs)
+
+
+_deprecated_import_lookup = {
+    'FieldValidationInfo': ValidationInfo,
+    'FieldValidatorFunction': WithInfoValidatorFunction,
+    'GeneralValidatorFunction': WithInfoValidatorFunction,
+    'FieldWrapValidatorFunction': WithInfoWrapValidatorFunction,
+}
+
+
+def __getattr__(attr_name: str) -> object:
+    new_attr = _deprecated_import_lookup.get(attr_name)
+    if new_attr is None:
+        raise AttributeError(f"module 'pydantic_core' has no attribute '{attr_name}'")
+    else:
+        import warnings
+
+        msg = f'`{attr_name}` is deprecated, use `{new_attr.__name__}` instead.'
+        warnings.warn(msg, DeprecationWarning, stacklevel=1)
+        return new_attr
diff --git a/src/validators/function.rs b/src/validators/function.rs
index 6334a5e16..be0d6374f 100644
--- a/src/validators/function.rs
+++ b/src/validators/function.rs
@@ -1,4 +1,4 @@
-use pyo3::exceptions::{PyAssertionError, PyAttributeError, PyTypeError, PyValueError};
+use pyo3::exceptions::{PyAssertionError, PyTypeError, PyValueError};
 use pyo3::prelude::*;
 use pyo3::types::{PyAny, PyDict, PyString};
 use pyo3::{intern, PyTraverseError, PyVisit};
@@ -8,7 +8,7 @@ use crate::errors::{
 };
 use crate::input::Input;
 use crate::py_gc::PyGcTraverse;
-use crate::tools::{function_name, py_err, SchemaDict};
+use crate::tools::{function_name, py_err, safe_repr, SchemaDict};
 use crate::PydanticUseDefault;
 
 use super::generator::InternalValidator;
@@ -28,20 +28,14 @@ fn destructure_function_schema(schema: &PyDict) -> PyResult<FunctionInfo> {
     let func_dict: &PyDict = schema.get_as_req(intern!(schema.py(), "function"))?;
     let function: &PyAny = func_dict.get_as_req(intern!(schema.py(), "function"))?;
     let func_type: &str = func_dict.get_as_req(intern!(schema.py(), "type"))?;
-    let (is_field_validator, info_arg) = match func_type {
-        "field" => (true, true),
-        "general" => (false, true),
-        "no-info" => (false, false),
+    let info_arg = match func_type {
+        "with-info" => true,
+        "no-info" => false,
         _ => unreachable!(),
     };
-    let field_name: Option<Py<PyString>> = match is_field_validator {
-        true => Some(
-            func_dict
-                .get_as_req::<&PyString>(intern!(schema.py(), "field_name"))?
-                .into(),
-        ),
-        false => None,
-    };
+    let field_name = func_dict
+        .get_as::<&PyString>(intern!(schema.py(), "field_name"))?
+        .map(Into::into);
     Ok(FunctionInfo {
         function: function.into(),
         field_name,
@@ -525,15 +519,12 @@ pub fn convert_err<'a>(py: Python<'a>, err: PyErr, input: &'a impl Input<'a>) ->
     }
 }
 
-#[pyclass(module = "pydantic_core._pydantic_core")]
+#[pyclass(module = "pydantic_core._pydantic_core", get_all)]
 pub struct ValidationInfo {
-    #[pyo3(get)]
     config: PyObject,
-    #[pyo3(get)]
     context: Option<PyObject>,
     data: Option<Py<PyDict>>,
     field_name: Option<Py<PyString>>,
-    #[pyo3(get)]
     mode: InputType,
 }
 
@@ -551,40 +542,22 @@ impl ValidationInfo {
 
 #[pymethods]
 impl ValidationInfo {
-    #[getter]
-    fn get_data(&self, py: Python) -> PyResult<Py<PyDict>> {
-        match (&self.data, &self.field_name) {
-            (Some(data), Some(_)) => Ok(data.clone_ref(py)),
-            _ => Err(PyAttributeError::new_err("No attribute named 'data'")),
-        }
-    }
-
-    #[getter]
-    fn get_field_name(&self) -> PyResult<Py<PyString>> {
-        match self.field_name {
-            Some(ref field_name) => Ok(field_name.clone()),
-            None => Err(PyAttributeError::new_err("No attribute named 'field_name'")),
-        }
-    }
-
     fn __repr__(&self, py: Python) -> PyResult<String> {
         let context = match self.context {
-            Some(ref context) => context.as_ref(py).repr()?.extract()?,
-            None => "None",
+            Some(ref context) => safe_repr(context.as_ref(py)),
+            None => "None".into(),
         };
         let config = self.config.as_ref(py).repr()?;
-        let mut s = if self.field_name.is_some() {
-            format!("FieldValidationInfo(config={config}, context={context}")
-        } else {
-            format!("ValidationInfo(config={config}, context={context}")
+        let data = match self.data {
+            Some(ref data) => safe_repr(data.as_ref(py)),
+            None => "None".into(),
         };
-        if let Ok(data) = self.get_data(py) {
-            s += &format!(", data={}", data.as_ref(py).repr()?);
-        }
-        if let Ok(field_name) = self.get_field_name() {
-            s += &format!(", field_name='{field_name}'");
-        }
-        s += ")";
-        Ok(s)
+        let field_name = match self.field_name {
+            Some(ref field_name) => safe_repr(field_name.as_ref(py)),
+            None => "None".into(),
+        };
+        Ok(format!(
+            "ValidationInfo(config={config}, context={context}, data={data}, field_name={field_name})"
+        ))
     }
 }
diff --git a/tests/benchmarks/complete_schema.py b/tests/benchmarks/complete_schema.py
index d4eff16b2..8c24b9b7e 100644
--- a/tests/benchmarks/complete_schema.py
+++ b/tests/benchmarks/complete_schema.py
@@ -158,7 +158,7 @@ def wrap_function(input_value, validator, info):
                                 'type': 'typed-dict-field',
                                 'schema': {
                                     'type': 'function-before',
-                                    'function': {'type': 'general', 'function': append_func},
+                                    'function': {'type': 'with-info', 'function': append_func},
                                     'schema': {'type': 'str'},
                                 },
                             },
@@ -166,7 +166,7 @@ def wrap_function(input_value, validator, info):
                                 'type': 'typed-dict-field',
                                 'schema': {
                                     'type': 'function-after',
-                                    'function': {'type': 'general', 'function': append_func},
+                                    'function': {'type': 'with-info', 'function': append_func},
                                     'schema': {'type': 'str'},
                                 },
                             },
@@ -174,7 +174,7 @@ def wrap_function(input_value, validator, info):
                                 'type': 'typed-dict-field',
                                 'schema': {
                                     'type': 'function-wrap',
-                                    'function': {'type': 'general', 'function': wrap_function},
+                                    'function': {'type': 'with-info', 'function': wrap_function},
                                     'schema': {'type': 'str'},
                                 },
                             },
@@ -182,7 +182,7 @@ def wrap_function(input_value, validator, info):
                                 'type': 'typed-dict-field',
                                 'schema': {
                                     'type': 'function-plain',
-                                    'function': {'type': 'general', 'function': append_func},
+                                    'function': {'type': 'with-info', 'function': append_func},
                                 },
                             },
                         },
diff --git a/tests/benchmarks/test_micro_benchmarks.py b/tests/benchmarks/test_micro_benchmarks.py
index 7e6799a74..cb08436c6 100644
--- a/tests/benchmarks/test_micro_benchmarks.py
+++ b/tests/benchmarks/test_micro_benchmarks.py
@@ -791,7 +791,7 @@ def test_dont_raise_error(benchmark):
     def f(input_value, info):
         return input_value
 
-    v = SchemaValidator({'type': 'function-plain', 'function': {'type': 'general', 'function': f}})
+    v = SchemaValidator(core_schema.with_info_plain_validator_function(f))
 
     @benchmark
     def t():
@@ -803,7 +803,7 @@ def test_dont_raise_error_no_info(benchmark):
     def f(input_value):
         return input_value
 
-    v = SchemaValidator({'type': 'function-plain', 'function': {'type': 'no-info', 'function': f}})
+    v = SchemaValidator(core_schema.no_info_plain_validator_function(f))
 
     @benchmark
     def t():
@@ -815,7 +815,7 @@ def test_raise_error_value_error(benchmark):
     def f(input_value, info):
         raise ValueError('this is a custom error')
 
-    v = SchemaValidator({'type': 'function-plain', 'function': {'type': 'general', 'function': f}})
+    v = SchemaValidator(core_schema.with_info_plain_validator_function(f))
 
     @benchmark
     def t():
@@ -832,7 +832,7 @@ def test_raise_error_custom(benchmark):
     def f(input_value, info):
         raise PydanticCustomError('my_error', 'this is a custom error {foo}', {'foo': 'FOOBAR'})
 
-    v = SchemaValidator({'type': 'function-plain', 'function': {'type': 'general', 'function': f}})
+    v = SchemaValidator(core_schema.with_info_plain_validator_function(f))
 
     @benchmark
     def t():
@@ -927,10 +927,7 @@ def test_chain_list(benchmark):
     validator = SchemaValidator(
         {
             'type': 'chain',
-            'steps': [
-                {'type': 'str'},
-                {'type': 'function-plain', 'function': {'type': 'general', 'function': lambda v, info: Decimal(v)}},
-            ],
+            'steps': [{'type': 'str'}, core_schema.with_info_plain_validator_function(lambda v, info: Decimal(v))],
         }
     )
     assert validator.validate_python('42.42') == Decimal('42.42')
@@ -944,7 +941,7 @@ def test_chain_function(benchmark):
         {
             'type': 'function-after',
             'schema': {'type': 'str'},
-            'function': {'type': 'general', 'function': lambda v, info: Decimal(v)},
+            'function': {'type': 'with-info', 'function': lambda v, info: Decimal(v)},
         }
     )
     assert validator.validate_python('42.42') == Decimal('42.42')
@@ -959,8 +956,8 @@ def test_chain_two_functions(benchmark):
             'type': 'chain',
             'steps': [
                 {'type': 'str'},
-                {'type': 'function-plain', 'function': {'type': 'general', 'function': lambda v, info: Decimal(v)}},
-                {'type': 'function-plain', 'function': {'type': 'general', 'function': lambda v, info: v * 2}},
+                core_schema.with_info_plain_validator_function(lambda v, info: Decimal(v)),
+                core_schema.with_info_plain_validator_function(lambda v, info: v * 2),
             ],
         }
     )
@@ -977,9 +974,9 @@ def test_chain_nested_functions(benchmark):
             'schema': {
                 'type': 'function-after',
                 'schema': {'type': 'str'},
-                'function': {'type': 'general', 'function': lambda v, info: Decimal(v)},
+                'function': {'type': 'with-info', 'function': lambda v, info: Decimal(v)},
             },
-            'function': {'type': 'general', 'function': lambda v, info: v * 2},
+            'function': {'type': 'with-info', 'function': lambda v, info: v * 2},
         }
     )
     assert validator.validate_python('42.42') == Decimal('84.84')
@@ -1002,7 +999,7 @@ def generator_gen_python(v, validator, info):
 
 @pytest.mark.benchmark(group='generator')
 def test_generator_python(benchmark):
-    schema = core_schema.general_wrap_validator_function(generator_gen_python, {'type': 'int'})
+    schema = core_schema.with_info_wrap_validator_function(generator_gen_python, {'type': 'int'})
     v = SchemaValidator(schema)
     input_value = tuple(range(100))
 
@@ -1301,7 +1298,7 @@ def test_tagged_union_int_keys_json(benchmark):
 @skip_wasm_deep_stack
 @pytest.mark.benchmark(group='field_function_validator')
 def test_field_function_validator(benchmark) -> None:
-    def f(v: int, info: core_schema.FieldValidationInfo) -> int:
+    def f(v: int, info: core_schema.ValidationInfo) -> int:
         assert info.field_name == 'x'
         return v + 1
 
@@ -1309,7 +1306,7 @@ def f(v: int, info: core_schema.FieldValidationInfo) -> int:
     limit = pydantic_core._pydantic_core._recursion_limit - 3
 
     for _ in range(limit):
-        schema = core_schema.field_after_validator_function(f, 'x', schema)
+        schema = core_schema.with_info_after_validator_function(f, schema, field_name='x')
 
     schema = core_schema.typed_dict_schema({'x': core_schema.typed_dict_field(schema)})
 
diff --git a/tests/serializers/test_functions.py b/tests/serializers/test_functions.py
index 660b5e2f2..318254602 100644
--- a/tests/serializers/test_functions.py
+++ b/tests/serializers/test_functions.py
@@ -588,7 +588,7 @@ def test_function_after_preserves_wrapped_serialization():
     def f(value, _info):
         return value
 
-    s = SchemaSerializer(core_schema.general_after_validator_function(f, core_schema.int_schema()))
+    s = SchemaSerializer(core_schema.with_info_after_validator_function(f, core_schema.int_schema()))
     with pytest.warns(UserWarning, match='Expected `int` but got `str` - serialized value may not be as expected'):
         assert s.to_python('abc') == 'abc'
 
@@ -597,7 +597,7 @@ def test_function_wrap_preserves_wrapped_serialization():
     def f(value, handler, _info):
         return handler(value)
 
-    s = SchemaSerializer(core_schema.general_wrap_validator_function(f, core_schema.int_schema()))
+    s = SchemaSerializer(core_schema.with_info_wrap_validator_function(f, core_schema.int_schema()))
     with pytest.warns(UserWarning, match='Expected `int` but got `str` - serialized value may not be as expected'):
         assert s.to_python('abc') == 'abc'
 
diff --git a/tests/serializers/test_other.py b/tests/serializers/test_other.py
index 06183d773..42549b0b5 100644
--- a/tests/serializers/test_other.py
+++ b/tests/serializers/test_other.py
@@ -16,20 +16,24 @@ def test_chain():
 
 
 def test_function_plain():
-    s = SchemaSerializer(core_schema.general_plain_validator_function(lambda v, info: v + 1))
+    s = SchemaSerializer(core_schema.with_info_plain_validator_function(lambda v, info: v + 1))
     # can't infer the type from plain function validators
     # insert_assert(plain_repr(s))
     assert plain_repr(s) == 'SchemaSerializer(serializer=Any(AnySerializer),definitions=[])'
 
 
 def test_function_before():
-    s = SchemaSerializer(core_schema.general_before_validator_function(lambda v, info: v + 1, core_schema.int_schema()))
+    s = SchemaSerializer(
+        core_schema.with_info_before_validator_function(lambda v, info: v + 1, core_schema.int_schema())
+    )
     # insert_assert(plain_repr(s))
     assert plain_repr(s) == 'SchemaSerializer(serializer=Int(IntSerializer),definitions=[])'
 
 
 def test_function_after():
-    s = SchemaSerializer(core_schema.general_after_validator_function(lambda v, info: v + 1, core_schema.int_schema()))
+    s = SchemaSerializer(
+        core_schema.with_info_after_validator_function(lambda v, info: v + 1, core_schema.int_schema())
+    )
     # insert_assert(plain_repr(s))
     assert plain_repr(s) == 'SchemaSerializer(serializer=Int(IntSerializer),definitions=[])'
 
diff --git a/tests/test_errors.py b/tests/test_errors.py
index 15d2c78af..293880977 100644
--- a/tests/test_errors.py
+++ b/tests/test_errors.py
@@ -64,7 +64,7 @@ def test_pydantic_value_error_usage():
     def f(input_value, info):
         raise PydanticCustomError('my_error', 'this is a custom error {foo} {bar}', {'foo': 'FOOBAR', 'bar': 42})
 
-    v = SchemaValidator({'type': 'function-plain', 'function': {'type': 'general', 'function': f}})
+    v = SchemaValidator(core_schema.with_info_plain_validator_function(f))
 
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python(42)
@@ -84,7 +84,7 @@ def test_pydantic_value_error_invalid_dict():
     def my_function(input_value, info):
         raise PydanticCustomError('my_error', 'this is a custom error {foo}', {(): 'foobar'})
 
-    v = SchemaValidator({'type': 'function-plain', 'function': {'type': 'general', 'function': my_function}})
+    v = SchemaValidator(core_schema.with_info_plain_validator_function(my_function))
 
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python(42)
@@ -102,7 +102,7 @@ def test_pydantic_value_error_invalid_type():
     def f(input_value, info):
         raise PydanticCustomError('my_error', 'this is a custom error {foo}', [('foo', 123)])
 
-    v = SchemaValidator({'type': 'function-plain', 'function': {'type': 'general', 'function': f}})
+    v = SchemaValidator(core_schema.with_info_plain_validator_function(f))
 
     with pytest.raises(TypeError, match="argument 'context': 'list' object cannot be converted to 'PyDict'"):
         v.validate_python(42)
@@ -118,9 +118,7 @@ def validate(self, input_value, info):
             return f'{input_value} {self.foo} {self.bar}'
 
     c = CustomValidator()
-    v = SchemaValidator(
-        {'type': 'function-plain', 'metadata': {'instance': c}, 'function': {'type': 'general', 'function': c.validate}}
-    )
+    v = SchemaValidator(core_schema.with_info_plain_validator_function(c.validate, metadata={'instance': c}))
     c.foo += 1
 
     assert v.validate_python('input value') == 'input value 43 before'
@@ -139,12 +137,7 @@ def validate(self, input_value, info):
 
     c = CustomValidator()
     v = SchemaValidator(
-        {
-            'type': 'function-after',
-            'metadata': {'instance': c},
-            'function': {'type': 'general', 'function': c.validate},
-            'schema': {'type': 'str'},
-        }
+        core_schema.with_info_after_validator_function(c.validate, core_schema.str_schema(), metadata={'instance': c})
     )
     c.foo += 1
 
@@ -175,9 +168,7 @@ def test_pydantic_error_type_raise_no_ctx():
     def f(input_value, info):
         raise PydanticKnownError('finite_number')
 
-    v = SchemaValidator(
-        {'type': 'function-before', 'function': {'type': 'general', 'function': f}, 'schema': {'type': 'int'}}
-    )
+    v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.int_schema()))
 
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python(4)
@@ -196,9 +187,7 @@ def test_pydantic_error_type_raise_ctx(extra: dict):
     def f(input_value, info):
         raise PydanticKnownError('greater_than', ctx)
 
-    v = SchemaValidator(
-        {'type': 'function-before', 'function': {'type': 'general', 'function': f}, 'schema': {'type': 'int'}}
-    )
+    v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.int_schema()))
 
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python(4)
@@ -213,9 +202,7 @@ def test_pydantic_error_type_raise_custom_no_ctx(ctx: Optional[dict]):
     def f(input_value, info):
         raise PydanticKnownError('int_type', ctx)
 
-    v = SchemaValidator(
-        {'type': 'function-before', 'function': {'type': 'general', 'function': f}, 'schema': {'type': 'int'}}
-    )
+    v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.int_schema()))
 
     expect_ctx = {'ctx': {}} if ctx is not None else {}
 
@@ -236,9 +223,7 @@ def test_pydantic_custom_error_type_raise_custom_ctx(extra: dict):
     def f(input_value, info):
         raise PydanticCustomError('my_error', 'my message with {val}', ctx)
 
-    v = SchemaValidator(
-        {'type': 'function-before', 'function': {'type': 'general', 'function': f}, 'schema': {'type': 'int'}}
-    )
+    v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.int_schema()))
 
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python(4)
@@ -253,9 +238,7 @@ def test_pydantic_custom_error_type_raise_custom_no_ctx(ctx: Optional[dict]):
     def f(input_value, info):
         raise PydanticCustomError('my_error', 'my message', ctx)
 
-    v = SchemaValidator(
-        {'type': 'function-before', 'function': {'type': 'general', 'function': f}, 'schema': {'type': 'int'}}
-    )
+    v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.int_schema()))
 
     expect_ctx = {'ctx': {}} if ctx is not None else {}
 
@@ -422,28 +405,19 @@ def test_pydantic_value_error_plain(py_and_json: PyAndJson):
     def f(input_value, info):
         raise PydanticCustomError
 
-    v = py_and_json({'type': 'function-plain', 'function': {'type': 'general', 'function': f}})
+    v = py_and_json(core_schema.with_info_plain_validator_function(f))
     with pytest.raises(TypeError, match='missing 2 required positional arguments'):
         v.validate_test('4')
 
 
 @pytest.mark.parametrize('exception', [PydanticOmit(), PydanticOmit])
 def test_list_omit_exception(py_and_json: PyAndJson, exception):
-    def f(input_value, info):
+    def f(input_value):
         if input_value % 2 == 0:
             raise exception
         return input_value
 
-    v = py_and_json(
-        {
-            'type': 'list',
-            'items_schema': {
-                'type': 'function-after',
-                'schema': {'type': 'int'},
-                'function': {'type': 'general', 'function': f},
-            },
-        }
-    )
+    v = py_and_json(core_schema.list_schema(core_schema.no_info_after_validator_function(f, core_schema.int_schema())))
     assert v.validate_test([1, 2, '3', '4']) == [1, 3]
 
 
diff --git a/tests/test_isinstance.py b/tests/test_isinstance.py
index 44c3f2390..38b6f0160 100644
--- a/tests/test_isinstance.py
+++ b/tests/test_isinstance.py
@@ -56,7 +56,7 @@ def omit(v, info):
         else:
             return v
 
-    v = py_and_json(core_schema.general_plain_validator_function(omit))
+    v = py_and_json(core_schema.with_info_plain_validator_function(omit))
     assert v.validate_test('foo') == 'foo'
     if v.validator_type == 'python':
         assert v.isinstance_test('foo') is True
diff --git a/tests/test_misc.py b/tests/test_misc.py
index 98aac82da..806c4cca9 100644
--- a/tests/test_misc.py
+++ b/tests/test_misc.py
@@ -204,3 +204,13 @@ def test_unicode_error_input_repr() -> None:
     actual = repr(exc_info.value).split('For further information visit ')[0].strip()
 
     assert expected == actual
+
+
+def test_core_schema_import_field_validation_info():
+    with pytest.warns(DeprecationWarning, match='`FieldValidationInfo` is deprecated, use `ValidationInfo` instead.'):
+        core_schema.FieldValidationInfo
+
+
+def test_core_schema_import_missing():
+    with pytest.raises(AttributeError, match="module 'pydantic_core' has no attribute 'foobar'"):
+        core_schema.foobar
diff --git a/tests/test_schema_functions.py b/tests/test_schema_functions.py
index c119ca567..d4b53cbe4 100644
--- a/tests/test_schema_functions.py
+++ b/tests/test_schema_functions.py
@@ -108,32 +108,36 @@ def args(*args, **kwargs):
         {'type': 'dict', 'keys_schema': {'type': 'str'}, 'values_schema': {'type': 'int'}},
     ),
     (
-        core_schema.general_before_validator_function,
+        core_schema.with_info_before_validator_function,
         args(val_function, {'type': 'int'}),
         {
             'type': 'function-before',
-            'function': {'type': 'general', 'function': val_function},
+            'function': {'type': 'with-info', 'function': val_function},
             'schema': {'type': 'int'},
         },
     ),
     (
-        core_schema.general_after_validator_function,
+        core_schema.with_info_after_validator_function,
         args(val_function, {'type': 'int'}),
         {
             'type': 'function-after',
-            'function': {'type': 'general', 'function': val_function},
+            'function': {'type': 'with-info', 'function': val_function},
             'schema': {'type': 'int'},
         },
     ),
     (
-        core_schema.general_wrap_validator_function,
+        core_schema.with_info_wrap_validator_function,
         args(val_function, {'type': 'int'}),
-        {'type': 'function-wrap', 'function': {'type': 'general', 'function': val_function}, 'schema': {'type': 'int'}},
+        {
+            'type': 'function-wrap',
+            'function': {'type': 'with-info', 'function': val_function},
+            'schema': {'type': 'int'},
+        },
     ),
     (
-        core_schema.general_plain_validator_function,
+        core_schema.with_info_plain_validator_function,
         args(val_function),
-        {'type': 'function-plain', 'function': {'type': 'general', 'function': val_function}},
+        core_schema.with_info_plain_validator_function(val_function),
     ),
     (
         core_schema.with_default_schema,
diff --git a/tests/test_typing.py b/tests/test_typing.py
index 55c3732e8..0d527c619 100644
--- a/tests/test_typing.py
+++ b/tests/test_typing.py
@@ -111,11 +111,11 @@ def test_schema_typing() -> None:
     SchemaValidator(schema)
     schema: CoreSchema = {
         'type': 'function-wrap',
-        'function': {'type': 'general', 'function': wrap_validator},
+        'function': {'type': 'with-info', 'function': wrap_validator, 'field_name': 'foobar'},
         'schema': {'type': 'str'},
     }
     SchemaValidator(schema)
-    schema: CoreSchema = {'type': 'function-plain', 'function': {'type': 'general', 'function': validator}}
+    schema: CoreSchema = core_schema.with_info_plain_validator_function(validator)
     SchemaValidator(schema)
     schema: CoreSchema = {
         'type': 'definitions',
@@ -189,7 +189,7 @@ def test_correct_function_signature() -> None:
     def my_validator(value: Any, info: Any) -> str:
         return str(value)
 
-    v = SchemaValidator(core_schema.general_plain_validator_function(my_validator))
+    v = SchemaValidator(core_schema.with_info_plain_validator_function(my_validator))
     assert v.validate_python(1) == '1'
 
 
@@ -197,7 +197,7 @@ def test_wrong_function_signature() -> None:
     def wrong_validator(value: Any) -> Any:
         return value
 
-    v = SchemaValidator(core_schema.general_plain_validator_function(wrong_validator))  # type: ignore
+    v = SchemaValidator(core_schema.with_info_plain_validator_function(wrong_validator))  # type: ignore
 
     # use this instead of pytest.raises since pyright complains about input when pytest isn't installed
     try:
diff --git a/tests/test_validation_context.py b/tests/test_validation_context.py
index 838bd66e2..5d71f5b55 100644
--- a/tests/test_validation_context.py
+++ b/tests/test_validation_context.py
@@ -1,6 +1,6 @@
 import pytest
 
-from pydantic_core import SchemaValidator, ValidationError
+from pydantic_core import SchemaValidator, ValidationError, core_schema
 
 from .conftest import PyAndJson
 
@@ -9,9 +9,7 @@ def test_after(py_and_json: PyAndJson):
     def f(input_value, info):
         return input_value + f'| context: {info.context}'
 
-    v = py_and_json(
-        {'type': 'function-after', 'function': {'type': 'general', 'function': f}, 'schema': {'type': 'str'}}
-    )
+    v = py_and_json(core_schema.with_info_after_validator_function(f, core_schema.str_schema()))
 
     assert v.validate_test('foobar') == 'foobar| context: None'
     assert v.validate_test('foobar', None, {1: 10}) == 'foobar| context: {1: 10}'
@@ -23,9 +21,7 @@ def f(input_value, info):
         info.context['foo'] = input_value
         return input_value
 
-    v = py_and_json(
-        {'type': 'function-before', 'function': {'type': 'general', 'function': f}, 'schema': {'type': 'str'}}
-    )
+    v = py_and_json(core_schema.with_info_before_validator_function(f, core_schema.str_schema()))
     mutable_context = {}
     assert v.validate_test('foobar', None, mutable_context) == 'foobar'
     assert mutable_context == {'foo': 'foobar'}
@@ -41,19 +37,12 @@ def f2(input_value, info):
         return input_value + f'| context: {info.context}'
 
     v = py_and_json(
-        {
-            'type': 'typed-dict',
-            'fields': {
-                'f1': {
-                    'type': 'typed-dict-field',
-                    'schema': {'type': 'function-plain', 'function': {'type': 'general', 'function': f1}},
-                },
-                'f2': {
-                    'type': 'typed-dict-field',
-                    'schema': {'type': 'function-plain', 'function': {'type': 'general', 'function': f2}},
-                },
-            },
-        }
+        core_schema.typed_dict_schema(
+            {
+                'f1': core_schema.typed_dict_field(core_schema.with_info_plain_validator_function(f1)),
+                'f2': core_schema.typed_dict_field(core_schema.with_info_plain_validator_function(f2)),
+            }
+        )
     )
 
     assert v.validate_test({'f1': '1', 'f2': '2'}, None, {'x': 'y'}) == {
@@ -66,9 +55,7 @@ def test_wrap(py_and_json: PyAndJson):
     def f(input_value, validator, info):
         return validator(input_value) + f'| context: {info.context}'
 
-    v = py_and_json(
-        {'type': 'function-wrap', 'function': {'type': 'general', 'function': f}, 'schema': {'type': 'str'}}
-    )
+    v = py_and_json(core_schema.with_info_wrap_validator_function(f, core_schema.str_schema()))
 
     assert v.validate_test('foobar') == 'foobar| context: None'
     assert v.validate_test('foobar', None, {1: 10}) == 'foobar| context: {1: 10}'
@@ -81,9 +68,7 @@ def f(input_value, validator, info):
             raise ValueError('wrong')
         return validator(input_value)
 
-    v = py_and_json(
-        {'type': 'function-wrap', 'function': {'type': 'general', 'function': f}, 'schema': {'type': 'str'}}
-    )
+    v = py_and_json(core_schema.with_info_wrap_validator_function(f, core_schema.str_schema()))
 
     assert v.validate_python('foobar', None, {}) == 'foobar'
 
@@ -115,19 +100,12 @@ def f2(input_value, info):
         return input_value + f'| context: {info.context}'
 
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'fields': {
-                'f1': {
-                    'type': 'model-field',
-                    'schema': {'type': 'function-plain', 'function': {'type': 'general', 'function': f1}},
-                },
-                'f2': {
-                    'type': 'model-field',
-                    'schema': {'type': 'function-plain', 'function': {'type': 'general', 'function': f2}},
-                },
-            },
-        }
+        core_schema.model_fields_schema(
+            {
+                'f1': core_schema.model_field(core_schema.with_info_plain_validator_function(f1)),
+                'f2': core_schema.model_field(core_schema.with_info_plain_validator_function(f2)),
+            }
+        )
     )
 
     m1, model_extra, fields_set = v.validate_python({'f1': '1', 'f2': '2'}, strict=None, context={'x': 'y'})
diff --git a/tests/validators/test_arguments.py b/tests/validators/test_arguments.py
index 0f634eb54..4ef581b47 100644
--- a/tests/validators/test_arguments.py
+++ b/tests/validators/test_arguments.py
@@ -621,7 +621,7 @@ def test_internal_error(py_and_json: PyAndJson):
                 {
                     'name': 'b',
                     'mode': 'positional_only',
-                    'schema': {'type': 'function-plain', 'function': {'type': 'general', 'function': double_or_bust}},
+                    'schema': core_schema.with_info_plain_validator_function(double_or_bust),
                 },
             ],
         }
diff --git a/tests/validators/test_chain.py b/tests/validators/test_chain.py
index 36561b735..0ba59084d 100644
--- a/tests/validators/test_chain.py
+++ b/tests/validators/test_chain.py
@@ -2,7 +2,7 @@
 
 import pytest
 
-from pydantic_core import SchemaError, SchemaValidator, ValidationError
+from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema
 
 from ..conftest import PyAndJson
 
@@ -11,10 +11,7 @@ def test_chain():
     validator = SchemaValidator(
         {
             'type': 'chain',
-            'steps': [
-                {'type': 'str'},
-                {'type': 'function-plain', 'function': {'type': 'general', 'function': lambda v, info: Decimal(v)}},
-            ],
+            'steps': [{'type': 'str'}, core_schema.with_info_plain_validator_function(lambda v, info: Decimal(v))],
         }
     )
 
@@ -27,10 +24,10 @@ def test_chain_many():
         {
             'type': 'chain',
             'steps': [
-                {'type': 'function-plain', 'function': {'type': 'general', 'function': lambda v, info: f'{v}-1'}},
-                {'type': 'function-plain', 'function': {'type': 'general', 'function': lambda v, info: f'{v}-2'}},
-                {'type': 'function-plain', 'function': {'type': 'general', 'function': lambda v, info: f'{v}-3'}},
-                {'type': 'function-plain', 'function': {'type': 'general', 'function': lambda v, info: f'{v}-4'}},
+                core_schema.with_info_plain_validator_function(lambda v, info: f'{v}-1'),
+                core_schema.with_info_plain_validator_function(lambda v, info: f'{v}-2'),
+                core_schema.with_info_plain_validator_function(lambda v, info: f'{v}-3'),
+                core_schema.with_info_plain_validator_function(lambda v, info: f'{v}-4'),
             ],
         }
     )
@@ -66,7 +63,7 @@ def test_json(py_and_json: PyAndJson, input_value, expected):
             'type': 'chain',
             'steps': [
                 {'type': 'union', 'choices': [{'type': 'str'}, {'type': 'float'}]},
-                {'type': 'function-plain', 'function': {'type': 'general', 'function': lambda v, info: Decimal(v)}},
+                core_schema.with_info_plain_validator_function(lambda v, info: Decimal(v)),
             ],
         }
     )
@@ -80,17 +77,17 @@ def test_flatten():
         {
             'type': 'chain',
             'steps': [
-                {'type': 'function-plain', 'function': {'type': 'general', 'function': lambda v, info: f'{v}-1'}},
+                core_schema.with_info_plain_validator_function(lambda v, info: f'{v}-1'),
                 {
                     'type': 'chain',
                     'steps': [
                         {
                             'type': 'function-plain',
-                            'function': {'type': 'general', 'function': lambda v, info: f'{v}-2'},
+                            'function': {'type': 'with-info', 'function': lambda v, info: f'{v}-2'},
                         },
                         {
                             'type': 'function-plain',
-                            'function': {'type': 'general', 'function': lambda v, info: f'{v}-3'},
+                            'function': {'type': 'with-info', 'function': lambda v, info: f'{v}-3'},
                         },
                     ],
                 },
@@ -109,12 +106,7 @@ def test_chain_empty():
 
 def test_chain_one():
     validator = SchemaValidator(
-        {
-            'type': 'chain',
-            'steps': [
-                {'type': 'function-plain', 'function': {'type': 'general', 'function': lambda v, info: f'{v}-1'}}
-            ],
-        }
+        {'type': 'chain', 'steps': [core_schema.with_info_plain_validator_function(lambda v, info: f'{v}-1')]}
     )
     assert validator.validate_python('input') == 'input-1'
     assert validator.title == 'function-plain[<lambda>()]'
diff --git a/tests/validators/test_dataclasses.py b/tests/validators/test_dataclasses.py
index 895f4f2bd..9c2b93dfe 100644
--- a/tests/validators/test_dataclasses.py
+++ b/tests/validators/test_dataclasses.py
@@ -493,7 +493,7 @@ class Foo:
         b: str
 
         @classmethod
-        def validate_b(cls, v: str, info: core_schema.FieldValidationInfo) -> str:
+        def validate_b(cls, v: str, info: core_schema.ValidationInfo) -> str:
             assert v == 'hello'
             assert info.field_name == 'b'
             assert info.data == {'a': 1}
@@ -507,7 +507,9 @@ def validate_b(cls, v: str, info: core_schema.FieldValidationInfo) -> str:
                 core_schema.dataclass_field(name='a', schema=core_schema.int_schema()),
                 core_schema.dataclass_field(
                     name='b',
-                    schema=core_schema.field_after_validator_function(Foo.validate_b, 'b', core_schema.str_schema()),
+                    schema=core_schema.with_info_after_validator_function(
+                        Foo.validate_b, core_schema.str_schema(), field_name='b'
+                    ),
                 ),
             ],
         ),
@@ -526,7 +528,7 @@ class Foo:
         b: str
 
         @classmethod
-        def validate_b(cls, v: bytes, info: core_schema.FieldValidationInfo) -> str:
+        def validate_b(cls, v: bytes, info: core_schema.ValidationInfo) -> str:
             assert v == b'hello'
             assert info.field_name == 'b'
             assert info.data == {'a': 1}
@@ -539,7 +541,7 @@ def validate_b(cls, v: bytes, info: core_schema.FieldValidationInfo) -> str:
             [
                 core_schema.dataclass_field(name='a', schema=core_schema.int_schema()),
                 core_schema.dataclass_field(
-                    name='b', schema=core_schema.field_plain_validator_function(Foo.validate_b, 'b')
+                    name='b', schema=core_schema.with_info_plain_validator_function(Foo.validate_b, field_name='b')
                 ),
             ],
         ),
@@ -558,7 +560,7 @@ class Foo:
         b: str
 
         @classmethod
-        def validate_b(cls, v: bytes, info: core_schema.FieldValidationInfo) -> bytes:
+        def validate_b(cls, v: bytes, info: core_schema.ValidationInfo) -> bytes:
             assert v == b'hello'
             assert info.field_name == 'b'
             assert info.data == {'a': 1}
@@ -572,7 +574,9 @@ def validate_b(cls, v: bytes, info: core_schema.FieldValidationInfo) -> bytes:
                 core_schema.dataclass_field(name='a', schema=core_schema.int_schema()),
                 core_schema.dataclass_field(
                     name='b',
-                    schema=core_schema.field_before_validator_function(Foo.validate_b, 'b', core_schema.str_schema()),
+                    schema=core_schema.with_info_before_validator_function(
+                        Foo.validate_b, core_schema.str_schema(), field_name='b'
+                    ),
                 ),
             ],
         ),
@@ -592,7 +596,7 @@ class Foo:
 
         @classmethod
         def validate_b(
-            cls, v: bytes, nxt: core_schema.ValidatorFunctionWrapHandler, info: core_schema.FieldValidationInfo
+            cls, v: bytes, nxt: core_schema.ValidatorFunctionWrapHandler, info: core_schema.ValidationInfo
         ) -> str:
             assert v == b'hello'
             v = nxt(v)
@@ -609,7 +613,9 @@ def validate_b(
                 core_schema.dataclass_field(name='a', schema=core_schema.int_schema()),
                 core_schema.dataclass_field(
                     name='b',
-                    schema=core_schema.field_wrap_validator_function(Foo.validate_b, 'b', core_schema.str_schema()),
+                    schema=core_schema.with_info_wrap_validator_function(
+                        Foo.validate_b, core_schema.str_schema(), field_name='b'
+                    ),
                 ),
             ],
         ),
@@ -629,7 +635,7 @@ class Foo:
 
         @classmethod
         def validate_b(
-            cls, v: bytes, nxt: core_schema.ValidatorFunctionWrapHandler, info: core_schema.FieldValidationInfo
+            cls, v: bytes, nxt: core_schema.ValidatorFunctionWrapHandler, info: core_schema.ValidationInfo
         ) -> bytes:
             assert v == b'hello'
             assert info.field_name == 'b'
@@ -644,7 +650,9 @@ def validate_b(
                 core_schema.dataclass_field(name='a', schema=core_schema.int_schema()),
                 core_schema.dataclass_field(
                     name='b',
-                    schema=core_schema.field_wrap_validator_function(Foo.validate_b, 'b', core_schema.str_schema()),
+                    schema=core_schema.with_info_wrap_validator_function(
+                        Foo.validate_b, core_schema.str_schema(), field_name='b'
+                    ),
                 ),
             ],
         ),
@@ -870,7 +878,10 @@ def func(x, info):
                 [
                     core_schema.dataclass_field('field_a', core_schema.str_schema()),
                     core_schema.dataclass_field(
-                        'field_b', core_schema.field_after_validator_function(func, 'field_b', core_schema.int_schema())
+                        'field_b',
+                        core_schema.with_info_after_validator_function(
+                            func, core_schema.int_schema(), field_name='field_b'
+                        ),
                     ),
                     core_schema.dataclass_field('field_c', core_schema.int_schema()),
                 ],
@@ -883,14 +894,14 @@ def func(x, info):
     assert m.field_a == 'x'
     assert m.field_b == 246
     assert m.field_c == 456
-    assert calls == ["FieldValidationInfo(config=None, context=None, data={'field_a': 'x'}, field_name='field_b')"]
+    assert calls == ["ValidationInfo(config=None, context=None, data={'field_a': 'x'}, field_name='field_b')"]
 
     v.validate_assignment(m, 'field_b', '111')
 
     assert m.field_b == 222
     assert calls == [
-        "FieldValidationInfo(config=None, context=None, data={'field_a': 'x'}, field_name='field_b')",
-        "FieldValidationInfo(config=None, context=None, data={'field_a': 'x', 'field_c': 456}, field_name='field_b')",
+        "ValidationInfo(config=None, context=None, data={'field_a': 'x'}, field_name='field_b')",
+        "ValidationInfo(config=None, context=None, data={'field_a': 'x', 'field_c': 456}, field_name='field_b')",
     ]
 
 
@@ -1271,7 +1282,7 @@ class Foo:
         b: str
 
         @classmethod
-        def validate_b(cls, v: bytes, info: core_schema.FieldValidationInfo) -> bytes:
+        def validate_b(cls, v: bytes, info: core_schema.ValidationInfo) -> bytes:
             assert v == b'hello'
             assert info.field_name == 'b'
             assert info.data == {'a': 1}
@@ -1285,7 +1296,9 @@ def validate_b(cls, v: bytes, info: core_schema.FieldValidationInfo) -> bytes:
                 core_schema.dataclass_field(name='a', schema=core_schema.int_schema()),
                 core_schema.dataclass_field(
                     name='b',
-                    schema=core_schema.field_before_validator_function(Foo.validate_b, 'b', core_schema.str_schema()),
+                    schema=core_schema.with_info_before_validator_function(
+                        Foo.validate_b, core_schema.str_schema(), field_name='b'
+                    ),
                 ),
             ],
         ),
@@ -1306,7 +1319,7 @@ class Foo:
         b: str
 
         @classmethod
-        def validate_b(cls, v: str, info: core_schema.FieldValidationInfo) -> str:
+        def validate_b(cls, v: str, info: core_schema.ValidationInfo) -> str:
             assert v == 'hello'
             assert info.field_name == 'b'
             assert info.data == {'a': 1}
@@ -1320,7 +1333,9 @@ def validate_b(cls, v: str, info: core_schema.FieldValidationInfo) -> str:
                 core_schema.dataclass_field(name='a', schema=core_schema.int_schema()),
                 core_schema.dataclass_field(
                     name='b',
-                    schema=core_schema.field_after_validator_function(Foo.validate_b, 'b', core_schema.str_schema()),
+                    schema=core_schema.with_info_after_validator_function(
+                        Foo.validate_b, core_schema.str_schema(), field_name='b'
+                    ),
                 ),
             ],
         ),
@@ -1515,9 +1530,15 @@ def _wrap_validator(cls, v, validator, info):
 
         field_schema = core_schema.int_schema()
         if validator == 'field':
-            field_schema = core_schema.field_before_validator_function(Dataclass._validator, 'a', field_schema)
-            field_schema = core_schema.field_wrap_validator_function(Dataclass._wrap_validator, 'a', field_schema)
-            field_schema = core_schema.field_after_validator_function(Dataclass._validator, 'a', field_schema)
+            field_schema = core_schema.with_info_before_validator_function(
+                Dataclass._validator, field_schema, field_name='a'
+            )
+            field_schema = core_schema.with_info_wrap_validator_function(
+                Dataclass._wrap_validator, field_schema, field_name='a'
+            )
+            field_schema = core_schema.with_info_after_validator_function(
+                Dataclass._validator, field_schema, field_name='a'
+            )
 
         dataclass_schema = core_schema.dataclass_schema(
             Dataclass,
@@ -1526,9 +1547,11 @@ def _wrap_validator(cls, v, validator, info):
         )
 
         if validator == 'dataclass':
-            dataclass_schema = core_schema.general_before_validator_function(Dataclass._validator, dataclass_schema)
-            dataclass_schema = core_schema.general_wrap_validator_function(Dataclass._wrap_validator, dataclass_schema)
-            dataclass_schema = core_schema.general_after_validator_function(Dataclass._validator, dataclass_schema)
+            dataclass_schema = core_schema.with_info_before_validator_function(Dataclass._validator, dataclass_schema)
+            dataclass_schema = core_schema.with_info_wrap_validator_function(
+                Dataclass._wrap_validator, dataclass_schema
+            )
+            dataclass_schema = core_schema.with_info_after_validator_function(Dataclass._validator, dataclass_schema)
 
         # If any of the Rust validators don't implement traversal properly,
         # there will be an undetectable cycle created by this assignment
diff --git a/tests/validators/test_definitions_recursive.py b/tests/validators/test_definitions_recursive.py
index f23999cfa..b836eb7a1 100644
--- a/tests/validators/test_definitions_recursive.py
+++ b/tests/validators/test_definitions_recursive.py
@@ -519,7 +519,7 @@ def wrap_func(input_value, validator, info):
         core_schema.definitions_schema(
             core_schema.definition_reference_schema('wrapper'),
             [
-                core_schema.general_wrap_validator_function(
+                core_schema.with_info_wrap_validator_function(
                     wrap_func,
                     core_schema.tuple_positional_schema(
                         [
@@ -653,7 +653,7 @@ def f(input_value, info):
             [
                 core_schema.union_schema(
                     [
-                        core_schema.general_after_validator_function(
+                        core_schema.with_info_after_validator_function(
                             f, core_schema.definition_reference_schema('root-schema')
                         ),
                         core_schema.int_schema(),
@@ -701,7 +701,7 @@ def f(input_value, info):
             [
                 core_schema.union_schema(
                     [
-                        core_schema.general_before_validator_function(
+                        core_schema.with_info_before_validator_function(
                             f, core_schema.definition_reference_schema('root-schema')
                         )
                     ],
diff --git a/tests/validators/test_function.py b/tests/validators/test_function.py
index 1b35a9c25..9f94ceb1b 100644
--- a/tests/validators/test_function.py
+++ b/tests/validators/test_function.py
@@ -2,7 +2,7 @@
 import platform
 import re
 from copy import deepcopy
-from typing import Any, Dict, List, Type, Union
+from typing import Any, Dict, List, Type
 
 import pytest
 from dirty_equals import HasRepr
@@ -12,11 +12,11 @@
 from ..conftest import plain_repr
 
 
-def deepcopy_info(info: Union[core_schema.ValidationInfo, core_schema.FieldValidationInfo]) -> Dict[str, Any]:
+def deepcopy_info(info: core_schema.ValidationInfo) -> Dict[str, Any]:
     return {
         'context': deepcopy(info.context),
-        'data': deepcopy(getattr(info, 'data', None)),
-        'field_name': deepcopy(getattr(info, 'field_name', None)),
+        'data': deepcopy(info.data),
+        'field_name': deepcopy(info.field_name),
         'config': deepcopy(info.config),
     }
 
@@ -25,9 +25,7 @@ def test_function_before():
     def f(input_value, _info):
         return input_value + ' Changed'
 
-    v = SchemaValidator(
-        {'type': 'function-before', 'function': {'type': 'general', 'function': f}, 'schema': {'type': 'str'}}
-    )
+    v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.str_schema()))
 
     assert v.validate_python('input value') == 'input value Changed'
 
@@ -36,9 +34,7 @@ def test_function_before_no_info():
     def f(input_value):
         return input_value + ' Changed'
 
-    v = SchemaValidator(
-        {'type': 'function-before', 'function': {'type': 'no-info', 'function': f}, 'schema': {'type': 'str'}}
-    )
+    v = SchemaValidator(core_schema.no_info_before_validator_function(f, core_schema.str_schema()))
 
     assert v.validate_python('input value') == 'input value Changed'
 
@@ -47,9 +43,7 @@ def test_function_before_raise():
     def f(input_value, info):
         raise ValueError('foobar')
 
-    v = SchemaValidator(
-        {'type': 'function-before', 'function': {'type': 'general', 'function': f}, 'schema': {'type': 'str'}}
-    )
+    v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.str_schema()))
 
     with pytest.raises(ValidationError) as exc_info:
         assert v.validate_python('input value') == 'input value Changed'
@@ -72,7 +66,7 @@ def my_function(input_value, info):
     v = SchemaValidator(
         {
             'type': 'function-before',
-            'function': {'type': 'general', 'function': my_function},
+            'function': {'type': 'with-info', 'function': my_function},
             'schema': {'type': 'str', 'max_length': 5},
         }
     )
@@ -107,7 +101,7 @@ def my_function(input_value, info):
     v = SchemaValidator(
         {
             'type': 'function-before',
-            'function': {'type': 'general', 'function': my_function},
+            'function': {'type': 'with-info', 'function': my_function},
             'schema': {'type': 'str', 'max_length': 5},
         },
         config,
@@ -126,7 +120,7 @@ def f(input_value, info):
     v = SchemaValidator(
         {
             'type': 'function-before',
-            'function': {'type': 'general', 'function': f},
+            'function': {'type': 'with-info', 'function': f},
             'schema': {
                 'type': 'typed-dict',
                 'fields': {'my_field': {'type': 'typed-dict-field', 'schema': {'type': 'str', 'max_length': 5}}},
@@ -151,10 +145,10 @@ def f(input_value, info):
 @pytest.mark.parametrize(
     'config,kwargs,expected_repr',
     [
-        (None, {}, 'ValidationInfo(config=None, context=None)'),
-        (None, {'context': {1: 2}}, 'ValidationInfo(config=None, context={1: 2})'),
-        (None, {'context': None}, 'ValidationInfo(config=None, context=None)'),
-        ({'title': 'hello'}, {}, "ValidationInfo(config={'title': 'hello'}, context=None)"),
+        (None, {}, 'ValidationInfo(config=None, context=None, data=None, field_name=None)'),
+        (None, {'context': {1: 2}}, 'ValidationInfo(config=None, context={1: 2}, data=None, field_name=None)'),
+        (None, {'context': None}, 'ValidationInfo(config=None, context=None, data=None, field_name=None)'),
+        ({'title': 'hello'}, {}, "ValidationInfo(config={'title': 'hello'}, context=None, data=None, field_name=None)"),
     ],
 )
 def test_val_info_repr(config, kwargs, expected_repr):
@@ -163,9 +157,7 @@ def f(input_value, info: core_schema.ValidationInfo):
         assert str(info) == expected_repr
         return input_value
 
-    v = SchemaValidator(
-        {'type': 'function-before', 'function': {'type': 'general', 'function': f}, 'schema': {'type': 'str'}}, config
-    )
+    v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.str_schema()), config)
 
     assert v.validate_python('input value', **kwargs) == 'input value'
 
@@ -174,9 +166,7 @@ def test_function_wrap():
     def f(input_value, validator, info):
         return validator(input_value=input_value) + ' Changed'
 
-    v = SchemaValidator(
-        {'type': 'function-wrap', 'function': {'type': 'general', 'function': f}, 'schema': {'type': 'str'}}
-    )
+    v = SchemaValidator(core_schema.with_info_wrap_validator_function(f, core_schema.str_schema()))
 
     assert v.validate_python('input value') == 'input value Changed'
 
@@ -185,9 +175,7 @@ def test_function_wrap_no_info():
     def f(input_value, validator):
         return validator(input_value=input_value) + ' Changed'
 
-    v = SchemaValidator(
-        {'type': 'function-wrap', 'function': {'type': 'no-info', 'function': f}, 'schema': {'type': 'str'}}
-    )
+    v = SchemaValidator(core_schema.no_info_wrap_validator_function(f, core_schema.str_schema()))
 
     assert v.validate_python('input value') == 'input value Changed'
 
@@ -197,9 +185,7 @@ def f(input_value, validator, info):
         assert repr(validator) == str(validator)
         return plain_repr(validator)
 
-    v = SchemaValidator(
-        {'type': 'function-wrap', 'function': {'type': 'general', 'function': f}, 'schema': {'type': 'str'}}
-    )
+    v = SchemaValidator(core_schema.with_info_wrap_validator_function(f, core_schema.str_schema()))
 
     assert (
         v.validate_python('input value')
@@ -211,9 +197,7 @@ def test_function_wrap_str():
     def f(input_value, validator, info):
         return plain_repr(validator)
 
-    v = SchemaValidator(
-        {'type': 'function-wrap', 'function': {'type': 'general', 'function': f}, 'schema': {'type': 'str'}}
-    )
+    v = SchemaValidator(core_schema.with_info_wrap_validator_function(f, core_schema.str_schema()))
 
     assert (
         v.validate_python('input value')
@@ -223,9 +207,7 @@ def f(input_value, validator, info):
 
 def test_function_wrap_not_callable():
     with pytest.raises(SchemaError, match='function-wrap.function.typed-dict.function\n  Input should be callable'):
-        validate_core_schema(
-            {'type': 'function-wrap', 'function': {'type': 'general', 'function': []}, 'schema': {'type': 'str'}}
-        )
+        validate_core_schema(core_schema.with_info_wrap_validator_function([], core_schema.str_schema()))
 
     with pytest.raises(SchemaError, match='function-wrap.function\n  Field required'):
         validate_core_schema({'type': 'function-wrap', 'schema': {'type': 'str'}})
@@ -240,9 +222,7 @@ def f(input_value, validator, info):
             assert str(e).startswith('1 validation error for ValidatorCallable\n')
             raise e
 
-    v = SchemaValidator(
-        {'type': 'function-wrap', 'function': {'type': 'general', 'function': f}, 'schema': {'type': 'int'}}
-    )
+    v = SchemaValidator(core_schema.with_info_wrap_validator_function(f, core_schema.int_schema()))
 
     assert v.validate_python('42') == 84
     with pytest.raises(ValidationError) as exc_info:
@@ -274,9 +254,7 @@ def f(input_value, validator, info):
             assert str(e).startswith('1 validation error for ValidatorCallable\n')
             raise e
 
-    v = SchemaValidator(
-        {'type': 'function-wrap', 'function': {'type': 'general', 'function': f}, 'schema': {'type': 'int'}}, config
-    )
+    v = SchemaValidator(core_schema.with_info_wrap_validator_function(f, core_schema.int_schema()), config)
 
     with pytest.raises(
         ValidationError,
@@ -289,9 +267,7 @@ def test_function_wrap_location():
     def f(input_value, validator, info):
         return validator(input_value, outer_location='foo') + 2
 
-    v = SchemaValidator(
-        {'type': 'function-wrap', 'function': {'type': 'general', 'function': f}, 'schema': {'type': 'int'}}
-    )
+    v = SchemaValidator(core_schema.with_info_wrap_validator_function(f, core_schema.int_schema()))
 
     assert v.validate_python(4) == 6
     with pytest.raises(ValidationError) as exc_info:
@@ -311,9 +287,7 @@ def test_function_wrap_invalid_location():
     def f(input_value, validator, info):
         return validator(input_value, ('4',)) + 2
 
-    v = SchemaValidator(
-        {'type': 'function-wrap', 'function': {'type': 'general', 'function': f}, 'schema': {'type': 'int'}}
-    )
+    v = SchemaValidator(core_schema.with_info_wrap_validator_function(f, core_schema.int_schema()))
 
     with pytest.raises(TypeError, match='^outer_location must be a str or int$'):
         v.validate_python(4)
@@ -323,9 +297,7 @@ def test_function_after():
     def f(input_value, _info):
         return input_value + ' Changed'
 
-    v = SchemaValidator(
-        {'type': 'function-after', 'function': {'type': 'general', 'function': f}, 'schema': {'type': 'str'}}
-    )
+    v = SchemaValidator(core_schema.with_info_after_validator_function(f, core_schema.str_schema()))
 
     assert v.validate_python('input value') == 'input value Changed'
 
@@ -334,9 +306,7 @@ def test_function_no_info():
     def f(input_value):
         return input_value + ' Changed'
 
-    v = SchemaValidator(
-        {'type': 'function-after', 'function': {'type': 'no-info', 'function': f}, 'schema': {'type': 'str'}}
-    )
+    v = SchemaValidator(core_schema.no_info_after_validator_function(f, core_schema.str_schema()))
 
     assert v.validate_python('input value') == 'input value Changed'
 
@@ -345,9 +315,7 @@ def test_function_after_raise():
     def f(input_value, info):
         raise ValueError('foobar')
 
-    v = SchemaValidator(
-        {'type': 'function-after', 'function': {'type': 'general', 'function': f}, 'schema': {'type': 'str'}}
-    )
+    v = SchemaValidator(core_schema.with_info_after_validator_function(f, core_schema.str_schema()))
 
     with pytest.raises(ValidationError) as exc_info:
         assert v.validate_python('input value') == 'input value Changed'
@@ -375,9 +343,7 @@ def test_function_after_error_hide_input(config, input_str):
     def f(input_value, info):
         raise ValueError('foobar')
 
-    v = SchemaValidator(
-        {'type': 'function-after', 'function': {'type': 'general', 'function': f}, 'schema': {'type': 'str'}}, config
-    )
+    v = SchemaValidator(core_schema.with_info_after_validator_function(f, core_schema.str_schema()), config)
 
     with pytest.raises(ValidationError, match=re.escape(f'Value error, foobar [{input_str}]')):
         v.validate_python('input value')
@@ -399,7 +365,7 @@ def f(input_value, info):
                     'type': 'typed-dict-field',
                     'schema': {
                         'type': 'function-after',
-                        'function': {'type': 'field', 'function': f, 'field_name': 'test_field'},
+                        'function': {'type': 'with-info', 'function': f, 'field_name': 'test_field'},
                         'schema': {'type': 'str'},
                     },
                 }
@@ -420,9 +386,7 @@ def f(input_value, info: core_schema.ValidationInfo):
         f_kwargs = deepcopy_info(info)
         return input_value + ' Changed'
 
-    v = SchemaValidator(
-        {'type': 'function-after', 'function': {'type': 'general', 'function': f}, 'schema': {'type': 'str'}}
-    )
+    v = SchemaValidator(core_schema.with_info_after_validator_function(f, core_schema.str_schema()))
 
     assert v.validate_python(b'abc') == 'abc Changed'
     assert f_kwargs == {'data': None, 'config': None, 'context': None, 'field_name': None}
@@ -432,7 +396,7 @@ def test_function_plain():
     def f(input_value, _info):
         return input_value * 2
 
-    v = SchemaValidator({'type': 'function-plain', 'function': {'type': 'general', 'function': f}})
+    v = SchemaValidator(core_schema.with_info_plain_validator_function(f))
 
     assert v.validate_python(1) == 2
     assert v.validate_python('x') == 'xx'
@@ -442,7 +406,7 @@ def test_function_plain_no_info():
     def f(input_value):
         return input_value * 2
 
-    v = SchemaValidator({'type': 'function-plain', 'function': {'type': 'no-info', 'function': f}})
+    v = SchemaValidator(core_schema.no_info_plain_validator_function(f))
 
     assert v.validate_python(1) == 2
     assert v.validate_python('x') == 'xx'
@@ -453,7 +417,7 @@ def test_plain_with_schema():
         validate_core_schema(
             {
                 'type': 'function-plain',
-                'function': {'type': 'general', 'function': lambda x: x},
+                'function': {'type': 'with-info', 'function': lambda x: x},
                 'schema': {'type': 'str'},
             }
         )
@@ -497,9 +461,7 @@ def test_function_wrong_sig():
     def f(input_value):
         return input_value + ' Changed'
 
-    v = SchemaValidator(
-        {'type': 'function-before', 'function': {'type': 'general', 'function': f}, 'schema': {'type': 'str'}}
-    )
+    v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.str_schema()))
 
     # exception messages differ between python and pypy
     if platform.python_implementation() == 'PyPy':
@@ -525,7 +487,7 @@ def __validate__(cls, input_value, info):
     v = SchemaValidator(
         {
             'type': 'function-after',
-            'function': {'type': 'general', 'function': Foobar.__validate__},
+            'function': {'type': 'with-info', 'function': Foobar.__validate__},
             'schema': {'type': 'str'},
         }
     )
@@ -550,9 +512,7 @@ def test_raise_assertion_error():
     def f(input_value, info):
         raise AssertionError('foobar')
 
-    v = SchemaValidator(
-        {'type': 'function-before', 'function': {'type': 'general', 'function': f}, 'schema': {'type': 'str'}}
-    )
+    v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.str_schema()))
 
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python('input value')
@@ -572,9 +532,7 @@ def test_raise_assertion_error_plain():
     def f(input_value, info):
         raise AssertionError
 
-    v = SchemaValidator(
-        {'type': 'function-before', 'function': {'type': 'general', 'function': f}, 'schema': {'type': 'str'}}
-    )
+    v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.str_schema()))
 
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python('input value')
@@ -599,9 +557,7 @@ def __str__(self):
     def f(input_value, info):
         raise MyError()
 
-    v = SchemaValidator(
-        {'type': 'function-before', 'function': {'type': 'general', 'function': f}, 'schema': {'type': 'str'}}
-    )
+    v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.str_schema()))
 
     with pytest.raises(RuntimeError, match='internal error'):
         v.validate_python('input value')
@@ -611,9 +567,7 @@ def test_raise_type_error():
     def f(input_value, info):
         raise TypeError('foobar')
 
-    v = SchemaValidator(
-        {'type': 'function-before', 'function': {'type': 'general', 'function': f}, 'schema': {'type': 'str'}}
-    )
+    v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.str_schema()))
 
     with pytest.raises(TypeError, match='^foobar$'):
         v.validate_python('input value')
@@ -623,11 +577,11 @@ def test_model_field_before_validator() -> None:
     class Model:
         x: str
 
-    def f(input_value: Any, info: core_schema.FieldValidationInfo) -> Any:
+    def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
         assert info.field_name == 'x'
         assert info.data == {}
-        assert repr(info) == "FieldValidationInfo(config=None, context=None, data={}, field_name='x')"
-        assert str(info) == "FieldValidationInfo(config=None, context=None, data={}, field_name='x')"
+        assert repr(info) == "ValidationInfo(config=None, context=None, data={}, field_name='x')"
+        assert str(info) == "ValidationInfo(config=None, context=None, data={}, field_name='x')"
         assert isinstance(input_value, bytes)
         return f'input: {input_value.decode()}'
 
@@ -637,7 +591,7 @@ def f(input_value: Any, info: core_schema.FieldValidationInfo) -> Any:
             core_schema.model_fields_schema(
                 {
                     'x': core_schema.model_field(
-                        core_schema.field_before_validator_function(f, 'x', core_schema.str_schema())
+                        core_schema.with_info_before_validator_function(f, core_schema.str_schema(), field_name='x')
                     )
                 }
             ),
@@ -651,7 +605,7 @@ def test_model_field_after_validator() -> None:
     class Model:
         x: str
 
-    def f(input_value: str, info: core_schema.FieldValidationInfo) -> Any:
+    def f(input_value: str, info: core_schema.ValidationInfo) -> Any:
         assert info.field_name == 'x'
         assert info.data == {}
         assert isinstance(input_value, str)
@@ -663,7 +617,7 @@ def f(input_value: str, info: core_schema.FieldValidationInfo) -> Any:
             core_schema.model_fields_schema(
                 {
                     'x': core_schema.model_field(
-                        core_schema.field_after_validator_function(f, 'x', core_schema.str_schema())
+                        core_schema.with_info_after_validator_function(f, core_schema.str_schema(), field_name='x')
                     )
                 }
             ),
@@ -677,7 +631,7 @@ def test_model_field_plain_validator() -> None:
     class Model:
         x: str
 
-    def f(input_value: Any, info: core_schema.FieldValidationInfo) -> Any:
+    def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
         assert info.field_name == 'x'
         assert info.data == {}
         assert isinstance(input_value, bytes)
@@ -687,7 +641,7 @@ def f(input_value: Any, info: core_schema.FieldValidationInfo) -> Any:
         core_schema.model_schema(
             Model,
             core_schema.model_fields_schema(
-                {'x': core_schema.model_field(core_schema.field_plain_validator_function(f, 'x'))}
+                {'x': core_schema.model_field(core_schema.with_info_plain_validator_function(f, field_name='x'))}
             ),
         )
     )
@@ -699,9 +653,7 @@ def test_model_field_wrap_validator() -> None:
     class Model:
         x: str
 
-    def f(
-        input_value: Any, val: core_schema.ValidatorFunctionWrapHandler, info: core_schema.FieldValidationInfo
-    ) -> Any:
+    def f(input_value: Any, val: core_schema.ValidatorFunctionWrapHandler, info: core_schema.ValidationInfo) -> Any:
         assert info.field_name == 'x'
         assert info.data == {}
         assert isinstance(input_value, bytes)
@@ -713,7 +665,7 @@ def f(
             core_schema.model_fields_schema(
                 {
                     'x': core_schema.model_field(
-                        core_schema.field_wrap_validator_function(f, 'x', core_schema.str_schema())
+                        core_schema.with_info_wrap_validator_function(f, core_schema.str_schema(), field_name='x')
                     )
                 }
             ),
@@ -723,13 +675,9 @@ def f(
     assert v.validate_python({'x': b'foo'}).x == 'input: foo'
 
 
-def check_that_info_has_no_model_data(info: core_schema.ValidationInfo) -> None:
-    with pytest.raises(AttributeError, match="No attribute named 'field_name'"):
-        info.field_name  # type: ignore[attr-defined]
-    with pytest.raises(AttributeError, match="No attribute named 'data'"):
-        info.data  # type: ignore[attr-defined]
-    assert not hasattr(info, 'field_name')
-    assert not hasattr(info, 'data')
+def check_info_field_name_none(info: core_schema.ValidationInfo) -> None:
+    assert info.field_name is None
+    assert info.data == {}
 
 
 def test_non_model_field_before_validator_tries_to_access_field_info() -> None:
@@ -737,7 +685,7 @@ class Model:
         x: str
 
     def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
-        check_that_info_has_no_model_data(info)
+        check_info_field_name_none(info)
         assert isinstance(input_value, bytes)
         return f'input: {input_value.decode()}'
 
@@ -747,7 +695,7 @@ def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
             core_schema.model_fields_schema(
                 {
                     'x': core_schema.model_field(
-                        core_schema.general_before_validator_function(f, core_schema.str_schema())
+                        core_schema.with_info_before_validator_function(f, core_schema.str_schema())
                     )
                 }
             ),
@@ -762,7 +710,7 @@ class Model:
         x: str
 
     def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
-        check_that_info_has_no_model_data(info)
+        check_info_field_name_none(info)
         return f'input: {input_value}'
 
     v = SchemaValidator(
@@ -771,7 +719,7 @@ def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
             core_schema.model_fields_schema(
                 {
                     'x': core_schema.model_field(
-                        core_schema.general_after_validator_function(f, core_schema.str_schema())
+                        core_schema.with_info_after_validator_function(f, core_schema.str_schema())
                     )
                 }
             ),
@@ -786,7 +734,7 @@ class Model:
         x: str
 
     def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
-        check_that_info_has_no_model_data(info)
+        check_info_field_name_none(info)
         assert isinstance(input_value, bytes)
         return f'input: {input_value.decode()}'
 
@@ -794,7 +742,7 @@ def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
         core_schema.model_schema(
             Model,
             core_schema.model_fields_schema(
-                {'x': core_schema.model_field(core_schema.general_plain_validator_function(f))}
+                {'x': core_schema.model_field(core_schema.with_info_plain_validator_function(f))}
             ),
         )
     )
@@ -808,14 +756,18 @@ class Model:
         x: str
 
     def f(input_value: Any, val: core_schema.ValidatorFunctionWrapHandler, info: core_schema.ValidationInfo) -> Any:
-        check_that_info_has_no_model_data(info)
+        check_info_field_name_none(info)
         return f'input: {val(input_value)}'
 
     v = SchemaValidator(
         core_schema.model_schema(
             Model,
             core_schema.model_fields_schema(
-                {'x': core_schema.model_field(core_schema.general_wrap_validator_function(f, core_schema.str_schema()))}
+                {
+                    'x': core_schema.model_field(
+                        core_schema.with_info_wrap_validator_function(f, core_schema.str_schema())
+                    )
+                }
             ),
         )
     )
@@ -826,7 +778,7 @@ def f(input_value: Any, val: core_schema.ValidatorFunctionWrapHandler, info: cor
 def test_typed_dict_data() -> None:
     info_stuff = None
 
-    def f(input_value: Any, info: core_schema.FieldValidationInfo) -> Any:
+    def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
         nonlocal info_stuff
         info_stuff = {'field_name': info.field_name, 'data': info.data.copy()}
         assert isinstance(input_value, str)
@@ -838,7 +790,7 @@ def f(input_value: Any, info: core_schema.FieldValidationInfo) -> Any:
                 'a': core_schema.typed_dict_field(core_schema.int_schema()),
                 'b': core_schema.typed_dict_field(core_schema.int_schema()),
                 'c': core_schema.typed_dict_field(
-                    core_schema.field_after_validator_function(f, 'c', core_schema.str_schema())
+                    core_schema.with_info_after_validator_function(f, core_schema.str_schema(), field_name='c')
                 ),
             }
         )
@@ -894,7 +846,7 @@ def f(input_value: Any, *args: Any) -> Any:
             Model,
             {
                 'type': f'function-{mode}',
-                'function': {'type': 'general', 'function': f},
+                'function': {'type': 'with-info', 'function': f},
                 'schema': core_schema.model_fields_schema(
                     {
                         'x': core_schema.model_field(core_schema.str_schema()),
@@ -922,7 +874,7 @@ def f(v: Any, info: core_schema.ValidationInfo) -> Any:
         calls.append(info.mode)
         return v
 
-    v = SchemaValidator(core_schema.general_before_validator_function(f, core_schema.int_schema()))
+    v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.int_schema()))
     assert v.validate_python(1) == 1
     assert calls == ['python']
     calls.clear()
@@ -930,7 +882,7 @@ def f(v: Any, info: core_schema.ValidationInfo) -> Any:
     assert calls == ['json']
     calls.clear()
 
-    v = SchemaValidator(core_schema.general_after_validator_function(f, core_schema.int_schema()))
+    v = SchemaValidator(core_schema.with_info_after_validator_function(f, core_schema.int_schema()))
     assert v.validate_python(1) == 1
     assert calls == ['python']
     calls.clear()
@@ -942,7 +894,7 @@ def f_w(v: Any, handler: core_schema.ValidatorFunctionWrapHandler, info: core_sc
         calls.append(info.mode)
         return handler(v)
 
-    v = SchemaValidator(core_schema.general_wrap_validator_function(f_w, core_schema.int_schema()))
+    v = SchemaValidator(core_schema.with_info_wrap_validator_function(f_w, core_schema.int_schema()))
     assert v.validate_python(1) == 1
     assert calls == ['python']
     calls.clear()
@@ -961,8 +913,8 @@ def sample_repr(v: Any, info: core_schema.ValidationInfo) -> Any:
     v = SchemaValidator(
         core_schema.chain_schema(
             [
-                core_schema.general_plain_validator_function(sample_repr),
-                core_schema.field_plain_validator_function(sample_repr, field_name='x'),
+                core_schema.with_info_plain_validator_function(sample_repr),
+                core_schema.with_info_plain_validator_function(sample_repr, field_name='x'),
             ]
         )
     )
@@ -975,8 +927,8 @@ def __repr__(self) -> str:
 
     # insert_assert(reprs)
     assert reprs == [
-        'ValidationInfo(config=None, context=None)',
-        "FieldValidationInfo(config=None, context=None, field_name='x')",
+        'ValidationInfo(config=None, context=None, data=None, field_name=None)',
+        "ValidationInfo(config=None, context=None, data=None, field_name='x')",
     ]
 
 
diff --git a/tests/validators/test_list.py b/tests/validators/test_list.py
index d3cfaa528..05e5ed832 100644
--- a/tests/validators/test_list.py
+++ b/tests/validators/test_list.py
@@ -236,9 +236,7 @@ def test_list_function():
     def f(input_value, info):
         return input_value * 2
 
-    v = SchemaValidator(
-        {'type': 'list', 'items_schema': {'type': 'function-plain', 'function': {'type': 'general', 'function': f}}}
-    )
+    v = SchemaValidator({'type': 'list', 'items_schema': core_schema.with_info_plain_validator_function(f)})
 
     assert v.validate_python([1, 2, 3]) == [2, 4, 6]
 
@@ -247,9 +245,7 @@ def test_list_function_val_error():
     def f(input_value, info):
         raise ValueError(f'error {input_value}')
 
-    v = SchemaValidator(
-        {'type': 'list', 'items_schema': {'type': 'function-plain', 'function': {'type': 'general', 'function': f}}}
-    )
+    v = SchemaValidator({'type': 'list', 'items_schema': core_schema.with_info_plain_validator_function(f)})
 
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python([1, 2])
@@ -275,9 +271,7 @@ def test_list_function_internal_error():
     def f(input_value, info):
         raise RuntimeError(f'error {input_value}')
 
-    v = SchemaValidator(
-        {'type': 'list', 'items_schema': {'type': 'function-plain', 'function': {'type': 'general', 'function': f}}}
-    )
+    v = SchemaValidator({'type': 'list', 'items_schema': core_schema.with_info_plain_validator_function(f)})
 
     with pytest.raises(RuntimeError, match='^error 1$') as exc_info:
         v.validate_python([1, 2])
diff --git a/tests/validators/test_model.py b/tests/validators/test_model.py
index 7d5c9ff89..69b6a06ec 100644
--- a/tests/validators/test_model.py
+++ b/tests/validators/test_model.py
@@ -121,7 +121,7 @@ def f(
 
     schema = core_schema.model_schema(
         MyModel,
-        core_schema.general_wrap_validator_function(
+        core_schema.with_info_wrap_validator_function(
             f, core_schema.model_fields_schema({'field_a': core_schema.model_field(core_schema.int_schema())})
         ),
     )
@@ -155,7 +155,7 @@ def f(input_value: Dict[str, Any], info: core_schema.ValidationInfo):
 
     schema = core_schema.model_schema(
         MyModel,
-        core_schema.general_before_validator_function(
+        core_schema.with_info_before_validator_function(
             f, core_schema.model_fields_schema({'field_a': core_schema.model_field(core_schema.int_schema())})
         ),
     )
@@ -227,7 +227,7 @@ def f(input_value, info):
             'cls': MyModel,
             'schema': {
                 'type': f'function-{mode}',
-                'function': {'type': 'general', 'function': f},
+                'function': {'type': 'with-info', 'function': f},
                 'schema': {
                     'type': 'model-fields',
                     'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}},
@@ -244,13 +244,7 @@ class MyModel:
     def f(input_value):
         return input_value, {1: 2}, {'field_a'}
 
-    v = SchemaValidator(
-        {
-            'type': 'model',
-            'cls': MyModel,
-            'schema': {'type': 'function-plain', 'function': {'type': 'no-info', 'function': f}},
-        }
-    )
+    v = SchemaValidator({'type': 'model', 'cls': MyModel, 'schema': core_schema.no_info_plain_validator_function(f)})
     m = v.validate_python({'field_a': 'test'})
     assert isinstance(m, MyModel)
     assert m.__dict__ == {'field_a': 'test'}
@@ -363,7 +357,7 @@ def f(input_value, info):
             'cls': MyModel,
             'schema': {
                 'type': 'function-after',
-                'function': {'type': 'general', 'function': f},
+                'function': {'type': 'with-info', 'function': f},
                 'schema': {
                     'type': 'model-fields',
                     'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}},
@@ -996,7 +990,9 @@ def func(x, info):
                 {
                     'field_a': core_schema.model_field(core_schema.str_schema()),
                     'field_b': core_schema.model_field(
-                        core_schema.field_after_validator_function(func, 'field_b', core_schema.int_schema())
+                        core_schema.with_info_after_validator_function(
+                            func, core_schema.int_schema(), field_name='field_b'
+                        )
                     ),
                     'field_c': core_schema.model_field(core_schema.int_schema()),
                 }
@@ -1009,14 +1005,14 @@ def func(x, info):
     assert m.field_b == 246
     assert m.field_c == 456
     assert m.__pydantic_fields_set__ == {'field_a', 'field_b', 'field_c'}
-    assert calls == ["FieldValidationInfo(config=None, context=None, data={'field_a': 'x'}, field_name='field_b')"]
+    assert calls == ["ValidationInfo(config=None, context=None, data={'field_a': 'x'}, field_name='field_b')"]
 
     v.validate_assignment(m, 'field_b', '111')
 
     assert m.field_b == 222
     assert calls == [
-        "FieldValidationInfo(config=None, context=None, data={'field_a': 'x'}, field_name='field_b')",
-        "FieldValidationInfo(config=None, context=None, data={'field_a': 'x', 'field_c': 456}, field_name='field_b')",
+        "ValidationInfo(config=None, context=None, data={'field_a': 'x'}, field_name='field_b')",
+        "ValidationInfo(config=None, context=None, data={'field_a': 'x', 'field_c': 456}, field_name='field_b')",
     ]
 
 
@@ -1085,19 +1081,19 @@ class MyModel:
     'function_schema,call1, call2',
     [
         (
-            core_schema.general_after_validator_function,
-            (({'a': 1, 'b': 2}, None, {'b'}), 'ValidationInfo(config=None, context=None)'),
-            (({'a': 10, 'b': 2}, None, {'a'}), 'ValidationInfo(config=None, context=None)'),
+            core_schema.with_info_after_validator_function,
+            (({'a': 1, 'b': 2}, None, {'b'}), 'ValidationInfo(config=None, context=None, data=None, field_name=None)'),
+            (({'a': 10, 'b': 2}, None, {'a'}), 'ValidationInfo(config=None, context=None, data=None, field_name=None)'),
         ),
         (
-            core_schema.general_before_validator_function,
-            ({'b': 2}, 'ValidationInfo(config=None, context=None)'),
-            ({'a': 10, 'b': 2}, 'ValidationInfo(config=None, context=None)'),
+            core_schema.with_info_before_validator_function,
+            ({'b': 2}, 'ValidationInfo(config=None, context=None, data=None, field_name=None)'),
+            ({'a': 10, 'b': 2}, 'ValidationInfo(config=None, context=None, data=None, field_name=None)'),
         ),
         (
-            core_schema.general_wrap_validator_function,
-            ({'b': 2}, 'ValidationInfo(config=None, context=None)'),
-            ({'a': 10, 'b': 2}, 'ValidationInfo(config=None, context=None)'),
+            core_schema.with_info_wrap_validator_function,
+            ({'b': 2}, 'ValidationInfo(config=None, context=None, data=None, field_name=None)'),
+            ({'a': 10, 'b': 2}, 'ValidationInfo(config=None, context=None, data=None, field_name=None)'),
         ),
     ],
 )
diff --git a/tests/validators/test_model_fields.py b/tests/validators/test_model_fields.py
index 05201759a..e21f50008 100644
--- a/tests/validators/test_model_fields.py
+++ b/tests/validators/test_model_fields.py
@@ -280,7 +280,7 @@ def func_b(input_value, info):
                     'type': 'model-field',
                     'schema': {
                         'type': 'function-after',
-                        'function': {'type': 'general', 'function': func_a},
+                        'function': {'type': 'with-info', 'function': func_a},
                         'schema': {'type': 'str'},
                     },
                 },
@@ -288,7 +288,7 @@ def func_b(input_value, info):
                     'type': 'model-field',
                     'schema': {
                         'type': 'function-after',
-                        'function': {'type': 'general', 'function': func_b},
+                        'function': {'type': 'with-info', 'function': func_b},
                         'schema': {'type': 'int'},
                     },
                 },
@@ -1608,7 +1608,7 @@ def wrap_function(input_value, validator, info):
                             'on_error': 'raise',
                             'schema': {
                                 'type': 'function-wrap',
-                                'function': {'type': 'general', 'function': wrap_function},
+                                'function': {'type': 'with-info', 'function': wrap_function},
                                 'schema': {'type': 'str'},
                             },
                         },
diff --git a/tests/validators/test_model_init.py b/tests/validators/test_model_init.py
index fb8ef9f43..5521f8da4 100644
--- a/tests/validators/test_model_init.py
+++ b/tests/validators/test_model_init.py
@@ -100,7 +100,7 @@ def f(input_value, _info):
     v = SchemaValidator(
         {
             'type': 'function-before',
-            'function': {'type': 'general', 'function': f},
+            'function': {'type': 'with-info', 'function': f},
             'schema': {
                 'type': 'model',
                 'cls': MyModel,
@@ -136,7 +136,7 @@ def f(input_value, _info):
     v = SchemaValidator(
         {
             'type': 'function-after',
-            'function': {'type': 'general', 'function': f},
+            'function': {'type': 'with-info', 'function': f},
             'schema': {
                 'type': 'model',
                 'cls': MyModel,
@@ -174,7 +174,7 @@ def f(input_value, handler, _info):
     v = SchemaValidator(
         {
             'type': 'function-wrap',
-            'function': {'type': 'general', 'function': f},
+            'function': {'type': 'with-info', 'function': f},
             'schema': {
                 'type': 'model',
                 'cls': MyModel,
@@ -442,18 +442,24 @@ def _wrap_validator(cls, v, validator, info):
 
         field_schema = core_schema.int_schema()
         if validator == 'field':
-            field_schema = core_schema.field_before_validator_function(Model._validator, 'a', field_schema)
-            field_schema = core_schema.field_wrap_validator_function(Model._wrap_validator, 'a', field_schema)
-            field_schema = core_schema.field_after_validator_function(Model._validator, 'a', field_schema)
+            field_schema = core_schema.with_info_before_validator_function(
+                Model._validator, field_schema, field_name='a'
+            )
+            field_schema = core_schema.with_info_wrap_validator_function(
+                Model._wrap_validator, field_schema, field_name='a'
+            )
+            field_schema = core_schema.with_info_after_validator_function(
+                Model._validator, field_schema, field_name='a'
+            )
 
         model_schema = core_schema.model_schema(
             Model, core_schema.model_fields_schema({'a': core_schema.model_field(field_schema)})
         )
 
         if validator == 'model':
-            model_schema = core_schema.general_before_validator_function(Model._validator, model_schema)
-            model_schema = core_schema.general_wrap_validator_function(Model._wrap_validator, model_schema)
-            model_schema = core_schema.general_after_validator_function(Model._validator, model_schema)
+            model_schema = core_schema.with_info_before_validator_function(Model._validator, model_schema)
+            model_schema = core_schema.with_info_wrap_validator_function(Model._wrap_validator, model_schema)
+            model_schema = core_schema.with_info_after_validator_function(Model._validator, model_schema)
 
         # If any of the Rust validators don't implement traversal properly,
         # there will be an undetectable cycle created by this assignment
diff --git a/tests/validators/test_model_root.py b/tests/validators/test_model_root.py
index db9d91eb5..8daa326ea 100644
--- a/tests/validators/test_model_root.py
+++ b/tests/validators/test_model_root.py
@@ -139,20 +139,22 @@ def f(input_value: str, info):
 
     v = SchemaValidator(
         core_schema.model_schema(
-            RootModel, core_schema.field_after_validator_function(f, 'root', core_schema.str_schema()), root_model=True
+            RootModel,
+            core_schema.with_info_after_validator_function(f, core_schema.str_schema(), field_name='root'),
+            root_model=True,
         )
     )
     m = v.validate_python('foobar', context='call 1')
     assert isinstance(m, RootModel)
     assert m.root == 'foobar validated'
-    assert call_infos == ["FieldValidationInfo(config=None, context='call 1', field_name='root')"]
+    assert call_infos == ["ValidationInfo(config=None, context='call 1', data=None, field_name='root')"]
 
     m2 = v.validate_assignment(m, 'root', 'baz', context='assignment call')
     assert m2 is m
     assert m.root == 'baz validated'
     assert call_infos == [
-        "FieldValidationInfo(config=None, context='call 1', field_name='root')",
-        "FieldValidationInfo(config=None, context='assignment call', field_name='root')",
+        "ValidationInfo(config=None, context='call 1', data=None, field_name='root')",
+        "ValidationInfo(config=None, context='assignment call', data=None, field_name='root')",
     ]
 
 
diff --git a/tests/validators/test_nullable.py b/tests/validators/test_nullable.py
index fc20aa414..a74d56138 100644
--- a/tests/validators/test_nullable.py
+++ b/tests/validators/test_nullable.py
@@ -47,7 +47,7 @@ def fn():
         def validate(v, info):
             return v
 
-        schema = core_schema.general_plain_validator_function(validate)
+        schema = core_schema.with_info_plain_validator_function(validate)
         schema = core_schema.nullable_schema(schema)
 
         # If any of the Rust validators don't implement traversal properly,
diff --git a/tests/validators/test_typed_dict.py b/tests/validators/test_typed_dict.py
index 67cf97d97..5f0729d25 100644
--- a/tests/validators/test_typed_dict.py
+++ b/tests/validators/test_typed_dict.py
@@ -1066,7 +1066,7 @@ def wrap_function(input_value, validator, info):
                             'on_error': 'raise',
                             'schema': {
                                 'type': 'function-wrap',
-                                'function': {'type': 'general', 'function': wrap_function},
+                                'function': {'type': 'with-info', 'function': wrap_function},
                                 'schema': {'type': 'str'},
                             },
                         },
@@ -1173,7 +1173,7 @@ def fn():
         def validate(v, info):
             return v
 
-        schema = core_schema.general_plain_validator_function(validate)
+        schema = core_schema.with_info_plain_validator_function(validate)
         schema = core_schema.typed_dict_schema(
             {'f': core_schema.typed_dict_field(schema)}, extra_behavior='allow', extras_schema=schema
         )
diff --git a/tests/validators/test_with_default.py b/tests/validators/test_with_default.py
index e0ebd2fb3..808e4807d 100644
--- a/tests/validators/test_with_default.py
+++ b/tests/validators/test_with_default.py
@@ -633,7 +633,7 @@ class Defaulted(int):
             def _validator(cls, v, info):
                 return Defaulted(v)
 
-        schema = core_schema.general_plain_validator_function(Defaulted._validator)
+        schema = core_schema.with_info_plain_validator_function(Defaulted._validator)
         schema = core_schema.with_default_schema(schema, default=Defaulted(0))
 
         # If any of the Rust validators don't implement traversal properly,

From 0ebd60703814b3f5a03eb483e6ec41df15650dec Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 25 Sep 2023 13:48:43 +0100
Subject: [PATCH 051/550] Bump smallvec from 1.11.0 to 1.11.1 (#988)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index d70598ad8..cfcbf6591 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -434,9 +434,9 @@ dependencies = [
 
 [[package]]
 name = "smallvec"
-version = "1.11.0"
+version = "1.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62bb4feee49fdd9f707ef802e22365a35de4b7b299de4763d44bfea899442ff9"
+checksum = "942b4a808e05215192e39f4ab80813e599068285906cc91aa64f923db842bd5a"
 
 [[package]]
 name = "speedate"
diff --git a/Cargo.toml b/Cargo.toml
index 154d310de..f28ec2944 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -34,7 +34,7 @@ serde_json = {version = "1.0.107", features = ["arbitrary_precision", "preserve_
 enum_dispatch = "0.3.8"
 serde = { version = "1.0.188", features = ["derive"] }
 speedate = "0.12.0"
-smallvec = "1.11.0"
+smallvec = "1.11.1"
 ahash = "0.8.0"
 url = "2.4.1"
 # idna is already required by url, added here to be explicit

From e610984bd12a673f62892f6d2ab42d344e2714ec Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 25 Sep 2023 13:48:53 +0100
Subject: [PATCH 052/550] Bump ruff from 0.0.290 to 0.0.291 (#987)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index ff8f85657..48e914dbb 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,5 +1,5 @@
 black==23.9.1
 griffe==0.36.2
 pyright==1.1.327
-ruff==0.0.290
+ruff==0.0.291
 mypy==1.5.1

From 8435153f2c125b0ea4dbfc9c352bfcd02ae75181 Mon Sep 17 00:00:00 2001
From: David Hewitt <1939362+davidhewitt@users.noreply.github.com>
Date: Tue, 26 Sep 2023 10:59:40 +0100
Subject: [PATCH 053/550] improve quality of too short / too long error
 messages (#990)

---
 src/errors/types.rs                |  7 +--
 src/input/return_enums.rs          | 72 +++++++++++-------------------
 src/validators/generator.rs        |  2 +-
 src/validators/list.rs             |  2 +-
 src/validators/tuple.rs            | 20 +++++----
 tests/validators/test_frozenset.py |  6 +--
 tests/validators/test_generator.py |  8 ++--
 tests/validators/test_list.py      |  3 +-
 tests/validators/test_set.py       |  6 +--
 tests/validators/test_tuple.py     |  6 +--
 10 files changed, 56 insertions(+), 76 deletions(-)

diff --git a/src/errors/types.rs b/src/errors/types.rs
index da4d5fdd7..d537158ba 100644
--- a/src/errors/types.rs
+++ b/src/errors/types.rs
@@ -227,7 +227,7 @@ error_types! {
     TooLong {
         field_type: {ctx_type: String, ctx_fn: field_from_context},
         max_length: {ctx_type: usize, ctx_fn: field_from_context},
-        actual_length: {ctx_type: usize, ctx_fn: field_from_context},
+        actual_length: {ctx_type: Option<usize>, ctx_fn: field_from_context},
     },
     // ---------------------
     // generic collection and iteration errors
@@ -630,7 +630,7 @@ impl ErrorType {
                 ..
             } => {
                 let expected_plural = plural_s(*min_length);
-                to_string_render!(tmpl, field_type, min_length, actual_length, expected_plural)
+                to_string_render!(tmpl, field_type, min_length, actual_length, expected_plural,)
             }
             Self::TooLong {
                 field_type,
@@ -639,7 +639,8 @@ impl ErrorType {
                 ..
             } => {
                 let expected_plural = plural_s(*max_length);
-                to_string_render!(tmpl, field_type, max_length, actual_length, expected_plural)
+                let actual_length = actual_length.map_or(Cow::Borrowed("more"), |v| Cow::Owned(v.to_string()));
+                to_string_render!(tmpl, field_type, max_length, actual_length, expected_plural,)
             }
             Self::IterationError { error, .. } => render!(tmpl, error),
             Self::StringTooShort { min_length, .. } => to_string_render!(tmpl, min_length),
diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index d7d5a7f3b..c492f40f0 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -106,54 +106,33 @@ struct MaxLengthCheck<'a, INPUT> {
     max_length: Option<usize>,
     field_type: &'a str,
     input: &'a INPUT,
-    known_input_length: usize,
+    actual_length: Option<usize>,
 }
 
 impl<'a, INPUT: Input<'a>> MaxLengthCheck<'a, INPUT> {
-    fn new(max_length: Option<usize>, field_type: &'a str, input: &'a INPUT, known_input_length: usize) -> Self {
+    fn new(max_length: Option<usize>, field_type: &'a str, input: &'a INPUT, actual_length: Option<usize>) -> Self {
         Self {
             current_length: 0,
             max_length,
             field_type,
             input,
-            known_input_length,
+            actual_length,
         }
     }
 
     fn incr(&mut self) -> ValResult<'a, ()> {
-        match self.max_length {
-            Some(max_length) => {
-                self.current_length += 1;
-                if self.current_length > max_length {
-                    let biggest_length = if self.known_input_length > self.current_length {
-                        self.known_input_length
-                    } else {
-                        self.current_length
-                    };
-                    return Err(ValError::new(
-                        ErrorType::TooLong {
-                            field_type: self.field_type.to_string(),
-                            max_length,
-                            actual_length: biggest_length,
-                            context: None,
-                        },
-                        self.input,
-                    ));
-                }
-            }
-            None => {
-                self.current_length += 1;
-                if self.current_length > self.known_input_length {
-                    return Err(ValError::new(
-                        ErrorType::TooLong {
-                            field_type: self.field_type.to_string(),
-                            max_length: self.known_input_length,
-                            actual_length: self.current_length,
-                            context: None,
-                        },
-                        self.input,
-                    ));
-                }
+        if let Some(max_length) = self.max_length {
+            self.current_length += 1;
+            if self.current_length > max_length {
+                return Err(ValError::new(
+                    ErrorType::TooLong {
+                        field_type: self.field_type.to_string(),
+                        max_length,
+                        actual_length: self.actual_length,
+                        context: None,
+                    },
+                    self.input,
+                ));
             }
         }
         Ok(())
@@ -255,13 +234,15 @@ fn validate_iter_to_set<'a, 's>(
             Ok(item) => {
                 set.build_add(item)?;
                 if let Some(max_length) = max_length {
-                    let actual_length = set.build_len();
-                    if actual_length > max_length {
+                    if set.build_len() > max_length {
                         return Err(ValError::new(
                             ErrorType::TooLong {
                                 field_type: field_type.to_string(),
                                 max_length,
-                                actual_length,
+                                // The logic here is that it doesn't matter how many elements the
+                                // input actually had; all we know is it had more than the allowed
+                                // number of deduplicated elements.
+                                actual_length: None,
                                 context: None,
                             },
                             input,
@@ -335,10 +316,9 @@ impl<'a> GenericIterable<'a> {
         validator: &'s CombinedValidator,
         state: &mut ValidationState,
     ) -> ValResult<'a, Vec<PyObject>> {
-        let capacity = self
-            .generic_len()
-            .unwrap_or_else(|| max_length.unwrap_or(DEFAULT_CAPACITY));
-        let max_length_check = MaxLengthCheck::new(max_length, field_type, input, capacity);
+        let actual_length = self.generic_len();
+        let capacity = actual_length.unwrap_or(DEFAULT_CAPACITY);
+        let max_length_check = MaxLengthCheck::new(max_length, field_type, input, actual_length);
 
         macro_rules! validate {
             ($iter:expr) => {
@@ -394,10 +374,8 @@ impl<'a> GenericIterable<'a> {
         field_type: &'static str,
         max_length: Option<usize>,
     ) -> ValResult<'a, Vec<PyObject>> {
-        let capacity = self
-            .generic_len()
-            .unwrap_or_else(|| max_length.unwrap_or(DEFAULT_CAPACITY));
-        let max_length_check = MaxLengthCheck::new(max_length, field_type, input, capacity);
+        let actual_length = self.generic_len();
+        let max_length_check = MaxLengthCheck::new(max_length, field_type, input, actual_length);
 
         match self {
             GenericIterable::List(collection) => {
diff --git a/src/validators/generator.rs b/src/validators/generator.rs
index bf6d009e1..0cff7e28e 100644
--- a/src/validators/generator.rs
+++ b/src/validators/generator.rs
@@ -145,7 +145,7 @@ impl ValidatorIterator {
                                         ErrorType::TooLong {
                                             field_type: "Generator".to_string(),
                                             max_length,
-                                            actual_length: index + 1,
+                                            actual_length: None,
                                             context: None,
                                         },
                                         $iter.input_as_error_value(py),
diff --git a/src/validators/list.rs b/src/validators/list.rs
index 49eaede67..ffd7a118e 100644
--- a/src/validators/list.rs
+++ b/src/validators/list.rs
@@ -58,7 +58,7 @@ macro_rules! length_check {
                     crate::errors::ErrorType::TooLong {
                         field_type: $field_type.to_string(),
                         max_length,
-                        actual_length,
+                        actual_length: Some(actual_length),
                         context: None,
                     },
                     $input,
diff --git a/src/validators/tuple.rs b/src/validators/tuple.rs
index 07887fddb..5c2c09bec 100644
--- a/src/validators/tuple.rs
+++ b/src/validators/tuple.rs
@@ -137,8 +137,7 @@ fn validate_tuple_positional<'s, 'data, T: Iterator<Item = PyResult<&'data I>>,
     extras_validator: &Option<Box<CombinedValidator>>,
     items_validators: &[CombinedValidator],
     collection_iter: &mut T,
-    collection_len: Option<usize>,
-    expected_length: usize,
+    actual_length: Option<usize>,
 ) -> ValResult<'data, ()> {
     for (index, validator) in items_validators.iter().enumerate() {
         match collection_iter.next() {
@@ -167,7 +166,7 @@ fn validate_tuple_positional<'s, 'data, T: Iterator<Item = PyResult<&'data I>>,
                     errors.extend(
                         line_errors
                             .into_iter()
-                            .map(|err| err.with_outer_location((index + expected_length).into())),
+                            .map(|err| err.with_outer_location((index + items_validators.len()).into())),
                     );
                 }
                 Err(ValError::Omit) => (),
@@ -177,8 +176,8 @@ fn validate_tuple_positional<'s, 'data, T: Iterator<Item = PyResult<&'data I>>,
                 errors.push(ValLineError::new(
                     ErrorType::TooLong {
                         field_type: "Tuple".to_string(),
-                        max_length: expected_length,
-                        actual_length: collection_len.unwrap_or(index),
+                        max_length: items_validators.len(),
+                        actual_length,
                         context: None,
                     },
                     input,
@@ -204,8 +203,12 @@ impl Validator for TuplePositionalValidator {
         state: &mut ValidationState,
     ) -> ValResult<'data, PyObject> {
         let collection = input.validate_tuple(state.strict_or(self.strict))?;
-        let expected_length = self.items_validators.len();
-        let collection_len = collection.generic_len();
+        let actual_length = collection.generic_len();
+        let expected_length = if self.extras_validator.is_some() {
+            actual_length.unwrap_or(self.items_validators.len())
+        } else {
+            self.items_validators.len()
+        };
 
         let mut output: Vec<PyObject> = Vec::with_capacity(expected_length);
         let mut errors: Vec<ValLineError> = Vec::new();
@@ -221,8 +224,7 @@ impl Validator for TuplePositionalValidator {
                     &self.extras_validator,
                     &self.items_validators,
                     &mut $collection_iter,
-                    collection_len,
-                    expected_length,
+                    actual_length,
                 )?
             }};
         }
diff --git a/tests/validators/test_frozenset.py b/tests/validators/test_frozenset.py
index 2e53b38cb..9ec2f10d5 100644
--- a/tests/validators/test_frozenset.py
+++ b/tests/validators/test_frozenset.py
@@ -148,12 +148,12 @@ def generate_repeats():
         (
             {'max_length': 3},
             {1, 2, 3, 4},
-            Err('Frozenset should have at most 3 items after validation, not 4 [type=too_long,'),
+            Err('Frozenset should have at most 3 items after validation, not more [type=too_long,'),
         ),
         (
             {'items_schema': {'type': 'int'}, 'max_length': 3},
             {1, 2, 3, 4},
-            Err('Frozenset should have at most 3 items after validation, not 4 [type=too_long,'),
+            Err('Frozenset should have at most 3 items after validation, not more [type=too_long,'),
         ),
         # length check after set creation
         ({'max_length': 3}, [1, 1, 2, 2, 3, 3], {1, 2, 3}),
@@ -161,7 +161,7 @@ def generate_repeats():
         (
             {'max_length': 3},
             infinite_generator(),
-            Err('Frozenset should have at most 3 items after validation, not 4 [type=too_long,'),
+            Err('Frozenset should have at most 3 items after validation, not more [type=too_long,'),
         ),
     ],
 )
diff --git a/tests/validators/test_generator.py b/tests/validators/test_generator.py
index 0bb637443..f8d7fd429 100644
--- a/tests/validators/test_generator.py
+++ b/tests/validators/test_generator.py
@@ -118,9 +118,9 @@ def test_too_long(py_and_json: PyAndJson):
         {
             'type': 'too_long',
             'loc': (),
-            'msg': 'Generator should have at most 2 items after validation, not 3',
+            'msg': 'Generator should have at most 2 items after validation, not more',
             'input': [1, 2, 3],
-            'ctx': {'field_type': 'Generator', 'max_length': 2, 'actual_length': 3},
+            'ctx': {'field_type': 'Generator', 'max_length': 2, 'actual_length': None},
         }
     ]
 
@@ -167,8 +167,8 @@ def test_generator_too_long():
             'type': 'too_long',
             'loc': (),
             'input': HasRepr(IsStr(regex='<generator object gen at .+>')),
-            'msg': 'Generator should have at most 2 items after validation, not 3',
-            'ctx': {'field_type': 'Generator', 'max_length': 2, 'actual_length': 3},
+            'msg': 'Generator should have at most 2 items after validation, not more',
+            'ctx': {'field_type': 'Generator', 'max_length': 2, 'actual_length': None},
         }
     ]
 
diff --git a/tests/validators/test_list.py b/tests/validators/test_list.py
index 05e5ed832..6f5ca8a34 100644
--- a/tests/validators/test_list.py
+++ b/tests/validators/test_list.py
@@ -160,14 +160,13 @@ def test_list_error(input_value, index):
         (
             {'max_length': 44},
             infinite_generator(),
-            Err('List should have at most 44 items after validation, not 45 [type=too_long,'),
+            Err('List should have at most 44 items after validation, not more [type=too_long,'),
         ),
         (
             {'max_length': 4, 'items_schema': {'type': 'int'}},
             [0, 1, 2, 3, 4, 5, 6, 7, 8],
             Err('List should have at most 4 items after validation, not 9 [type=too_long,'),
         ),
-        ({}, infinite_generator(), Err('List should have at most 10 items after validation, not 11 [type=too_long,')),
     ],
 )
 def test_list_length_constraints(kwargs: Dict[str, Any], input_value, expected):
diff --git a/tests/validators/test_set.py b/tests/validators/test_set.py
index 0b7bbe373..a6babb80d 100644
--- a/tests/validators/test_set.py
+++ b/tests/validators/test_set.py
@@ -126,12 +126,12 @@ def generate_repeats():
         (
             {'max_length': 3},
             {1, 2, 3, 4},
-            Err('Set should have at most 3 items after validation, not 4 [type=too_long,'),
+            Err('Set should have at most 3 items after validation, not more [type=too_long,'),
         ),
         (
             {'max_length': 3},
             [1, 2, 3, 4],
-            Err('Set should have at most 3 items after validation, not 4 [type=too_long,'),
+            Err('Set should have at most 3 items after validation, not more [type=too_long,'),
         ),
         ({'max_length': 3, 'items_schema': {'type': 'int'}}, {1, 2, 3, 4}, Err('type=too_long,')),
         ({'max_length': 3, 'items_schema': {'type': 'int'}}, [1, 2, 3, 4], Err('type=too_long,')),
@@ -141,7 +141,7 @@ def generate_repeats():
         (
             {'max_length': 3},
             infinite_generator(),
-            Err('Set should have at most 3 items after validation, not 4 [type=too_long,'),
+            Err('Set should have at most 3 items after validation, not more [type=too_long,'),
         ),
     ],
     ids=repr,
diff --git a/tests/validators/test_tuple.py b/tests/validators/test_tuple.py
index b7f3e9720..023a2b48e 100644
--- a/tests/validators/test_tuple.py
+++ b/tests/validators/test_tuple.py
@@ -107,13 +107,13 @@ def test_tuple_strict_fails_without_tuple(wrong_coll_type: Type[Any], mode, item
         ),
         (
             {'max_length': 3},
-            [1, 2, 3, 4],
-            Err('Tuple should have at most 3 items after validation, not 4 [type=too_long,'),
+            [1, 2, 3, 4, 5],
+            Err('Tuple should have at most 3 items after validation, not 5 [type=too_long,'),
         ),
         (
             {'max_length': 3},
             infinite_generator(),
-            Err('Tuple should have at most 3 items after validation, not 4 [type=too_long,'),
+            Err('Tuple should have at most 3 items after validation, not more [type=too_long,'),
         ),
     ],
     ids=repr,

From 1a966d55581e1a1379cfe6274da6323c9786aefb Mon Sep 17 00:00:00 2001
From: David Hewitt <1939362+davidhewitt@users.noreply.github.com>
Date: Tue, 26 Sep 2023 11:24:48 +0100
Subject: [PATCH 054/550] bump version to 10.0.1 (#991)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index cfcbf6591..a2db9901f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -242,7 +242,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.10.0"
+version = "2.10.1"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index f28ec2944..7101a7019 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.10.0"
+version = "2.10.1"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From a8fb1e3f46598498b2f01d2a5949ae501739717f Mon Sep 17 00:00:00 2001
From: David Hewitt <1939362+davidhewitt@users.noreply.github.com>
Date: Thu, 28 Sep 2023 09:45:34 +0100
Subject: [PATCH 055/550] Replace definitions `Vec` with `OnceLock` slots
 (#992)

---
 src/definitions.rs                            | 268 +++++++++++++-----
 src/py_gc.rs                                  |   8 +
 src/serializers/extra.rs                      |   9 -
 src/serializers/mod.rs                        |   9 +-
 src/serializers/shared.rs                     |   4 +-
 src/serializers/type_serializers/dataclass.rs |   4 +-
 .../type_serializers/definitions.rs           |  30 +-
 src/serializers/type_serializers/model.rs     |   4 +-
 src/serializers/type_serializers/nullable.rs  |   6 +-
 src/serializers/type_serializers/union.rs     |  14 +-
 .../type_serializers/with_default.rs          |   6 +-
 src/validators/any.rs                         |   8 +-
 src/validators/arguments.rs                   |  26 +-
 src/validators/bool.rs                        |   8 +-
 src/validators/bytes.rs                       |  16 +-
 src/validators/call.rs                        |  21 +-
 src/validators/callable.rs                    |   8 +-
 src/validators/chain.rs                       |  16 +-
 src/validators/custom_error.rs                |  14 +-
 src/validators/dataclass.rs                   |  32 +--
 src/validators/date.rs                        |   8 +-
 src/validators/datetime.rs                    |   8 +-
 src/validators/decimal.rs                     |   8 +-
 src/validators/definitions.rs                 | 100 +++----
 src/validators/dict.rs                        |  17 +-
 src/validators/float.rs                       |  16 +-
 src/validators/frozenset.rs                   |  14 +-
 src/validators/function.rs                    |  53 ++--
 src/validators/generator.rs                   |  39 ++-
 src/validators/int.rs                         |  16 +-
 src/validators/is_instance.rs                 |   8 +-
 src/validators/is_subclass.rs                 |   8 +-
 src/validators/json.rs                        |  16 +-
 src/validators/json_or_python.rs              |  17 +-
 src/validators/lax_or_strict.rs               |  16 +-
 src/validators/list.rs                        |  49 ++--
 src/validators/literal.rs                     |  14 +-
 src/validators/mod.rs                         |  56 ++--
 src/validators/model.rs                       |  14 +-
 src/validators/model_fields.rs                |  22 +-
 src/validators/none.rs                        |   8 +-
 src/validators/nullable.rs                    |  14 +-
 src/validators/set.rs                         |  14 +-
 src/validators/string.rs                      |  18 +-
 src/validators/time.rs                        |   8 +-
 src/validators/timedelta.rs                   |   8 +-
 src/validators/tuple.rs                       |  44 +--
 src/validators/typed_dict.rs                  |  22 +-
 src/validators/union.rs                       |  89 +++---
 src/validators/url.rs                         |  16 +-
 src/validators/uuid.rs                        |   8 +-
 src/validators/validation_state.rs            |  18 +-
 src/validators/with_default.rs                |  14 +-
 .../validators/test_definitions_recursive.py  | 192 ++++++++++++-
 54 files changed, 793 insertions(+), 690 deletions(-)

diff --git a/src/definitions.rs b/src/definitions.rs
index 0d01fd2ae..1eb813015 100644
--- a/src/definitions.rs
+++ b/src/definitions.rs
@@ -3,16 +3,20 @@
 /// Unlike json schema we let you put definitions inline, not just in a single '#/$defs/' block or similar.
 /// We use DefinitionsBuilder to collect the references / definitions into a single vector
 /// and then get a definition from a reference using an integer id (just for performance of not using a HashMap)
-use std::collections::hash_map::Entry;
+use std::{
+    collections::hash_map::Entry,
+    fmt::Debug,
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc, OnceLock,
+    },
+};
 
-use pyo3::prelude::*;
+use pyo3::{prelude::*, PyTraverseError, PyVisit};
 
 use ahash::AHashMap;
 
-use crate::build_tools::py_schema_err;
-
-// An integer id for the reference
-pub type ReferenceId = usize;
+use crate::{build_tools::py_schema_err, py_gc::PyGcTraverse};
 
 /// Definitions are validators and serializers that are
 /// shared by reference.
@@ -24,91 +28,227 @@ pub type ReferenceId = usize;
 /// They get indexed by a ReferenceId, which are integer identifiers
 /// that are handed out and managed by DefinitionsBuilder when the Schema{Validator,Serializer}
 /// gets build.
-pub type Definitions<T> = [T];
+#[derive(Clone)]
+pub struct Definitions<T>(AHashMap<Arc<String>, Definition<T>>);
 
-#[derive(Clone, Debug)]
-struct Definition<T> {
-    pub id: ReferenceId,
-    pub value: Option<T>,
+impl<T> Definitions<T> {
+    pub fn values(&self) -> impl Iterator<Item = &Definition<T>> {
+        self.0.values()
+    }
+}
+
+/// Internal type which contains a definition to be filled
+pub struct Definition<T>(Arc<DefinitionInner<T>>);
+
+impl<T> Definition<T> {
+    pub fn get(&self) -> Option<&T> {
+        self.0.value.get()
+    }
+}
+
+struct DefinitionInner<T> {
+    value: OnceLock<T>,
+    name: LazyName,
+}
+
+/// Reference to a definition.
+pub struct DefinitionRef<T> {
+    name: Arc<String>,
+    value: Definition<T>,
+}
+
+// DefinitionRef can always be cloned (#[derive(Clone)] would require T: Clone)
+impl<T> Clone for DefinitionRef<T> {
+    fn clone(&self) -> Self {
+        Self {
+            name: self.name.clone(),
+            value: self.value.clone(),
+        }
+    }
+}
+
+impl<T> DefinitionRef<T> {
+    pub fn id(&self) -> usize {
+        Arc::as_ptr(&self.value.0) as usize
+    }
+
+    pub fn get_or_init_name(&self, init: impl FnOnce(&T) -> String) -> &str {
+        match self.value.0.value.get() {
+            Some(value) => self.value.0.name.get_or_init(|| init(value)),
+            None => "...",
+        }
+    }
+
+    pub fn get(&self) -> Option<&T> {
+        self.value.0.value.get()
+    }
+}
+
+impl<T: Debug> Debug for DefinitionRef<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        // To avoid possible infinite recursion from recursive definitions,
+        // a DefinitionRef just displays debug as its name
+        self.name.fmt(f)
+    }
+}
+
+impl<T: Debug> Debug for Definitions<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        // Formatted as a list for backwards compatibility; in principle
+        // this could be formatted as a map. Maybe change in a future
+        // minor release of pydantic.
+        write![f, "["]?;
+        let mut first = true;
+        for def in self.0.values() {
+            write![f, "{sep}{def:?}", sep = if first { "" } else { ", " }]?;
+            first = false;
+        }
+        write![f, "]"]?;
+        Ok(())
+    }
+}
+
+impl<T> Clone for Definition<T> {
+    fn clone(&self) -> Self {
+        Self(self.0.clone())
+    }
+}
+
+impl<T: Debug> Debug for Definition<T> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self.0.value.get() {
+            Some(value) => value.fmt(f),
+            None => "...".fmt(f),
+        }
+    }
+}
+
+impl<T: PyGcTraverse> PyGcTraverse for DefinitionRef<T> {
+    fn py_gc_traverse(&self, visit: &PyVisit<'_>) -> Result<(), PyTraverseError> {
+        if let Some(value) = self.value.0.value.get() {
+            value.py_gc_traverse(visit)?;
+        }
+        Ok(())
+    }
+}
+
+impl<T: PyGcTraverse> PyGcTraverse for Definitions<T> {
+    fn py_gc_traverse(&self, visit: &PyVisit<'_>) -> Result<(), PyTraverseError> {
+        for value in self.0.values() {
+            if let Some(value) = value.0.value.get() {
+                value.py_gc_traverse(visit)?;
+            }
+        }
+        Ok(())
+    }
 }
 
 #[derive(Clone, Debug)]
 pub struct DefinitionsBuilder<T> {
-    definitions: AHashMap<String, Definition<T>>,
+    definitions: Definitions<T>,
 }
 
-impl<T: Clone + std::fmt::Debug> DefinitionsBuilder<T> {
+impl<T: std::fmt::Debug> DefinitionsBuilder<T> {
     pub fn new() -> Self {
         Self {
-            definitions: AHashMap::new(),
+            definitions: Definitions(AHashMap::new()),
         }
     }
 
     /// Get a ReferenceId for the given reference string.
-    // This ReferenceId can later be used to retrieve a definition
-    pub fn get_reference_id(&mut self, reference: &str) -> ReferenceId {
-        let next_id = self.definitions.len();
+    pub fn get_definition(&mut self, reference: &str) -> DefinitionRef<T> {
         // We either need a String copy or two hashmap lookups
         // Neither is better than the other
         // We opted for the easier outward facing API
-        match self.definitions.entry(reference.to_string()) {
-            Entry::Occupied(entry) => entry.get().id,
-            Entry::Vacant(entry) => {
-                entry.insert(Definition {
-                    id: next_id,
-                    value: None,
-                });
-                next_id
-            }
+        let name = Arc::new(reference.to_string());
+        let value = match self.definitions.0.entry(name.clone()) {
+            Entry::Occupied(entry) => entry.into_mut(),
+            Entry::Vacant(entry) => entry.insert(Definition(Arc::new(DefinitionInner {
+                value: OnceLock::new(),
+                name: LazyName::new(),
+            }))),
+        };
+        DefinitionRef {
+            name,
+            value: value.clone(),
         }
     }
 
     /// Add a definition, returning the ReferenceId that maps to it
-    pub fn add_definition(&mut self, reference: String, value: T) -> PyResult<ReferenceId> {
-        let next_id = self.definitions.len();
-        match self.definitions.entry(reference.clone()) {
-            Entry::Occupied(mut entry) => match entry.get_mut().value.replace(value) {
-                Some(_) => py_schema_err!("Duplicate ref: `{}`", reference),
-                None => Ok(entry.get().id),
-            },
-            Entry::Vacant(entry) => {
-                entry.insert(Definition {
-                    id: next_id,
-                    value: Some(value),
-                });
-                Ok(next_id)
+    pub fn add_definition(&mut self, reference: String, value: T) -> PyResult<DefinitionRef<T>> {
+        let name = Arc::new(reference);
+        let value = match self.definitions.0.entry(name.clone()) {
+            Entry::Occupied(entry) => {
+                let definition = entry.into_mut();
+                match definition.0.value.set(value) {
+                    Ok(()) => definition.clone(),
+                    Err(_) => return py_schema_err!("Duplicate ref: `{}`", name),
+                }
+            }
+            Entry::Vacant(entry) => entry
+                .insert(Definition(Arc::new(DefinitionInner {
+                    value: OnceLock::from(value),
+                    name: LazyName::new(),
+                })))
+                .clone(),
+        };
+        Ok(DefinitionRef { name, value })
+    }
+
+    /// Consume this Definitions into a vector of items, indexed by each items ReferenceId
+    pub fn finish(self) -> PyResult<Definitions<T>> {
+        for (reference, def) in &self.definitions.0 {
+            if def.0.value.get().is_none() {
+                return py_schema_err!("Definitions error: definition `{}` was never filled", reference);
             }
         }
+        Ok(self.definitions)
     }
+}
 
-    /// Retrieve an item definition using a ReferenceId
-    /// If the definition doesn't yet exist (as happens in recursive types) then we create it
-    /// At the end (in finish()) we check that there are no undefined definitions
-    pub fn get_definition(&self, reference_id: ReferenceId) -> PyResult<&T> {
-        let (reference, def) = match self.definitions.iter().find(|(_, def)| def.id == reference_id) {
-            Some(v) => v,
-            None => return py_schema_err!("Definitions error: no definition for ReferenceId `{}`", reference_id),
-        };
-        match def.value.as_ref() {
-            Some(v) => Ok(v),
-            None => py_schema_err!(
-                "Definitions error: attempted to use `{}` before it was filled",
-                reference
-            ),
+struct LazyName {
+    initialized: OnceLock<String>,
+    in_recursion: AtomicBool,
+}
+
+impl LazyName {
+    fn new() -> Self {
+        Self {
+            initialized: OnceLock::new(),
+            in_recursion: AtomicBool::new(false),
         }
     }
 
-    /// Consume this Definitions into a vector of items, indexed by each items ReferenceId
-    pub fn finish(self) -> PyResult<Vec<T>> {
-        // We need to create a vec of defs according to the order in their ids
-        let mut defs: Vec<(usize, T)> = Vec::new();
-        for (reference, def) in self.definitions {
-            match def.value {
-                None => return py_schema_err!("Definitions error: definition {} was never filled", reference),
-                Some(v) => defs.push((def.id, v)),
-            }
+    /// Gets the validator name, returning the default in the case of recursion loops
+    fn get_or_init(&self, init: impl FnOnce() -> String) -> &str {
+        if let Some(s) = self.initialized.get() {
+            return s.as_str();
+        }
+
+        if self
+            .in_recursion
+            .compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst)
+            .is_err()
+        {
+            return "...";
+        }
+        let result = self.initialized.get_or_init(init).as_str();
+        self.in_recursion.store(false, Ordering::SeqCst);
+        result
+    }
+}
+
+impl Debug for LazyName {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.initialized.get().map_or("...", String::as_str).fmt(f)
+    }
+}
+
+impl Clone for LazyName {
+    fn clone(&self) -> Self {
+        Self {
+            initialized: OnceLock::new(),
+            in_recursion: AtomicBool::new(false),
         }
-        defs.sort_by_key(|(id, _)| *id);
-        Ok(defs.into_iter().map(|(_, v)| v).collect())
     }
 }
diff --git a/src/py_gc.rs b/src/py_gc.rs
index 02df02e13..8af285afb 100644
--- a/src/py_gc.rs
+++ b/src/py_gc.rs
@@ -1,3 +1,5 @@
+use std::sync::Arc;
+
 use ahash::AHashMap;
 use enum_dispatch::enum_dispatch;
 use pyo3::{AsPyPointer, Py, PyTraverseError, PyVisit};
@@ -35,6 +37,12 @@ impl<T: PyGcTraverse> PyGcTraverse for AHashMap<String, T> {
     }
 }
 
+impl<T: PyGcTraverse> PyGcTraverse for Arc<T> {
+    fn py_gc_traverse(&self, visit: &PyVisit<'_>) -> Result<(), PyTraverseError> {
+        T::py_gc_traverse(self, visit)
+    }
+}
+
 impl<T: PyGcTraverse> PyGcTraverse for Box<T> {
     fn py_gc_traverse(&self, visit: &PyVisit<'_>) -> Result<(), PyTraverseError> {
         T::py_gc_traverse(self, visit)
diff --git a/src/serializers/extra.rs b/src/serializers/extra.rs
index 9972a82c4..65c5a1ba9 100644
--- a/src/serializers/extra.rs
+++ b/src/serializers/extra.rs
@@ -10,8 +10,6 @@ use serde::ser::Error;
 use super::config::SerializationConfig;
 use super::errors::{PydanticSerializationUnexpectedValue, UNEXPECTED_TYPE_SER_MARKER};
 use super::ob_type::ObTypeLookup;
-use super::shared::CombinedSerializer;
-use crate::definitions::Definitions;
 use crate::recursion_guard::RecursionGuard;
 
 /// this is ugly, would be much better if extra could be stored in `SerializationState`
@@ -48,7 +46,6 @@ impl SerializationState {
         Extra::new(
             py,
             mode,
-            &[],
             by_alias,
             &self.warnings,
             false,
@@ -72,7 +69,6 @@ impl SerializationState {
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub(crate) struct Extra<'a> {
     pub mode: &'a SerMode,
-    pub definitions: &'a Definitions<CombinedSerializer>,
     pub ob_type_lookup: &'a ObTypeLookup,
     pub warnings: &'a CollectWarnings,
     pub by_alias: bool,
@@ -98,7 +94,6 @@ impl<'a> Extra<'a> {
     pub fn new(
         py: Python<'a>,
         mode: &'a SerMode,
-        definitions: &'a Definitions<CombinedSerializer>,
         by_alias: bool,
         warnings: &'a CollectWarnings,
         exclude_unset: bool,
@@ -112,7 +107,6 @@ impl<'a> Extra<'a> {
     ) -> Self {
         Self {
             mode,
-            definitions,
             ob_type_lookup: ObTypeLookup::cached(py),
             warnings,
             by_alias,
@@ -156,7 +150,6 @@ impl SerCheck {
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub(crate) struct ExtraOwned {
     mode: SerMode,
-    definitions: Vec<CombinedSerializer>,
     warnings: CollectWarnings,
     by_alias: bool,
     exclude_unset: bool,
@@ -176,7 +169,6 @@ impl ExtraOwned {
     pub fn new(extra: &Extra) -> Self {
         Self {
             mode: extra.mode.clone(),
-            definitions: extra.definitions.to_vec(),
             warnings: extra.warnings.clone(),
             by_alias: extra.by_alias,
             exclude_unset: extra.exclude_unset,
@@ -196,7 +188,6 @@ impl ExtraOwned {
     pub fn to_extra<'py>(&'py self, py: Python<'py>) -> Extra<'py> {
         Extra {
             mode: &self.mode,
-            definitions: &self.definitions,
             ob_type_lookup: ObTypeLookup::cached(py),
             warnings: &self.warnings,
             by_alias: self.by_alias,
diff --git a/src/serializers/mod.rs b/src/serializers/mod.rs
index 6dbc076fe..72028346b 100644
--- a/src/serializers/mod.rs
+++ b/src/serializers/mod.rs
@@ -5,7 +5,7 @@ use pyo3::prelude::*;
 use pyo3::types::{PyBytes, PyDict};
 use pyo3::{PyTraverseError, PyVisit};
 
-use crate::definitions::DefinitionsBuilder;
+use crate::definitions::{Definitions, DefinitionsBuilder};
 use crate::py_gc::PyGcTraverse;
 
 use config::SerializationConfig;
@@ -30,7 +30,7 @@ mod type_serializers;
 #[derive(Debug)]
 pub struct SchemaSerializer {
     serializer: CombinedSerializer,
-    definitions: Vec<CombinedSerializer>,
+    definitions: Definitions<CombinedSerializer>,
     expected_json_size: AtomicUsize,
     config: SerializationConfig,
 }
@@ -54,7 +54,6 @@ impl SchemaSerializer {
         Extra::new(
             py,
             mode,
-            &self.definitions,
             by_alias,
             warnings,
             exclude_unset,
@@ -184,9 +183,7 @@ impl SchemaSerializer {
 
     fn __traverse__(&self, visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
         self.serializer.py_gc_traverse(&visit)?;
-        for slot in &self.definitions {
-            slot.py_gc_traverse(&visit)?;
-        }
+        self.definitions.py_gc_traverse(&visit)?;
         Ok(())
     }
 }
diff --git a/src/serializers/shared.rs b/src/serializers/shared.rs
index b9b0c1fe1..7c24ff6db 100644
--- a/src/serializers/shared.rs
+++ b/src/serializers/shared.rs
@@ -13,7 +13,7 @@ use serde_json::ser::PrettyFormatter;
 
 use crate::build_tools::py_schema_err;
 use crate::build_tools::py_schema_error_type;
-use crate::definitions::{Definitions, DefinitionsBuilder};
+use crate::definitions::DefinitionsBuilder;
 use crate::py_gc::PyGcTraverse;
 use crate::tools::{py_err, SchemaDict};
 
@@ -293,7 +293,7 @@ pub(crate) trait TypeSerializer: Send + Sync + Clone + Debug {
     fn get_name(&self) -> &str;
 
     /// Used by union serializers to decide if it's worth trying again while allowing subclasses
-    fn retry_with_lax_check(&self, _definitions: &Definitions<CombinedSerializer>) -> bool {
+    fn retry_with_lax_check(&self) -> bool {
         false
     }
 
diff --git a/src/serializers/type_serializers/dataclass.rs b/src/serializers/type_serializers/dataclass.rs
index 124f962ad..787e267dd 100644
--- a/src/serializers/type_serializers/dataclass.rs
+++ b/src/serializers/type_serializers/dataclass.rs
@@ -6,7 +6,7 @@ use std::borrow::Cow;
 use ahash::AHashMap;
 
 use crate::build_tools::{py_schema_error_type, ExtraBehavior};
-use crate::definitions::{Definitions, DefinitionsBuilder};
+use crate::definitions::DefinitionsBuilder;
 use crate::tools::SchemaDict;
 
 use super::{
@@ -179,7 +179,7 @@ impl TypeSerializer for DataclassSerializer {
         &self.name
     }
 
-    fn retry_with_lax_check(&self, _definitions: &Definitions<CombinedSerializer>) -> bool {
+    fn retry_with_lax_check(&self) -> bool {
         true
     }
 }
diff --git a/src/serializers/type_serializers/definitions.rs b/src/serializers/type_serializers/definitions.rs
index 4614bbc56..cf92df244 100644
--- a/src/serializers/type_serializers/definitions.rs
+++ b/src/serializers/type_serializers/definitions.rs
@@ -4,7 +4,7 @@ use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList};
 
-use crate::definitions::Definitions;
+use crate::definitions::DefinitionRef;
 use crate::definitions::DefinitionsBuilder;
 
 use crate::tools::SchemaDict;
@@ -41,7 +41,7 @@ impl BuildSerializer for DefinitionsSerializerBuilder {
 
 #[derive(Debug, Clone)]
 pub struct DefinitionRefSerializer {
-    serializer_id: usize,
+    definition: DefinitionRef<CombinedSerializer>,
 }
 
 impl BuildSerializer for DefinitionRefSerializer {
@@ -52,9 +52,9 @@ impl BuildSerializer for DefinitionRefSerializer {
         _config: Option<&PyDict>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
-        let schema_ref: String = schema.get_as_req(intern!(schema.py(), "schema_ref"))?;
-        let serializer_id = definitions.get_reference_id(&schema_ref);
-        Ok(Self { serializer_id }.into())
+        let schema_ref = schema.get_as_req(intern!(schema.py(), "schema_ref"))?;
+        let definition = definitions.get_definition(schema_ref);
+        Ok(Self { definition }.into())
     }
 }
 
@@ -68,10 +68,10 @@ impl TypeSerializer for DefinitionRefSerializer {
         exclude: Option<&PyAny>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
-        let value_id = extra.rec_guard.add(value, self.serializer_id)?;
-        let comb_serializer = extra.definitions.get(self.serializer_id).unwrap();
+        let comb_serializer = self.definition.get().unwrap();
+        let value_id = extra.rec_guard.add(value, self.definition.id())?;
         let r = comb_serializer.to_python(value, include, exclude, extra);
-        extra.rec_guard.pop(value_id, self.serializer_id);
+        extra.rec_guard.pop(value_id, self.definition.id());
         r
     }
 
@@ -87,10 +87,13 @@ impl TypeSerializer for DefinitionRefSerializer {
         exclude: Option<&PyAny>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
-        let value_id = extra.rec_guard.add(value, self.serializer_id).map_err(py_err_se_err)?;
-        let comb_serializer = extra.definitions.get(self.serializer_id).unwrap();
+        let comb_serializer = self.definition.get().unwrap();
+        let value_id = extra
+            .rec_guard
+            .add(value, self.definition.id())
+            .map_err(py_err_se_err)?;
         let r = comb_serializer.serde_serialize(value, serializer, include, exclude, extra);
-        extra.rec_guard.pop(value_id, self.serializer_id);
+        extra.rec_guard.pop(value_id, self.definition.id());
         r
     }
 
@@ -98,8 +101,7 @@ impl TypeSerializer for DefinitionRefSerializer {
         Self::EXPECTED_TYPE
     }
 
-    fn retry_with_lax_check(&self, definitions: &Definitions<CombinedSerializer>) -> bool {
-        let comb_serializer = definitions.get(self.serializer_id).unwrap();
-        comb_serializer.retry_with_lax_check(definitions)
+    fn retry_with_lax_check(&self) -> bool {
+        self.definition.get().unwrap().retry_with_lax_check()
     }
 }
diff --git a/src/serializers/type_serializers/model.rs b/src/serializers/type_serializers/model.rs
index c5b252fbf..8a2eeb4e1 100644
--- a/src/serializers/type_serializers/model.rs
+++ b/src/serializers/type_serializers/model.rs
@@ -13,7 +13,7 @@ use super::{
 };
 use crate::build_tools::py_schema_err;
 use crate::build_tools::{py_schema_error_type, ExtraBehavior};
-use crate::definitions::{Definitions, DefinitionsBuilder};
+use crate::definitions::DefinitionsBuilder;
 use crate::serializers::errors::PydanticSerializationUnexpectedValue;
 use crate::tools::SchemaDict;
 
@@ -228,7 +228,7 @@ impl TypeSerializer for ModelSerializer {
         &self.name
     }
 
-    fn retry_with_lax_check(&self, _definitions: &Definitions<CombinedSerializer>) -> bool {
+    fn retry_with_lax_check(&self) -> bool {
         true
     }
 }
diff --git a/src/serializers/type_serializers/nullable.rs b/src/serializers/type_serializers/nullable.rs
index 837d6c5f1..23349ec81 100644
--- a/src/serializers/type_serializers/nullable.rs
+++ b/src/serializers/type_serializers/nullable.rs
@@ -4,7 +4,7 @@ use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
 
-use crate::definitions::{Definitions, DefinitionsBuilder};
+use crate::definitions::DefinitionsBuilder;
 use crate::tools::SchemaDict;
 
 use super::{infer_json_key_known, BuildSerializer, CombinedSerializer, Extra, IsType, ObType, TypeSerializer};
@@ -75,7 +75,7 @@ impl TypeSerializer for NullableSerializer {
         Self::EXPECTED_TYPE
     }
 
-    fn retry_with_lax_check(&self, definitions: &Definitions<CombinedSerializer>) -> bool {
-        self.serializer.retry_with_lax_check(definitions)
+    fn retry_with_lax_check(&self) -> bool {
+        self.serializer.retry_with_lax_check()
     }
 }
diff --git a/src/serializers/type_serializers/union.rs b/src/serializers/type_serializers/union.rs
index 70818959e..788620408 100644
--- a/src/serializers/type_serializers/union.rs
+++ b/src/serializers/type_serializers/union.rs
@@ -4,7 +4,7 @@ use pyo3::types::{PyDict, PyList, PyTuple};
 use std::borrow::Cow;
 
 use crate::build_tools::py_schema_err;
-use crate::definitions::{Definitions, DefinitionsBuilder};
+use crate::definitions::DefinitionsBuilder;
 use crate::tools::SchemaDict;
 use crate::PydanticSerializationUnexpectedValue;
 
@@ -87,7 +87,7 @@ impl TypeSerializer for UnionSerializer {
                 },
             }
         }
-        if self.retry_with_lax_check(extra.definitions) {
+        if self.retry_with_lax_check() {
             new_extra.check = SerCheck::Lax;
             for comb_serializer in &self.choices {
                 match comb_serializer.to_python(value, include, exclude, &new_extra) {
@@ -116,7 +116,7 @@ impl TypeSerializer for UnionSerializer {
                 },
             }
         }
-        if self.retry_with_lax_check(extra.definitions) {
+        if self.retry_with_lax_check() {
             new_extra.check = SerCheck::Lax;
             for comb_serializer in &self.choices {
                 match comb_serializer.json_key(key, &new_extra) {
@@ -153,7 +153,7 @@ impl TypeSerializer for UnionSerializer {
                 },
             }
         }
-        if self.retry_with_lax_check(extra.definitions) {
+        if self.retry_with_lax_check() {
             new_extra.check = SerCheck::Lax;
             for comb_serializer in &self.choices {
                 match comb_serializer.to_python(value, include, exclude, &new_extra) {
@@ -174,10 +174,8 @@ impl TypeSerializer for UnionSerializer {
         &self.name
     }
 
-    fn retry_with_lax_check(&self, definitions: &Definitions<CombinedSerializer>) -> bool {
-        self.choices
-            .iter()
-            .any(|choice| choice.retry_with_lax_check(definitions))
+    fn retry_with_lax_check(&self) -> bool {
+        self.choices.iter().any(CombinedSerializer::retry_with_lax_check)
     }
 }
 
diff --git a/src/serializers/type_serializers/with_default.rs b/src/serializers/type_serializers/with_default.rs
index 148c05052..d20c273a1 100644
--- a/src/serializers/type_serializers/with_default.rs
+++ b/src/serializers/type_serializers/with_default.rs
@@ -4,7 +4,7 @@ use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
 
-use crate::definitions::{Definitions, DefinitionsBuilder};
+use crate::definitions::DefinitionsBuilder;
 use crate::tools::SchemaDict;
 use crate::validators::DefaultType;
 
@@ -67,8 +67,8 @@ impl TypeSerializer for WithDefaultSerializer {
         Self::EXPECTED_TYPE
     }
 
-    fn retry_with_lax_check(&self, definitions: &Definitions<CombinedSerializer>) -> bool {
-        self.serializer.retry_with_lax_check(definitions)
+    fn retry_with_lax_check(&self) -> bool {
+        self.serializer.retry_with_lax_check()
     }
 
     fn get_default(&self, py: Python) -> PyResult<Option<PyObject>> {
diff --git a/src/validators/any.rs b/src/validators/any.rs
index eddde1725..625eb4adf 100644
--- a/src/validators/any.rs
+++ b/src/validators/any.rs
@@ -34,11 +34,7 @@ impl Validator for AnyValidator {
         Ok(input.to_object(py))
     }
 
-    fn different_strict_behavior(
-        &self,
-        _definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        _ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, _ultra_strict: bool) -> bool {
         false
     }
 
@@ -46,7 +42,7 @@ impl Validator for AnyValidator {
         Self::EXPECTED_TYPE
     }
 
-    fn complete(&mut self, _definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
+    fn complete(&self) -> PyResult<()> {
         Ok(())
     }
 }
diff --git a/src/validators/arguments.rs b/src/validators/arguments.rs
index 2c0fe4a0a..aa0870043 100644
--- a/src/validators/arguments.rs
+++ b/src/validators/arguments.rs
@@ -15,7 +15,7 @@ use crate::tools::SchemaDict;
 use super::validation_state::ValidationState;
 use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, Validator};
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 struct Parameter {
     positional: bool,
     name: String,
@@ -24,7 +24,7 @@ struct Parameter {
     validator: CombinedValidator,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct ArgumentsValidator {
     parameters: Vec<Parameter>,
     positional_params_count: usize,
@@ -332,29 +332,25 @@ impl Validator for ArgumentsValidator {
         }
     }
 
-    fn different_strict_behavior(
-        &self,
-        definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
         self.parameters
             .iter()
-            .any(|p| p.validator.different_strict_behavior(definitions, ultra_strict))
+            .any(|p| p.validator.different_strict_behavior(ultra_strict))
     }
 
     fn get_name(&self) -> &str {
         Self::EXPECTED_TYPE
     }
 
-    fn complete(&mut self, definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
+    fn complete(&self) -> PyResult<()> {
         self.parameters
-            .iter_mut()
-            .try_for_each(|parameter| parameter.validator.complete(definitions))?;
-        if let Some(v) = &mut self.var_args_validator {
-            v.complete(definitions)?;
+            .iter()
+            .try_for_each(|parameter| parameter.validator.complete())?;
+        if let Some(v) = &self.var_args_validator {
+            v.complete()?;
         }
-        if let Some(v) = &mut self.var_kwargs_validator {
-            v.complete(definitions)?;
+        if let Some(v) = &self.var_kwargs_validator {
+            v.complete()?;
         };
         Ok(())
     }
diff --git a/src/validators/bool.rs b/src/validators/bool.rs
index d87c1c1d7..3a38cf3e5 100644
--- a/src/validators/bool.rs
+++ b/src/validators/bool.rs
@@ -42,11 +42,7 @@ impl Validator for BoolValidator {
         Ok(input.validate_bool(strict)?.into_py(py))
     }
 
-    fn different_strict_behavior(
-        &self,
-        _definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
         !ultra_strict
     }
 
@@ -54,7 +50,7 @@ impl Validator for BoolValidator {
         Self::EXPECTED_TYPE
     }
 
-    fn complete(&mut self, _definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
+    fn complete(&self) -> PyResult<()> {
         Ok(())
     }
 }
diff --git a/src/validators/bytes.rs b/src/validators/bytes.rs
index 2084f916e..0f662af1c 100644
--- a/src/validators/bytes.rs
+++ b/src/validators/bytes.rs
@@ -50,11 +50,7 @@ impl Validator for BytesValidator {
         Ok(either_bytes.into_py(py))
     }
 
-    fn different_strict_behavior(
-        &self,
-        _definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
         !ultra_strict
     }
 
@@ -62,7 +58,7 @@ impl Validator for BytesValidator {
         Self::EXPECTED_TYPE
     }
 
-    fn complete(&mut self, _definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
+    fn complete(&self) -> PyResult<()> {
         Ok(())
     }
 }
@@ -112,11 +108,7 @@ impl Validator for BytesConstrainedValidator {
         Ok(either_bytes.into_py(py))
     }
 
-    fn different_strict_behavior(
-        &self,
-        _definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
         !ultra_strict
     }
 
@@ -124,7 +116,7 @@ impl Validator for BytesConstrainedValidator {
         "constrained-bytes"
     }
 
-    fn complete(&mut self, _definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
+    fn complete(&self) -> PyResult<()> {
         Ok(())
     }
 }
diff --git a/src/validators/call.rs b/src/validators/call.rs
index 24c7f4111..3f6eb4d35 100644
--- a/src/validators/call.rs
+++ b/src/validators/call.rs
@@ -11,7 +11,7 @@ use crate::tools::SchemaDict;
 use super::validation_state::ValidationState;
 use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, Validator};
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct CallValidator {
     function: PyObject,
     arguments_validator: Box<CombinedValidator>,
@@ -98,28 +98,23 @@ impl Validator for CallValidator {
         }
     }
 
-    fn different_strict_behavior(
-        &self,
-        definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
         if let Some(return_validator) = &self.return_validator {
-            if return_validator.different_strict_behavior(definitions, ultra_strict) {
+            if return_validator.different_strict_behavior(ultra_strict) {
                 return true;
             }
         }
-        self.arguments_validator
-            .different_strict_behavior(definitions, ultra_strict)
+        self.arguments_validator.different_strict_behavior(ultra_strict)
     }
 
     fn get_name(&self) -> &str {
         &self.name
     }
 
-    fn complete(&mut self, definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
-        self.arguments_validator.complete(definitions)?;
-        match &mut self.return_validator {
-            Some(v) => v.complete(definitions),
+    fn complete(&self) -> PyResult<()> {
+        self.arguments_validator.complete()?;
+        match &self.return_validator {
+            Some(v) => v.complete(),
             None => Ok(()),
         }
     }
diff --git a/src/validators/callable.rs b/src/validators/callable.rs
index 9b565e3eb..83eb37cbe 100644
--- a/src/validators/callable.rs
+++ b/src/validators/callable.rs
@@ -36,11 +36,7 @@ impl Validator for CallableValidator {
         }
     }
 
-    fn different_strict_behavior(
-        &self,
-        _definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        _ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, _ultra_strict: bool) -> bool {
         false
     }
 
@@ -48,7 +44,7 @@ impl Validator for CallableValidator {
         Self::EXPECTED_TYPE
     }
 
-    fn complete(&mut self, _definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
+    fn complete(&self) -> PyResult<()> {
         Ok(())
     }
 }
diff --git a/src/validators/chain.rs b/src/validators/chain.rs
index 001947d1f..c0f356fa0 100644
--- a/src/validators/chain.rs
+++ b/src/validators/chain.rs
@@ -10,7 +10,7 @@ use crate::tools::SchemaDict;
 use super::validation_state::ValidationState;
 use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, Validator};
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct ChainValidator {
     steps: Vec<CombinedValidator>,
     name: String,
@@ -83,21 +83,15 @@ impl Validator for ChainValidator {
         steps_iter.try_fold(value, |v, step| step.validate(py, v.into_ref(py), state))
     }
 
-    fn different_strict_behavior(
-        &self,
-        definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
-        self.steps
-            .iter()
-            .any(|v| v.different_strict_behavior(definitions, ultra_strict))
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
+        self.steps.iter().any(|v| v.different_strict_behavior(ultra_strict))
     }
 
     fn get_name(&self) -> &str {
         &self.name
     }
 
-    fn complete(&mut self, definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
-        self.steps.iter_mut().try_for_each(|v| v.complete(definitions))
+    fn complete(&self) -> PyResult<()> {
+        self.steps.iter().try_for_each(CombinedValidator::complete)
     }
 }
diff --git a/src/validators/custom_error.rs b/src/validators/custom_error.rs
index 1e8258090..0d9931c62 100644
--- a/src/validators/custom_error.rs
+++ b/src/validators/custom_error.rs
@@ -57,7 +57,7 @@ impl CustomError {
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct CustomErrorValidator {
     validator: Box<CombinedValidator>,
     custom_error: CustomError,
@@ -99,19 +99,15 @@ impl Validator for CustomErrorValidator {
             .map_err(|_| self.custom_error.as_val_error(input))
     }
 
-    fn different_strict_behavior(
-        &self,
-        definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
-        self.validator.different_strict_behavior(definitions, ultra_strict)
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
+        self.validator.different_strict_behavior(ultra_strict)
     }
 
     fn get_name(&self) -> &str {
         &self.name
     }
 
-    fn complete(&mut self, definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
-        self.validator.complete(definitions)
+    fn complete(&self) -> PyResult<()> {
+        self.validator.complete()
     }
 }
diff --git a/src/validators/dataclass.rs b/src/validators/dataclass.rs
index 117596b9f..dff7735a3 100644
--- a/src/validators/dataclass.rs
+++ b/src/validators/dataclass.rs
@@ -19,7 +19,7 @@ use super::{
     build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, Extra, ValidationState, Validator,
 };
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 struct Field {
     kw_only: bool,
     name: String,
@@ -30,7 +30,7 @@ struct Field {
     frozen: bool,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct DataclassArgsValidator {
     fields: Vec<Field>,
     positional_count: usize,
@@ -426,28 +426,22 @@ impl Validator for DataclassArgsValidator {
         }
     }
 
-    fn different_strict_behavior(
-        &self,
-        definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
         self.fields
             .iter()
-            .any(|f| f.validator.different_strict_behavior(definitions, ultra_strict))
+            .any(|f| f.validator.different_strict_behavior(ultra_strict))
     }
 
     fn get_name(&self) -> &str {
         &self.validator_name
     }
 
-    fn complete(&mut self, definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
-        self.fields
-            .iter_mut()
-            .try_for_each(|field| field.validator.complete(definitions))
+    fn complete(&self) -> PyResult<()> {
+        self.fields.iter().try_for_each(|field| field.validator.complete())
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct DataclassValidator {
     strict: bool,
     validator: Box<CombinedValidator>,
@@ -588,13 +582,9 @@ impl Validator for DataclassValidator {
         Ok(obj.to_object(py))
     }
 
-    fn different_strict_behavior(
-        &self,
-        definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
         if ultra_strict {
-            self.validator.different_strict_behavior(definitions, ultra_strict)
+            self.validator.different_strict_behavior(ultra_strict)
         } else {
             true
         }
@@ -604,8 +594,8 @@ impl Validator for DataclassValidator {
         &self.name
     }
 
-    fn complete(&mut self, definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
-        self.validator.complete(definitions)
+    fn complete(&self) -> PyResult<()> {
+        self.validator.complete()
     }
 }
 
diff --git a/src/validators/date.rs b/src/validators/date.rs
index a771a5045..3549f66f0 100644
--- a/src/validators/date.rs
+++ b/src/validators/date.rs
@@ -96,11 +96,7 @@ impl Validator for DateValidator {
         Ok(date.try_into_py(py)?)
     }
 
-    fn different_strict_behavior(
-        &self,
-        _definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
         !ultra_strict
     }
 
@@ -108,7 +104,7 @@ impl Validator for DateValidator {
         Self::EXPECTED_TYPE
     }
 
-    fn complete(&mut self, _definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
+    fn complete(&self) -> PyResult<()> {
         Ok(())
     }
 }
diff --git a/src/validators/datetime.rs b/src/validators/datetime.rs
index 7596b7aca..baf4ca467 100644
--- a/src/validators/datetime.rs
+++ b/src/validators/datetime.rs
@@ -125,11 +125,7 @@ impl Validator for DateTimeValidator {
         Ok(datetime.try_into_py(py)?)
     }
 
-    fn different_strict_behavior(
-        &self,
-        _definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
         !ultra_strict
     }
 
@@ -137,7 +133,7 @@ impl Validator for DateTimeValidator {
         Self::EXPECTED_TYPE
     }
 
-    fn complete(&mut self, _definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
+    fn complete(&self) -> PyResult<()> {
         Ok(())
     }
 }
diff --git a/src/validators/decimal.rs b/src/validators/decimal.rs
index 2564e096a..211befe07 100644
--- a/src/validators/decimal.rs
+++ b/src/validators/decimal.rs
@@ -230,11 +230,7 @@ impl Validator for DecimalValidator {
         Ok(decimal.into())
     }
 
-    fn different_strict_behavior(
-        &self,
-        _definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        _ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, _ultra_strict: bool) -> bool {
         true
     }
 
@@ -242,7 +238,7 @@ impl Validator for DecimalValidator {
         Self::EXPECTED_TYPE
     }
 
-    fn complete(&mut self, _definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
+    fn complete(&self) -> PyResult<()> {
         Ok(())
     }
 }
diff --git a/src/validators/definitions.rs b/src/validators/definitions.rs
index 3a35fce4c..16aea8cd4 100644
--- a/src/validators/definitions.rs
+++ b/src/validators/definitions.rs
@@ -1,7 +1,12 @@
+use std::cell::RefCell;
+
+use ahash::HashSet;
+use ahash::HashSetExt;
 use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList};
 
+use crate::definitions::DefinitionRef;
 use crate::errors::{ErrorTypeDefaults, ValError, ValResult};
 use crate::input::Input;
 
@@ -39,17 +44,12 @@ impl BuildValidator for DefinitionsValidatorBuilder {
 
 #[derive(Debug, Clone)]
 pub struct DefinitionRefValidator {
-    validator_id: usize,
-    inner_name: String,
-    // we have to record the answers to `Question`s as we can't access the validator when `ask()` is called
+    definition: DefinitionRef<CombinedValidator>,
 }
 
 impl DefinitionRefValidator {
-    pub fn new(validator_id: usize) -> Self {
-        Self {
-            validator_id,
-            inner_name: "...".to_string(),
-        }
+    pub fn new(definition: DefinitionRef<CombinedValidator>) -> Self {
+        Self { definition }
     }
 }
 
@@ -61,15 +61,10 @@ impl BuildValidator for DefinitionRefValidator {
         _config: Option<&PyDict>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
-        let schema_ref: String = schema.get_as_req(intern!(schema.py(), "schema_ref"))?;
-
-        let validator_id = definitions.get_reference_id(&schema_ref);
+        let schema_ref = schema.get_as_req(intern!(schema.py(), "schema_ref"))?;
 
-        Ok(Self {
-            validator_id,
-            inner_name: "...".to_string(),
-        }
-        .into())
+        let definition = definitions.get_definition(schema_ref);
+        Ok(Self::new(definition).into())
     }
 }
 
@@ -82,21 +77,22 @@ impl Validator for DefinitionRefValidator {
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
     ) -> ValResult<'data, PyObject> {
+        let validator = self.definition.get().unwrap();
         if let Some(id) = input.identity() {
-            if state.recursion_guard.contains_or_insert(id, self.validator_id) {
+            if state.recursion_guard.contains_or_insert(id, self.definition.id()) {
                 // we don't remove id here, we leave that to the validator which originally added id to `recursion_guard`
                 Err(ValError::new(ErrorTypeDefaults::RecursionLoop, input))
             } else {
                 if state.recursion_guard.incr_depth() {
                     return Err(ValError::new(ErrorTypeDefaults::RecursionLoop, input));
                 }
-                let output = validate(self.validator_id, py, input, state);
-                state.recursion_guard.remove(id, self.validator_id);
+                let output = validator.validate(py, input, state);
+                state.recursion_guard.remove(id, self.definition.id());
                 state.recursion_guard.decr_depth();
                 output
             }
         } else {
-            validate(self.validator_id, py, input, state)
+            validator.validate(py, input, state)
         }
     }
 
@@ -108,69 +104,51 @@ impl Validator for DefinitionRefValidator {
         field_value: &'data PyAny,
         state: &mut ValidationState,
     ) -> ValResult<'data, PyObject> {
+        let validator = self.definition.get().unwrap();
         if let Some(id) = obj.identity() {
-            if state.recursion_guard.contains_or_insert(id, self.validator_id) {
+            if state.recursion_guard.contains_or_insert(id, self.definition.id()) {
                 // we don't remove id here, we leave that to the validator which originally added id to `recursion_guard`
                 Err(ValError::new(ErrorTypeDefaults::RecursionLoop, obj))
             } else {
                 if state.recursion_guard.incr_depth() {
                     return Err(ValError::new(ErrorTypeDefaults::RecursionLoop, obj));
                 }
-                let output = validate_assignment(self.validator_id, py, obj, field_name, field_value, state);
-                state.recursion_guard.remove(id, self.validator_id);
+                let output = validator.validate_assignment(py, obj, field_name, field_value, state);
+                state.recursion_guard.remove(id, self.definition.id());
                 state.recursion_guard.decr_depth();
                 output
             }
         } else {
-            validate_assignment(self.validator_id, py, obj, field_name, field_value, state)
+            validator.validate_assignment(py, obj, field_name, field_value, state)
         }
     }
 
-    fn different_strict_behavior(
-        &self,
-        definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
-        if let Some(definitions) = definitions {
-            // have to unwrap here, because we can't return an error from this function, should be okay
-            let validator = definitions.get_definition(self.validator_id).unwrap();
-            validator.different_strict_behavior(None, ultra_strict)
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
+        thread_local! {
+            static RECURSION_SET: RefCell<Option<HashSet<usize>>> = RefCell::new(None);
+        }
+
+        let id = self as *const _ as usize;
+        // have to unwrap here, because we can't return an error from this function, should be okay
+        let validator: &CombinedValidator = self.definition.get().unwrap();
+        if RECURSION_SET.with(
+            |set: &RefCell<Option<std::collections::HashSet<usize, ahash::RandomState>>>| {
+                set.borrow_mut().get_or_insert_with(HashSet::new).insert(id)
+            },
+        ) {
+            let different_strict_behavior = validator.different_strict_behavior(ultra_strict);
+            RECURSION_SET.with(|set| set.borrow_mut().get_or_insert_with(HashSet::new).remove(&id));
+            different_strict_behavior
         } else {
             false
         }
     }
 
     fn get_name(&self) -> &str {
-        &self.inner_name
+        self.definition.get_or_init_name(|v| v.get_name().into())
     }
 
-    /// don't need to call complete on the inner validator here, complete_validators takes care of that.
-    fn complete(&mut self, definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
-        let validator = definitions.get_definition(self.validator_id)?;
-        self.inner_name = validator.get_name().to_string();
+    fn complete(&self) -> PyResult<()> {
         Ok(())
     }
 }
-
-fn validate<'data>(
-    validator_id: usize,
-    py: Python<'data>,
-    input: &'data impl Input<'data>,
-    state: &mut ValidationState,
-) -> ValResult<'data, PyObject> {
-    let validator = state.definitions.get(validator_id).unwrap();
-    validator.validate(py, input, state)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn validate_assignment<'data>(
-    validator_id: usize,
-    py: Python<'data>,
-    obj: &'data PyAny,
-    field_name: &'data str,
-    field_value: &'data PyAny,
-    state: &mut ValidationState,
-) -> ValResult<'data, PyObject> {
-    let validator = state.definitions.get(validator_id).unwrap();
-    validator.validate_assignment(py, obj, field_name, field_value, state)
-}
diff --git a/src/validators/dict.rs b/src/validators/dict.rs
index dc8f03937..250145290 100644
--- a/src/validators/dict.rs
+++ b/src/validators/dict.rs
@@ -16,7 +16,7 @@ use super::any::AnyValidator;
 use super::list::length_check;
 use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct DictValidator {
     strict: bool,
     key_validator: Box<CombinedValidator>,
@@ -92,14 +92,9 @@ impl Validator for DictValidator {
         }
     }
 
-    fn different_strict_behavior(
-        &self,
-        definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
         if ultra_strict {
-            self.key_validator.different_strict_behavior(definitions, true)
-                || self.value_validator.different_strict_behavior(definitions, true)
+            self.key_validator.different_strict_behavior(true) || self.value_validator.different_strict_behavior(true)
         } else {
             true
         }
@@ -109,9 +104,9 @@ impl Validator for DictValidator {
         &self.name
     }
 
-    fn complete(&mut self, definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
-        self.key_validator.complete(definitions)?;
-        self.value_validator.complete(definitions)
+    fn complete(&self) -> PyResult<()> {
+        self.key_validator.complete()?;
+        self.value_validator.complete()
     }
 }
 
diff --git a/src/validators/float.rs b/src/validators/float.rs
index f0eb41750..2e9434d9f 100644
--- a/src/validators/float.rs
+++ b/src/validators/float.rs
@@ -76,11 +76,7 @@ impl Validator for FloatValidator {
         Ok(either_float.into_py(py))
     }
 
-    fn different_strict_behavior(
-        &self,
-        _definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        _ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, _ultra_strict: bool) -> bool {
         true
     }
 
@@ -88,7 +84,7 @@ impl Validator for FloatValidator {
         Self::EXPECTED_TYPE
     }
 
-    fn complete(&mut self, _definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
+    fn complete(&self) -> PyResult<()> {
         Ok(())
     }
 }
@@ -179,11 +175,7 @@ impl Validator for ConstrainedFloatValidator {
         Ok(either_float.into_py(py))
     }
 
-    fn different_strict_behavior(
-        &self,
-        _definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        _ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, _ultra_strict: bool) -> bool {
         true
     }
 
@@ -191,7 +183,7 @@ impl Validator for ConstrainedFloatValidator {
         "constrained-float"
     }
 
-    fn complete(&mut self, _definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
+    fn complete(&self) -> PyResult<()> {
         Ok(())
     }
 }
diff --git a/src/validators/frozenset.rs b/src/validators/frozenset.rs
index ad7708324..4b4cdcb6f 100644
--- a/src/validators/frozenset.rs
+++ b/src/validators/frozenset.rs
@@ -10,7 +10,7 @@ use super::set::set_build;
 use super::validation_state::ValidationState;
 use super::{BuildValidator, CombinedValidator, DefinitionsBuilder, Validator};
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct FrozenSetValidator {
     strict: bool,
     item_validator: Box<CombinedValidator>,
@@ -48,13 +48,9 @@ impl Validator for FrozenSetValidator {
         Ok(f_set.into_py(py))
     }
 
-    fn different_strict_behavior(
-        &self,
-        definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
         if ultra_strict {
-            self.item_validator.different_strict_behavior(definitions, true)
+            self.item_validator.different_strict_behavior(true)
         } else {
             true
         }
@@ -64,7 +60,7 @@ impl Validator for FrozenSetValidator {
         &self.name
     }
 
-    fn complete(&mut self, definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
-        self.item_validator.complete(definitions)
+    fn complete(&self) -> PyResult<()> {
+        self.item_validator.complete()
     }
 }
diff --git a/src/validators/function.rs b/src/validators/function.rs
index be0d6374f..adb143696 100644
--- a/src/validators/function.rs
+++ b/src/validators/function.rs
@@ -1,3 +1,5 @@
+use std::sync::Arc;
+
 use pyo3::exceptions::{PyAssertionError, PyTypeError, PyValueError};
 use pyo3::prelude::*;
 use pyo3::types::{PyAny, PyDict, PyString};
@@ -111,14 +113,9 @@ macro_rules! impl_validator {
                 self._validate(validate, py, obj, state)
             }
 
-            fn different_strict_behavior(
-                &self,
-                definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-                ultra_strict: bool,
-            ) -> bool {
+            fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
                 if ultra_strict {
-                    self.validator
-                        .different_strict_behavior(definitions, ultra_strict)
+                    self.validator.different_strict_behavior(ultra_strict)
                 } else {
                     true
                 }
@@ -128,14 +125,14 @@ macro_rules! impl_validator {
                 &self.name
             }
 
-            fn complete(&mut self, definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
-                self.validator.complete(definitions)
+            fn complete(&self) -> PyResult<()> {
+                self.validator.complete()
             }
         }
     };
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct FunctionBeforeValidator {
     validator: Box<CombinedValidator>,
     func: PyObject,
@@ -168,7 +165,7 @@ impl FunctionBeforeValidator {
 
 impl_validator!(FunctionBeforeValidator);
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct FunctionAfterValidator {
     validator: Box<CombinedValidator>,
     func: PyObject,
@@ -255,11 +252,7 @@ impl Validator for FunctionPlainValidator {
         r.map_err(|e| convert_err(py, e, input))
     }
 
-    fn different_strict_behavior(
-        &self,
-        _definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
         // best guess, should we change this?
         !ultra_strict
     }
@@ -268,14 +261,14 @@ impl Validator for FunctionPlainValidator {
         &self.name
     }
 
-    fn complete(&mut self, _definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
+    fn complete(&self) -> PyResult<()> {
         Ok(())
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct FunctionWrapValidator {
-    validator: Box<CombinedValidator>,
+    validator: Arc<CombinedValidator>,
     func: PyObject,
     config: PyObject,
     name: String,
@@ -299,7 +292,7 @@ impl BuildValidator for FunctionWrapValidator {
         let hide_input_in_errors: bool = config.get_as(intern!(py, "hide_input_in_errors"))?.unwrap_or(false);
         let validation_error_cause: bool = config.get_as(intern!(py, "validation_error_cause"))?.unwrap_or(false);
         Ok(Self {
-            validator: Box::new(validator),
+            validator: Arc::new(validator),
             func: function_info.function.clone(),
             config: match config {
                 Some(c) => c.into(),
@@ -350,7 +343,7 @@ impl Validator for FunctionWrapValidator {
             validator: InternalValidator::new(
                 py,
                 "ValidatorCallable",
-                &self.validator,
+                self.validator.clone(),
                 state,
                 self.hide_input_in_errors,
                 self.validation_error_cause,
@@ -376,7 +369,7 @@ impl Validator for FunctionWrapValidator {
             validator: InternalValidator::new(
                 py,
                 "AssignmentValidatorCallable",
-                &self.validator,
+                self.validator.clone(),
                 state,
                 self.hide_input_in_errors,
                 self.validation_error_cause,
@@ -387,13 +380,9 @@ impl Validator for FunctionWrapValidator {
         self._validate(Py::new(py, handler)?.into_ref(py), py, obj, state)
     }
 
-    fn different_strict_behavior(
-        &self,
-        definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
         if ultra_strict {
-            self.validator.different_strict_behavior(definitions, ultra_strict)
+            self.validator.different_strict_behavior(ultra_strict)
         } else {
             true
         }
@@ -403,13 +392,13 @@ impl Validator for FunctionWrapValidator {
         &self.name
     }
 
-    fn complete(&mut self, definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
-        self.validator.complete(definitions)
+    fn complete(&self) -> PyResult<()> {
+        self.validator.complete()
     }
 }
 
 #[pyclass(module = "pydantic_core._pydantic_core")]
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 struct ValidatorCallable {
     validator: InternalValidator,
 }
@@ -441,7 +430,7 @@ impl ValidatorCallable {
 }
 
 #[pyclass(module = "pydantic_core._pydantic_core")]
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 struct AssignmentValidatorCallable {
     updated_field_name: String,
     updated_field_value: Py<PyAny>,
diff --git a/src/validators/generator.rs b/src/validators/generator.rs
index 0cff7e28e..111b5c101 100644
--- a/src/validators/generator.rs
+++ b/src/validators/generator.rs
@@ -1,4 +1,5 @@
 use std::fmt;
+use std::sync::Arc;
 
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
@@ -14,7 +15,7 @@ use super::{BuildValidator, CombinedValidator, DefinitionsBuilder, Extra, InputT
 
 #[derive(Debug, Clone)]
 pub struct GeneratorValidator {
-    item_validator: Option<Box<CombinedValidator>>,
+    item_validator: Option<Arc<CombinedValidator>>,
     min_length: Option<usize>,
     max_length: Option<usize>,
     name: String,
@@ -30,7 +31,7 @@ impl BuildValidator for GeneratorValidator {
         config: Option<&PyDict>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
-        let item_validator = get_items_schema(schema, config, definitions)?;
+        let item_validator = get_items_schema(schema, config, definitions)?.map(Arc::new);
         let name = match item_validator {
             Some(ref v) => format!("{}[{}]", Self::EXPECTED_TYPE, v.get_name()),
             None => format!("{}[any]", Self::EXPECTED_TYPE),
@@ -67,7 +68,7 @@ impl Validator for GeneratorValidator {
             InternalValidator::new(
                 py,
                 "ValidatorIterator",
-                v,
+                v.clone(),
                 state,
                 self.hide_input_in_errors,
                 self.validation_error_cause,
@@ -85,13 +86,9 @@ impl Validator for GeneratorValidator {
         Ok(v_iterator.into_py(py))
     }
 
-    fn different_strict_behavior(
-        &self,
-        definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
         if let Some(ref v) = self.item_validator {
-            v.different_strict_behavior(definitions, ultra_strict)
+            v.different_strict_behavior(ultra_strict)
         } else {
             false
         }
@@ -101,16 +98,16 @@ impl Validator for GeneratorValidator {
         &self.name
     }
 
-    fn complete(&mut self, definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
-        match self.item_validator {
-            Some(ref mut v) => v.complete(definitions),
+    fn complete(&self) -> PyResult<()> {
+        match &self.item_validator {
+            Some(v) => v.complete(),
             None => Ok(()),
         }
     }
 }
 
 #[pyclass(module = "pydantic_core._pydantic_core")]
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 struct ValidatorIterator {
     iterator: GenericIterator,
     validator: Option<InternalValidator>,
@@ -217,13 +214,11 @@ impl ValidatorIterator {
     }
 }
 
-/// Cloneable validator wrapper for use in generators in functions, this can be passed back to python
+/// Owned validator wrapper for use in generators in functions, this can be passed back to python
 /// mid-validation
-#[derive(Clone)]
 pub struct InternalValidator {
     name: String,
-    validator: CombinedValidator,
-    definitions: Vec<CombinedValidator>,
+    validator: Arc<CombinedValidator>,
     // TODO, do we need data?
     data: Option<Py<PyDict>>,
     strict: Option<bool>,
@@ -246,7 +241,7 @@ impl InternalValidator {
     pub fn new(
         py: Python,
         name: &str,
-        validator: &CombinedValidator,
+        validator: Arc<CombinedValidator>,
         state: &ValidationState,
         hide_input_in_errors: bool,
         validation_error_cause: bool,
@@ -254,8 +249,7 @@ impl InternalValidator {
         let extra = state.extra();
         Self {
             name: name.to_string(),
-            validator: validator.clone(),
-            definitions: state.definitions.to_vec(),
+            validator,
             data: extra.data.map(|d| d.into_py(py)),
             strict: extra.strict,
             from_attributes: extra.from_attributes,
@@ -285,7 +279,7 @@ impl InternalValidator {
             context: self.context.as_ref().map(|data| data.as_ref(py)),
             self_instance: self.self_instance.as_ref().map(|data| data.as_ref(py)),
         };
-        let mut state = ValidationState::new(extra, &self.definitions, &mut self.recursion_guard);
+        let mut state = ValidationState::new(extra, &mut self.recursion_guard);
         self.validator
             .validate_assignment(py, model, field_name, field_value, &mut state)
             .map_err(|e| {
@@ -316,7 +310,7 @@ impl InternalValidator {
             context: self.context.as_ref().map(|data| data.as_ref(py)),
             self_instance: self.self_instance.as_ref().map(|data| data.as_ref(py)),
         };
-        let mut state = ValidationState::new(extra, &self.definitions, &mut self.recursion_guard);
+        let mut state = ValidationState::new(extra, &mut self.recursion_guard);
         self.validator.validate(py, input, &mut state).map_err(|e| {
             ValidationError::from_val_error(
                 py,
@@ -333,7 +327,6 @@ impl InternalValidator {
 
 impl_py_gc_traverse!(InternalValidator {
     validator,
-    definitions,
     data,
     context,
     self_instance
diff --git a/src/validators/int.rs b/src/validators/int.rs
index 3fba2199d..0903e1998 100644
--- a/src/validators/int.rs
+++ b/src/validators/int.rs
@@ -54,11 +54,7 @@ impl Validator for IntValidator {
         Ok(either_int.into_py(py))
     }
 
-    fn different_strict_behavior(
-        &self,
-        _definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
         !ultra_strict
     }
 
@@ -66,7 +62,7 @@ impl Validator for IntValidator {
         Self::EXPECTED_TYPE
     }
 
-    fn complete(&mut self, _definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
+    fn complete(&self) -> PyResult<()> {
         Ok(())
     }
 }
@@ -151,11 +147,7 @@ impl Validator for ConstrainedIntValidator {
         Ok(either_int.into_py(py))
     }
 
-    fn different_strict_behavior(
-        &self,
-        _definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
         !ultra_strict
     }
 
@@ -163,7 +155,7 @@ impl Validator for ConstrainedIntValidator {
         "constrained-int"
     }
 
-    fn complete(&mut self, _definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
+    fn complete(&self) -> PyResult<()> {
         Ok(())
     }
 }
diff --git a/src/validators/is_instance.rs b/src/validators/is_instance.rs
index 78705482c..e64d0717c 100644
--- a/src/validators/is_instance.rs
+++ b/src/validators/is_instance.rs
@@ -83,11 +83,7 @@ impl Validator for IsInstanceValidator {
         }
     }
 
-    fn different_strict_behavior(
-        &self,
-        _definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        _ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, _ultra_strict: bool) -> bool {
         false
     }
 
@@ -95,7 +91,7 @@ impl Validator for IsInstanceValidator {
         &self.name
     }
 
-    fn complete(&mut self, _definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
+    fn complete(&self) -> PyResult<()> {
         Ok(())
     }
 }
diff --git a/src/validators/is_subclass.rs b/src/validators/is_subclass.rs
index d0f5a6cfe..0866fa1e7 100644
--- a/src/validators/is_subclass.rs
+++ b/src/validators/is_subclass.rs
@@ -62,11 +62,7 @@ impl Validator for IsSubclassValidator {
         }
     }
 
-    fn different_strict_behavior(
-        &self,
-        _definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        _ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, _ultra_strict: bool) -> bool {
         false
     }
 
@@ -74,7 +70,7 @@ impl Validator for IsSubclassValidator {
         &self.name
     }
 
-    fn complete(&mut self, _definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
+    fn complete(&self) -> PyResult<()> {
         Ok(())
     }
 }
diff --git a/src/validators/json.rs b/src/validators/json.rs
index 5eda007be..fd832f874 100644
--- a/src/validators/json.rs
+++ b/src/validators/json.rs
@@ -9,7 +9,7 @@ use crate::tools::SchemaDict;
 use super::ValidationState;
 use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, Validator};
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct JsonValidator {
     validator: Option<Box<CombinedValidator>>,
     name: String,
@@ -61,13 +61,9 @@ impl Validator for JsonValidator {
         }
     }
 
-    fn different_strict_behavior(
-        &self,
-        definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
         if let Some(ref v) = self.validator {
-            v.different_strict_behavior(definitions, ultra_strict)
+            v.different_strict_behavior(ultra_strict)
         } else {
             false
         }
@@ -77,9 +73,9 @@ impl Validator for JsonValidator {
         &self.name
     }
 
-    fn complete(&mut self, definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
-        match self.validator {
-            Some(ref mut v) => v.complete(definitions),
+    fn complete(&self) -> PyResult<()> {
+        match &self.validator {
+            Some(v) => v.complete(),
             None => Ok(()),
         }
     }
diff --git a/src/validators/json_or_python.rs b/src/validators/json_or_python.rs
index 828532fe5..cd952bed1 100644
--- a/src/validators/json_or_python.rs
+++ b/src/validators/json_or_python.rs
@@ -11,7 +11,7 @@ use super::InputType;
 use super::ValidationState;
 use super::{build_validator, BuildValidator, CombinedValidator, Validator};
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct JsonOrPython {
     json: Box<CombinedValidator>,
     python: Box<CombinedValidator>,
@@ -63,21 +63,16 @@ impl Validator for JsonOrPython {
         }
     }
 
-    fn different_strict_behavior(
-        &self,
-        definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
-        self.json.different_strict_behavior(definitions, ultra_strict)
-            || self.python.different_strict_behavior(definitions, ultra_strict)
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
+        self.json.different_strict_behavior(ultra_strict) || self.python.different_strict_behavior(ultra_strict)
     }
 
     fn get_name(&self) -> &str {
         &self.name
     }
 
-    fn complete(&mut self, definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
-        self.json.complete(definitions)?;
-        self.python.complete(definitions)
+    fn complete(&self) -> PyResult<()> {
+        self.json.complete()?;
+        self.python.complete()
     }
 }
diff --git a/src/validators/lax_or_strict.rs b/src/validators/lax_or_strict.rs
index 9681cf689..b5cec61be 100644
--- a/src/validators/lax_or_strict.rs
+++ b/src/validators/lax_or_strict.rs
@@ -10,7 +10,7 @@ use crate::tools::SchemaDict;
 use super::ValidationState;
 use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, Validator};
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct LaxOrStrictValidator {
     strict: bool,
     lax_validator: Box<CombinedValidator>,
@@ -68,13 +68,9 @@ impl Validator for LaxOrStrictValidator {
         }
     }
 
-    fn different_strict_behavior(
-        &self,
-        definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
         if ultra_strict {
-            self.strict_validator.different_strict_behavior(definitions, true)
+            self.strict_validator.different_strict_behavior(true)
         } else {
             true
         }
@@ -84,8 +80,8 @@ impl Validator for LaxOrStrictValidator {
         &self.name
     }
 
-    fn complete(&mut self, definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
-        self.lax_validator.complete(definitions)?;
-        self.strict_validator.complete(definitions)
+    fn complete(&self) -> PyResult<()> {
+        self.lax_validator.complete()?;
+        self.strict_validator.complete()
     }
 }
diff --git a/src/validators/list.rs b/src/validators/list.rs
index ffd7a118e..8e931657f 100644
--- a/src/validators/list.rs
+++ b/src/validators/list.rs
@@ -1,3 +1,5 @@
+use std::sync::OnceLock;
+
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
 
@@ -7,26 +9,26 @@ use crate::tools::SchemaDict;
 
 use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct ListValidator {
     strict: bool,
     item_validator: Option<Box<CombinedValidator>>,
     min_length: Option<usize>,
     max_length: Option<usize>,
-    name: String,
+    name: OnceLock<String>,
 }
 
 pub fn get_items_schema(
     schema: &PyDict,
     config: Option<&PyDict>,
     definitions: &mut DefinitionsBuilder<CombinedValidator>,
-) -> PyResult<Option<Box<CombinedValidator>>> {
+) -> PyResult<Option<CombinedValidator>> {
     match schema.get_item(pyo3::intern!(schema.py(), "items_schema")) {
         Some(d) => {
             let validator = build_validator(d, config, definitions)?;
             match validator {
                 CombinedValidator::Any(_) => Ok(None),
-                _ => Ok(Some(Box::new(validator))),
+                _ => Ok(Some(validator)),
             }
         }
         None => Ok(None),
@@ -98,15 +100,13 @@ impl BuildValidator for ListValidator {
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
-        let item_validator = get_items_schema(schema, config, definitions)?;
-        let inner_name = item_validator.as_ref().map_or("any", |v| v.get_name());
-        let name = format!("{}[{inner_name}]", Self::EXPECTED_TYPE);
+        let item_validator = get_items_schema(schema, config, definitions)?.map(Box::new);
         Ok(Self {
             strict: crate::build_tools::is_strict(schema, config)?,
             item_validator,
             min_length: schema.get_as(pyo3::intern!(py, "min_length"))?,
             max_length: schema.get_as(pyo3::intern!(py, "max_length"))?,
-            name,
+            name: OnceLock::new(),
         }
         .into())
     }
@@ -138,14 +138,10 @@ impl Validator for ListValidator {
         Ok(output.into_py(py))
     }
 
-    fn different_strict_behavior(
-        &self,
-        definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
         if ultra_strict {
             match self.item_validator {
-                Some(ref v) => v.different_strict_behavior(definitions, true),
+                Some(ref v) => v.different_strict_behavior(true),
                 None => false,
             }
         } else {
@@ -154,14 +150,27 @@ impl Validator for ListValidator {
     }
 
     fn get_name(&self) -> &str {
-        &self.name
+        // The logic here is a little janky, it's done to try to cache the formatted name
+        // while also trying to render definitions correctly when possible.
+        //
+        // Probably an opportunity for a future refactor
+        match self.name.get() {
+            Some(s) => s.as_str(),
+            None => {
+                let name = self.item_validator.as_ref().map_or("any", |v| v.get_name());
+                if name == "..." {
+                    // when inner name is not initialized yet, don't cache it here
+                    "list[...]"
+                } else {
+                    self.name.get_or_init(|| format!("list[{name}]")).as_str()
+                }
+            }
+        }
     }
 
-    fn complete(&mut self, definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
-        if let Some(ref mut v) = self.item_validator {
-            v.complete(definitions)?;
-            let inner_name = v.get_name();
-            self.name = format!("{}[{inner_name}]", Self::EXPECTED_TYPE);
+    fn complete(&self) -> PyResult<()> {
+        if let Some(v) = &self.item_validator {
+            v.complete()?;
         }
         Ok(())
     }
diff --git a/src/validators/literal.rs b/src/validators/literal.rs
index de394affb..25cb94bd9 100644
--- a/src/validators/literal.rs
+++ b/src/validators/literal.rs
@@ -22,7 +22,7 @@ struct BoolLiteral {
 }
 
 #[derive(Debug, Clone)]
-pub struct LiteralLookup<T: Clone + Debug> {
+pub struct LiteralLookup<T: Debug> {
     // Specialized lookups for ints, bools and strings because they
     // (1) are easy to convert between Rust and Python
     // (2) hashing them in Rust is very fast
@@ -35,7 +35,7 @@ pub struct LiteralLookup<T: Clone + Debug> {
     pub values: Vec<T>,
 }
 
-impl<T: Clone + Debug> LiteralLookup<T> {
+impl<T: Debug> LiteralLookup<T> {
     pub fn new<'py>(py: Python<'py>, expected: impl Iterator<Item = (&'py PyAny, T)>) -> PyResult<Self> {
         let mut expected_int = AHashMap::new();
         let mut expected_str: AHashMap<String, usize> = AHashMap::new();
@@ -135,7 +135,7 @@ impl<T: Clone + Debug> LiteralLookup<T> {
     }
 }
 
-impl<T: PyGcTraverse + Clone + Debug> PyGcTraverse for LiteralLookup<T> {
+impl<T: PyGcTraverse + Debug> PyGcTraverse for LiteralLookup<T> {
     fn py_gc_traverse(&self, visit: &PyVisit<'_>) -> Result<(), PyTraverseError> {
         self.expected_py.py_gc_traverse(visit)?;
         self.values.py_gc_traverse(visit)?;
@@ -198,11 +198,7 @@ impl Validator for LiteralValidator {
         }
     }
 
-    fn different_strict_behavior(
-        &self,
-        _definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
         !ultra_strict
     }
 
@@ -210,7 +206,7 @@ impl Validator for LiteralValidator {
         &self.name
     }
 
-    fn complete(&mut self, _definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
+    fn complete(&self) -> PyResult<()> {
         Ok(())
     }
 }
diff --git a/src/validators/mod.rs b/src/validators/mod.rs
index 4ee677663..42aad2001 100644
--- a/src/validators/mod.rs
+++ b/src/validators/mod.rs
@@ -9,7 +9,7 @@ use pyo3::types::{PyAny, PyDict, PyTuple, PyType};
 use pyo3::{intern, PyTraverseError, PyVisit};
 
 use crate::build_tools::{py_schema_err, py_schema_error_type, SchemaError};
-use crate::definitions::DefinitionsBuilder;
+use crate::definitions::{Definitions, DefinitionsBuilder};
 use crate::errors::{LocItem, ValError, ValResult, ValidationError};
 use crate::input::{Input, InputType, StringMapping};
 use crate::py_gc::PyGcTraverse;
@@ -98,10 +98,10 @@ impl PySome {
 }
 
 #[pyclass(module = "pydantic_core._pydantic_core")]
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct SchemaValidator {
     validator: CombinedValidator,
-    definitions: Vec<CombinedValidator>,
+    definitions: Definitions<CombinedValidator>,
     schema: PyObject,
     #[pyo3(get)]
     title: PyObject,
@@ -115,11 +115,11 @@ impl SchemaValidator {
     pub fn py_new(py: Python, schema: &PyAny, config: Option<&PyDict>) -> PyResult<Self> {
         let mut definitions_builder = DefinitionsBuilder::new();
 
-        let mut validator = build_validator(schema, config, &mut definitions_builder)?;
-        validator.complete(&definitions_builder)?;
-        let mut definitions = definitions_builder.clone().finish()?;
-        for val in &mut definitions {
-            val.complete(&definitions_builder)?;
+        let validator = build_validator(schema, config, &mut definitions_builder)?;
+        let definitions = definitions_builder.finish()?;
+        validator.complete()?;
+        for val in definitions.values() {
+            val.get().unwrap().complete()?;
         }
         let config_title = match config {
             Some(c) => c.get_item("title"),
@@ -141,9 +141,10 @@ impl SchemaValidator {
         })
     }
 
-    pub fn __reduce__(&self, py: Python) -> PyResult<PyObject> {
-        let args = (self.schema.as_ref(py),);
-        let cls = Py::new(py, self.clone())?.getattr(py, "__class__")?;
+    pub fn __reduce__(slf: &PyCell<Self>) -> PyResult<PyObject> {
+        let py = slf.py();
+        let args = (slf.try_borrow()?.schema.to_object(py),);
+        let cls = slf.getattr("__class__")?;
         Ok((cls, args).into_py(py))
     }
 
@@ -266,7 +267,7 @@ impl SchemaValidator {
         };
 
         let guard = &mut RecursionGuard::default();
-        let mut state = ValidationState::new(extra, &self.definitions, guard);
+        let mut state = ValidationState::new(extra, guard);
         self.validator
             .validate_assignment(py, obj, field_name, field_value, &mut state)
             .map_err(|e| self.prepare_validation_err(py, e, InputType::Python))
@@ -284,7 +285,7 @@ impl SchemaValidator {
             self_instance: None,
         };
         let recursion_guard = &mut RecursionGuard::default();
-        let mut state = ValidationState::new(extra, &self.definitions, recursion_guard);
+        let mut state = ValidationState::new(extra, recursion_guard);
         let r = self.validator.default_value(py, None::<i64>, &mut state);
         match r {
             Ok(maybe_default) => match maybe_default {
@@ -307,9 +308,6 @@ impl SchemaValidator {
     fn __traverse__(&self, visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
         self.validator.py_gc_traverse(&visit)?;
         visit.call(&self.schema)?;
-        for slot in &self.definitions {
-            slot.py_gc_traverse(&visit)?;
-        }
         Ok(())
     }
 }
@@ -332,7 +330,6 @@ impl SchemaValidator {
     {
         let mut state = ValidationState::new(
             Extra::new(strict, from_attributes, context, self_instance, input_type),
-            &self.definitions,
             recursion_guard,
         );
         self.validator.validate(py, input, &mut state)
@@ -371,7 +368,6 @@ impl<'py> SelfValidator<'py> {
         let mut recursion_guard = RecursionGuard::default();
         let mut state = ValidationState::new(
             Extra::new(strict, None, None, None, InputType::Python),
-            &self.validator.definitions,
             &mut recursion_guard,
         );
         match self.validator.validator.validate(py, schema, &mut state) {
@@ -388,14 +384,14 @@ impl<'py> SelfValidator<'py> {
 
         let mut definitions_builder = DefinitionsBuilder::new();
 
-        let mut validator = match build_validator(self_schema, None, &mut definitions_builder) {
+        let validator = match build_validator(self_schema, None, &mut definitions_builder) {
             Ok(v) => v,
             Err(err) => return py_schema_err!("Error building self-schema:\n  {}", err),
         };
-        validator.complete(&definitions_builder)?;
-        let mut definitions = definitions_builder.clone().finish()?;
-        for val in &mut definitions {
-            val.complete(&definitions_builder)?;
+        let definitions = definitions_builder.finish()?;
+        validator.complete()?;
+        for val in definitions.values() {
+            val.get().unwrap().complete()?;
         }
         Ok(SchemaValidator {
             validator,
@@ -603,7 +599,7 @@ impl<'a> Extra<'a> {
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 #[enum_dispatch(PyGcTraverse)]
 pub enum CombinedValidator {
     // typed dict e.g. heterogeneous dicts or simply a model
@@ -699,7 +695,7 @@ pub enum CombinedValidator {
 /// This trait must be implemented by all validators, it allows various validators to be accessed consistently,
 /// validators defined in `build_validator` also need `EXPECTED_TYPE` as a const, but that can't be part of the trait
 #[enum_dispatch(CombinedValidator)]
-pub trait Validator: Send + Sync + Clone + Debug {
+pub trait Validator: Send + Sync + Debug {
     /// Do the actual validation for this schema/type
     fn validate<'data>(
         &self,
@@ -734,17 +730,13 @@ pub trait Validator: Send + Sync + Clone + Debug {
 
     /// whether the validator behaves differently in strict mode, and in ultra strict mode
     /// implementations should return true if any of their sub-validators return true
-    fn different_strict_behavior(
-        &self,
-        definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool;
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool;
 
     /// `get_name` generally returns `Self::EXPECTED_TYPE` or some other clear identifier of the validator
     /// this is used in the error location in unions, and in the top level message in `ValidationError`
     fn get_name(&self) -> &str;
 
     /// this method must be implemented for any validator which holds references to other validators,
-    /// it is used by `DefinitionRefValidator` to set its name
-    fn complete(&mut self, _definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()>;
+    /// it is used by `UnionValidator` to calculate strictness
+    fn complete(&self) -> PyResult<()>;
 }
diff --git a/src/validators/model.rs b/src/validators/model.rs
index 2ec7185a9..1459f56f5 100644
--- a/src/validators/model.rs
+++ b/src/validators/model.rs
@@ -50,7 +50,7 @@ impl Revalidate {
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct ModelValidator {
     revalidate: Revalidate,
     validator: Box<CombinedValidator>,
@@ -206,13 +206,9 @@ impl Validator for ModelValidator {
         Ok(model.into_py(py))
     }
 
-    fn different_strict_behavior(
-        &self,
-        definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
         if ultra_strict {
-            self.validator.different_strict_behavior(definitions, ultra_strict)
+            self.validator.different_strict_behavior(ultra_strict)
         } else {
             true
         }
@@ -222,8 +218,8 @@ impl Validator for ModelValidator {
         &self.name
     }
 
-    fn complete(&mut self, definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
-        self.validator.complete(definitions)
+    fn complete(&self) -> PyResult<()> {
+        self.validator.complete()
     }
 }
 
diff --git a/src/validators/model_fields.rs b/src/validators/model_fields.rs
index f2654c33e..30d937cb8 100644
--- a/src/validators/model_fields.rs
+++ b/src/validators/model_fields.rs
@@ -20,7 +20,7 @@ use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuild
 
 use std::ops::ControlFlow;
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 struct Field {
     name: String,
     lookup_key: LookupKey,
@@ -31,7 +31,7 @@ struct Field {
 
 impl_py_gc_traverse!(Field { validator });
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct ModelFieldsValidator {
     fields: Vec<Field>,
     model_name: String,
@@ -415,26 +415,20 @@ impl Validator for ModelFieldsValidator {
         Ok((new_data.to_object(py), new_extra, fields_set.to_object(py)).to_object(py))
     }
 
-    fn different_strict_behavior(
-        &self,
-        definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
         self.fields
             .iter()
-            .any(|f| f.validator.different_strict_behavior(definitions, ultra_strict))
+            .any(|f| f.validator.different_strict_behavior(ultra_strict))
     }
 
     fn get_name(&self) -> &str {
         Self::EXPECTED_TYPE
     }
 
-    fn complete(&mut self, definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
-        self.fields
-            .iter_mut()
-            .try_for_each(|f| f.validator.complete(definitions))?;
-        match &mut self.extras_validator {
-            Some(v) => v.complete(definitions),
+    fn complete(&self) -> PyResult<()> {
+        self.fields.iter().try_for_each(|f| f.validator.complete())?;
+        match &self.extras_validator {
+            Some(v) => v.complete(),
             None => Ok(()),
         }
     }
diff --git a/src/validators/none.rs b/src/validators/none.rs
index 36be70acb..f241be9d8 100644
--- a/src/validators/none.rs
+++ b/src/validators/none.rs
@@ -36,11 +36,7 @@ impl Validator for NoneValidator {
         }
     }
 
-    fn different_strict_behavior(
-        &self,
-        _definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        _ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, _ultra_strict: bool) -> bool {
         false
     }
 
@@ -48,7 +44,7 @@ impl Validator for NoneValidator {
         Self::EXPECTED_TYPE
     }
 
-    fn complete(&mut self, _definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
+    fn complete(&self) -> PyResult<()> {
         Ok(())
     }
 }
diff --git a/src/validators/nullable.rs b/src/validators/nullable.rs
index 4b408f206..7f4cf19fc 100644
--- a/src/validators/nullable.rs
+++ b/src/validators/nullable.rs
@@ -9,7 +9,7 @@ use crate::tools::SchemaDict;
 use super::ValidationState;
 use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, Validator};
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct NullableValidator {
     validator: Box<CombinedValidator>,
     name: String,
@@ -45,19 +45,15 @@ impl Validator for NullableValidator {
         }
     }
 
-    fn different_strict_behavior(
-        &self,
-        definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
-        self.validator.different_strict_behavior(definitions, ultra_strict)
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
+        self.validator.different_strict_behavior(ultra_strict)
     }
 
     fn get_name(&self) -> &str {
         &self.name
     }
 
-    fn complete(&mut self, definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
-        self.validator.complete(definitions)
+    fn complete(&self) -> PyResult<()> {
+        self.validator.complete()
     }
 }
diff --git a/src/validators/set.rs b/src/validators/set.rs
index e5e2cecf3..626572139 100644
--- a/src/validators/set.rs
+++ b/src/validators/set.rs
@@ -8,7 +8,7 @@ use crate::tools::SchemaDict;
 use super::list::min_length_check;
 use super::{BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct SetValidator {
     strict: bool,
     item_validator: Box<CombinedValidator>,
@@ -70,13 +70,9 @@ impl Validator for SetValidator {
         Ok(set.into_py(py))
     }
 
-    fn different_strict_behavior(
-        &self,
-        definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
         if ultra_strict {
-            self.item_validator.different_strict_behavior(definitions, true)
+            self.item_validator.different_strict_behavior(true)
         } else {
             true
         }
@@ -86,7 +82,7 @@ impl Validator for SetValidator {
         &self.name
     }
 
-    fn complete(&mut self, definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
-        self.item_validator.complete(definitions)
+    fn complete(&self) -> PyResult<()> {
+        self.item_validator.complete()
     }
 }
diff --git a/src/validators/string.rs b/src/validators/string.rs
index 6b646224d..4eab4602a 100644
--- a/src/validators/string.rs
+++ b/src/validators/string.rs
@@ -10,7 +10,7 @@ use crate::tools::SchemaDict;
 
 use super::{BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct StrValidator {
     strict: bool,
     coerce_numbers_to_str: bool,
@@ -51,11 +51,7 @@ impl Validator for StrValidator {
         Ok(either_str.into_py(py))
     }
 
-    fn different_strict_behavior(
-        &self,
-        _definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
         !ultra_strict
     }
 
@@ -63,7 +59,7 @@ impl Validator for StrValidator {
         Self::EXPECTED_TYPE
     }
 
-    fn complete(&mut self, _definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
+    fn complete(&self) -> PyResult<()> {
         Ok(())
     }
 }
@@ -150,11 +146,7 @@ impl Validator for StrConstrainedValidator {
         Ok(py_string.into_py(py))
     }
 
-    fn different_strict_behavior(
-        &self,
-        _definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
         !ultra_strict
     }
 
@@ -162,7 +154,7 @@ impl Validator for StrConstrainedValidator {
         "constrained-str"
     }
 
-    fn complete(&mut self, _definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
+    fn complete(&self) -> PyResult<()> {
         Ok(())
     }
 }
diff --git a/src/validators/time.rs b/src/validators/time.rs
index 7bbd7e511..f5e2be7c7 100644
--- a/src/validators/time.rs
+++ b/src/validators/time.rs
@@ -78,11 +78,7 @@ impl Validator for TimeValidator {
         Ok(time.try_into_py(py)?)
     }
 
-    fn different_strict_behavior(
-        &self,
-        _definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
         !ultra_strict
     }
 
@@ -90,7 +86,7 @@ impl Validator for TimeValidator {
         Self::EXPECTED_TYPE
     }
 
-    fn complete(&mut self, _definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
+    fn complete(&self) -> PyResult<()> {
         Ok(())
     }
 }
diff --git a/src/validators/timedelta.rs b/src/validators/timedelta.rs
index 106d5a64a..21340f2f0 100644
--- a/src/validators/timedelta.rs
+++ b/src/validators/timedelta.rs
@@ -101,11 +101,7 @@ impl Validator for TimeDeltaValidator {
         Ok(py_timedelta.into())
     }
 
-    fn different_strict_behavior(
-        &self,
-        _definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
         !ultra_strict
     }
 
@@ -113,7 +109,7 @@ impl Validator for TimeDeltaValidator {
         Self::EXPECTED_TYPE
     }
 
-    fn complete(&mut self, _definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
+    fn complete(&self) -> PyResult<()> {
         Ok(())
     }
 }
diff --git a/src/validators/tuple.rs b/src/validators/tuple.rs
index 5c2c09bec..cfa239e3b 100644
--- a/src/validators/tuple.rs
+++ b/src/validators/tuple.rs
@@ -10,7 +10,7 @@ use crate::tools::SchemaDict;
 use super::list::{get_items_schema, min_length_check};
 use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct TupleVariableValidator {
     strict: bool,
     item_validator: Option<Box<CombinedValidator>>,
@@ -27,7 +27,7 @@ impl BuildValidator for TupleVariableValidator {
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
-        let item_validator = get_items_schema(schema, config, definitions)?;
+        let item_validator = get_items_schema(schema, config, definitions)?.map(Box::new);
         let inner_name = item_validator.as_ref().map_or("any", |v| v.get_name());
         let name = format!("tuple[{inner_name}, ...]");
         Ok(Self {
@@ -60,14 +60,10 @@ impl Validator for TupleVariableValidator {
         Ok(PyTuple::new(py, &output).into_py(py))
     }
 
-    fn different_strict_behavior(
-        &self,
-        definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
         if ultra_strict {
             match self.item_validator {
-                Some(ref v) => v.different_strict_behavior(definitions, true),
+                Some(ref v) => v.different_strict_behavior(true),
                 None => false,
             }
         } else {
@@ -79,15 +75,15 @@ impl Validator for TupleVariableValidator {
         &self.name
     }
 
-    fn complete(&mut self, definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
-        match self.item_validator {
-            Some(ref mut v) => v.complete(definitions),
+    fn complete(&self) -> PyResult<()> {
+        match &self.item_validator {
+            Some(v) => v.complete(),
             None => Ok(()),
         }
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct TuplePositionalValidator {
     strict: bool,
     items_validators: Vec<CombinedValidator>,
@@ -242,20 +238,12 @@ impl Validator for TuplePositionalValidator {
         }
     }
 
-    fn different_strict_behavior(
-        &self,
-        definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
         if ultra_strict {
-            if self
-                .items_validators
-                .iter()
-                .any(|v| v.different_strict_behavior(definitions, true))
-            {
+            if self.items_validators.iter().any(|v| v.different_strict_behavior(true)) {
                 true
             } else if let Some(ref v) = self.extras_validator {
-                v.different_strict_behavior(definitions, true)
+                v.different_strict_behavior(true)
             } else {
                 false
             }
@@ -268,12 +256,10 @@ impl Validator for TuplePositionalValidator {
         &self.name
     }
 
-    fn complete(&mut self, definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
-        self.items_validators
-            .iter_mut()
-            .try_for_each(|v| v.complete(definitions))?;
-        match &mut self.extras_validator {
-            Some(v) => v.complete(definitions),
+    fn complete(&self) -> PyResult<()> {
+        self.items_validators.iter().try_for_each(CombinedValidator::complete)?;
+        match &self.extras_validator {
+            Some(v) => v.complete(),
             None => Ok(()),
         }
     }
diff --git a/src/validators/typed_dict.rs b/src/validators/typed_dict.rs
index 56e4a8225..1a5b52dc6 100644
--- a/src/validators/typed_dict.rs
+++ b/src/validators/typed_dict.rs
@@ -20,7 +20,7 @@ use super::{
     build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, Extra, ValidationState, Validator,
 };
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 struct TypedDictField {
     name: String,
     lookup_key: LookupKey,
@@ -31,7 +31,7 @@ struct TypedDictField {
 
 impl_py_gc_traverse!(TypedDictField { validator });
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct TypedDictValidator {
     fields: Vec<TypedDictField>,
     extra_behavior: ExtraBehavior,
@@ -307,26 +307,20 @@ impl Validator for TypedDictValidator {
         }
     }
 
-    fn different_strict_behavior(
-        &self,
-        definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
         self.fields
             .iter()
-            .any(|f| f.validator.different_strict_behavior(definitions, ultra_strict))
+            .any(|f| f.validator.different_strict_behavior(ultra_strict))
     }
 
     fn get_name(&self) -> &str {
         Self::EXPECTED_TYPE
     }
 
-    fn complete(&mut self, definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
-        self.fields
-            .iter_mut()
-            .try_for_each(|f| f.validator.complete(definitions))?;
-        match &mut self.extras_validator {
-            Some(v) => v.complete(definitions),
+    fn complete(&self) -> PyResult<()> {
+        self.fields.iter().try_for_each(|f| f.validator.complete())?;
+        match &self.extras_validator {
+            Some(v) => v.complete(),
             None => Ok(()),
         }
     }
diff --git a/src/validators/union.rs b/src/validators/union.rs
index 4d3b0bd78..79a21e78d 100644
--- a/src/validators/union.rs
+++ b/src/validators/union.rs
@@ -1,5 +1,6 @@
 use std::fmt::Write;
 use std::str::FromStr;
+use std::sync::atomic::{AtomicBool, Ordering};
 
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList, PyString, PyTuple};
@@ -18,11 +19,11 @@ use super::custom_error::CustomError;
 use super::literal::LiteralLookup;
 use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
 
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug)]
 enum UnionMode {
     Smart {
-        strict_required: bool,
-        ultra_strict_required: bool,
+        strict_required: AtomicBool,
+        ultra_strict_required: AtomicBool,
     },
     LeftToRight,
 }
@@ -31,8 +32,23 @@ impl UnionMode {
     // construct smart with some default values
     const fn default_smart() -> Self {
         Self::Smart {
-            strict_required: true,
-            ultra_strict_required: false,
+            strict_required: AtomicBool::new(true),
+            ultra_strict_required: AtomicBool::new(false),
+        }
+    }
+}
+
+impl Clone for UnionMode {
+    fn clone(&self) -> Self {
+        match self {
+            Self::Smart {
+                strict_required,
+                ultra_strict_required,
+            } => Self::Smart {
+                strict_required: AtomicBool::new(strict_required.load(Ordering::SeqCst)),
+                ultra_strict_required: AtomicBool::new(ultra_strict_required.load(Ordering::SeqCst)),
+            },
+            Self::LeftToRight => Self::LeftToRight,
         }
     }
 }
@@ -49,7 +65,7 @@ impl FromStr for UnionMode {
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct UnionValidator {
     mode: UnionMode,
     choices: Vec<(CombinedValidator, Option<String>)>,
@@ -216,44 +232,46 @@ impl Validator for UnionValidator {
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
     ) -> ValResult<'data, PyObject> {
-        match self.mode {
+        match &self.mode {
             UnionMode::Smart {
                 strict_required,
                 ultra_strict_required,
-            } => self.validate_smart(py, input, state, strict_required, ultra_strict_required),
+            } => self.validate_smart(
+                py,
+                input,
+                state,
+                strict_required.load(Ordering::SeqCst),
+                ultra_strict_required.load(Ordering::SeqCst),
+            ),
             UnionMode::LeftToRight => self.validate_left_to_right(py, input, state),
         }
     }
 
-    fn different_strict_behavior(
-        &self,
-        definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
         self.choices
             .iter()
-            .any(|(v, _)| v.different_strict_behavior(definitions, ultra_strict))
+            .any(|(v, _)| v.different_strict_behavior(ultra_strict))
     }
 
     fn get_name(&self) -> &str {
         &self.name
     }
 
-    fn complete(&mut self, definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
-        self.choices.iter_mut().try_for_each(|(v, _)| v.complete(definitions))?;
+    fn complete(&self) -> PyResult<()> {
+        self.choices.iter().try_for_each(|(v, _)| v.complete())?;
         if let UnionMode::Smart {
-            ref mut strict_required,
-            ref mut ultra_strict_required,
-        } = self.mode
+            strict_required,
+            ultra_strict_required,
+        } = &self.mode
         {
-            *strict_required = self
-                .choices
-                .iter()
-                .any(|(v, _)| v.different_strict_behavior(Some(definitions), false));
-            *ultra_strict_required = self
-                .choices
-                .iter()
-                .any(|(v, _)| v.different_strict_behavior(Some(definitions), true));
+            strict_required.store(
+                self.choices.iter().any(|(v, _)| v.different_strict_behavior(false)),
+                Ordering::SeqCst,
+            );
+            ultra_strict_required.store(
+                self.choices.iter().any(|(v, _)| v.different_strict_behavior(true)),
+                Ordering::SeqCst,
+            );
         }
 
         Ok(())
@@ -357,7 +375,7 @@ impl PyGcTraverse for Discriminator {
     }
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct TaggedUnionValidator {
     discriminator: Discriminator,
     lookup: LiteralLookup<CombinedValidator>,
@@ -476,26 +494,19 @@ impl Validator for TaggedUnionValidator {
         }
     }
 
-    fn different_strict_behavior(
-        &self,
-        definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
         self.lookup
             .values
             .iter()
-            .any(|v| v.different_strict_behavior(definitions, ultra_strict))
+            .any(|v| v.different_strict_behavior(ultra_strict))
     }
 
     fn get_name(&self) -> &str {
         &self.name
     }
 
-    fn complete(&mut self, definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
-        self.lookup
-            .values
-            .iter_mut()
-            .try_for_each(|validator| validator.complete(definitions))
+    fn complete(&self) -> PyResult<()> {
+        self.lookup.values.iter().try_for_each(CombinedValidator::complete)
     }
 }
 
diff --git a/src/validators/url.rs b/src/validators/url.rs
index 0afc76e59..4584ae652 100644
--- a/src/validators/url.rs
+++ b/src/validators/url.rs
@@ -92,11 +92,7 @@ impl Validator for UrlValidator {
         }
     }
 
-    fn different_strict_behavior(
-        &self,
-        _definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
         !ultra_strict
     }
 
@@ -104,7 +100,7 @@ impl Validator for UrlValidator {
         &self.name
     }
 
-    fn complete(&mut self, _definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
+    fn complete(&self) -> PyResult<()> {
         Ok(())
     }
 }
@@ -232,11 +228,7 @@ impl Validator for MultiHostUrlValidator {
         }
     }
 
-    fn different_strict_behavior(
-        &self,
-        _definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
         !ultra_strict
     }
 
@@ -244,7 +236,7 @@ impl Validator for MultiHostUrlValidator {
         &self.name
     }
 
-    fn complete(&mut self, _definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
+    fn complete(&self) -> PyResult<()> {
         Ok(())
     }
 }
diff --git a/src/validators/uuid.rs b/src/validators/uuid.rs
index ca924ce66..94d302438 100644
--- a/src/validators/uuid.rs
+++ b/src/validators/uuid.rs
@@ -122,11 +122,7 @@ impl Validator for UuidValidator {
         }
     }
 
-    fn different_strict_behavior(
-        &self,
-        _definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
         !ultra_strict
     }
 
@@ -134,7 +130,7 @@ impl Validator for UuidValidator {
         Self::EXPECTED_TYPE
     }
 
-    fn complete(&mut self, _definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
+    fn complete(&self) -> PyResult<()> {
         Ok(())
     }
 }
diff --git a/src/validators/validation_state.rs b/src/validators/validation_state.rs
index 6cf5ce313..79ec8b87a 100644
--- a/src/validators/validation_state.rs
+++ b/src/validators/validation_state.rs
@@ -1,25 +1,16 @@
-use crate::{definitions::Definitions, recursion_guard::RecursionGuard};
+use crate::recursion_guard::RecursionGuard;
 
-use super::{CombinedValidator, Extra};
+use super::Extra;
 
 pub struct ValidationState<'a> {
     pub recursion_guard: &'a mut RecursionGuard,
-    pub definitions: &'a Definitions<CombinedValidator>,
     // deliberately make Extra readonly
     extra: Extra<'a>,
 }
 
 impl<'a> ValidationState<'a> {
-    pub fn new(
-        extra: Extra<'a>,
-        definitions: &'a Definitions<CombinedValidator>,
-        recursion_guard: &'a mut RecursionGuard,
-    ) -> Self {
-        Self {
-            recursion_guard,
-            definitions,
-            extra,
-        }
+    pub fn new(extra: Extra<'a>, recursion_guard: &'a mut RecursionGuard) -> Self {
+        Self { recursion_guard, extra }
     }
 
     pub fn with_new_extra<'r, R: 'r>(
@@ -31,7 +22,6 @@ impl<'a> ValidationState<'a> {
         // but lifetimes get in a tangle. Maybe someone brave wants to have a go at unpicking lifetimes.
         let mut new_state = ValidationState {
             recursion_guard: self.recursion_guard,
-            definitions: self.definitions,
             extra,
         };
         f(&mut new_state)
diff --git a/src/validators/with_default.rs b/src/validators/with_default.rs
index d68590766..36b275dd1 100644
--- a/src/validators/with_default.rs
+++ b/src/validators/with_default.rs
@@ -66,7 +66,7 @@ enum OnError {
     Default,
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct WithDefaultValidator {
     default: DefaultType,
     on_error: OnError,
@@ -182,20 +182,16 @@ impl Validator for WithDefaultValidator {
         }
     }
 
-    fn different_strict_behavior(
-        &self,
-        definitions: Option<&DefinitionsBuilder<CombinedValidator>>,
-        ultra_strict: bool,
-    ) -> bool {
-        self.validator.different_strict_behavior(definitions, ultra_strict)
+    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
+        self.validator.different_strict_behavior(ultra_strict)
     }
 
     fn get_name(&self) -> &str {
         &self.name
     }
 
-    fn complete(&mut self, definitions: &DefinitionsBuilder<CombinedValidator>) -> PyResult<()> {
-        self.validator.complete(definitions)
+    fn complete(&self) -> PyResult<()> {
+        self.validator.complete()
     }
 }
 
diff --git a/tests/validators/test_definitions_recursive.py b/tests/validators/test_definitions_recursive.py
index b836eb7a1..2d676ac17 100644
--- a/tests/validators/test_definitions_recursive.py
+++ b/tests/validators/test_definitions_recursive.py
@@ -1,3 +1,4 @@
+import datetime
 import platform
 from dataclasses import dataclass
 from typing import List, Optional
@@ -243,7 +244,7 @@ class Branch:
 
 
 def test_invalid_schema():
-    with pytest.raises(SchemaError, match='Definitions error: attempted to use `Branch` before it was filled'):
+    with pytest.raises(SchemaError, match='Definitions error: definition `Branch` was never filled'):
         SchemaValidator(
             {
                 'type': 'list',
@@ -895,3 +896,192 @@ class Model:
             'url': f'https://errors.pydantic.dev/{pydantic_version}/v/dataclass_type',
         }
     ]
+
+
+def test_cyclic_data() -> None:
+    cyclic_data = {}
+    cyclic_data['b'] = {'a': cyclic_data}
+
+    schema = core_schema.definitions_schema(
+        core_schema.definition_reference_schema('a'),
+        [
+            core_schema.typed_dict_schema(
+                {
+                    'b': core_schema.typed_dict_field(
+                        core_schema.nullable_schema(core_schema.definition_reference_schema('b'))
+                    )
+                },
+                ref='a',
+            ),
+            core_schema.typed_dict_schema(
+                {
+                    'a': core_schema.typed_dict_field(
+                        core_schema.nullable_schema(core_schema.definition_reference_schema('a'))
+                    )
+                },
+                ref='b',
+            ),
+        ],
+    )
+
+    validator = SchemaValidator(schema)
+
+    with pytest.raises(ValidationError) as exc_info:
+        validator.validate_python(cyclic_data)
+
+    assert exc_info.value.title == 'typed-dict'
+    assert exc_info.value.errors(include_url=False) == [
+        {
+            'type': 'recursion_loop',
+            'loc': ('b', 'a'),
+            'msg': 'Recursion error - cyclic reference detected',
+            'input': cyclic_data,
+        }
+    ]
+
+
+def test_cyclic_data_threeway() -> None:
+    cyclic_data = {}
+    cyclic_data['b'] = {'c': {'a': cyclic_data}}
+
+    schema = core_schema.definitions_schema(
+        core_schema.definition_reference_schema('a'),
+        [
+            core_schema.typed_dict_schema(
+                {
+                    'b': core_schema.typed_dict_field(
+                        core_schema.nullable_schema(core_schema.definition_reference_schema('b'))
+                    )
+                },
+                ref='a',
+            ),
+            core_schema.typed_dict_schema(
+                {
+                    'c': core_schema.typed_dict_field(
+                        core_schema.nullable_schema(core_schema.definition_reference_schema('c'))
+                    )
+                },
+                ref='b',
+            ),
+            core_schema.typed_dict_schema(
+                {
+                    'a': core_schema.typed_dict_field(
+                        core_schema.nullable_schema(core_schema.definition_reference_schema('a'))
+                    )
+                },
+                ref='c',
+            ),
+        ],
+    )
+
+    validator = SchemaValidator(schema)
+
+    with pytest.raises(ValidationError) as exc_info:
+        validator.validate_python(cyclic_data)
+
+    assert exc_info.value.title == 'typed-dict'
+    assert exc_info.value.errors(include_url=False) == [
+        {
+            'type': 'recursion_loop',
+            'loc': ('b', 'c', 'a'),
+            'msg': 'Recursion error - cyclic reference detected',
+            'input': cyclic_data,
+        }
+    ]
+
+
+def test_complex_recursive_type() -> None:
+    schema = core_schema.definitions_schema(
+        core_schema.definition_reference_schema('JsonType'),
+        [
+            core_schema.nullable_schema(
+                core_schema.union_schema(
+                    [
+                        core_schema.list_schema(core_schema.definition_reference_schema('JsonType')),
+                        core_schema.dict_schema(
+                            core_schema.str_schema(), core_schema.definition_reference_schema('JsonType')
+                        ),
+                        core_schema.str_schema(),
+                        core_schema.int_schema(),
+                        core_schema.float_schema(),
+                        core_schema.bool_schema(),
+                    ]
+                ),
+                ref='JsonType',
+            )
+        ],
+    )
+
+    validator = SchemaValidator(schema)
+
+    with pytest.raises(ValidationError) as exc_info:
+        validator.validate_python({'a': datetime.date(year=1992, month=12, day=11)})
+
+    assert exc_info.value.errors(include_url=False) == [
+        {
+            'type': 'list_type',
+            'loc': ('list[nullable[union[list[...],dict[str,...],str,int,float,bool]]]',),
+            'msg': 'Input should be a valid list',
+            'input': {'a': datetime.date(1992, 12, 11)},
+        },
+        {
+            'type': 'list_type',
+            'loc': ('dict[str,...]', 'a', 'list[nullable[union[list[...],dict[str,...],str,int,float,bool]]]'),
+            'msg': 'Input should be a valid list',
+            'input': datetime.date(1992, 12, 11),
+        },
+        {
+            'type': 'dict_type',
+            'loc': ('dict[str,...]', 'a', 'dict[str,...]'),
+            'msg': 'Input should be a valid dictionary',
+            'input': datetime.date(1992, 12, 11),
+        },
+        {
+            'type': 'string_type',
+            'loc': ('dict[str,...]', 'a', 'str'),
+            'msg': 'Input should be a valid string',
+            'input': datetime.date(1992, 12, 11),
+        },
+        {
+            'type': 'int_type',
+            'loc': ('dict[str,...]', 'a', 'int'),
+            'msg': 'Input should be a valid integer',
+            'input': datetime.date(1992, 12, 11),
+        },
+        {
+            'type': 'float_type',
+            'loc': ('dict[str,...]', 'a', 'float'),
+            'msg': 'Input should be a valid number',
+            'input': datetime.date(1992, 12, 11),
+        },
+        {
+            'type': 'bool_type',
+            'loc': ('dict[str,...]', 'a', 'bool'),
+            'msg': 'Input should be a valid boolean',
+            'input': datetime.date(1992, 12, 11),
+        },
+        {
+            'type': 'string_type',
+            'loc': ('str',),
+            'msg': 'Input should be a valid string',
+            'input': {'a': datetime.date(1992, 12, 11)},
+        },
+        {
+            'type': 'int_type',
+            'loc': ('int',),
+            'msg': 'Input should be a valid integer',
+            'input': {'a': datetime.date(1992, 12, 11)},
+        },
+        {
+            'type': 'float_type',
+            'loc': ('float',),
+            'msg': 'Input should be a valid number',
+            'input': {'a': datetime.date(1992, 12, 11)},
+        },
+        {
+            'type': 'bool_type',
+            'loc': ('bool',),
+            'msg': 'Input should be a valid boolean',
+            'input': {'a': datetime.date(1992, 12, 11)},
+        },
+    ]

From f3c5714c47681264e1346c9ead3b7ad0f29e514e Mon Sep 17 00:00:00 2001
From: Sigurd Spieckermann <2206639+sisp@users.noreply.github.com>
Date: Fri, 29 Sep 2023 16:08:13 +0200
Subject: [PATCH 056/550] Fix backwards compatibility of type-checking when
 using deprecated `FieldValidationInfo` (#995)

---
 python/pydantic_core/core_schema.py | 3 +++
 tests/test_typing.py                | 4 ++++
 2 files changed, 7 insertions(+)

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index 2d7061ffd..347b93239 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -3909,6 +3909,9 @@ def general_plain_validator_function(*args, **kwargs):
     'FieldWrapValidatorFunction': WithInfoWrapValidatorFunction,
 }
 
+if TYPE_CHECKING:
+    FieldValidationInfo = ValidationInfo
+
 
 def __getattr__(attr_name: str) -> object:
     new_attr = _deprecated_import_lookup.get(attr_name)
diff --git a/tests/test_typing.py b/tests/test_typing.py
index 0d527c619..dcd2f267a 100644
--- a/tests/test_typing.py
+++ b/tests/test_typing.py
@@ -23,6 +23,10 @@ def foo(bar: str) -> None:
     ...
 
 
+def validator_deprecated(value: Any, info: core_schema.FieldValidationInfo) -> None:
+    ...
+
+
 def validator(value: Any, info: core_schema.ValidationInfo) -> None:
     ...
 

From 49126b0b981c6acc10dfb77f86aeaeb417a5979b Mon Sep 17 00:00:00 2001
From: Adrian Garcia Badaracco <1755071+adriangb@users.noreply.github.com>
Date: Fri, 29 Sep 2023 22:05:39 -0500
Subject: [PATCH 057/550] Add benchmark for nested/wide model using definitions
 (#997)

---
 benches/main.rs                           | 44 +++++++++++
 tests/benchmarks/nested_schema.py         | 93 +++++++++++++++++++++++
 tests/benchmarks/test_nested_benchmark.py | 23 ++++++
 3 files changed, 160 insertions(+)
 create mode 100644 tests/benchmarks/nested_schema.py
 create mode 100644 tests/benchmarks/test_nested_benchmark.py

diff --git a/benches/main.rs b/benches/main.rs
index 9d46131d1..4b8a2b106 100644
--- a/benches/main.rs
+++ b/benches/main.rs
@@ -458,6 +458,50 @@ fn complete_model(bench: &mut Bencher) {
     })
 }
 
+#[bench]
+fn nested_model_using_definitions(bench: &mut Bencher) {
+    Python::with_gil(|py| {
+        let sys_path = py.import("sys").unwrap().getattr("path").unwrap();
+        sys_path.call_method1("append", ("./tests/benchmarks/",)).unwrap();
+
+        let complete_schema = py.import("nested_schema").unwrap();
+        let mut schema = complete_schema.call_method0("schema_using_defs").unwrap();
+        schema = validate_core_schema(py, schema, None).unwrap().extract().unwrap();
+        let validator = SchemaValidator::py_new(py, schema, None).unwrap();
+
+        let input = complete_schema.call_method0("input_data_valid").unwrap();
+        let input = black_box(input);
+
+        validator.validate_python(py, input, None, None, None, None).unwrap();
+
+        bench.iter(|| {
+            black_box(validator.validate_python(py, input, None, None, None, None).unwrap());
+        })
+    })
+}
+
+#[bench]
+fn nested_model_inlined(bench: &mut Bencher) {
+    Python::with_gil(|py| {
+        let sys_path = py.import("sys").unwrap().getattr("path").unwrap();
+        sys_path.call_method1("append", ("./tests/benchmarks/",)).unwrap();
+
+        let complete_schema = py.import("nested_schema").unwrap();
+        let mut schema = complete_schema.call_method0("inlined_schema").unwrap();
+        schema = validate_core_schema(py, schema, None).unwrap().extract().unwrap();
+        let validator = SchemaValidator::py_new(py, schema, None).unwrap();
+
+        let input = complete_schema.call_method0("input_data_valid").unwrap();
+        let input = black_box(input);
+
+        validator.validate_python(py, input, None, None, None, None).unwrap();
+
+        bench.iter(|| {
+            black_box(validator.validate_python(py, input, None, None, None, None).unwrap());
+        })
+    })
+}
+
 #[bench]
 fn literal_ints_few_python(bench: &mut Bencher) {
     Python::with_gil(|py| {
diff --git a/tests/benchmarks/nested_schema.py b/tests/benchmarks/nested_schema.py
new file mode 100644
index 000000000..0d91d1217
--- /dev/null
+++ b/tests/benchmarks/nested_schema.py
@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING, Any
+
+if TYPE_CHECKING:
+    from pydantic_core import core_schema as cs
+
+N = 5  # arbitrary number that takes ~0.05s per run
+
+
+class MyModel:
+    # __slots__ is not required, but it avoids __pydantic_fields_set__ falling into __dict__
+    __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__'
+
+
+def schema_using_defs() -> cs.CoreSchema:
+    definitions: list[cs.CoreSchema] = [
+        {'type': 'int', 'ref': 'int'},
+        {
+            'type': 'model',
+            'cls': MyModel,
+            'schema': {
+                'type': 'model-fields',
+                'fields': {
+                    str(c): {'type': 'model-field', 'schema': {'type': 'definition-ref', 'schema_ref': 'int'}}
+                    for c in range(N)
+                },
+            },
+            'ref': f'model_{N}',
+        },
+    ]
+    level = N
+    for level in reversed(range(N)):
+        definitions.append(
+            {
+                'type': 'model',
+                'cls': MyModel,
+                'schema': {
+                    'type': 'model-fields',
+                    'fields': {
+                        str(c): {
+                            'type': 'model-field',
+                            'schema': {'type': 'definition-ref', 'schema_ref': f'model_{level+1}'},
+                        }
+                        for c in range(N)
+                    },
+                },
+                'ref': f'model_{level}',
+            }
+        )
+    return {
+        'type': 'definitions',
+        'definitions': definitions,
+        'schema': {'type': 'definition-ref', 'schema_ref': 'model_0'},
+    }
+
+
+def inlined_schema() -> cs.CoreSchema:
+    level = N
+    schema: cs.CoreSchema = {
+        'type': 'model',
+        'cls': MyModel,
+        'schema': {
+            'type': 'model-fields',
+            'fields': {str(c): {'type': 'model-field', 'schema': {'type': 'int'}} for c in range(N)},
+        },
+        'ref': f'model_{N}',
+    }
+    for level in reversed(range(N)):
+        schema = {
+            'type': 'model',
+            'cls': MyModel,
+            'schema': {
+                'type': 'model-fields',
+                'fields': {str(c): {'type': 'model-field', 'schema': schema} for c in range(N)},
+            },
+            'ref': f'model_{level}',
+        }
+    return schema
+
+
+def input_data_valid(levels: int = N) -> Any:
+    data = {str(c): 1 for c in range(N)}
+    for _ in range(levels):
+        data = {str(c): data for c in range(N)}
+    return data
+
+
+if __name__ == '__main__':
+    from pydantic_core import SchemaValidator
+
+    SchemaValidator(schema_using_defs()).validate_python(input_data_valid())
+    SchemaValidator(inlined_schema()).validate_python(input_data_valid())
diff --git a/tests/benchmarks/test_nested_benchmark.py b/tests/benchmarks/test_nested_benchmark.py
new file mode 100644
index 000000000..6c8d50e83
--- /dev/null
+++ b/tests/benchmarks/test_nested_benchmark.py
@@ -0,0 +1,23 @@
+"""
+Benchmarks for nested / recursive schemas using definitions.
+"""
+
+from typing import Callable
+
+from pydantic_core import SchemaValidator
+
+from .nested_schema import inlined_schema, input_data_valid, schema_using_defs
+
+
+def test_nested_schema_using_defs(benchmark: Callable[..., None]) -> None:
+    v = SchemaValidator(schema_using_defs())
+    data = input_data_valid()
+    v.validate_python(data)
+    benchmark(v.validate_python, data)
+
+
+def test_nested_schema_inlined(benchmark: Callable[..., None]) -> None:
+    v = SchemaValidator(inlined_schema())
+    data = input_data_valid()
+    v.validate_python(data)
+    benchmark(v.validate_python, data)

From b5fb6875b201c9d0764f2c6931ac5618b81329f1 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 2 Oct 2023 12:42:35 +0100
Subject: [PATCH 058/550] Bump griffe from 0.36.2 to 0.36.4 (#1000)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index 48e914dbb..bece1c8ae 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,5 +1,5 @@
 black==23.9.1
-griffe==0.36.2
+griffe==0.36.4
 pyright==1.1.327
 ruff==0.0.291
 mypy==1.5.1

From a8ac5b1baffc28ba8f54ba04ad7c1d28f50527e2 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 2 Oct 2023 11:50:47 +0000
Subject: [PATCH 059/550] Bump pyright from 1.1.327 to 1.1.329 (#998)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index bece1c8ae..d1ae42ff5 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,5 +1,5 @@
 black==23.9.1
 griffe==0.36.4
-pyright==1.1.327
+pyright==1.1.329
 ruff==0.0.291
 mypy==1.5.1

From 4622ed72d10b97dffba5d9fc46020f7510680a74 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 2 Oct 2023 13:17:34 +0100
Subject: [PATCH 060/550] Bump regex from 1.9.5 to 1.9.6 (#1001)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 8 ++++----
 Cargo.toml | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index a2db9901f..0898b6b1f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -355,9 +355,9 @@ dependencies = [
 
 [[package]]
 name = "regex"
-version = "1.9.5"
+version = "1.9.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "697061221ea1b4a94a624f67d0ae2bfe4e22b8a17b6a192afb11046542cc8c47"
+checksum = "ebee201405406dbf528b8b672104ae6d6d63e6d118cb10e4d51abbc7b58044ff"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -367,9 +367,9 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.3.8"
+version = "0.3.9"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2f401f4955220693b56f8ec66ee9c78abffd8d1c4f23dc41a23839eb88f0795"
+checksum = "59b23e92ee4318893fa3fe3e6fb365258efbfe6ac6ab30f090cdcbb7aa37efa9"
 dependencies = [
  "aho-corasick",
  "memchr",
diff --git a/Cargo.toml b/Cargo.toml
index 7101a7019..9d18e224d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -27,7 +27,7 @@ include = [
 
 [dependencies]
 pyo3 = { version = "0.19.2", features = ["generate-import-lib", "num-bigint"] }
-regex = "1.9.5"
+regex = "1.9.6"
 strum = { version = "0.25.0", features = ["derive"] }
 strum_macros = "0.25.2"
 serde_json = {version = "1.0.107", features = ["arbitrary_precision", "preserve_order"]}

From d93482e3b83f33cc134e8aa83992467c6dda8395 Mon Sep 17 00:00:00 2001
From: sydney-runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Mon, 2 Oct 2023 16:10:20 -0500
Subject: [PATCH 061/550] Fix pydantic 7715 (#1002)

Co-authored-by: David Montague <35119617+dmontagu@users.noreply.github.com>
---
 src/validators/dataclass.rs           |  38 ++++---
 src/validators/model_fields.rs        |  36 +++++--
 src/validators/typed_dict.rs          |  38 +++++--
 tests/validators/test_with_default.py | 150 ++++++++++++++++++++++++++
 4 files changed, 231 insertions(+), 31 deletions(-)

diff --git a/src/validators/dataclass.rs b/src/validators/dataclass.rs
index dff7735a3..2706cadef 100644
--- a/src/validators/dataclass.rs
+++ b/src/validators/dataclass.rs
@@ -232,19 +232,31 @@ impl Validator for DataclassArgsValidator {
                                 }
                                 // found neither, check if there is a default value, otherwise error
                                 (None, None) => {
-                                    if let Some(value) =
-                                        field
-                                            .validator
-                                            .default_value(py, Some(field.name.as_str()), state)?
-                                    {
-                                        set_item!(field, value);
-                                    } else {
-                                        errors.push(field.lookup_key.error(
-                                            ErrorTypeDefaults::Missing,
-                                            input,
-                                            self.loc_by_alias,
-                                            &field.name,
-                                        ));
+                                    match field.validator.default_value(py, Some(field.name.as_str()), state) {
+                                        Ok(Some(value)) => {
+                                            // Default value exists, and passed validation if required
+                                            set_item!(field, value);
+                                        },
+                                        Ok(None) => {
+                                            // This means there was no default value
+                                            errors.push(field.lookup_key.error(
+                                                ErrorTypeDefaults::Missing,
+                                                input,
+                                                self.loc_by_alias,
+                                                &field.name
+                                            ));
+                                        },
+                                        Err(ValError::Omit) => continue,
+                                        Err(ValError::LineErrors(line_errors)) => {
+                                            for err in line_errors {
+                                                // Note: this will always use the field name even if there is an alias
+                                                // However, we don't mind so much because this error can only happen if the
+                                                // default value fails validation, which is arguably a developer error.
+                                                // We could try to "fix" this in the future if desired.
+                                                errors.push(err);
+                                            }
+                                        }
+                                        Err(err) => return Err(err),
                                     }
                                 }
                             }
diff --git a/src/validators/model_fields.rs b/src/validators/model_fields.rs
index 30d937cb8..774d3eef9 100644
--- a/src/validators/model_fields.rs
+++ b/src/validators/model_fields.rs
@@ -211,15 +211,33 @@ impl Validator for ModelFieldsValidator {
                                 Err(err) => return ControlFlow::Break(err.into_owned(py)),
                             }
                             continue;
-                        } else if let Some(value) = control_flow!(field.validator.default_value(py, Some(field.name.as_str()), state))? {
-                            control_flow!(model_dict.set_item(&field.name_py, value))?;
-                        } else {
-                            errors.push(field.lookup_key.error(
-                                ErrorTypeDefaults::Missing,
-                                input,
-                                self.loc_by_alias,
-                                &field.name
-                            ));
+                        }
+
+                        match field.validator.default_value(py, Some(field.name.as_str()), state) {
+                            Ok(Some(value)) => {
+                                // Default value exists, and passed validation if required
+                                control_flow!(model_dict.set_item(&field.name_py, value))?;
+                            },
+                            Ok(None) => {
+                                // This means there was no default value
+                                errors.push(field.lookup_key.error(
+                                    ErrorTypeDefaults::Missing,
+                                    input,
+                                    self.loc_by_alias,
+                                    &field.name
+                                ));
+                            },
+                            Err(ValError::Omit) => continue,
+                            Err(ValError::LineErrors(line_errors)) => {
+                                for err in line_errors {
+                                    // Note: this will always use the field name even if there is an alias
+                                    // However, we don't mind so much because this error can only happen if the
+                                    // default value fails validation, which is arguably a developer error.
+                                    // We could try to "fix" this in the future if desired.
+                                    errors.push(err);
+                                }
+                            }
+                            Err(err) => return ControlFlow::Break(err),
                         }
                     }
                     ControlFlow::Continue(())
diff --git a/src/validators/typed_dict.rs b/src/validators/typed_dict.rs
index 1a5b52dc6..118d992a2 100644
--- a/src/validators/typed_dict.rs
+++ b/src/validators/typed_dict.rs
@@ -212,15 +212,35 @@ impl Validator for TypedDictValidator {
                                 Err(err) => return ControlFlow::Break(err.into_owned(py)),
                             }
                             continue;
-                        } else if let Some(value) = control_flow!(field.validator.default_value(py, Some(field.name.as_str()), state))? {
-                            control_flow!(output_dict.set_item(&field.name_py, value))?;
-                        } else if field.required {
-                            errors.push(field.lookup_key.error(
-                                ErrorTypeDefaults::Missing,
-                                input,
-                                self.loc_by_alias,
-                                &field.name
-                            ));
+                        }
+
+                        match field.validator.default_value(py, Some(field.name.as_str()), state) {
+                            Ok(Some(value)) => {
+                                // Default value exists, and passed validation if required
+                                control_flow!(output_dict.set_item(&field.name_py, value))?;
+                            },
+                            Ok(None) => {
+                                // This means there was no default value
+                                if (field.required) {
+                                    errors.push(field.lookup_key.error(
+                                        ErrorTypeDefaults::Missing,
+                                        input,
+                                        self.loc_by_alias,
+                                        &field.name
+                                    ));
+                                }
+                            },
+                            Err(ValError::Omit) => continue,
+                            Err(ValError::LineErrors(line_errors)) => {
+                                for err in line_errors {
+                                    // Note: this will always use the field name even if there is an alias
+                                    // However, we don't mind so much because this error can only happen if the
+                                    // default value fails validation, which is arguably a developer error.
+                                    // We could try to "fix" this in the future if desired.
+                                    errors.push(err);
+                                }
+                            }
+                            Err(err) => return ControlFlow::Break(err),
                         }
                     }
                     ControlFlow::Continue(())
diff --git a/tests/validators/test_with_default.py b/tests/validators/test_with_default.py
index 808e4807d..7ca0d9f54 100644
--- a/tests/validators/test_with_default.py
+++ b/tests/validators/test_with_default.py
@@ -654,3 +654,153 @@ def _validator(cls, v, info):
     gc.collect()
 
     assert ref() is None
+
+
+validate_default_raises_examples = [
+    (
+        {},
+        [
+            {'type': 'assertion_error', 'loc': ('x',), 'msg': 'Assertion failed, ', 'input': None},
+            {'type': 'assertion_error', 'loc': ('y',), 'msg': 'Assertion failed, ', 'input': None},
+            {'type': 'missing', 'loc': ('z',), 'msg': 'Field required', 'input': {}},
+        ],
+    ),
+    (
+        {'z': 'some str'},
+        [
+            {'type': 'assertion_error', 'loc': ('x',), 'msg': 'Assertion failed, ', 'input': None},
+            {'type': 'assertion_error', 'loc': ('y',), 'msg': 'Assertion failed, ', 'input': None},
+        ],
+    ),
+    (
+        {'x': None},
+        [
+            {'type': 'assertion_error', 'loc': ('x',), 'msg': 'Assertion failed, ', 'input': None},
+            {'type': 'assertion_error', 'loc': ('y',), 'msg': 'Assertion failed, ', 'input': None},
+            {'type': 'missing', 'loc': ('z',), 'msg': 'Field required', 'input': {'x': None}},
+        ],
+    ),
+    (
+        {'x': None, 'z': 'some str'},
+        [
+            {'type': 'assertion_error', 'loc': ('x',), 'msg': 'Assertion failed, ', 'input': None},
+            {'type': 'assertion_error', 'loc': ('y',), 'msg': 'Assertion failed, ', 'input': None},
+        ],
+    ),
+    (
+        {'y': None},
+        [
+            {'type': 'assertion_error', 'loc': ('x',), 'msg': 'Assertion failed, ', 'input': None},
+            {'type': 'assertion_error', 'loc': ('y',), 'msg': 'Assertion failed, ', 'input': None},
+            {'type': 'missing', 'loc': ('z',), 'msg': 'Field required', 'input': {'y': None}},
+        ],
+    ),
+    (
+        {'y': None, 'z': 'some str'},
+        [
+            {'type': 'assertion_error', 'loc': ('x',), 'msg': 'Assertion failed, ', 'input': None},
+            {'type': 'assertion_error', 'loc': ('y',), 'msg': 'Assertion failed, ', 'input': None},
+        ],
+    ),
+    (
+        {'x': None, 'y': None},
+        [
+            {'type': 'assertion_error', 'loc': ('x',), 'msg': 'Assertion failed, ', 'input': None},
+            {'type': 'assertion_error', 'loc': ('y',), 'msg': 'Assertion failed, ', 'input': None},
+            {'type': 'missing', 'loc': ('z',), 'msg': 'Field required', 'input': {'x': None, 'y': None}},
+        ],
+    ),
+    (
+        {'x': None, 'y': None, 'z': 'some str'},
+        [
+            {'type': 'assertion_error', 'loc': ('x',), 'msg': 'Assertion failed, ', 'input': None},
+            {'type': 'assertion_error', 'loc': ('y',), 'msg': 'Assertion failed, ', 'input': None},
+        ],
+    ),
+    (
+        {'x': 1, 'y': None, 'z': 'some str'},
+        [
+            {'type': 'assertion_error', 'loc': ('x',), 'msg': 'Assertion failed, ', 'input': 1},
+            {'type': 'assertion_error', 'loc': ('y',), 'msg': 'Assertion failed, ', 'input': None},
+        ],
+    ),
+    (
+        {'x': None, 'y': 1, 'z': 'some str'},
+        [
+            {'type': 'assertion_error', 'loc': ('x',), 'msg': 'Assertion failed, ', 'input': None},
+            {'type': 'assertion_error', 'loc': ('y',), 'msg': 'Assertion failed, ', 'input': 1},
+        ],
+    ),
+    (
+        {'x': 1, 'y': 1, 'z': 'some str'},
+        [
+            {'type': 'assertion_error', 'loc': ('x',), 'msg': 'Assertion failed, ', 'input': 1},
+            {'type': 'assertion_error', 'loc': ('y',), 'msg': 'Assertion failed, ', 'input': 1},
+        ],
+    ),
+]
+
+
+@pytest.mark.parametrize(
+    'core_schema_constructor,field_constructor',
+    [
+        (core_schema.model_fields_schema, core_schema.model_field),
+        (core_schema.typed_dict_schema, core_schema.typed_dict_field),
+    ],
+)
+@pytest.mark.parametrize('input_value,expected', validate_default_raises_examples)
+def test_validate_default_raises(
+    core_schema_constructor: Union[core_schema.ModelFieldsSchema, core_schema.TypedDictSchema],
+    field_constructor: Union[core_schema.model_field, core_schema.typed_dict_field],
+    input_value: dict,
+    expected: Any,
+) -> None:
+    def _raise(ex: Exception) -> None:
+        raise ex()
+
+    inner_schema = core_schema.no_info_after_validator_function(
+        lambda x: _raise(AssertionError), core_schema.nullable_schema(core_schema.int_schema())
+    )
+
+    v = SchemaValidator(
+        core_schema_constructor(
+            {
+                'x': field_constructor(
+                    core_schema.with_default_schema(inner_schema, default=None, validate_default=True)
+                ),
+                'y': field_constructor(
+                    core_schema.with_default_schema(inner_schema, default=None, validate_default=True)
+                ),
+                'z': field_constructor(core_schema.str_schema()),
+            }
+        )
+    )
+
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_python(input_value)
+        assert exc_info.value.errors(include_url=False, include_context=False) == expected
+
+
+@pytest.mark.parametrize('input_value,expected', validate_default_raises_examples)
+def test_validate_default_raises_dataclass(input_value: dict, expected: Any) -> None:
+    def _raise(ex: Exception) -> None:
+        raise ex()
+
+    inner_schema = core_schema.no_info_after_validator_function(
+        lambda x: _raise(AssertionError), core_schema.nullable_schema(core_schema.int_schema())
+    )
+
+    x = core_schema.dataclass_field(
+        name='x', schema=core_schema.with_default_schema(inner_schema, default=None, validate_default=True)
+    )
+    y = core_schema.dataclass_field(
+        name='y', schema=core_schema.with_default_schema(inner_schema, default=None, validate_default=True)
+    )
+    z = core_schema.dataclass_field(name='z', schema=core_schema.str_schema())
+
+    v = SchemaValidator(core_schema.dataclass_args_schema('XYZ', [x, y, z]))
+
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_python(input_value)
+
+    assert exc_info.value.errors(include_url=False, include_context=False) == expected

From 493621705d5a19b6f4cbf3b7591d61f62f3029f5 Mon Sep 17 00:00:00 2001
From: David Hewitt <1939362+davidhewitt@users.noreply.github.com>
Date: Mon, 9 Oct 2023 13:39:31 +0100
Subject: [PATCH 062/550] Fix new lint error from Rust 1.73 (#1010)

---
 src/validators/url.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/validators/url.rs b/src/validators/url.rs
index 4584ae652..b5fe8bf4c 100644
--- a/src/validators/url.rs
+++ b/src/validators/url.rs
@@ -498,7 +498,7 @@ fn check_sub_defaults(
         if let Some(default_port) = default_port {
             lib_url
                 .set_port(Some(default_port))
-                .map_err(|_| map_parse_err(ParseError::EmptyHost))?;
+                .map_err(|()| map_parse_err(ParseError::EmptyHost))?;
         }
     }
     if let Some(ref default_path) = default_path {

From 30444546a3a0ca54b9762a660f65f15e0bd52db3 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 9 Oct 2023 14:12:04 +0100
Subject: [PATCH 063/550] Bump ruff from 0.0.291 to 0.0.292 (#1009)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index d1ae42ff5..f16ee3288 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,5 +1,5 @@
 black==23.9.1
 griffe==0.36.4
 pyright==1.1.329
-ruff==0.0.291
+ruff==0.0.292
 mypy==1.5.1

From 172f6fcf99d2b7753e8f8eb61b8e02465491472e Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 9 Oct 2023 14:12:25 +0100
Subject: [PATCH 064/550] Bump pytest-timeout from 2.1.0 to 2.2.0 (#1008)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements.txt b/tests/requirements.txt
index ae8b9e50d..98cef770f 100644
--- a/tests/requirements.txt
+++ b/tests/requirements.txt
@@ -10,7 +10,7 @@ pytest-examples==0.0.10
 pytest-speed==0.3.5
 pytest-mock==3.11.1
 pytest-pretty==1.2.0
-pytest-timeout==2.1.0
+pytest-timeout==2.2.0
 pytz==2023.3.post1
 # numpy doesn't offer prebuilt wheels for all versions and platforms we test in CI e.g. aarch64 musllinux
 numpy==1.25.2; python_version >= "3.9" and python_version < "3.12" and implementation_name == "cpython" and platform_machine == 'x86_64'

From 8bbfb33bc8089f55715a5d1e6ea05a0ef43c4fc0 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 9 Oct 2023 13:20:44 +0000
Subject: [PATCH 065/550] Bump pyright from 1.1.329 to 1.1.330.post0 (#1007)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index f16ee3288..25b74ce08 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,5 +1,5 @@
 black==23.9.1
 griffe==0.36.4
-pyright==1.1.329
+pyright==1.1.330.post0
 ruff==0.0.292
 mypy==1.5.1

From 8e66bd94758ab8b42d6645f29b7ce954e565ebf3 Mon Sep 17 00:00:00 2001
From: David Hewitt <1939362+davidhewitt@users.noreply.github.com>
Date: Mon, 9 Oct 2023 15:19:01 +0100
Subject: [PATCH 066/550] Fix `regex_engine` being rejected by
 `validate_core_schema` (#1011)

---
 python/pydantic_core/core_schema.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index 347b93239..adb8e5647 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -106,6 +106,7 @@ class CoreConfig(TypedDict, total=False):
     hide_input_in_errors: bool
     validation_error_cause: bool  # default: False
     coerce_numbers_to_str: bool  # default: False
+    regex_engine: Literal['rust-regex', 'python-re']  # default: 'rust-regex'
 
 
 IncExCall: TypeAlias = 'set[int | str] | dict[int | str, IncExCall] | None'

From b51105a4d459d93ae33ebc1f22219be71b03786f Mon Sep 17 00:00:00 2001
From: Edward Oakes <ed.nmi.oakes@gmail.com>
Date: Mon, 9 Oct 2023 12:13:01 -0500
Subject: [PATCH 067/550] Add `SchemaSerializer.__reduce__` method to enable
 `pickle` serialization (#1006)

Signed-off-by: Edward Oakes <ed.nmi.oakes@gmail.com>
---
 src/serializers/mod.rs             | 26 +++++++++++++--
 src/validators/mod.rs              | 32 +++++++++++++-----
 tests/serializers/test_pickling.py | 50 ++++++++++++++++++++++++++++
 tests/test.rs                      |  4 +--
 tests/test_garbage_collection.py   |  9 +++--
 tests/validators/test_datetime.py  | 12 -------
 tests/validators/test_pickling.py  | 53 ++++++++++++++++++++++++++++++
 7 files changed, 158 insertions(+), 28 deletions(-)
 create mode 100644 tests/serializers/test_pickling.py
 create mode 100644 tests/validators/test_pickling.py

diff --git a/src/serializers/mod.rs b/src/serializers/mod.rs
index 72028346b..00d70162f 100644
--- a/src/serializers/mod.rs
+++ b/src/serializers/mod.rs
@@ -26,13 +26,17 @@ mod ob_type;
 mod shared;
 mod type_serializers;
 
-#[pyclass(module = "pydantic_core._pydantic_core")]
+#[pyclass(module = "pydantic_core._pydantic_core", frozen)]
 #[derive(Debug)]
 pub struct SchemaSerializer {
     serializer: CombinedSerializer,
     definitions: Definitions<CombinedSerializer>,
     expected_json_size: AtomicUsize,
     config: SerializationConfig,
+    // References to the Python schema and config objects are saved to enable
+    // reconstructing the object for pickle support (see `__reduce__`).
+    py_schema: Py<PyDict>,
+    py_config: Option<Py<PyDict>>,
 }
 
 impl SchemaSerializer {
@@ -71,15 +75,19 @@ impl SchemaSerializer {
 #[pymethods]
 impl SchemaSerializer {
     #[new]
-    pub fn py_new(schema: &PyDict, config: Option<&PyDict>) -> PyResult<Self> {
+    pub fn py_new(py: Python, schema: &PyDict, config: Option<&PyDict>) -> PyResult<Self> {
         let mut definitions_builder = DefinitionsBuilder::new();
-
         let serializer = CombinedSerializer::build(schema.downcast()?, config, &mut definitions_builder)?;
         Ok(Self {
             serializer,
             definitions: definitions_builder.finish()?,
             expected_json_size: AtomicUsize::new(1024),
             config: SerializationConfig::from_config(config)?,
+            py_schema: schema.into_py(py),
+            py_config: match config {
+                Some(c) if !c.is_empty() => Some(c.into_py(py)),
+                _ => None,
+            },
         })
     }
 
@@ -174,6 +182,14 @@ impl SchemaSerializer {
         Ok(py_bytes.into())
     }
 
+    pub fn __reduce__(slf: &PyCell<Self>) -> PyResult<(PyObject, (PyObject, PyObject))> {
+        // Enables support for `pickle` serialization.
+        let py = slf.py();
+        let cls = slf.get_type().into();
+        let init_args = (slf.get().py_schema.to_object(py), slf.get().py_config.to_object(py));
+        Ok((cls, init_args))
+    }
+
     pub fn __repr__(&self) -> String {
         format!(
             "SchemaSerializer(serializer={:#?}, definitions={:#?})",
@@ -182,6 +198,10 @@ impl SchemaSerializer {
     }
 
     fn __traverse__(&self, visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
+        visit.call(&self.py_schema)?;
+        if let Some(ref py_config) = self.py_config {
+            visit.call(py_config)?;
+        }
         self.serializer.py_gc_traverse(&visit)?;
         self.definitions.py_gc_traverse(&visit)?;
         Ok(())
diff --git a/src/validators/mod.rs b/src/validators/mod.rs
index 42aad2001..5db192f3a 100644
--- a/src/validators/mod.rs
+++ b/src/validators/mod.rs
@@ -97,12 +97,15 @@ impl PySome {
     }
 }
 
-#[pyclass(module = "pydantic_core._pydantic_core")]
+#[pyclass(module = "pydantic_core._pydantic_core", frozen)]
 #[derive(Debug)]
 pub struct SchemaValidator {
     validator: CombinedValidator,
     definitions: Definitions<CombinedValidator>,
-    schema: PyObject,
+    // References to the Python schema and config objects are saved to enable
+    // reconstructing the object for cloudpickle support (see `__reduce__`).
+    py_schema: Py<PyAny>,
+    py_config: Option<Py<PyDict>>,
     #[pyo3(get)]
     title: PyObject,
     hide_input_in_errors: bool,
@@ -121,6 +124,11 @@ impl SchemaValidator {
         for val in definitions.values() {
             val.get().unwrap().complete()?;
         }
+        let py_schema = schema.into_py(py);
+        let py_config = match config {
+            Some(c) if !c.is_empty() => Some(c.into_py(py)),
+            _ => None,
+        };
         let config_title = match config {
             Some(c) => c.get_item("title"),
             None => None,
@@ -134,18 +142,20 @@ impl SchemaValidator {
         Ok(Self {
             validator,
             definitions,
-            schema: schema.into_py(py),
+            py_schema,
+            py_config,
             title,
             hide_input_in_errors,
             validation_error_cause,
         })
     }
 
-    pub fn __reduce__(slf: &PyCell<Self>) -> PyResult<PyObject> {
+    pub fn __reduce__(slf: &PyCell<Self>) -> PyResult<(PyObject, (PyObject, PyObject))> {
+        // Enables support for `pickle` serialization.
         let py = slf.py();
-        let args = (slf.try_borrow()?.schema.to_object(py),);
-        let cls = slf.getattr("__class__")?;
-        Ok((cls, args).into_py(py))
+        let cls = slf.get_type().into();
+        let init_args = (slf.get().py_schema.to_object(py), slf.get().py_config.to_object(py));
+        Ok((cls, init_args))
     }
 
     #[pyo3(signature = (input, *, strict=None, from_attributes=None, context=None, self_instance=None))]
@@ -307,7 +317,10 @@ impl SchemaValidator {
 
     fn __traverse__(&self, visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
         self.validator.py_gc_traverse(&visit)?;
-        visit.call(&self.schema)?;
+        visit.call(&self.py_schema)?;
+        if let Some(ref py_config) = self.py_config {
+            visit.call(py_config)?;
+        }
         Ok(())
     }
 }
@@ -396,7 +409,8 @@ impl<'py> SelfValidator<'py> {
         Ok(SchemaValidator {
             validator,
             definitions,
-            schema: py.None(),
+            py_schema: py.None(),
+            py_config: None,
             title: "Self Schema".into_py(py),
             hide_input_in_errors: false,
             validation_error_cause: false,
diff --git a/tests/serializers/test_pickling.py b/tests/serializers/test_pickling.py
new file mode 100644
index 000000000..2ca230313
--- /dev/null
+++ b/tests/serializers/test_pickling.py
@@ -0,0 +1,50 @@
+import json
+import pickle
+from datetime import timedelta
+
+import pytest
+
+from pydantic_core import core_schema
+from pydantic_core._pydantic_core import SchemaSerializer
+
+
+def repr_function(value, _info):
+    return repr(value)
+
+
+def test_basic_schema_serializer():
+    s = SchemaSerializer(core_schema.dict_schema())
+    s = pickle.loads(pickle.dumps(s))
+    assert s.to_python({'a': 1, b'b': 2, 33: 3}) == {'a': 1, b'b': 2, 33: 3}
+    assert s.to_python({'a': 1, b'b': 2, 33: 3, True: 4}, mode='json') == {'a': 1, 'b': 2, '33': 3, 'true': 4}
+    assert s.to_json({'a': 1, b'b': 2, 33: 3, True: 4}) == b'{"a":1,"b":2,"33":3,"true":4}'
+
+    assert s.to_python({(1, 2): 3}) == {(1, 2): 3}
+    assert s.to_python({(1, 2): 3}, mode='json') == {'1,2': 3}
+    assert s.to_json({(1, 2): 3}) == b'{"1,2":3}'
+
+
+@pytest.mark.parametrize(
+    'value,expected_python,expected_json',
+    [(None, 'None', b'"None"'), (1, '1', b'"1"'), ([1, 2, 3], '[1, 2, 3]', b'"[1, 2, 3]"')],
+)
+def test_schema_serializer_capturing_function(value, expected_python, expected_json):
+    # Test a SchemaSerializer that captures a function.
+    s = SchemaSerializer(
+        core_schema.any_schema(
+            serialization=core_schema.plain_serializer_function_ser_schema(repr_function, info_arg=True)
+        )
+    )
+    s = pickle.loads(pickle.dumps(s))
+    assert s.to_python(value) == expected_python
+    assert s.to_json(value) == expected_json
+    assert s.to_python(value, mode='json') == json.loads(expected_json)
+
+
+def test_schema_serializer_containing_config():
+    s = SchemaSerializer(core_schema.timedelta_schema(), config={'ser_json_timedelta': 'float'})
+    s = pickle.loads(pickle.dumps(s))
+
+    assert s.to_python(timedelta(seconds=4, microseconds=500_000)) == timedelta(seconds=4, microseconds=500_000)
+    assert s.to_python(timedelta(seconds=4, microseconds=500_000), mode='json') == 4.5
+    assert s.to_json(timedelta(seconds=4, microseconds=500_000)) == b'4.5'
diff --git a/tests/test.rs b/tests/test.rs
index 526b30e5e..9b2fb99b5 100644
--- a/tests/test.rs
+++ b/tests/test.rs
@@ -46,7 +46,7 @@ mod tests {
                 ]
             }"#;
             let schema: &PyDict = py.eval(code, None, None).unwrap().extract().unwrap();
-            SchemaSerializer::py_new(schema, None).unwrap();
+            SchemaSerializer::py_new(py, schema, None).unwrap();
         });
     }
 
@@ -77,7 +77,7 @@ a = A()
             py.run(code, None, Some(locals)).unwrap();
             let a: &PyAny = locals.get_item("a").unwrap().extract().unwrap();
             let schema: &PyDict = locals.get_item("schema").unwrap().extract().unwrap();
-            let serialized: Vec<u8> = SchemaSerializer::py_new(schema, None)
+            let serialized: Vec<u8> = SchemaSerializer::py_new(py, schema, None)
                 .unwrap()
                 .to_json(py, a, None, None, None, true, false, false, false, false, true, None)
                 .unwrap()
diff --git a/tests/test_garbage_collection.py b/tests/test_garbage_collection.py
index d848c91ea..97107e61b 100644
--- a/tests/test_garbage_collection.py
+++ b/tests/test_garbage_collection.py
@@ -27,7 +27,9 @@ class BaseModel:
         __schema__: SchemaSerializer
 
         def __init_subclass__(cls) -> None:
-            cls.__schema__ = SchemaSerializer(core_schema.model_schema(cls, GC_TEST_SCHEMA_INNER))
+            cls.__schema__ = SchemaSerializer(
+                core_schema.model_schema(cls, GC_TEST_SCHEMA_INNER), config={'ser_json_timedelta': 'float'}
+            )
 
     cache: 'WeakValueDictionary[int, Any]' = WeakValueDictionary()
 
@@ -56,7 +58,10 @@ class BaseModel:
         __validator__: SchemaValidator
 
         def __init_subclass__(cls) -> None:
-            cls.__validator__ = SchemaValidator(core_schema.model_schema(cls, GC_TEST_SCHEMA_INNER))
+            cls.__validator__ = SchemaValidator(
+                core_schema.model_schema(cls, GC_TEST_SCHEMA_INNER),
+                config=core_schema.CoreConfig(extra_fields_behavior='allow'),
+            )
 
     cache: 'WeakValueDictionary[int, Any]' = WeakValueDictionary()
 
diff --git a/tests/validators/test_datetime.py b/tests/validators/test_datetime.py
index df04d1631..67581119b 100644
--- a/tests/validators/test_datetime.py
+++ b/tests/validators/test_datetime.py
@@ -1,6 +1,5 @@
 import copy
 import json
-import pickle
 import platform
 import re
 from datetime import date, datetime, time, timedelta, timezone, tzinfo
@@ -480,17 +479,6 @@ def test_tz_constraint_wrong():
         validate_core_schema(core_schema.datetime_schema(tz_constraint='wrong'))
 
 
-def test_tz_pickle() -> None:
-    """
-    https://github.com/pydantic/pydantic-core/issues/589
-    """
-    v = SchemaValidator(core_schema.datetime_schema())
-    original = datetime(2022, 6, 8, 12, 13, 14, tzinfo=timezone(timedelta(hours=-12, minutes=-15)))
-    validated = v.validate_python('2022-06-08T12:13:14-12:15')
-    assert validated == original
-    assert pickle.loads(pickle.dumps(validated)) == validated == original
-
-
 def test_tz_hash() -> None:
     v = SchemaValidator(core_schema.datetime_schema())
     lookup: Dict[datetime, str] = {}
diff --git a/tests/validators/test_pickling.py b/tests/validators/test_pickling.py
new file mode 100644
index 000000000..2037ab8c9
--- /dev/null
+++ b/tests/validators/test_pickling.py
@@ -0,0 +1,53 @@
+import pickle
+import re
+from datetime import datetime, timedelta, timezone
+
+import pytest
+
+from pydantic_core import core_schema, validate_core_schema
+from pydantic_core._pydantic_core import SchemaValidator, ValidationError
+
+
+def test_basic_schema_validator():
+    v = SchemaValidator(
+        validate_core_schema(
+            {'type': 'dict', 'strict': True, 'keys_schema': {'type': 'int'}, 'values_schema': {'type': 'int'}}
+        )
+    )
+    v = pickle.loads(pickle.dumps(v))
+    assert v.validate_python({'1': 2, '3': 4}) == {1: 2, 3: 4}
+    assert v.validate_python({}) == {}
+    with pytest.raises(ValidationError, match=re.escape('[type=dict_type, input_value=[], input_type=list]')):
+        v.validate_python([])
+
+
+def test_schema_validator_containing_config():
+    """
+    Verify that the config object is not lost during (de)serialization.
+    """
+    v = SchemaValidator(
+        core_schema.model_fields_schema({'f': core_schema.model_field(core_schema.str_schema())}),
+        config=core_schema.CoreConfig(extra_fields_behavior='allow'),
+    )
+    v = pickle.loads(pickle.dumps(v))
+
+    m, model_extra, fields_set = v.validate_python({'f': 'x', 'extra_field': '123'})
+    assert m == {'f': 'x'}
+    # If the config was lost during (de)serialization, the below checks would fail as
+    # the default behavior is to ignore extra fields.
+    assert model_extra == {'extra_field': '123'}
+    assert fields_set == {'f', 'extra_field'}
+
+    v.validate_assignment(m, 'f', 'y')
+    assert m == {'f': 'y'}
+
+
+def test_schema_validator_tz_pickle() -> None:
+    """
+    https://github.com/pydantic/pydantic-core/issues/589
+    """
+    v = SchemaValidator(core_schema.datetime_schema())
+    original = datetime(2022, 6, 8, 12, 13, 14, tzinfo=timezone(timedelta(hours=-12, minutes=-15)))
+    validated = v.validate_python('2022-06-08T12:13:14-12:15')
+    assert validated == original
+    assert pickle.loads(pickle.dumps(validated)) == validated == original

From f67e25c2c03a33bf60a18e66718df7e23fb0e79f Mon Sep 17 00:00:00 2001
From: sydney-runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Thu, 12 Oct 2023 07:56:25 -0500
Subject: [PATCH 068/550] Fix `definition-ref` bug with `Dict` keys (#1014)

---
 .../type_serializers/definitions.rs           |  2 +-
 tests/serializers/test_definitions.py         | 21 +++++++++++++++++++
 2 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/src/serializers/type_serializers/definitions.rs b/src/serializers/type_serializers/definitions.rs
index cf92df244..b7bf63365 100644
--- a/src/serializers/type_serializers/definitions.rs
+++ b/src/serializers/type_serializers/definitions.rs
@@ -76,7 +76,7 @@ impl TypeSerializer for DefinitionRefSerializer {
     }
 
     fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
-        self._invalid_as_json_key(key, extra, Self::EXPECTED_TYPE)
+        self.definition.get().unwrap().json_key(key, extra)
     }
 
     fn serde_serialize<S: serde::ser::Serializer>(
diff --git a/tests/serializers/test_definitions.py b/tests/serializers/test_definitions.py
index 2da4d353d..d45398097 100644
--- a/tests/serializers/test_definitions.py
+++ b/tests/serializers/test_definitions.py
@@ -113,3 +113,24 @@ def test_use_after():
         )
     )
     assert v.to_python((1, 2)) == ('1', '2')
+
+
+def test_defs_with_dict():
+    s = SchemaSerializer(
+        core_schema.definitions_schema(
+            schema=core_schema.typed_dict_schema(
+                {
+                    'foo': core_schema.typed_dict_field(
+                        core_schema.dict_schema(
+                            keys_schema=core_schema.definition_reference_schema('key'),
+                            values_schema=core_schema.definition_reference_schema('val'),
+                        )
+                    )
+                }
+            ),
+            definitions=[core_schema.str_schema(ref='key'), core_schema.str_schema(ref='val')],
+        )
+    )
+
+    assert s.to_json({'foo': {'key': 'val'}}) == b'{"foo":{"key":"val"}}'
+    assert s.to_python({'foo': {'key': 'val'}}) == {'foo': {'key': 'val'}}

From 372904c53c94aa410e4778755dcb4b2567a3a4d9 Mon Sep 17 00:00:00 2001
From: David Hewitt <1939362+davidhewitt@users.noreply.github.com>
Date: Sat, 14 Oct 2023 21:13:41 +0100
Subject: [PATCH 069/550] Update PyO3 to 0.20 (#1003)

---
 Cargo.lock                                    | 50 ++++++++-----------
 Cargo.toml                                    |  6 +--
 src/errors/types.rs                           |  2 +-
 src/errors/validation_exception.rs            |  8 +--
 src/errors/value_exception.rs                 |  4 +-
 src/input/input_python.rs                     | 14 +++---
 src/input/return_enums.rs                     |  2 +-
 src/lookup_key.rs                             |  6 +--
 src/serializers/extra.rs                      |  2 +-
 src/serializers/filter.rs                     | 10 ++--
 src/serializers/type_serializers/dict.rs      |  4 +-
 src/serializers/type_serializers/model.rs     |  2 +-
 .../type_serializers/typed_dict.rs            |  2 +-
 src/tools.rs                                  |  4 +-
 src/validators/arguments.rs                   |  6 +--
 src/validators/bytes.rs                       |  4 +-
 src/validators/call.rs                        |  2 +-
 src/validators/dataclass.rs                   |  6 +--
 src/validators/datetime.rs                    |  2 +-
 src/validators/decimal.rs                     |  2 +-
 src/validators/dict.rs                        |  4 +-
 src/validators/float.rs                       | 10 ++--
 src/validators/int.rs                         | 10 ++--
 src/validators/list.rs                        |  2 +-
 src/validators/literal.rs                     |  2 +-
 src/validators/mod.rs                         |  2 +-
 src/validators/model_fields.rs                |  4 +-
 src/validators/set.rs                         |  2 +-
 src/validators/string.rs                      |  8 +--
 src/validators/timedelta.rs                   |  2 +-
 src/validators/tuple.rs                       |  2 +-
 src/validators/typed_dict.rs                  |  4 +-
 src/validators/union.rs                       |  4 +-
 tests/test.rs                                 |  4 +-
 34 files changed, 94 insertions(+), 104 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 0898b6b1f..3c2af0c54 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -62,7 +62,7 @@ dependencies = [
  "once_cell",
  "proc-macro2",
  "quote",
- "syn 2.0.28",
+ "syn",
 ]
 
 [[package]]
@@ -125,9 +125,9 @@ dependencies = [
 
 [[package]]
 name = "indoc"
-version = "1.0.9"
+version = "2.0.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bfa799dd5ed20a7e349f3b4639aa80d74549c81716d9ec4f994c9b5815598306"
+checksum = "1e186cfbae8084e513daff4240b4797e342f988cecda4fb6c939150f96315fd8"
 
 [[package]]
 name = "itoa"
@@ -266,9 +266,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.19.2"
+version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e681a6cfdc4adcc93b4d3cf993749a4552018ee0a9b65fc0ccfad74352c72a38"
+checksum = "04e8453b658fe480c3e70c8ed4e3d3ec33eb74988bd186561b0cc66b85c3bc4b"
 dependencies = [
  "cfg-if",
  "indoc",
@@ -284,9 +284,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.19.2"
+version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "076c73d0bc438f7a4ef6fdd0c3bb4732149136abd952b110ac93e4edb13a6ba5"
+checksum = "a96fe70b176a89cff78f2fa7b3c930081e163d5379b4dcdf993e3ae29ca662e5"
 dependencies = [
  "once_cell",
  "python3-dll-a",
@@ -295,9 +295,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.19.2"
+version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e53cee42e77ebe256066ba8aa77eff722b3bb91f3419177cf4cd0f304d3284d9"
+checksum = "214929900fd25e6604661ed9cf349727c8920d47deff196c4e28165a6ef2a96b"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -305,25 +305,26 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.19.2"
+version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dfeb4c99597e136528c6dd7d5e3de5434d1ceaf487436a3f03b2d56b6fc9efd1"
+checksum = "dac53072f717aa1bfa4db832b39de8c875b7c7af4f4a6fe93cdbf9264cf8383b"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
  "quote",
- "syn 1.0.109",
+ "syn",
 ]
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.19.2"
+version = "0.20.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "947dc12175c254889edc0c02e399476c2f652b4b9ebd123aa655c224de259536"
+checksum = "7774b5a8282bd4f25f803b1f0d945120be959a36c72e08e7cd031c792fdfd424"
 dependencies = [
+ "heck",
  "proc-macro2",
  "quote",
- "syn 1.0.109",
+ "syn",
 ]
 
 [[package]]
@@ -417,7 +418,7 @@ checksum = "4eca7ac642d82aa35b60049a6eccb4be6be75e599bd2e9adb5f875a737654af2"
 dependencies = [
  "proc-macro2",
  "quote",
- "syn 2.0.28",
+ "syn",
 ]
 
 [[package]]
@@ -467,18 +468,7 @@ dependencies = [
  "proc-macro2",
  "quote",
  "rustversion",
- "syn 2.0.28",
-]
-
-[[package]]
-name = "syn"
-version = "1.0.109"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
-dependencies = [
- "proc-macro2",
- "quote",
- "unicode-ident",
+ "syn",
 ]
 
 [[package]]
@@ -536,9 +526,9 @@ dependencies = [
 
 [[package]]
 name = "unindent"
-version = "0.1.11"
+version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1766d682d402817b5ac4490b3c3002d91dfa0d22812f341609f97b08757359c"
+checksum = "c7de7d73e1754487cb58364ee906a499937a0dfabd86bcb980fa99ec8c8fa2ce"
 
 [[package]]
 name = "url"
diff --git a/Cargo.toml b/Cargo.toml
index 9d18e224d..4a6541781 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -26,7 +26,7 @@ include = [
 ]
 
 [dependencies]
-pyo3 = { version = "0.19.2", features = ["generate-import-lib", "num-bigint"] }
+pyo3 = { version = "0.20.0", features = ["generate-import-lib", "num-bigint"] }
 regex = "1.9.6"
 strum = { version = "0.25.0", features = ["derive"] }
 strum_macros = "0.25.2"
@@ -62,9 +62,9 @@ debug = true
 strip = false
 
 [dev-dependencies]
-pyo3 = { version= "0.19.2", features = ["auto-initialize"] }
+pyo3 = { version = "0.20.0", features = ["auto-initialize"] }
 
 [build-dependencies]
 version_check = "0.9.4"
 # used where logic has to be version/distribution specific, e.g. pypy
-pyo3-build-config = { version = "0.19.2" }
+pyo3-build-config = { version = "0.20.0" }
diff --git a/src/errors/types.rs b/src/errors/types.rs
index d537158ba..e31307e2b 100644
--- a/src/errors/types.rs
+++ b/src/errors/types.rs
@@ -50,7 +50,7 @@ fn field_from_context<'py, T: FromPyObject<'py>>(
 ) -> PyResult<T> {
     context
         .ok_or_else(|| py_error_type!(PyTypeError; "{}: '{}' required in context", enum_name, field_name))?
-        .get_item(field_name)
+        .get_item(field_name)?
         .ok_or_else(|| py_error_type!(PyTypeError; "{}: '{}' required in context", enum_name, field_name))?
         .extract::<T>()
         .map_err(|_| py_error_type!(PyTypeError; "{}: '{}' context value must be a {}", enum_name, field_name, type_name_fn()))
diff --git a/src/errors/validation_exception.rs b/src/errors/validation_exception.rs
index 09154d8ac..cb3802d56 100644
--- a/src/errors/validation_exception.rs
+++ b/src/errors/validation_exception.rs
@@ -4,10 +4,10 @@ use std::str::from_utf8;
 
 use pyo3::exceptions::{PyKeyError, PyTypeError, PyValueError};
 use pyo3::ffi;
+use pyo3::intern;
 use pyo3::once_cell::GILOnceCell;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList, PyString};
-use pyo3::{intern, AsPyPointer};
 use serde::ser::{Error, SerializeMap, SerializeSeq};
 use serde::{Serialize, Serializer};
 
@@ -445,7 +445,7 @@ impl TryFrom<&PyAny> for PyLineError {
         let py = value.py();
 
         let type_raw = dict
-            .get_item(intern!(py, "type"))
+            .get_item(intern!(py, "type"))?
             .ok_or_else(|| PyKeyError::new_err("type"))?;
 
         let error_type = if let Ok(type_str) = type_raw.downcast::<PyString>() {
@@ -459,9 +459,9 @@ impl TryFrom<&PyAny> for PyLineError {
             ));
         };
 
-        let location = Location::try_from(dict.get_item("loc"))?;
+        let location = Location::try_from(dict.get_item("loc")?)?;
 
-        let input_value = match dict.get_item("input") {
+        let input_value = match dict.get_item("input")? {
             Some(i) => i.into_py(py),
             None => py.None(),
         };
diff --git a/src/errors/value_exception.rs b/src/errors/value_exception.rs
index f7d877b30..7bc7e5227 100644
--- a/src/errors/value_exception.rs
+++ b/src/errors/value_exception.rs
@@ -72,7 +72,7 @@ impl PydanticCustomError {
         }
     }
 
-    #[getter(type)]
+    #[getter(r#type)]
     pub fn error_type(&self) -> String {
         self.error_type.clone()
     }
@@ -147,7 +147,7 @@ impl PydanticKnownError {
         Ok(Self { error_type })
     }
 
-    #[getter(type)]
+    #[getter(r#type)]
     pub fn error_type(&self) -> String {
         self.error_type.to_string()
     }
diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index cf84c5517..cd8ecf267 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -8,7 +8,7 @@ use pyo3::types::{
 };
 #[cfg(not(PyPy))]
 use pyo3::types::{PyDictItems, PyDictKeys, PyDictValues};
-use pyo3::{intern, AsPyPointer, PyTypeInfo};
+use pyo3::{intern, PyTypeInfo};
 use speedate::MicrosecondsPrecisionOverflowBehavior;
 
 use crate::errors::{ErrorType, ErrorTypeDefaults, InputValue, LocItem, ValError, ValResult};
@@ -32,7 +32,7 @@ macro_rules! extract_dict_keys {
     ($py:expr, $obj:ident) => {
         $obj.downcast::<PyDictKeys>()
             .ok()
-            .map(|v| PyIterator::from_object($py, v).unwrap())
+            .map(|v| PyIterator::from_object(v).unwrap())
     };
 }
 
@@ -40,7 +40,7 @@ macro_rules! extract_dict_keys {
 macro_rules! extract_dict_keys {
     ($py:expr, $obj:ident) => {
         if is_dict_keys_type($obj) {
-            Some(PyIterator::from_object($py, $obj).unwrap())
+            Some(PyIterator::from_object($obj).unwrap())
         } else {
             None
         }
@@ -52,7 +52,7 @@ macro_rules! extract_dict_values {
     ($py:expr, $obj:ident) => {
         $obj.downcast::<PyDictValues>()
             .ok()
-            .map(|v| PyIterator::from_object($py, v).unwrap())
+            .map(|v| PyIterator::from_object(v).unwrap())
     };
 }
 
@@ -60,7 +60,7 @@ macro_rules! extract_dict_values {
 macro_rules! extract_dict_values {
     ($py:expr, $obj:ident) => {
         if is_dict_values_type($obj) {
-            Some(PyIterator::from_object($py, $obj).unwrap())
+            Some(PyIterator::from_object($obj).unwrap())
         } else {
             None
         }
@@ -72,7 +72,7 @@ macro_rules! extract_dict_items {
     ($py:expr, $obj:ident) => {
         $obj.downcast::<PyDictItems>()
             .ok()
-            .map(|v| PyIterator::from_object($py, v).unwrap())
+            .map(|v| PyIterator::from_object(v).unwrap())
     };
 }
 
@@ -80,7 +80,7 @@ macro_rules! extract_dict_items {
 macro_rules! extract_dict_items {
     ($py:expr, $obj:ident) => {
         if is_dict_items_type($obj) {
-            Some(PyIterator::from_object($py, $obj).unwrap())
+            Some(PyIterator::from_object($obj).unwrap())
         } else {
             None
         }
diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index c492f40f0..daa9f39fe 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -13,7 +13,7 @@ use pyo3::types::{
     PyByteArray, PyBytes, PyDict, PyFloat, PyFrozenSet, PyIterator, PyList, PyMapping, PySequence, PySet, PyString,
     PyTuple,
 };
-use pyo3::{ffi, intern, AsPyPointer, PyNativeType};
+use pyo3::{ffi, intern, PyNativeType};
 
 #[cfg(not(PyPy))]
 use pyo3::types::PyFunction;
diff --git a/src/lookup_key.rs b/src/lookup_key.rs
index 36190c069..bb7d7e3d7 100644
--- a/src/lookup_key.rs
+++ b/src/lookup_key.rs
@@ -111,7 +111,7 @@ impl LookupKey {
         dict: &'data PyDict,
     ) -> ValResult<'data, Option<(&'s LookupPath, &'data PyAny)>> {
         match self {
-            Self::Simple { py_key, path, .. } => match dict.get_item(py_key) {
+            Self::Simple { py_key, path, .. } => match dict.get_item(py_key)? {
                 Some(value) => Ok(Some((path, value))),
                 None => Ok(None),
             },
@@ -121,9 +121,9 @@ impl LookupKey {
                 py_key2,
                 path2,
                 ..
-            } => match dict.get_item(py_key1) {
+            } => match dict.get_item(py_key1)? {
                 Some(value) => Ok(Some((path1, value))),
-                None => match dict.get_item(py_key2) {
+                None => match dict.get_item(py_key2)? {
                     Some(value) => Ok(Some((path2, value))),
                     None => Ok(None),
                 },
diff --git a/src/serializers/extra.rs b/src/serializers/extra.rs
index 65c5a1ba9..7a9b84704 100644
--- a/src/serializers/extra.rs
+++ b/src/serializers/extra.rs
@@ -2,8 +2,8 @@ use std::cell::RefCell;
 use std::fmt;
 
 use pyo3::exceptions::PyValueError;
+use pyo3::intern;
 use pyo3::prelude::*;
-use pyo3::{intern, AsPyPointer};
 
 use serde::ser::Error;
 
diff --git a/src/serializers/filter.rs b/src/serializers/filter.rs
index 89f923552..0efec56e8 100644
--- a/src/serializers/filter.rs
+++ b/src/serializers/filter.rs
@@ -60,8 +60,8 @@ impl SchemaFilter<usize> {
         let py = schema.py();
         match schema.get_as::<&PyDict>(intern!(py, "serialization"))? {
             Some(ser) => {
-                let include = Self::build_set_ints(ser.get_item(intern!(py, "include")))?;
-                let exclude = Self::build_set_ints(ser.get_item(intern!(py, "exclude")))?;
+                let include = Self::build_set_ints(ser.get_item(intern!(py, "include"))?)?;
+                let exclude = Self::build_set_ints(ser.get_item(intern!(py, "exclude"))?)?;
                 Ok(Self { include, exclude })
             }
             None => Ok(SchemaFilter::default()),
@@ -325,8 +325,8 @@ fn is_ellipsis_like(v: &PyAny) -> bool {
 
 /// lookup the dict, for the key and "__all__" key, and merge them following the same rules as pydantic V1
 fn merge_all_value(dict: &PyDict, py_key: impl ToPyObject + Copy) -> PyResult<Option<&PyAny>> {
-    let op_item_value = dict.get_item(py_key);
-    let op_all_value = dict.get_item(intern!(dict.py(), "__all__"));
+    let op_item_value = dict.get_item(py_key)?;
+    let op_all_value = dict.get_item(intern!(dict.py(), "__all__"))?;
 
     match (op_item_value, op_all_value) {
         (Some(item_value), Some(all_value)) => {
@@ -365,7 +365,7 @@ fn merge_dicts<'py>(item_dict: &'py PyDict, all_value: &'py PyAny) -> PyResult<&
     let item_dict = item_dict.copy()?;
     if let Ok(all_dict) = all_value.downcast::<PyDict>() {
         for (all_key, all_value) in all_dict {
-            if let Some(item_value) = item_dict.get_item(all_key) {
+            if let Some(item_value) = item_dict.get_item(all_key)? {
                 if is_ellipsis_like(item_value) {
                     continue;
                 }
diff --git a/src/serializers/type_serializers/dict.rs b/src/serializers/type_serializers/dict.rs
index bb2a18633..89851752e 100644
--- a/src/serializers/type_serializers/dict.rs
+++ b/src/serializers/type_serializers/dict.rs
@@ -43,8 +43,8 @@ impl BuildSerializer for DictSerializer {
         };
         let filter = match schema.get_as::<&PyDict>(intern!(py, "serialization"))? {
             Some(ser) => {
-                let include = ser.get_item(intern!(py, "include"));
-                let exclude = ser.get_item(intern!(py, "exclude"));
+                let include = ser.get_item(intern!(py, "include"))?;
+                let exclude = ser.get_item(intern!(py, "exclude"))?;
                 SchemaFilter::from_set_hash(include, exclude)?
             }
             None => SchemaFilter::default(),
diff --git a/src/serializers/type_serializers/model.rs b/src/serializers/type_serializers/model.rs
index 8a2eeb4e1..0d2d1d346 100644
--- a/src/serializers/type_serializers/model.rs
+++ b/src/serializers/type_serializers/model.rs
@@ -39,7 +39,7 @@ impl BuildSerializer for ModelFieldsBuilder {
         let fields_dict: &PyDict = schema.get_as_req(intern!(py, "fields"))?;
         let mut fields: AHashMap<String, SerField> = AHashMap::with_capacity(fields_dict.len());
 
-        let extra_serializer = match (schema.get_item(intern!(py, "extras_schema")), &fields_mode) {
+        let extra_serializer = match (schema.get_item(intern!(py, "extras_schema"))?, &fields_mode) {
             (Some(v), FieldsMode::ModelExtra) => Some(CombinedSerializer::build(v.extract()?, config, definitions)?),
             (Some(_), _) => return py_schema_err!("extras_schema can only be used if extra_behavior=allow"),
             (_, _) => None,
diff --git a/src/serializers/type_serializers/typed_dict.rs b/src/serializers/type_serializers/typed_dict.rs
index 5967738ae..fbef3486a 100644
--- a/src/serializers/type_serializers/typed_dict.rs
+++ b/src/serializers/type_serializers/typed_dict.rs
@@ -35,7 +35,7 @@ impl BuildSerializer for TypedDictBuilder {
         let fields_dict: &PyDict = schema.get_as_req(intern!(py, "fields"))?;
         let mut fields: AHashMap<String, SerField> = AHashMap::with_capacity(fields_dict.len());
 
-        let extra_serializer = match (schema.get_item(intern!(py, "extras_schema")), &fields_mode) {
+        let extra_serializer = match (schema.get_item(intern!(py, "extras_schema"))?, &fields_mode) {
             (Some(v), FieldsMode::TypedDictAllow) => {
                 Some(CombinedSerializer::build(v.extract()?, config, definitions)?)
             }
diff --git a/src/tools.rs b/src/tools.rs
index 3c75decf1..af58131f5 100644
--- a/src/tools.rs
+++ b/src/tools.rs
@@ -20,7 +20,7 @@ impl<'py> SchemaDict<'py> for PyDict {
     where
         T: FromPyObject<'py>,
     {
-        match self.get_item(key) {
+        match self.get_item(key)? {
             Some(t) => Ok(Some(<T>::extract(t)?)),
             None => Ok(None),
         }
@@ -30,7 +30,7 @@ impl<'py> SchemaDict<'py> for PyDict {
     where
         T: FromPyObject<'py>,
     {
-        match self.get_item(key) {
+        match self.get_item(key)? {
             Some(t) => <T>::extract(t),
             None => py_err!(PyKeyError; "{}", key),
         }
diff --git a/src/validators/arguments.rs b/src/validators/arguments.rs
index aa0870043..7f406ba16 100644
--- a/src/validators/arguments.rs
+++ b/src/validators/arguments.rs
@@ -66,7 +66,7 @@ impl BuildValidator for ArgumentsValidator {
             let mut kw_lookup_key = None;
             let mut kwarg_key = None;
             if mode == "keyword_only" || mode == "positional_or_keyword" {
-                kw_lookup_key = match arg.get_item(intern!(py, "alias")) {
+                kw_lookup_key = match arg.get_item(intern!(py, "alias"))? {
                     Some(alias) => {
                         let alt_alias = if populate_by_name { Some(name.as_str()) } else { None };
                         Some(LookupKey::from_py(py, alias, alt_alias)?)
@@ -110,11 +110,11 @@ impl BuildValidator for ArgumentsValidator {
         Ok(Self {
             parameters,
             positional_params_count,
-            var_args_validator: match schema.get_item(intern!(py, "var_args_schema")) {
+            var_args_validator: match schema.get_item(intern!(py, "var_args_schema"))? {
                 Some(v) => Some(Box::new(build_validator(v, config, definitions)?)),
                 None => None,
             },
-            var_kwargs_validator: match schema.get_item(intern!(py, "var_kwargs_schema")) {
+            var_kwargs_validator: match schema.get_item(intern!(py, "var_kwargs_schema"))? {
                 Some(v) => Some(Box::new(build_validator(v, config, definitions)?)),
                 None => None,
             },
diff --git a/src/validators/bytes.rs b/src/validators/bytes.rs
index 0f662af1c..fb90187ac 100644
--- a/src/validators/bytes.rs
+++ b/src/validators/bytes.rs
@@ -24,8 +24,8 @@ impl BuildValidator for BytesValidator {
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
-        let use_constrained = schema.get_item(intern!(py, "max_length")).is_some()
-            || schema.get_item(intern!(py, "min_length")).is_some();
+        let use_constrained = schema.get_item(intern!(py, "max_length"))?.is_some()
+            || schema.get_item(intern!(py, "min_length"))?.is_some();
         if use_constrained {
             BytesConstrainedValidator::build(schema, config)
         } else {
diff --git a/src/validators/call.rs b/src/validators/call.rs
index 3f6eb4d35..eca1f0206 100644
--- a/src/validators/call.rs
+++ b/src/validators/call.rs
@@ -32,7 +32,7 @@ impl BuildValidator for CallValidator {
         let arguments_schema: &PyAny = schema.get_as_req(intern!(py, "arguments_schema"))?;
         let arguments_validator = Box::new(build_validator(arguments_schema, config, definitions)?);
 
-        let return_schema = schema.get_item(intern!(py, "return_schema"));
+        let return_schema = schema.get_item(intern!(py, "return_schema"))?;
         let return_validator = match return_schema {
             Some(return_schema) => Some(Box::new(build_validator(return_schema, config, definitions)?)),
             None => None,
diff --git a/src/validators/dataclass.rs b/src/validators/dataclass.rs
index 2706cadef..b18faea2c 100644
--- a/src/validators/dataclass.rs
+++ b/src/validators/dataclass.rs
@@ -56,7 +56,7 @@ impl BuildValidator for DataclassArgsValidator {
 
         let extra_behavior = ExtraBehavior::from_schema_or_config(py, schema, config, ExtraBehavior::Ignore)?;
 
-        let extras_validator = match (schema.get_item(intern!(py, "extras_schema")), &extra_behavior) {
+        let extras_validator = match (schema.get_item(intern!(py, "extras_schema"))?, &extra_behavior) {
             (Some(v), ExtraBehavior::Allow) => Some(Box::new(build_validator(v, config, definitions)?)),
             (Some(_), _) => return py_schema_err!("extras_schema can only be used if extra_behavior=allow"),
             (_, _) => None,
@@ -73,7 +73,7 @@ impl BuildValidator for DataclassArgsValidator {
             let py_name: &PyString = field.get_as_req(intern!(py, "name"))?;
             let name: String = py_name.extract()?;
 
-            let lookup_key = match field.get_item(intern!(py, "validation_alias")) {
+            let lookup_key = match field.get_item(intern!(py, "validation_alias"))? {
                 Some(alias) => {
                     let alt_alias = if populate_by_name { Some(name.as_str()) } else { None };
                     LookupKey::from_py(py, alias, alt_alias)?
@@ -584,7 +584,7 @@ impl Validator for DataclassValidator {
 
         if self.slots {
             let value = dc_dict
-                .get_item(field_name)
+                .get_item(field_name)?
                 .ok_or_else(|| PyKeyError::new_err(field_name.to_string()))?;
             force_setattr(py, obj, field_name, value)?;
         } else {
diff --git a/src/validators/datetime.rs b/src/validators/datetime.rs
index baf4ca467..5f1fc8bef 100644
--- a/src/validators/datetime.rs
+++ b/src/validators/datetime.rs
@@ -256,7 +256,7 @@ impl TZConstraint {
 
     pub(super) fn from_py(schema: &PyDict) -> PyResult<Option<Self>> {
         let py = schema.py();
-        let tz_constraint = match schema.get_item(intern!(py, "tz_constraint")) {
+        let tz_constraint = match schema.get_item(intern!(py, "tz_constraint"))? {
             Some(c) => c,
             None => return Ok(None),
         };
diff --git a/src/validators/decimal.rs b/src/validators/decimal.rs
index 211befe07..be19d1eda 100644
--- a/src/validators/decimal.rs
+++ b/src/validators/decimal.rs
@@ -1,7 +1,7 @@
 use pyo3::exceptions::{PyTypeError, PyValueError};
+use pyo3::intern;
 use pyo3::sync::GILOnceCell;
 use pyo3::types::{IntoPyDict, PyDict, PyTuple, PyType};
-use pyo3::{intern, AsPyPointer};
 use pyo3::{prelude::*, PyTypeInfo};
 
 use crate::build_tools::{is_strict, schema_or_config_same};
diff --git a/src/validators/dict.rs b/src/validators/dict.rs
index 250145290..5026afba3 100644
--- a/src/validators/dict.rs
+++ b/src/validators/dict.rs
@@ -35,11 +35,11 @@ impl BuildValidator for DictValidator {
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
-        let key_validator = match schema.get_item(intern!(py, "keys_schema")) {
+        let key_validator = match schema.get_item(intern!(py, "keys_schema"))? {
             Some(schema) => Box::new(build_validator(schema, config, definitions)?),
             None => Box::new(AnyValidator::build(schema, config, definitions)?),
         };
-        let value_validator = match schema.get_item(intern!(py, "values_schema")) {
+        let value_validator = match schema.get_item(intern!(py, "values_schema"))? {
             Some(d) => Box::new(build_validator(d, config, definitions)?),
             None => Box::new(AnyValidator::build(schema, config, definitions)?),
         };
diff --git a/src/validators/float.rs b/src/validators/float.rs
index 2e9434d9f..1d62d2006 100644
--- a/src/validators/float.rs
+++ b/src/validators/float.rs
@@ -19,11 +19,11 @@ impl BuildValidator for FloatBuilder {
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
-        let use_constrained = schema.get_item(intern!(py, "multiple_of")).is_some()
-            || schema.get_item(intern!(py, "le")).is_some()
-            || schema.get_item(intern!(py, "lt")).is_some()
-            || schema.get_item(intern!(py, "ge")).is_some()
-            || schema.get_item(intern!(py, "gt")).is_some();
+        let use_constrained = schema.get_item(intern!(py, "multiple_of"))?.is_some()
+            || schema.get_item(intern!(py, "le"))?.is_some()
+            || schema.get_item(intern!(py, "lt"))?.is_some()
+            || schema.get_item(intern!(py, "ge"))?.is_some()
+            || schema.get_item(intern!(py, "gt"))?.is_some();
         if use_constrained {
             ConstrainedFloatValidator::build(schema, config, definitions)
         } else {
diff --git a/src/validators/int.rs b/src/validators/int.rs
index 0903e1998..1a807d1ef 100644
--- a/src/validators/int.rs
+++ b/src/validators/int.rs
@@ -25,11 +25,11 @@ impl BuildValidator for IntValidator {
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
-        let use_constrained = schema.get_item(intern!(py, "multiple_of")).is_some()
-            || schema.get_item(intern!(py, "le")).is_some()
-            || schema.get_item(intern!(py, "lt")).is_some()
-            || schema.get_item(intern!(py, "ge")).is_some()
-            || schema.get_item(intern!(py, "gt")).is_some();
+        let use_constrained = schema.get_item(intern!(py, "multiple_of"))?.is_some()
+            || schema.get_item(intern!(py, "le"))?.is_some()
+            || schema.get_item(intern!(py, "lt"))?.is_some()
+            || schema.get_item(intern!(py, "ge"))?.is_some()
+            || schema.get_item(intern!(py, "gt"))?.is_some();
         if use_constrained {
             ConstrainedIntValidator::build(schema, config)
         } else {
diff --git a/src/validators/list.rs b/src/validators/list.rs
index 8e931657f..c0af5fcb5 100644
--- a/src/validators/list.rs
+++ b/src/validators/list.rs
@@ -23,7 +23,7 @@ pub fn get_items_schema(
     config: Option<&PyDict>,
     definitions: &mut DefinitionsBuilder<CombinedValidator>,
 ) -> PyResult<Option<CombinedValidator>> {
-    match schema.get_item(pyo3::intern!(schema.py(), "items_schema")) {
+    match schema.get_item(pyo3::intern!(schema.py(), "items_schema"))? {
         Some(d) => {
             let validator = build_validator(d, config, definitions)?;
             match validator {
diff --git a/src/validators/literal.rs b/src/validators/literal.rs
index 25cb94bd9..19bbe91f5 100644
--- a/src/validators/literal.rs
+++ b/src/validators/literal.rs
@@ -126,7 +126,7 @@ impl<T: Debug> LiteralLookup<T> {
         }
         // must be an enum or bytes
         if let Some(expected_py) = &self.expected_py {
-            if let Some(v) = expected_py.as_ref(py).get_item(input) {
+            if let Some(v) = expected_py.as_ref(py).get_item(input)? {
                 let id: usize = v.extract().unwrap();
                 return Ok(Some((input, &self.values[id])));
             }
diff --git a/src/validators/mod.rs b/src/validators/mod.rs
index 5db192f3a..2a4cbf165 100644
--- a/src/validators/mod.rs
+++ b/src/validators/mod.rs
@@ -130,7 +130,7 @@ impl SchemaValidator {
             _ => None,
         };
         let config_title = match config {
-            Some(c) => c.get_item("title"),
+            Some(c) => c.get_item("title")?,
             None => None,
         };
         let title = match config_title {
diff --git a/src/validators/model_fields.rs b/src/validators/model_fields.rs
index 774d3eef9..b79145c97 100644
--- a/src/validators/model_fields.rs
+++ b/src/validators/model_fields.rs
@@ -58,7 +58,7 @@ impl BuildValidator for ModelFieldsValidator {
 
         let extra_behavior = ExtraBehavior::from_schema_or_config(py, schema, config, ExtraBehavior::Ignore)?;
 
-        let extras_validator = match (schema.get_item(intern!(py, "extras_schema")), &extra_behavior) {
+        let extras_validator = match (schema.get_item(intern!(py, "extras_schema"))?, &extra_behavior) {
             (Some(v), ExtraBehavior::Allow) => Some(Box::new(build_validator(v, config, definitions)?)),
             (Some(_), _) => return py_schema_err!("extras_schema can only be used if extra_behavior=allow"),
             (_, _) => None,
@@ -81,7 +81,7 @@ impl BuildValidator for ModelFieldsValidator {
                 Err(err) => return py_schema_err!("Field \"{}\":\n  {}", field_name, err),
             };
 
-            let lookup_key = match field_info.get_item(intern!(py, "validation_alias")) {
+            let lookup_key = match field_info.get_item(intern!(py, "validation_alias"))? {
                 Some(alias) => {
                     let alt_alias = if populate_by_name { Some(field_name) } else { None };
                     LookupKey::from_py(py, alias, alt_alias)?
diff --git a/src/validators/set.rs b/src/validators/set.rs
index 626572139..9270ea204 100644
--- a/src/validators/set.rs
+++ b/src/validators/set.rs
@@ -25,7 +25,7 @@ macro_rules! set_build {
             definitions: &mut DefinitionsBuilder<CombinedValidator>,
         ) -> PyResult<CombinedValidator> {
             let py = schema.py();
-            let item_validator = match schema.get_item(pyo3::intern!(schema.py(), "items_schema")) {
+            let item_validator = match schema.get_item(pyo3::intern!(schema.py(), "items_schema"))? {
                 Some(d) => Box::new(crate::validators::build_validator(d, config, definitions)?),
                 None => Box::new(crate::validators::any::AnyValidator::build(
                     schema,
diff --git a/src/validators/string.rs b/src/validators/string.rs
index 4eab4602a..0be51ece8 100644
--- a/src/validators/string.rs
+++ b/src/validators/string.rs
@@ -189,10 +189,10 @@ impl StrConstrainedValidator {
         let to_upper: bool =
             schema_or_config(schema, config, intern!(py, "to_upper"), intern!(py, "str_to_upper"))?.unwrap_or(false);
 
-        let coerce_numbers_to_str = config
-            .and_then(|c| c.get_item("coerce_numbers_to_str"))
-            .and_then(|v| v.is_true().ok())
-            .unwrap_or(false);
+        let coerce_numbers_to_str = match config {
+            Some(c) => c.get_item("coerce_numbers_to_str")?.map_or(Ok(false), PyAny::is_true)?,
+            None => false,
+        };
 
         Ok(Self {
             strict: is_strict(schema, config)?,
diff --git a/src/validators/timedelta.rs b/src/validators/timedelta.rs
index 21340f2f0..a58d98f7a 100644
--- a/src/validators/timedelta.rs
+++ b/src/validators/timedelta.rs
@@ -25,7 +25,7 @@ struct TimedeltaConstraints {
 }
 
 fn get_constraint(schema: &PyDict, key: &str) -> PyResult<Option<Duration>> {
-    match schema.get_item(key) {
+    match schema.get_item(key)? {
         Some(value) => {
             let either_timedelta = EitherTimedelta::try_from(value)?;
             Ok(Some(either_timedelta.to_duration()?))
diff --git a/src/validators/tuple.rs b/src/validators/tuple.rs
index cfa239e3b..1b7cf9b00 100644
--- a/src/validators/tuple.rs
+++ b/src/validators/tuple.rs
@@ -113,7 +113,7 @@ impl BuildValidator for TuplePositionalValidator {
         Ok(Self {
             strict: is_strict(schema, config)?,
             items_validators: validators,
-            extras_validator: match schema.get_item(intern!(py, "extras_schema")) {
+            extras_validator: match schema.get_item(intern!(py, "extras_schema"))? {
                 Some(v) => Some(Box::new(build_validator(v, config, definitions)?)),
                 None => None,
             },
diff --git a/src/validators/typed_dict.rs b/src/validators/typed_dict.rs
index 118d992a2..dab492da7 100644
--- a/src/validators/typed_dict.rs
+++ b/src/validators/typed_dict.rs
@@ -61,7 +61,7 @@ impl BuildValidator for TypedDictValidator {
 
         let extra_behavior = ExtraBehavior::from_schema_or_config(py, schema, config, ExtraBehavior::Ignore)?;
 
-        let extras_validator = match (schema.get_item(intern!(py, "extras_schema")), &extra_behavior) {
+        let extras_validator = match (schema.get_item(intern!(py, "extras_schema"))?, &extra_behavior) {
             (Some(v), ExtraBehavior::Allow) => Some(Box::new(build_validator(v, config, definitions)?)),
             (Some(_), _) => return py_schema_err!("extras_schema can only be used if extra_behavior=allow"),
             (_, _) => None,
@@ -109,7 +109,7 @@ impl BuildValidator for TypedDictValidator {
                 }
             }
 
-            let lookup_key = match field_info.get_item(intern!(py, "validation_alias")) {
+            let lookup_key = match field_info.get_item(intern!(py, "validation_alias"))? {
                 Some(alias) => {
                     let alt_alias = if populate_by_name { Some(field_name) } else { None };
                     LookupKey::from_py(py, alias, alt_alias)?
diff --git a/src/validators/union.rs b/src/validators/union.rs
index 79a21e78d..a8bd29d7d 100644
--- a/src/validators/union.rs
+++ b/src/validators/union.rs
@@ -518,7 +518,7 @@ impl TaggedUnionValidator {
     ) -> ValResult<'data, &'data PyString> {
         let dict = input.strict_dict()?;
         let either_tag = match dict {
-            GenericMapping::PyDict(dict) => match dict.get_item(intern!(py, "type")) {
+            GenericMapping::PyDict(dict) => match dict.get_item(intern!(py, "type"))? {
                 Some(t) => t.strict_str()?,
                 None => return Err(self.tag_not_found(input)),
             },
@@ -529,7 +529,7 @@ impl TaggedUnionValidator {
         // custom logic to distinguish between different function and tuple schemas
         if tag == "function" || tag == "tuple" {
             let mode = match dict {
-                GenericMapping::PyDict(dict) => match dict.get_item(intern!(py, "mode")) {
+                GenericMapping::PyDict(dict) => match dict.get_item(intern!(py, "mode"))? {
                     Some(m) => Some(m.strict_str()?),
                     None => None,
                 },
diff --git a/tests/test.rs b/tests/test.rs
index 9b2fb99b5..348520435 100644
--- a/tests/test.rs
+++ b/tests/test.rs
@@ -75,8 +75,8 @@ a = A()
             "#;
             let locals = PyDict::new(py);
             py.run(code, None, Some(locals)).unwrap();
-            let a: &PyAny = locals.get_item("a").unwrap().extract().unwrap();
-            let schema: &PyDict = locals.get_item("schema").unwrap().extract().unwrap();
+            let a: &PyAny = locals.get_item("a").unwrap().unwrap().extract().unwrap();
+            let schema: &PyDict = locals.get_item("schema").unwrap().unwrap().extract().unwrap();
             let serialized: Vec<u8> = SchemaSerializer::py_new(py, schema, None)
                 .unwrap()
                 .to_json(py, a, None, None, None, true, false, false, false, false, true, None)

From 005c8a752d6335d78a1f8cda5179cbbd3f44992e Mon Sep 17 00:00:00 2001
From: Eric Jolibois <em.jolibois@gmail.com>
Date: Sun, 15 Oct 2023 09:56:38 +0200
Subject: [PATCH 070/550] feat: add `ser_json_bytes` mode `'hex'` (#1016)

---
 python/pydantic_core/core_schema.py |  2 +-
 src/serializers/config.rs           | 13 ++++++++++++-
 tests/serializers/test_bytes.py     |  7 +++++++
 3 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index adb8e5647..40d1eec77 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -101,7 +101,7 @@ class CoreConfig(TypedDict, total=False):
     allow_inf_nan: bool  # default: True
     # the config options are used to customise serialization to JSON
     ser_json_timedelta: Literal['iso8601', 'float']  # default: 'iso8601'
-    ser_json_bytes: Literal['utf8', 'base64']  # default: 'utf8'
+    ser_json_bytes: Literal['utf8', 'base64', 'hex']  # default: 'utf8'
     # used to hide input data from ValidationError repr
     hide_input_in_errors: bool
     validation_error_cause: bool  # default: False
diff --git a/src/serializers/config.rs b/src/serializers/config.rs
index 4f3611129..fb65623b7 100644
--- a/src/serializers/config.rs
+++ b/src/serializers/config.rs
@@ -129,6 +129,7 @@ pub(crate) enum BytesMode {
     #[default]
     Utf8,
     Base64,
+    Hex,
 }
 
 impl FromStr for BytesMode {
@@ -138,7 +139,11 @@ impl FromStr for BytesMode {
         match s {
             "utf8" => Ok(Self::Utf8),
             "base64" => Ok(Self::Base64),
-            s => py_schema_err!("Invalid bytes serialization mode: `{}`, expected `utf8` or `base64`", s),
+            "hex" => Ok(Self::Hex),
+            s => py_schema_err!(
+                "Invalid bytes serialization mode: `{}`, expected `utf8`, `base64` or `hex`",
+                s
+            ),
         }
     }
 }
@@ -158,6 +163,9 @@ impl BytesMode {
                 .map_err(|err| utf8_py_error(py, err, bytes))
                 .map(Cow::Borrowed),
             Self::Base64 => Ok(Cow::Owned(base64::engine::general_purpose::URL_SAFE.encode(bytes))),
+            Self::Hex => Ok(Cow::Owned(
+                bytes.iter().fold(String::new(), |acc, b| acc + &format!("{b:02x}")),
+            )),
         }
     }
 
@@ -168,6 +176,9 @@ impl BytesMode {
                 Err(e) => Err(Error::custom(e.to_string())),
             },
             Self::Base64 => serializer.serialize_str(&base64::engine::general_purpose::URL_SAFE.encode(bytes)),
+            Self::Hex => {
+                serializer.serialize_str(&bytes.iter().fold(String::new(), |acc, b| acc + &format!("{b:02x}")))
+            }
         }
     }
 }
diff --git a/tests/serializers/test_bytes.py b/tests/serializers/test_bytes.py
index e313138c9..13849bed0 100644
--- a/tests/serializers/test_bytes.py
+++ b/tests/serializers/test_bytes.py
@@ -105,6 +105,13 @@ def test_bytes_base64():
     assert base64.b64decode(s.to_python(b'foo bar', mode='json').encode()) == b'foo bar'
 
 
+def test_bytes_hex():
+    s = SchemaSerializer(core_schema.bytes_schema(), {'ser_json_bytes': 'hex'})
+    assert s.to_python(b'\xff\xff') == b'\xff\xff'
+    assert s.to_json(b'\xff\xff') == b'"ffff"'
+    assert s.to_python(b'\xff\xff', mode='json') == 'ffff' == b'\xff\xff'.hex()
+
+
 def test_bytes_base64_dict_key():
     s = SchemaSerializer(core_schema.dict_schema(core_schema.bytes_schema()), {'ser_json_bytes': 'base64'})
 

From e866c1111181c8b4729636fb88ed2ad3b515718f Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 16 Oct 2023 13:01:01 +0100
Subject: [PATCH 071/550] Bump strum_macros from 0.25.2 to 0.25.3 (#1021)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 3c2af0c54..9e19810d3 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -460,9 +460,9 @@ dependencies = [
 
 [[package]]
 name = "strum_macros"
-version = "0.25.2"
+version = "0.25.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad8d03b598d3d0fff69bf533ee3ef19b8eeb342729596df84bcc7e1f96ec4059"
+checksum = "23dc1fa9ac9c169a78ba62f0b841814b7abae11bdd047b9c58f893439e309ea0"
 dependencies = [
  "heck",
  "proc-macro2",
diff --git a/Cargo.toml b/Cargo.toml
index 4a6541781..3afde2c50 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -29,7 +29,7 @@ include = [
 pyo3 = { version = "0.20.0", features = ["generate-import-lib", "num-bigint"] }
 regex = "1.9.6"
 strum = { version = "0.25.0", features = ["derive"] }
-strum_macros = "0.25.2"
+strum_macros = "0.25.3"
 serde_json = {version = "1.0.107", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.8"
 serde = { version = "1.0.188", features = ["derive"] }

From 085342ba351ddd7ef3452ff6fa8de05224a87531 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 16 Oct 2023 13:01:16 +0100
Subject: [PATCH 072/550] Bump serde from 1.0.188 to 1.0.189 (#1019)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 8 ++++----
 Cargo.toml | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 9e19810d3..350a03e14 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -403,18 +403,18 @@ checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
 
 [[package]]
 name = "serde"
-version = "1.0.188"
+version = "1.0.189"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cf9e0fcba69a370eed61bcf2b728575f726b50b55cba78064753d708ddc7549e"
+checksum = "8e422a44e74ad4001bdc8eede9a4570ab52f71190e9c076d14369f38b9200537"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.188"
+version = "1.0.189"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4eca7ac642d82aa35b60049a6eccb4be6be75e599bd2e9adb5f875a737654af2"
+checksum = "1e48d1f918009ce3145511378cf68d613e3b3d9137d67272562080d68a2b32d5"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/Cargo.toml b/Cargo.toml
index 3afde2c50..184f6ba0a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -32,7 +32,7 @@ strum = { version = "0.25.0", features = ["derive"] }
 strum_macros = "0.25.3"
 serde_json = {version = "1.0.107", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.8"
-serde = { version = "1.0.188", features = ["derive"] }
+serde = { version = "1.0.189", features = ["derive"] }
 speedate = "0.12.0"
 smallvec = "1.11.1"
 ahash = "0.8.0"

From d0704489f45045f3699f1d949e5dd96bb5ccf4c3 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 16 Oct 2023 13:02:09 +0100
Subject: [PATCH 073/550] Bump regex from 1.9.6 to 1.10.1 (#1020)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 12 ++++++------
 Cargo.toml |  2 +-
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 350a03e14..91e0a13c7 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -356,9 +356,9 @@ dependencies = [
 
 [[package]]
 name = "regex"
-version = "1.9.6"
+version = "1.10.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ebee201405406dbf528b8b672104ae6d6d63e6d118cb10e4d51abbc7b58044ff"
+checksum = "aaac441002f822bc9705a681810a4dd2963094b9ca0ddc41cb963a4c189189ea"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -368,9 +368,9 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.3.9"
+version = "0.4.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "59b23e92ee4318893fa3fe3e6fb365258efbfe6ac6ab30f090cdcbb7aa37efa9"
+checksum = "5011c7e263a695dc8ca064cddb722af1be54e517a280b12a5356f98366899e5d"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -379,9 +379,9 @@ dependencies = [
 
 [[package]]
 name = "regex-syntax"
-version = "0.7.5"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dbb5fb1acd8a1a18b3dd5be62d25485eb770e05afb408a9627d14d451bae12da"
+checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f"
 
 [[package]]
 name = "rustversion"
diff --git a/Cargo.toml b/Cargo.toml
index 184f6ba0a..1cb996450 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -27,7 +27,7 @@ include = [
 
 [dependencies]
 pyo3 = { version = "0.20.0", features = ["generate-import-lib", "num-bigint"] }
-regex = "1.9.6"
+regex = "1.10.1"
 strum = { version = "0.25.0", features = ["derive"] }
 strum_macros = "0.25.3"
 serde_json = {version = "1.0.107", features = ["arbitrary_precision", "preserve_order"]}

From b697abfbb2ab7381996e49697e5355b96ca7184b Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 16 Oct 2023 12:03:25 +0000
Subject: [PATCH 074/550] Bump pyright from 1.1.330.post0 to 1.1.331 (#1023)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index 25b74ce08..48a7e4a04 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,5 +1,5 @@
 black==23.9.1
 griffe==0.36.4
-pyright==1.1.330.post0
+pyright==1.1.331
 ruff==0.0.292
 mypy==1.5.1

From 1b7b6e90979451f89f709a0cc940846828da7d68 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 16 Oct 2023 12:12:05 +0000
Subject: [PATCH 075/550] Bump mypy from 1.5.1 to 1.6.0 (#1022)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index 48a7e4a04..7008082ff 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -2,4 +2,4 @@ black==23.9.1
 griffe==0.36.4
 pyright==1.1.331
 ruff==0.0.292
-mypy==1.5.1
+mypy==1.6.0

From f8c0920c977f2755c4c95381beac059b4142ec0e Mon Sep 17 00:00:00 2001
From: sydney-runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Mon, 16 Oct 2023 07:21:05 -0500
Subject: [PATCH 076/550] Fix bug allowing validation of `bool` types with
 `coerce_numbers_to_str=True` (#1017)

---
 src/input/input_python.rs       |  3 ++-
 tests/validators/test_string.py | 10 ++++++++++
 2 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index cd8ecf267..fe688a487 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -246,10 +246,11 @@ impl<'a> Input<'a> for PyAny {
                 Err(_) => return Err(ValError::new(ErrorTypeDefaults::StringUnicode, self)),
             };
             Ok(s.into())
-        } else if coerce_numbers_to_str && {
+        } else if coerce_numbers_to_str && !PyBool::is_exact_type_of(self) && {
             let py = self.py();
             let decimal_type: Py<PyType> = get_decimal_type(py);
 
+            // only allow int, float, and decimal (not bool)
             self.is_instance_of::<PyInt>()
                 || self.is_instance_of::<PyFloat>()
                 || self.is_instance(decimal_type.as_ref(py)).unwrap_or_default()
diff --git a/tests/validators/test_string.py b/tests/validators/test_string.py
index acb145a58..cab6e5127 100644
--- a/tests/validators/test_string.py
+++ b/tests/validators/test_string.py
@@ -277,6 +277,16 @@ def test_coerce_numbers_to_str_disabled_in_strict_mode() -> None:
         v.validate_json('42')
 
 
+def test_coerce_numbers_to_str_raises_for_bool() -> None:
+    config = core_schema.CoreConfig(coerce_numbers_to_str=True)
+
+    v = SchemaValidator(core_schema.str_schema(), config)
+    with pytest.raises(ValidationError):
+        v.validate_python(True)
+    with pytest.raises(ValidationError):
+        v.validate_json(False)
+
+
 @pytest.mark.parametrize(
     ('number', 'expected_str'),
     [

From 38c9e64e61bdca5e487cee7ed8399a9e43e189bd Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 16 Oct 2023 12:22:02 +0000
Subject: [PATCH 077/550] Bump griffe from 0.36.4 to 0.36.5 (#1025)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index 7008082ff..bcc66c749 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,5 +1,5 @@
 black==23.9.1
-griffe==0.36.4
+griffe==0.36.5
 pyright==1.1.331
 ruff==0.0.292
 mypy==1.6.0

From f8470df75b62c061caf5c5c09e26c5d2ac94aa8d Mon Sep 17 00:00:00 2001
From: David Hewitt <1939362+davidhewitt@users.noreply.github.com>
Date: Tue, 17 Oct 2023 19:20:28 +0100
Subject: [PATCH 078/550] Bump version to 2.11.0 (#1027)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 91e0a13c7..95d0363bc 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -242,7 +242,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.10.1"
+version = "2.11.0"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index 1cb996450..ed3ea71ed 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.10.1"
+version = "2.11.0"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From 8f347ff780a358f3c5efdf0593cc32b786b14b53 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 23 Oct 2023 14:03:42 +0100
Subject: [PATCH 079/550] Bump regex from 1.10.1 to 1.10.2 (#1036)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 8 ++++----
 Cargo.toml | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 95d0363bc..7e11a04cf 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -356,9 +356,9 @@ dependencies = [
 
 [[package]]
 name = "regex"
-version = "1.10.1"
+version = "1.10.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "aaac441002f822bc9705a681810a4dd2963094b9ca0ddc41cb963a4c189189ea"
+checksum = "380b951a9c5e80ddfd6136919eef32310721aa4aacd4889a8d39124b026ab343"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -368,9 +368,9 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.4.2"
+version = "0.4.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5011c7e263a695dc8ca064cddb722af1be54e517a280b12a5356f98366899e5d"
+checksum = "5f804c7828047e88b2d32e2d7fe5a105da8ee3264f01902f796c8e067dc2483f"
 dependencies = [
  "aho-corasick",
  "memchr",
diff --git a/Cargo.toml b/Cargo.toml
index ed3ea71ed..a5309acc4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -27,7 +27,7 @@ include = [
 
 [dependencies]
 pyo3 = { version = "0.20.0", features = ["generate-import-lib", "num-bigint"] }
-regex = "1.10.1"
+regex = "1.10.2"
 strum = { version = "0.25.0", features = ["derive"] }
 strum_macros = "0.25.3"
 serde_json = {version = "1.0.107", features = ["arbitrary_precision", "preserve_order"]}

From a3c367ec4fbe9242cb44a411d0051bc696279ae3 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 23 Oct 2023 14:04:16 +0100
Subject: [PATCH 080/550] Bump uuid from 1.4.1 to 1.5.0 (#1035)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 7e11a04cf..22f882816 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -543,9 +543,9 @@ dependencies = [
 
 [[package]]
 name = "uuid"
-version = "1.4.1"
+version = "1.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "79daa5ed5740825c40b389c5e50312b9c86df53fccd33f281df655642b43869d"
+checksum = "88ad59a7560b41a70d191093a945f0b87bc1deeda46fb237479708a1d6b6cdfc"
 
 [[package]]
 name = "version_check"
diff --git a/Cargo.toml b/Cargo.toml
index a5309acc4..03c6bda1b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -42,7 +42,7 @@ idna = "0.4.0"
 base64 = "0.21.4"
 num-bigint = "0.4.4"
 python3-dll-a = "0.2.7"
-uuid = "1.4.1"
+uuid = "1.5.0"
 
 [lib]
 name = "_pydantic_core"

From ad1d384568a0847bd9577ec7e3cc7e4fd4d5373f Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 23 Oct 2023 14:04:38 +0100
Subject: [PATCH 081/550] Bump ahash from 0.8.3 to 0.8.4 (#1034)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 33 +++++++++++++++++++++++++++------
 Cargo.toml |  2 +-
 2 files changed, 28 insertions(+), 7 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 22f882816..ed5454a87 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4,14 +4,15 @@ version = 3
 
 [[package]]
 name = "ahash"
-version = "0.8.3"
+version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c99f64d1e06488f620f932677e24bc6e2897582980441ae90a671415bd7ec2f"
+checksum = "72832d73be48bac96a5d7944568f305d829ed55b0ce3b483647089dfaf6cf704"
 dependencies = [
  "cfg-if",
  "getrandom",
  "once_cell",
  "version_check",
+ "zerocopy",
 ]
 
 [[package]]
@@ -233,9 +234,9 @@ checksum = "9b2a4787296e9989611394c33f193f676704af1686e70b8f8033ab5ba9a35a94"
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.64"
+version = "1.0.69"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "78803b62cbf1f46fde80d7c0e803111524b9877184cfe7c3033659490ac7a7da"
+checksum = "134c189feb4956b20f6f547d2cf727d4c0fe06722b20a0eec87ed445a97f92da"
 dependencies = [
  "unicode-ident",
 ]
@@ -473,9 +474,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.28"
+version = "2.0.38"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04361975b3f5e348b2189d8dc55bc942f278b2d482a6a0365de5bdd62d351567"
+checksum = "e96b79aaa137db8f61e26363a0c9b47d8b4ec75da28b7d1d614c2303e232408b"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -615,3 +616,23 @@ name = "windows_x86_64_msvc"
 version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1a515f5799fe4961cb532f983ce2b23082366b898e52ffbce459c86f67c8378a"
+
+[[package]]
+name = "zerocopy"
+version = "0.7.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "4c19fae0c8a9efc6a8281f2e623db8af1db9e57852e04cde3e754dd2dc29340f"
+dependencies = [
+ "zerocopy-derive",
+]
+
+[[package]]
+name = "zerocopy-derive"
+version = "0.7.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fc56589e9ddd1f1c28d4b4b5c773ce232910a6bb67a70133d61c9e347585efe9"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
diff --git a/Cargo.toml b/Cargo.toml
index 03c6bda1b..83b774ecd 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -35,7 +35,7 @@ enum_dispatch = "0.3.8"
 serde = { version = "1.0.189", features = ["derive"] }
 speedate = "0.12.0"
 smallvec = "1.11.1"
-ahash = "0.8.0"
+ahash = "0.8.4"
 url = "2.4.1"
 # idna is already required by url, added here to be explicit
 idna = "0.4.0"

From 53619bf8c60564f80db428cef2f2a06cbbd05408 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 23 Oct 2023 14:05:03 +0100
Subject: [PATCH 082/550] Bump base64 from 0.21.4 to 0.21.5 (#1033)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index ed5454a87..7c1ef6624 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -32,9 +32,9 @@ checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
 
 [[package]]
 name = "base64"
-version = "0.21.4"
+version = "0.21.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ba43ea6f343b788c8764558649e08df62f86c6ef251fdaeb1ffd010a9ae50a2"
+checksum = "35636a1494ede3b646cc98f74f8e62c773a38a659ebc777a2cf26b9b74171df9"
 
 [[package]]
 name = "bitflags"
diff --git a/Cargo.toml b/Cargo.toml
index 83b774ecd..ced489442 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -39,7 +39,7 @@ ahash = "0.8.4"
 url = "2.4.1"
 # idna is already required by url, added here to be explicit
 idna = "0.4.0"
-base64 = "0.21.4"
+base64 = "0.21.5"
 num-bigint = "0.4.4"
 python3-dll-a = "0.2.7"
 uuid = "1.5.0"

From 81924c0a864fb1ef9c7bc3c795a429c861640c5f Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 23 Oct 2023 14:05:16 +0100
Subject: [PATCH 083/550] Bump ruff from 0.0.292 to 0.1.1 (#1032)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index bcc66c749..21040cbb5 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,5 +1,5 @@
 black==23.9.1
 griffe==0.36.5
 pyright==1.1.331
-ruff==0.0.292
+ruff==0.1.1
 mypy==1.6.0

From 45e8df311be4082eec5de7cc57174e47b86dcaa6 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 23 Oct 2023 14:05:34 +0100
Subject: [PATCH 084/550] Bump griffe from 0.36.5 to 0.36.7 (#1031)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index 21040cbb5..8fde2c0a7 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,5 +1,5 @@
 black==23.9.1
-griffe==0.36.5
+griffe==0.36.7
 pyright==1.1.331
 ruff==0.1.1
 mypy==1.6.0

From f59bcc7b16d17c9ff19a074c5494ffbf86d90047 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 23 Oct 2023 13:13:21 +0000
Subject: [PATCH 085/550] Bump pyright from 1.1.331 to 1.1.332 (#1029)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index 8fde2c0a7..8531d72dd 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,5 +1,5 @@
 black==23.9.1
 griffe==0.36.7
-pyright==1.1.331
+pyright==1.1.332
 ruff==0.1.1
 mypy==1.6.0

From 22255ad209cc879488e9ea4e3fd17b3d4a8feb72 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 23 Oct 2023 13:14:16 +0000
Subject: [PATCH 086/550] Bump mypy from 1.6.0 to 1.6.1 (#1030)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index 8531d72dd..2f5b20469 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -2,4 +2,4 @@ black==23.9.1
 griffe==0.36.7
 pyright==1.1.332
 ruff==0.1.1
-mypy==1.6.0
+mypy==1.6.1

From acf15bf30205c1ae72689051055b0d253b46a505 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 23 Oct 2023 13:22:23 +0000
Subject: [PATCH 087/550] Bump black from 23.9.1 to 23.10.0 (#1028)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index 2f5b20469..91e454abf 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,4 +1,4 @@
-black==23.9.1
+black==23.10.0
 griffe==0.36.7
 pyright==1.1.332
 ruff==0.1.1

From 23d106551d14214f24a0bcd577b74a672ccfd0c0 Mon Sep 17 00:00:00 2001
From: David Hewitt <1939362+davidhewitt@users.noreply.github.com>
Date: Wed, 25 Oct 2023 09:52:26 +0100
Subject: [PATCH 088/550] Don't accept NaN in float and decimal constraints
 (#1037)

---
 src/validators/decimal.rs        | 19 +++++++++++++++----
 src/validators/float.rs          | 10 ++++++----
 tests/validators/test_decimal.py |  4 ++++
 tests/validators/test_float.py   |  4 ++++
 4 files changed, 29 insertions(+), 8 deletions(-)

diff --git a/src/validators/decimal.rs b/src/validators/decimal.rs
index be19d1eda..730eeac69 100644
--- a/src/validators/decimal.rs
+++ b/src/validators/decimal.rs
@@ -182,8 +182,19 @@ impl Validator for DecimalValidator {
             }
         }
 
+        // Decimal raises DecimalOperation when comparing NaN, so if it's necessary to compare
+        // the value to a number, we need to check for NaN first. We cache the result on the first
+        // time we check it.
+        let mut is_nan: Option<bool> = None;
+        let mut is_nan = || -> PyResult<bool> {
+            match is_nan {
+                Some(is_nan) => Ok(is_nan),
+                None => Ok(*is_nan.insert(decimal.call_method0(intern!(py, "is_nan"))?.extract()?)),
+            }
+        };
+
         if let Some(le) = &self.le {
-            if !decimal.le(le)? {
+            if is_nan()? || !decimal.le(le)? {
                 return Err(ValError::new(
                     ErrorType::LessThanEqual {
                         le: Number::String(le.to_string()),
@@ -194,7 +205,7 @@ impl Validator for DecimalValidator {
             }
         }
         if let Some(lt) = &self.lt {
-            if !decimal.lt(lt)? {
+            if is_nan()? || !decimal.lt(lt)? {
                 return Err(ValError::new(
                     ErrorType::LessThan {
                         lt: Number::String(lt.to_string()),
@@ -205,7 +216,7 @@ impl Validator for DecimalValidator {
             }
         }
         if let Some(ge) = &self.ge {
-            if !decimal.ge(ge)? {
+            if is_nan()? || !decimal.ge(ge)? {
                 return Err(ValError::new(
                     ErrorType::GreaterThanEqual {
                         ge: Number::String(ge.to_string()),
@@ -216,7 +227,7 @@ impl Validator for DecimalValidator {
             }
         }
         if let Some(gt) = &self.gt {
-            if !decimal.gt(gt)? {
+            if is_nan()? || !decimal.gt(gt)? {
                 return Err(ValError::new(
                     ErrorType::GreaterThan {
                         gt: Number::String(gt.to_string()),
diff --git a/src/validators/float.rs b/src/validators/float.rs
index 1d62d2006..646d8f4d8 100644
--- a/src/validators/float.rs
+++ b/src/validators/float.rs
@@ -1,3 +1,5 @@
+use std::cmp::Ordering;
+
 use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
@@ -129,7 +131,7 @@ impl Validator for ConstrainedFloatValidator {
             }
         }
         if let Some(le) = self.le {
-            if float > le {
+            if !matches!(float.partial_cmp(&le), Some(Ordering::Less | Ordering::Equal)) {
                 return Err(ValError::new(
                     ErrorType::LessThanEqual {
                         le: le.into(),
@@ -140,7 +142,7 @@ impl Validator for ConstrainedFloatValidator {
             }
         }
         if let Some(lt) = self.lt {
-            if float >= lt {
+            if !matches!(float.partial_cmp(&lt), Some(Ordering::Less)) {
                 return Err(ValError::new(
                     ErrorType::LessThan {
                         lt: lt.into(),
@@ -151,7 +153,7 @@ impl Validator for ConstrainedFloatValidator {
             }
         }
         if let Some(ge) = self.ge {
-            if float < ge {
+            if !matches!(float.partial_cmp(&ge), Some(Ordering::Greater | Ordering::Equal)) {
                 return Err(ValError::new(
                     ErrorType::GreaterThanEqual {
                         ge: ge.into(),
@@ -162,7 +164,7 @@ impl Validator for ConstrainedFloatValidator {
             }
         }
         if let Some(gt) = self.gt {
-            if float <= gt {
+            if !matches!(float.partial_cmp(&gt), Some(Ordering::Greater)) {
                 return Err(ValError::new(
                     ErrorType::GreaterThan {
                         gt: gt.into(),
diff --git a/tests/validators/test_decimal.py b/tests/validators/test_decimal.py
index 376a9816a..cd54c89ae 100644
--- a/tests/validators/test_decimal.py
+++ b/tests/validators/test_decimal.py
@@ -148,12 +148,16 @@ def test_decimal_strict_json(input_value, expected):
         ({'le': 0}, 0, Decimal(0)),
         ({'le': 0}, -1, Decimal(-1)),
         ({'le': 0}, 0.1, Err('Input should be less than or equal to 0')),
+        ({'lt': 0, 'allow_inf_nan': True}, float('nan'), Err('Input should be less than 0')),
+        ({'gt': 0, 'allow_inf_nan': True}, float('inf'), Decimal('inf')),
         ({'lt': 0}, 0, Err('Input should be less than 0')),
         ({'lt': 0.123456}, 1, Err('Input should be less than 0.123456')),
     ],
 )
 def test_decimal_kwargs(py_and_json: PyAndJson, kwargs: Dict[str, Any], input_value, expected):
     v = py_and_json({'type': 'decimal', **kwargs})
+    if v.validator_type == 'json' and isinstance(input_value, float) and not math.isfinite(input_value):
+        expected = Err('Invalid JSON')
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_test(input_value)
diff --git a/tests/validators/test_float.py b/tests/validators/test_float.py
index 74f0024ca..b18181fbb 100644
--- a/tests/validators/test_float.py
+++ b/tests/validators/test_float.py
@@ -86,10 +86,14 @@ def test_float_strict(py_and_json: PyAndJson, input_value, expected):
         ({'le': 0}, 0.1, Err('Input should be less than or equal to 0')),
         ({'lt': 0}, 0, Err('Input should be less than 0')),
         ({'lt': 0.123456}, 1, Err('Input should be less than 0.123456')),
+        ({'lt': 0, 'allow_inf_nan': True}, float('nan'), Err('Input should be less than 0')),
+        ({'gt': 0, 'allow_inf_nan': True}, float('inf'), float('inf')),
     ],
 )
 def test_float_kwargs(py_and_json: PyAndJson, kwargs: Dict[str, Any], input_value, expected):
     v = py_and_json({'type': 'float', **kwargs})
+    if v.validator_type == 'json' and isinstance(input_value, float) and not math.isfinite(input_value):
+        expected = Err('Invalid JSON')
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_test(input_value)

From 866eb2da06321cf4c99118b2331bf7eff7e81e1c Mon Sep 17 00:00:00 2001
From: Michael Huang <michaelhly@gmail.com>
Date: Thu, 26 Oct 2023 12:50:35 -0400
Subject: [PATCH 089/550] Add lax_str and lax_int support for enum values not
 inherited from str/int (#1015)

---
 src/input/input_python.rs       | 21 ++++++++++++++++++++-
 src/input/shared.rs             | 16 +++++++++++++++-
 src/serializers/ob_type.rs      |  3 ++-
 tests/validators/test_int.py    | 13 +++++++++++++
 tests/validators/test_string.py | 15 +++++++++++++++
 5 files changed, 65 insertions(+), 3 deletions(-)

diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index fe688a487..33d7ca296 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -21,7 +21,10 @@ use super::datetime::{
     float_as_duration, float_as_time, int_as_datetime, int_as_duration, int_as_time, EitherDate, EitherDateTime,
     EitherTime,
 };
-use super::shared::{decimal_as_int, float_as_int, int_as_bool, map_json_err, str_as_bool, str_as_float, str_as_int};
+use super::shared::{
+    decimal_as_int, float_as_int, get_enum_meta_object, int_as_bool, map_json_err, str_as_bool, str_as_float,
+    str_as_int,
+};
 use super::{
     py_string_str, BorrowInput, EitherBytes, EitherFloat, EitherInt, EitherString, EitherTimedelta, GenericArguments,
     GenericIterable, GenericIterator, GenericMapping, Input, JsonInput, PyArgs,
@@ -256,6 +259,8 @@ impl<'a> Input<'a> for PyAny {
                 || self.is_instance(decimal_type.as_ref(py)).unwrap_or_default()
         } {
             Ok(self.str()?.into())
+        } else if let Some(enum_val) = maybe_as_enum(self) {
+            Ok(enum_val.str()?.into())
         } else {
             Err(ValError::new(ErrorTypeDefaults::StringType, self))
         }
@@ -340,6 +345,8 @@ impl<'a> Input<'a> for PyAny {
             decimal_as_int(self.py(), self, decimal)
         } else if let Ok(float) = self.extract::<f64>() {
             float_as_int(self, float)
+        } else if let Some(enum_val) = maybe_as_enum(self) {
+            Ok(EitherInt::Py(enum_val))
         } else {
             Err(ValError::new(ErrorTypeDefaults::IntType, self))
         }
@@ -759,6 +766,18 @@ fn maybe_as_string(v: &PyAny, unicode_error: ErrorType) -> ValResult<Option<Cow<
     }
 }
 
+/// Utility for extracting an enum value, if possible.
+fn maybe_as_enum(v: &PyAny) -> Option<&PyAny> {
+    let py = v.py();
+    let enum_meta_object = get_enum_meta_object(py);
+    let meta_type = v.get_type().get_type();
+    if meta_type.is(&enum_meta_object) {
+        v.getattr(intern!(py, "value")).ok()
+    } else {
+        None
+    }
+}
+
 #[cfg(PyPy)]
 static DICT_KEYS_TYPE: pyo3::once_cell::GILOnceCell<Py<PyType>> = pyo3::once_cell::GILOnceCell::new();
 
diff --git a/src/input/shared.rs b/src/input/shared.rs
index 1a8e2b61c..105da4bcc 100644
--- a/src/input/shared.rs
+++ b/src/input/shared.rs
@@ -1,11 +1,25 @@
 use num_bigint::BigInt;
-use pyo3::{intern, PyAny, Python};
+use pyo3::sync::GILOnceCell;
+use pyo3::{intern, Py, PyAny, Python, ToPyObject};
 
 use crate::errors::{ErrorType, ErrorTypeDefaults, ValError, ValResult};
 
 use super::parse_json::{JsonArray, JsonInput};
 use super::{EitherFloat, EitherInt, Input};
 
+static ENUM_META_OBJECT: GILOnceCell<Py<PyAny>> = GILOnceCell::new();
+
+pub fn get_enum_meta_object(py: Python) -> Py<PyAny> {
+    ENUM_META_OBJECT
+        .get_or_init(py, || {
+            py.import(intern!(py, "enum"))
+                .and_then(|enum_module| enum_module.getattr(intern!(py, "EnumMeta")))
+                .unwrap()
+                .to_object(py)
+        })
+        .clone()
+}
+
 pub fn map_json_err<'a>(input: &'a impl Input<'a>, error: serde_json::Error) -> ValError<'a> {
     ValError::new(
         ErrorType::JsonInvalid {
diff --git a/src/serializers/ob_type.rs b/src/serializers/ob_type.rs
index fc491f618..109aed3bb 100644
--- a/src/serializers/ob_type.rs
+++ b/src/serializers/ob_type.rs
@@ -259,8 +259,9 @@ impl ObTypeLookup {
     fn is_enum(&self, op_value: Option<&PyAny>, py_type: &PyType) -> bool {
         // only test on the type itself, not base types
         if op_value.is_some() {
+            let enum_meta_type = self.enum_object.as_ref(py_type.py()).get_type();
             let meta_type = py_type.get_type();
-            meta_type.is(&self.enum_object)
+            meta_type.is(enum_meta_type)
         } else {
             false
         }
diff --git a/tests/validators/test_int.py b/tests/validators/test_int.py
index 8d5850dc8..dedc2bd93 100644
--- a/tests/validators/test_int.py
+++ b/tests/validators/test_int.py
@@ -459,3 +459,16 @@ def test_float_subclass() -> None:
     v_lax = v.validate_python(FloatSubclass(1))
     assert v_lax == 1
     assert type(v_lax) == int
+
+
+def test_int_subclass_plain_enum() -> None:
+    v = SchemaValidator({'type': 'int'})
+
+    from enum import Enum
+
+    class PlainEnum(Enum):
+        ONE = 1
+
+    v_lax = v.validate_python(PlainEnum.ONE)
+    assert v_lax == 1
+    assert type(v_lax) == int
diff --git a/tests/validators/test_string.py b/tests/validators/test_string.py
index cab6e5127..bc2102de2 100644
--- a/tests/validators/test_string.py
+++ b/tests/validators/test_string.py
@@ -249,6 +249,21 @@ def test_lax_subclass(FruitEnum, kwargs):
     assert repr(p) == "'pear'"
 
 
+@pytest.mark.parametrize('kwargs', [{}, {'to_lower': True}], ids=repr)
+def test_lax_subclass_plain_enum(kwargs):
+    v = SchemaValidator(core_schema.str_schema(**kwargs))
+
+    from enum import Enum
+
+    class PlainEnum(Enum):
+        ONE = 'one'
+
+    p = v.validate_python(PlainEnum.ONE)
+    assert p == 'one'
+    assert type(p) is str
+    assert repr(p) == "'one'"
+
+
 def test_subclass_preserved() -> None:
     class StrSubclass(str):
         pass

From dd75669bbb7a624e714afa66d3c7f8e24f339a7c Mon Sep 17 00:00:00 2001
From: sydney-runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Mon, 30 Oct 2023 10:34:36 -0500
Subject: [PATCH 090/550] Support subclasses in lists in `Union` of `List`
 types (#1039)

---
 src/serializers/type_serializers/list.rs  |  4 ++
 src/serializers/type_serializers/union.rs |  3 +-
 tests/serializers/test_union.py           | 56 +++++++++++++++++++++++
 3 files changed, 62 insertions(+), 1 deletion(-)

diff --git a/src/serializers/type_serializers/list.rs b/src/serializers/type_serializers/list.rs
index 4d68ae373..a71e3452a 100644
--- a/src/serializers/type_serializers/list.rs
+++ b/src/serializers/type_serializers/list.rs
@@ -116,4 +116,8 @@ impl TypeSerializer for ListSerializer {
     fn get_name(&self) -> &str {
         &self.name
     }
+
+    fn retry_with_lax_check(&self) -> bool {
+        self.item_serializer.retry_with_lax_check()
+    }
 }
diff --git a/src/serializers/type_serializers/union.rs b/src/serializers/type_serializers/union.rs
index 788620408..f05e2220e 100644
--- a/src/serializers/type_serializers/union.rs
+++ b/src/serializers/type_serializers/union.rs
@@ -75,9 +75,10 @@ impl TypeSerializer for UnionSerializer {
         exclude: Option<&PyAny>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
-        // try the serializers in with error_on fallback=true
+        // try the serializers in left to right order with error_on fallback=true
         let mut new_extra = extra.clone();
         new_extra.check = SerCheck::Strict;
+
         for comb_serializer in &self.choices {
             match comb_serializer.to_python(value, include, exclude, &new_extra) {
                 Ok(v) => return Ok(v),
diff --git a/tests/serializers/test_union.py b/tests/serializers/test_union.py
index f81e33a6b..9b021e66e 100644
--- a/tests/serializers/test_union.py
+++ b/tests/serializers/test_union.py
@@ -454,3 +454,59 @@ class Item(BaseModel):
     )
 
     assert s.to_python(DBUser(name='John', password='secret')) == {'name': 'John'}
+
+
+def test_union_serializes_list_of_model_subclass_from_definition() -> None:
+    class BaseModel:
+        __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__'
+
+        def __init__(self, **kwargs: Any):
+            for key, value in kwargs.items():
+                setattr(self, key, value)
+
+    class User(BaseModel):
+        name: str
+
+    class DBUser(User):
+        password: str
+        __pydantic_serializer__: ClassVar[SchemaSerializer]
+
+    DBUser.__pydantic_serializer__ = SchemaSerializer(
+        core_schema.model_schema(
+            DBUser,
+            core_schema.model_fields_schema(
+                {
+                    'name': core_schema.model_field(core_schema.str_schema()),
+                    'password': core_schema.model_field(core_schema.str_schema()),
+                }
+            ),
+        )
+    )
+
+    class Item(BaseModel):
+        price: float
+
+    s = SchemaSerializer(
+        core_schema.definitions_schema(
+            core_schema.union_schema(
+                [
+                    core_schema.list_schema(core_schema.definition_reference_schema('User'), strict=False),
+                    core_schema.list_schema(core_schema.definition_reference_schema('Item'), strict=False),
+                ]
+            ),
+            [
+                core_schema.model_schema(
+                    User,
+                    core_schema.model_fields_schema({'name': core_schema.model_field(core_schema.str_schema())}),
+                    ref='User',
+                ),
+                core_schema.model_schema(
+                    Item,
+                    core_schema.model_fields_schema({'price': core_schema.model_field(core_schema.float_schema())}),
+                    ref='Item',
+                ),
+            ],
+        )
+    )
+
+    assert s.to_python([DBUser(name='John', password='secret')]) == [{'name': 'John'}]

From ef3e8132e51df7189985c8a62c6bc2cb73879a13 Mon Sep 17 00:00:00 2001
From: sydney-runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Tue, 31 Oct 2023 09:26:59 -0500
Subject: [PATCH 091/550] Allow validation against `max_digits` and `decimals`
 to pass if normalized or non-normalized input is valid (#1049)

---
 src/validators/decimal.rs        | 129 ++++++++++++++++++-------------
 tests/validators/test_decimal.py |  28 +++++++
 2 files changed, 104 insertions(+), 53 deletions(-)

diff --git a/src/validators/decimal.rs b/src/validators/decimal.rs
index 730eeac69..eb3141c31 100644
--- a/src/validators/decimal.rs
+++ b/src/validators/decimal.rs
@@ -83,6 +83,41 @@ impl_py_gc_traverse!(DecimalValidator {
     gt
 });
 
+fn extract_decimal_digits_info<'data>(
+    decimal: &PyAny,
+    normalized: bool,
+    py: Python<'data>,
+) -> ValResult<'data, (u64, u64)> {
+    let mut normalized_decimal: Option<&PyAny> = None;
+    if normalized {
+        normalized_decimal = Some(decimal.call_method0(intern!(py, "normalize")).unwrap_or(decimal));
+    }
+    let (_, digit_tuple, exponent): (&PyAny, &PyTuple, &PyAny) = normalized_decimal
+        .unwrap_or(decimal)
+        .call_method0(intern!(py, "as_tuple"))?
+        .extract()?;
+
+    // finite values have numeric exponent, we checked is_finite above
+    let exponent: i64 = exponent.extract()?;
+    let mut digits: u64 = u64::try_from(digit_tuple.len()).map_err(|e| ValError::InternalErr(e.into()))?;
+    let decimals;
+    if exponent >= 0 {
+        // A positive exponent adds that many trailing zeros.
+        digits += exponent as u64;
+        decimals = 0;
+    } else {
+        // If the absolute value of the negative exponent is larger than the
+        // number of digits, then it's the same as the number of digits,
+        // because it'll consume all the digits in digit_tuple and then
+        // add abs(exponent) - len(digit_tuple) leading zeros after the
+        // decimal point.
+        decimals = exponent.unsigned_abs();
+        digits = digits.max(decimals);
+    }
+
+    Ok((decimals, digits))
+}
+
 impl Validator for DecimalValidator {
     fn validate<'data>(
         &self,
@@ -98,65 +133,53 @@ impl Validator for DecimalValidator {
             }
 
             if self.check_digits {
-                let normalized_value = decimal.call_method0(intern!(py, "normalize")).unwrap_or(decimal);
-                let (_, digit_tuple, exponent): (&PyAny, &PyTuple, &PyAny) =
-                    normalized_value.call_method0(intern!(py, "as_tuple"))?.extract()?;
+                if let Ok((normalized_decimals, normalized_digits)) = extract_decimal_digits_info(decimal, true, py) {
+                    if let Ok((decimals, digits)) = extract_decimal_digits_info(decimal, false, py) {
+                        if let Some(max_digits) = self.max_digits {
+                            if (digits > max_digits) & (normalized_digits > max_digits) {
+                                return Err(ValError::new(
+                                    ErrorType::DecimalMaxDigits {
+                                        max_digits,
+                                        context: None,
+                                    },
+                                    input,
+                                ));
+                            }
+                        }
 
-                // finite values have numeric exponent, we checked is_finite above
-                let exponent: i64 = exponent.extract()?;
-                let mut digits: u64 = u64::try_from(digit_tuple.len()).map_err(|e| ValError::InternalErr(e.into()))?;
-                let decimals;
-                if exponent >= 0 {
-                    // A positive exponent adds that many trailing zeros.
-                    digits += exponent as u64;
-                    decimals = 0;
-                } else {
-                    // If the absolute value of the negative exponent is larger than the
-                    // number of digits, then it's the same as the number of digits,
-                    // because it'll consume all the digits in digit_tuple and then
-                    // add abs(exponent) - len(digit_tuple) leading zeros after the
-                    // decimal point.
-                    decimals = exponent.unsigned_abs();
-                    digits = digits.max(decimals);
-                }
+                        if let Some(decimal_places) = self.decimal_places {
+                            if (decimals > decimal_places) & (normalized_decimals > decimal_places) {
+                                return Err(ValError::new(
+                                    ErrorType::DecimalMaxPlaces {
+                                        decimal_places,
+                                        context: None,
+                                    },
+                                    input,
+                                ));
+                            }
 
-                if let Some(max_digits) = self.max_digits {
-                    if digits > max_digits {
-                        return Err(ValError::new(
-                            ErrorType::DecimalMaxDigits {
-                                max_digits,
-                                context: None,
-                            },
-                            input,
-                        ));
-                    }
-                }
+                            if let Some(max_digits) = self.max_digits {
+                                let whole_digits = digits.saturating_sub(decimals);
+                                let max_whole_digits = max_digits.saturating_sub(decimal_places);
 
-                if let Some(decimal_places) = self.decimal_places {
-                    if decimals > decimal_places {
-                        return Err(ValError::new(
-                            ErrorType::DecimalMaxPlaces {
-                                decimal_places,
-                                context: None,
-                            },
-                            input,
-                        ));
-                    }
+                                let normalized_whole_digits = normalized_digits.saturating_sub(normalized_decimals);
+                                let normalized_max_whole_digits = max_digits.saturating_sub(decimal_places);
 
-                    if let Some(max_digits) = self.max_digits {
-                        let whole_digits = digits.saturating_sub(decimals);
-                        let max_whole_digits = max_digits.saturating_sub(decimal_places);
-                        if whole_digits > max_whole_digits {
-                            return Err(ValError::new(
-                                ErrorType::DecimalWholeDigits {
-                                    whole_digits: max_whole_digits,
-                                    context: None,
-                                },
-                                input,
-                            ));
+                                if (whole_digits > max_whole_digits)
+                                    & (normalized_whole_digits > normalized_max_whole_digits)
+                                {
+                                    return Err(ValError::new(
+                                        ErrorType::DecimalWholeDigits {
+                                            whole_digits: max_whole_digits,
+                                            context: None,
+                                        },
+                                        input,
+                                    ));
+                                }
+                            }
                         }
                     }
-                }
+                };
             }
         }
 
diff --git a/tests/validators/test_decimal.py b/tests/validators/test_decimal.py
index cd54c89ae..43b3d19b9 100644
--- a/tests/validators/test_decimal.py
+++ b/tests/validators/test_decimal.py
@@ -437,3 +437,31 @@ def test_non_finite_constrained_decimal_values(input_value, allow_inf_nan, expec
 def test_validate_scientific_notation_from_json(input_value, expected):
     v = SchemaValidator({'type': 'decimal'})
     assert v.validate_json(input_value) == expected
+
+
+def test_validate_max_digits_and_decimal_places() -> None:
+    v = SchemaValidator({'type': 'decimal', 'max_digits': 5, 'decimal_places': 2})
+
+    # valid inputs
+    assert v.validate_json('1.23') == Decimal('1.23')
+    assert v.validate_json('123.45') == Decimal('123.45')
+    assert v.validate_json('-123.45') == Decimal('-123.45')
+
+    # invalid inputs
+    with pytest.raises(ValidationError):
+        v.validate_json('1234.56')  # too many digits
+    with pytest.raises(ValidationError):
+        v.validate_json('123.456')  # too many decimal places
+    with pytest.raises(ValidationError):
+        v.validate_json('123456')  # too many digits
+    with pytest.raises(ValidationError):
+        v.validate_json('abc')  # not a valid decimal
+
+
+def test_validate_max_digits_and_decimal_places_edge_case() -> None:
+    v = SchemaValidator({'type': 'decimal', 'max_digits': 34, 'decimal_places': 18})
+
+    # valid inputs
+    assert v.validate_python(Decimal('9999999999999999.999999999999999999')) == Decimal(
+        '9999999999999999.999999999999999999'
+    )

From 383535655507ac3eeb4e3f3755f5e239bf021c28 Mon Sep 17 00:00:00 2001
From: Iipin <52832022+Iipin@users.noreply.github.com>
Date: Fri, 3 Nov 2023 19:22:13 +0100
Subject: [PATCH 092/550] Fix proper pluralization in validation error messages
 (#1050)

---
 src/errors/types.rs  | 60 +++++++++++++++++++++++++++++++-------------
 tests/test_errors.py | 12 +++++++++
 2 files changed, 54 insertions(+), 18 deletions(-)

diff --git a/src/errors/types.rs b/src/errors/types.rs
index e31307e2b..5c3fc1a7c 100644
--- a/src/errors/types.rs
+++ b/src/errors/types.rs
@@ -445,8 +445,8 @@ macro_rules! to_string_render {
     };
 }
 
-fn plural_s(value: usize) -> &'static str {
-    if value == 1 {
+fn plural_s<T: From<u8> + PartialEq>(value: T) -> &'static str {
+    if value == 1.into() {
         ""
     } else {
         "s"
@@ -494,8 +494,8 @@ impl ErrorType {
             Self::StringType {..} => "Input should be a valid string",
             Self::StringSubType {..} => "Input should be a string, not an instance of a subclass of str",
             Self::StringUnicode {..} => "Input should be a valid string, unable to parse raw data as a unicode string",
-            Self::StringTooShort {..} => "String should have at least {min_length} characters",
-            Self::StringTooLong {..} => "String should have at most {max_length} characters",
+            Self::StringTooShort {..} => "String should have at least {min_length} character{expected_plural}",
+            Self::StringTooLong {..} => "String should have at most {max_length} character{expected_plural}",
             Self::StringPatternMismatch {..} => "String should match pattern '{pattern}'",
             Self::Enum {..} => "Input should be {expected}",
             Self::DictType {..} => "Input should be a valid dictionary",
@@ -512,8 +512,8 @@ impl ErrorType {
             Self::FloatType {..} => "Input should be a valid number",
             Self::FloatParsing {..} => "Input should be a valid number, unable to parse string as a number",
             Self::BytesType {..} => "Input should be a valid bytes",
-            Self::BytesTooShort {..} => "Data should have at least {min_length} bytes",
-            Self::BytesTooLong {..} => "Data should have at most {max_length} bytes",
+            Self::BytesTooShort {..} => "Data should have at least {min_length} byte{expected_plural}",
+            Self::BytesTooLong {..} => "Data should have at most {max_length} byte{expected_plural}",
             Self::ValueError {..} => "Value error, {error}",
             Self::AssertionError {..} => "Assertion failed, {error}",
             Self::CustomError {..} => "",  // custom errors are handled separately
@@ -552,16 +552,16 @@ impl ErrorType {
             Self::UrlType {..} => "URL input should be a string or URL",
             Self::UrlParsing {..} => "Input should be a valid URL, {error}",
             Self::UrlSyntaxViolation {..} => "Input violated strict URL syntax rules, {error}",
-            Self::UrlTooLong {..} => "URL should have at most {max_length} characters",
+            Self::UrlTooLong {..} => "URL should have at most {max_length} character{expected_plural}",
             Self::UrlScheme {..} => "URL scheme should be {expected_schemes}",
             Self::UuidType {..} => "UUID input should be a string, bytes or UUID object",
             Self::UuidParsing {..} => "Input should be a valid UUID, {error}",
             Self::UuidVersion {..} => "UUID version {expected_version} expected",
             Self::DecimalType {..} => "Decimal input should be an integer, float, string or Decimal object",
             Self::DecimalParsing {..} => "Input should be a valid decimal",
-            Self::DecimalMaxDigits {..} => "Decimal input should have no more than {max_digits} digits in total",
-            Self::DecimalMaxPlaces {..} => "Decimal input should have no more than {decimal_places} decimal places",
-            Self::DecimalWholeDigits {..} => "Decimal input should have no more than {whole_digits} digits before the decimal point",
+            Self::DecimalMaxDigits {..} => "Decimal input should have no more than {max_digits} digit{expected_plural} in total",
+            Self::DecimalMaxPlaces {..} => "Decimal input should have no more than {decimal_places} decimal place{expected_plural}",
+            Self::DecimalWholeDigits {..} => "Decimal input should have no more than {whole_digits} digit{expected_plural} before the decimal point",
         }
     }
 
@@ -643,13 +643,25 @@ impl ErrorType {
                 to_string_render!(tmpl, field_type, max_length, actual_length, expected_plural,)
             }
             Self::IterationError { error, .. } => render!(tmpl, error),
-            Self::StringTooShort { min_length, .. } => to_string_render!(tmpl, min_length),
-            Self::StringTooLong { max_length, .. } => to_string_render!(tmpl, max_length),
+            Self::StringTooShort { min_length, .. } => {
+                let expected_plural = plural_s(*min_length);
+                to_string_render!(tmpl, min_length, expected_plural)
+            }
+            Self::StringTooLong { max_length, .. } => {
+                let expected_plural = plural_s(*max_length);
+                to_string_render!(tmpl, max_length, expected_plural)
+            }
             Self::StringPatternMismatch { pattern, .. } => render!(tmpl, pattern),
             Self::Enum { expected, .. } => to_string_render!(tmpl, expected),
             Self::MappingType { error, .. } => render!(tmpl, error),
-            Self::BytesTooShort { min_length, .. } => to_string_render!(tmpl, min_length),
-            Self::BytesTooLong { max_length, .. } => to_string_render!(tmpl, max_length),
+            Self::BytesTooShort { min_length, .. } => {
+                let expected_plural = plural_s(*min_length);
+                to_string_render!(tmpl, min_length, expected_plural)
+            }
+            Self::BytesTooLong { max_length, .. } => {
+                let expected_plural = plural_s(*max_length);
+                to_string_render!(tmpl, max_length, expected_plural)
+            }
             Self::ValueError { error, .. } => {
                 let error = &error
                     .as_ref()
@@ -688,13 +700,25 @@ impl ErrorType {
             Self::UnionTagNotFound { discriminator, .. } => render!(tmpl, discriminator),
             Self::UrlParsing { error, .. } => render!(tmpl, error),
             Self::UrlSyntaxViolation { error, .. } => render!(tmpl, error),
-            Self::UrlTooLong { max_length, .. } => to_string_render!(tmpl, max_length),
+            Self::UrlTooLong { max_length, .. } => {
+                let expected_plural = plural_s(*max_length);
+                to_string_render!(tmpl, max_length, expected_plural)
+            }
             Self::UrlScheme { expected_schemes, .. } => render!(tmpl, expected_schemes),
             Self::UuidParsing { error, .. } => render!(tmpl, error),
             Self::UuidVersion { expected_version, .. } => to_string_render!(tmpl, expected_version),
-            Self::DecimalMaxDigits { max_digits, .. } => to_string_render!(tmpl, max_digits),
-            Self::DecimalMaxPlaces { decimal_places, .. } => to_string_render!(tmpl, decimal_places),
-            Self::DecimalWholeDigits { whole_digits, .. } => to_string_render!(tmpl, whole_digits),
+            Self::DecimalMaxDigits { max_digits, .. } => {
+                let expected_plural = plural_s(*max_digits);
+                to_string_render!(tmpl, max_digits, expected_plural)
+            }
+            Self::DecimalMaxPlaces { decimal_places, .. } => {
+                let expected_plural = plural_s(*decimal_places);
+                to_string_render!(tmpl, decimal_places, expected_plural)
+            }
+            Self::DecimalWholeDigits { whole_digits, .. } => {
+                let expected_plural = plural_s(*whole_digits);
+                to_string_render!(tmpl, whole_digits, expected_plural)
+            }
             _ => Ok(tmpl.to_string()),
         }
     }
diff --git a/tests/test_errors.py b/tests/test_errors.py
index 293880977..3683150ec 100644
--- a/tests/test_errors.py
+++ b/tests/test_errors.py
@@ -289,7 +289,9 @@ def f(input_value, info):
     ('string_unicode', 'Input should be a valid string, unable to parse raw data as a unicode string', None),
     ('string_pattern_mismatch', "String should match pattern 'foo'", {'pattern': 'foo'}),
     ('string_too_short', 'String should have at least 42 characters', {'min_length': 42}),
+    ('string_too_short', 'String should have at least 1 character', {'min_length': 1}),
     ('string_too_long', 'String should have at most 42 characters', {'max_length': 42}),
+    ('string_too_long', 'String should have at most 1 character', {'max_length': 1}),
     ('dict_type', 'Input should be a valid dictionary', None),
     ('mapping_type', 'Input should be a valid mapping, error: foobar', {'error': 'foobar'}),
     ('iterable_type', 'Input should be iterable', None),
@@ -312,7 +314,9 @@ def f(input_value, info):
     ('float_parsing', 'Input should be a valid number, unable to parse string as a number', None),
     ('bytes_type', 'Input should be a valid bytes', None),
     ('bytes_too_short', 'Data should have at least 42 bytes', {'min_length': 42}),
+    ('bytes_too_short', 'Data should have at least 1 byte', {'min_length': 1}),
     ('bytes_too_long', 'Data should have at most 42 bytes', {'max_length': 42}),
+    ('bytes_too_long', 'Data should have at most 1 byte', {'max_length': 1}),
     ('value_error', 'Value error, foobar', {'error': ValueError('foobar')}),
     ('assertion_error', 'Assertion failed, foobar', {'error': AssertionError('foobar')}),
     ('literal_error', 'Input should be foo', {'expected': 'foo'}),
@@ -356,6 +360,7 @@ def f(input_value, info):
     ('url_parsing', 'Input should be a valid URL, Foobar', {'error': 'Foobar'}),
     ('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_too_long', 'URL should have at most 1 character', {'max_length': 1}),
     ('url_scheme', 'URL scheme should be "foo", "bar" or "spam"', {'expected_schemes': '"foo", "bar" or "spam"'}),
     ('uuid_type', 'UUID input should be a string, bytes or UUID object', None),
     ('uuid_parsing', 'Input should be a valid UUID, Foobar', {'error': 'Foobar'}),
@@ -363,12 +368,19 @@ def f(input_value, info):
     ('decimal_type', 'Decimal input should be an integer, float, string or Decimal object', None),
     ('decimal_parsing', 'Input should be a valid decimal', None),
     ('decimal_max_digits', 'Decimal input should have no more than 42 digits in total', {'max_digits': 42}),
+    ('decimal_max_digits', 'Decimal input should have no more than 1 digit in total', {'max_digits': 1}),
     ('decimal_max_places', 'Decimal input should have no more than 42 decimal places', {'decimal_places': 42}),
+    ('decimal_max_places', 'Decimal input should have no more than 1 decimal place', {'decimal_places': 1}),
     (
         'decimal_whole_digits',
         'Decimal input should have no more than 42 digits before the decimal point',
         {'whole_digits': 42},
     ),
+    (
+        'decimal_whole_digits',
+        'Decimal input should have no more than 1 digit before the decimal point',
+        {'whole_digits': 1},
+    ),
 ]
 
 

From 73c431b2c766e3c75541a2bb153286e0e6e87d61 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 6 Nov 2023 09:36:46 +0000
Subject: [PATCH 093/550] Bump serde from 1.0.189 to 1.0.190 (#1047)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 8 ++++----
 Cargo.toml | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 7c1ef6624..78a717da3 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -404,18 +404,18 @@ checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
 
 [[package]]
 name = "serde"
-version = "1.0.189"
+version = "1.0.190"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e422a44e74ad4001bdc8eede9a4570ab52f71190e9c076d14369f38b9200537"
+checksum = "91d3c334ca1ee894a2c6f6ad698fe8c435b76d504b13d436f0685d648d6d96f7"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.189"
+version = "1.0.190"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e48d1f918009ce3145511378cf68d613e3b3d9137d67272562080d68a2b32d5"
+checksum = "67c5609f394e5c2bd7fc51efda478004ea80ef42fee983d5c67a65e34f32c0e3"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/Cargo.toml b/Cargo.toml
index ced489442..c4f79d32d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -32,7 +32,7 @@ strum = { version = "0.25.0", features = ["derive"] }
 strum_macros = "0.25.3"
 serde_json = {version = "1.0.107", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.8"
-serde = { version = "1.0.189", features = ["derive"] }
+serde = { version = "1.0.190", features = ["derive"] }
 speedate = "0.12.0"
 smallvec = "1.11.1"
 ahash = "0.8.4"

From 8dba67ab8ed213ebf213a856e40ec52d5653ca0d Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 6 Nov 2023 09:37:08 +0000
Subject: [PATCH 094/550] Bump ahash from 0.8.4 to 0.8.6 (#1046)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 12 ++++++------
 Cargo.toml |  2 +-
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 78a717da3..14804774d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4,9 +4,9 @@ version = 3
 
 [[package]]
 name = "ahash"
-version = "0.8.4"
+version = "0.8.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "72832d73be48bac96a5d7944568f305d829ed55b0ce3b483647089dfaf6cf704"
+checksum = "91429305e9f0a25f6205c5b8e0d2db09e0708a7a6df0f42212bb56c32c8ac97a"
 dependencies = [
  "cfg-if",
  "getrandom",
@@ -619,18 +619,18 @@ checksum = "1a515f5799fe4961cb532f983ce2b23082366b898e52ffbce459c86f67c8378a"
 
 [[package]]
 name = "zerocopy"
-version = "0.7.11"
+version = "0.7.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4c19fae0c8a9efc6a8281f2e623db8af1db9e57852e04cde3e754dd2dc29340f"
+checksum = "dd66a62464e3ffd4e37bd09950c2b9dd6c4f8767380fabba0d523f9a775bc85a"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.7.11"
+version = "0.7.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fc56589e9ddd1f1c28d4b4b5c773ce232910a6bb67a70133d61c9e347585efe9"
+checksum = "255c4596d41e6916ced49cfafea18727b24d67878fa180ddfd69b9df34fd1726"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/Cargo.toml b/Cargo.toml
index c4f79d32d..cdd1b7056 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -35,7 +35,7 @@ enum_dispatch = "0.3.8"
 serde = { version = "1.0.190", features = ["derive"] }
 speedate = "0.12.0"
 smallvec = "1.11.1"
-ahash = "0.8.4"
+ahash = "0.8.6"
 url = "2.4.1"
 # idna is already required by url, added here to be explicit
 idna = "0.4.0"

From d98f14ff12669c5be6d0278b4b5ecd0876a2176a Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 6 Nov 2023 09:37:31 +0000
Subject: [PATCH 095/550] Bump actions/setup-node from 3 to 4 (#1045)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/ci.yml | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 85174fa41..62e998bda 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -236,7 +236,7 @@ jobs:
           python-version: '3.11'
 
       # used to lint js code
-      - uses: actions/setup-node@v3
+      - uses: actions/setup-node@v4
         with:
           node-version: '18'
 
@@ -318,7 +318,7 @@ jobs:
       - name: build wheels
         run: make build-wasm
 
-      - uses: actions/setup-node@v3
+      - uses: actions/setup-node@v4
         with:
           node-version: '18'
 

From fdaf9da2090a9e909757caabe72dbee87ac2b115 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 6 Nov 2023 09:38:05 +0000
Subject: [PATCH 096/550] Bump pytest from 7.4.2 to 7.4.3 (#1044)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements.txt b/tests/requirements.txt
index 98cef770f..66dda075f 100644
--- a/tests/requirements.txt
+++ b/tests/requirements.txt
@@ -3,7 +3,7 @@ dirty-equals==0.6.0
 hypothesis==6.79.4
 # pandas doesn't offer prebuilt wheels for all versions and platforms we test in CI e.g. aarch64 musllinux
 pandas==2.0.3; python_version >= "3.9" and python_version < "3.12" and implementation_name == "cpython" and platform_machine == 'x86_64'
-pytest==7.4.2
+pytest==7.4.3
 # we run codspeed benchmarks on x86_64 CPython (i.e. native github actions architecture)
 pytest-codspeed~=2.2.0; implementation_name == "cpython" and platform_machine == 'x86_64'
 pytest-examples==0.0.10

From 8484cec113c3c7a0e0b14d184211989205bea62f Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 6 Nov 2023 09:38:16 +0000
Subject: [PATCH 097/550] Bump ruff from 0.1.1 to 0.1.3 (#1043)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index 91e454abf..e12ef0928 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,5 +1,5 @@
 black==23.10.0
 griffe==0.36.7
 pyright==1.1.332
-ruff==0.1.1
+ruff==0.1.3
 mypy==1.6.1

From acf3361478499e4341644d66094011f6283a49cf Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 6 Nov 2023 09:38:27 +0000
Subject: [PATCH 098/550] Bump griffe from 0.36.7 to 0.36.9 (#1041)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index e12ef0928..f0c468109 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,5 +1,5 @@
 black==23.10.0
-griffe==0.36.7
+griffe==0.36.9
 pyright==1.1.332
 ruff==0.1.3
 mypy==1.6.1

From 9d07a8c6b6285a16192dc99e2d9ade3d3cf2214d Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 6 Nov 2023 10:38:13 +0000
Subject: [PATCH 099/550] Bump pyright from 1.1.332 to 1.1.334 (#1055)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index f0c468109..79a41f7ea 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,5 +1,5 @@
 black==23.10.0
 griffe==0.36.9
-pyright==1.1.332
+pyright==1.1.334
 ruff==0.1.3
 mypy==1.6.1

From 1f18da208721d993d344934adc4bcc5bbfadb17f Mon Sep 17 00:00:00 2001
From: Samuel Colvin <s@muelcolvin.com>
Date: Mon, 6 Nov 2023 11:32:53 +0000
Subject: [PATCH 100/550] jiter (#974)

---
 Cargo.lock                              |  85 +++++++++
 Cargo.toml                              |   2 +
 python/pydantic_core/__init__.py        |   2 +
 python/pydantic_core/_pydantic_core.pyi |  18 ++
 src/errors/line_error.rs                |   6 +-
 src/errors/location.rs                  |  28 +--
 src/errors/mod.rs                       |   2 +-
 src/input/input_abstract.rs             |  12 +-
 src/input/input_json.rs                 | 167 +++++++++---------
 src/input/input_python.rs               |  59 ++++---
 src/input/input_string.rs               |  13 +-
 src/input/mod.rs                        |   2 -
 src/input/parse_json.rs                 | 222 ------------------------
 src/input/return_enums.rs               |  16 +-
 src/input/shared.rs                     |  12 +-
 src/lazy_index_map.rs                   |  63 -------
 src/lib.rs                              |  17 +-
 src/lookup_key.rs                       |  18 +-
 src/validators/arguments.rs             |   2 +-
 src/validators/dataclass.rs             |   2 +-
 src/validators/dict.rs                  |   2 +-
 src/validators/function.rs              |  22 +--
 src/validators/model_fields.rs          |   2 +-
 src/validators/typed_dict.rs            |   2 +-
 src/validators/union.rs                 |   4 +-
 tests/test_json.py                      |   9 +-
 tests/validators/test_decimal.py        |   7 +-
 tests/validators/test_float.py          |  37 +++-
 tests/validators/test_function.py       |  15 +-
 tests/validators/test_int.py            |  26 ++-
 30 files changed, 385 insertions(+), 489 deletions(-)
 delete mode 100644 src/input/parse_json.rs
 delete mode 100644 src/lazy_index_map.rs

diff --git a/Cargo.lock b/Cargo.lock
index 14804774d..f16b93697 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -136,6 +136,84 @@ version = "1.0.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "62b02a5381cc465bd3041d84623d0fa3b66738b52b8e2fc3bab8ad63ab032f4a"
 
+[[package]]
+name = "jiter"
+version = "0.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b27d419c535bf7b50ad355278b1159cbf0cc8d507ea003d625b17bf0375720b8"
+dependencies = [
+ "ahash",
+ "lexical-core",
+ "num-bigint",
+ "num-traits",
+ "pyo3",
+ "smallvec",
+]
+
+[[package]]
+name = "lexical-core"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2cde5de06e8d4c2faabc400238f9ae1c74d5412d03a7bd067645ccbc47070e46"
+dependencies = [
+ "lexical-parse-float",
+ "lexical-parse-integer",
+ "lexical-util",
+ "lexical-write-float",
+ "lexical-write-integer",
+]
+
+[[package]]
+name = "lexical-parse-float"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "683b3a5ebd0130b8fb52ba0bdc718cc56815b6a097e28ae5a6997d0ad17dc05f"
+dependencies = [
+ "lexical-parse-integer",
+ "lexical-util",
+ "static_assertions",
+]
+
+[[package]]
+name = "lexical-parse-integer"
+version = "0.8.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6d0994485ed0c312f6d965766754ea177d07f9c00c9b82a5ee62ed5b47945ee9"
+dependencies = [
+ "lexical-util",
+ "static_assertions",
+]
+
+[[package]]
+name = "lexical-util"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5255b9ff16ff898710eb9eb63cb39248ea8a5bb036bea8085b1a767ff6c4e3fc"
+dependencies = [
+ "static_assertions",
+]
+
+[[package]]
+name = "lexical-write-float"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "accabaa1c4581f05a3923d1b4cfd124c329352288b7b9da09e766b0668116862"
+dependencies = [
+ "lexical-util",
+ "lexical-write-integer",
+ "static_assertions",
+]
+
+[[package]]
+name = "lexical-write-integer"
+version = "0.8.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e1b6f3d1f4422866b68192d62f77bc5c700bee84f3069f2469d7bc8c77852446"
+dependencies = [
+ "lexical-util",
+ "static_assertions",
+]
+
 [[package]]
 name = "libc"
 version = "0.2.147"
@@ -249,6 +327,7 @@ dependencies = [
  "base64",
  "enum_dispatch",
  "idna",
+ "jiter",
  "num-bigint",
  "pyo3",
  "pyo3-build-config",
@@ -450,6 +529,12 @@ dependencies = [
  "strum_macros",
 ]
 
+[[package]]
+name = "static_assertions"
+version = "1.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
+
 [[package]]
 name = "strum"
 version = "0.25.0"
diff --git a/Cargo.toml b/Cargo.toml
index cdd1b7056..211fdfe01 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -43,6 +43,8 @@ base64 = "0.21.5"
 num-bigint = "0.4.4"
 python3-dll-a = "0.2.7"
 uuid = "1.5.0"
+jiter = {version = "0.0.4", features = ["python"]}
+#jiter = {path = "../jiter", features = ["python"]}
 
 [lib]
 name = "_pydantic_core"
diff --git a/python/pydantic_core/__init__.py b/python/pydantic_core/__init__.py
index a46a77b7d..5b2655c91 100644
--- a/python/pydantic_core/__init__.py
+++ b/python/pydantic_core/__init__.py
@@ -22,6 +22,7 @@
     Url,
     ValidationError,
     __version__,
+    from_json,
     to_json,
     to_jsonable_python,
     validate_core_schema,
@@ -63,6 +64,7 @@
     'PydanticSerializationUnexpectedValue',
     'TzInfo',
     'to_json',
+    'from_json',
     'to_jsonable_python',
     'validate_core_schema',
 ]
diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index 8ed3092a9..f28b7a12a 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -41,6 +41,7 @@ __all__ = [
     'PydanticUndefinedType',
     'Some',
     'to_json',
+    'from_json',
     'to_jsonable_python',
     'list_all_errors',
     'TzInfo',
@@ -384,6 +385,23 @@ def to_json(
        JSON bytes.
     """
 
+def from_json(data: str | bytes | bytearray, *, allow_inf_nan: bool = True) -> Any:
+    """
+    Deserialize JSON data to a Python object.
+
+    This is effectively a faster version of [`json.loads()`][json.loads].
+
+    Arguments:
+        data: The JSON data to deserialize.
+        allow_inf_nan: Whether to allow `Infinity`, `-Infinity` and `NaN` values as `json.loads()` does by default.
+
+    Raises:
+        ValueError: If deserialization fails.
+
+    Returns:
+        The deserialized Python object.
+    """
+
 def to_jsonable_python(
     value: Any,
     *,
diff --git a/src/errors/line_error.rs b/src/errors/line_error.rs
index e5d3c7bac..3ee4c7894 100644
--- a/src/errors/line_error.rs
+++ b/src/errors/line_error.rs
@@ -2,7 +2,9 @@ use pyo3::exceptions::PyTypeError;
 use pyo3::prelude::*;
 use pyo3::PyDowncastError;
 
-use crate::input::{Input, JsonInput};
+use jiter::JsonValue;
+
+use crate::input::Input;
 
 use super::location::{LocItem, Location};
 use super::types::ErrorType;
@@ -147,7 +149,7 @@ impl<'a> ValLineError<'a> {
 #[derive(Clone)]
 pub enum InputValue<'a> {
     PyAny(&'a PyAny),
-    JsonInput(JsonInput),
+    JsonInput(JsonValue),
     String(&'a str),
 }
 
diff --git a/src/errors/location.rs b/src/errors/location.rs
index e5c32d5e2..8acc2a039 100644
--- a/src/errors/location.rs
+++ b/src/errors/location.rs
@@ -3,12 +3,11 @@ use pyo3::once_cell::GILOnceCell;
 use std::fmt;
 
 use pyo3::prelude::*;
-use pyo3::types::{PyList, PyString, PyTuple};
+use pyo3::types::{PyList, PyTuple};
 use serde::ser::SerializeSeq;
 use serde::{Serialize, Serializer};
 
 use crate::lookup_key::{LookupPath, PathItem};
-use crate::tools::extract_i64;
 
 /// Used to store individual items of the error location, e.g. a string for key/field names
 /// or a number for array indices.
@@ -35,6 +34,12 @@ impl fmt::Display for LocItem {
     }
 }
 
+// TODO rename to ToLocItem
+pub trait AsLocItem {
+    // TODO rename to to_loc_item
+    fn as_loc_item(&self) -> LocItem;
+}
+
 impl From<String> for LocItem {
     fn from(s: String) -> Self {
         Self::S(s)
@@ -82,21 +87,6 @@ impl ToPyObject for LocItem {
     }
 }
 
-impl TryFrom<&PyAny> for LocItem {
-    type Error = PyErr;
-
-    fn try_from(loc_item: &PyAny) -> PyResult<Self> {
-        if let Ok(py_str) = loc_item.downcast::<PyString>() {
-            let str = py_str.to_str()?.to_string();
-            Ok(Self::S(str))
-        } else if let Ok(int) = extract_i64(loc_item) {
-            Ok(Self::I(int))
-        } else {
-            Err(PyTypeError::new_err("Item in a location must be a string or int"))
-        }
-    }
-}
-
 impl Serialize for LocItem {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -211,9 +201,9 @@ impl TryFrom<Option<&PyAny>> for Location {
     fn try_from(location: Option<&PyAny>) -> PyResult<Self> {
         if let Some(location) = location {
             let mut loc_vec: Vec<LocItem> = if let Ok(tuple) = location.downcast::<PyTuple>() {
-                tuple.iter().map(LocItem::try_from).collect::<PyResult<_>>()?
+                tuple.iter().map(AsLocItem::as_loc_item).collect()
             } else if let Ok(list) = location.downcast::<PyList>() {
-                list.iter().map(LocItem::try_from).collect::<PyResult<_>>()?
+                list.iter().map(AsLocItem::as_loc_item).collect()
             } else {
                 return Err(PyTypeError::new_err(
                     "Location must be a list or tuple of strings and ints",
diff --git a/src/errors/mod.rs b/src/errors/mod.rs
index 6a253197f..bfc5b4329 100644
--- a/src/errors/mod.rs
+++ b/src/errors/mod.rs
@@ -7,7 +7,7 @@ mod validation_exception;
 mod value_exception;
 
 pub use self::line_error::{InputValue, ValError, ValLineError, ValResult};
-pub use self::location::LocItem;
+pub use self::location::{AsLocItem, LocItem};
 pub use self::types::{list_all_errors, ErrorType, ErrorTypeDefaults, Number};
 pub use self::validation_exception::ValidationError;
 pub use self::value_exception::{PydanticCustomError, PydanticKnownError, PydanticOmit, PydanticUseDefault};
diff --git a/src/input/input_abstract.rs b/src/input/input_abstract.rs
index 655ba24b9..52551ef42 100644
--- a/src/input/input_abstract.rs
+++ b/src/input/input_abstract.rs
@@ -4,13 +4,15 @@ use pyo3::exceptions::PyValueError;
 use pyo3::types::{PyDict, PyType};
 use pyo3::{intern, prelude::*};
 
-use crate::errors::{InputValue, LocItem, ValResult};
+use jiter::JsonValue;
+
+use crate::errors::{AsLocItem, InputValue, ValResult};
 use crate::tools::py_err;
 use crate::{PyMultiHostUrl, PyUrl};
 
 use super::datetime::{EitherDate, EitherDateTime, EitherTime, EitherTimedelta};
 use super::return_enums::{EitherBytes, EitherInt, EitherString};
-use super::{EitherFloat, GenericArguments, GenericIterable, GenericIterator, GenericMapping, JsonInput};
+use super::{EitherFloat, GenericArguments, GenericIterable, GenericIterator, GenericMapping};
 
 #[derive(Debug, Clone, Copy)]
 pub enum InputType {
@@ -46,9 +48,7 @@ impl TryFrom<&str> for InputType {
 /// the convention is to either implement:
 /// * `strict_*` & `lax_*` if they have different behavior
 /// * or, `validate_*` and `strict_*` to just call `validate_*` if the behavior for strict and lax is the same
-pub trait Input<'a>: fmt::Debug + ToPyObject {
-    fn as_loc_item(&self) -> LocItem;
-
+pub trait Input<'a>: fmt::Debug + ToPyObject + AsLocItem {
     fn as_error_value(&'a self) -> InputValue<'a>;
 
     fn identity(&self) -> Option<usize> {
@@ -89,7 +89,7 @@ pub trait Input<'a>: fmt::Debug + ToPyObject {
 
     fn validate_dataclass_args(&'a self, dataclass_name: &str) -> ValResult<'a, GenericArguments<'a>>;
 
-    fn parse_json(&'a self) -> ValResult<'a, JsonInput>;
+    fn parse_json(&'a self) -> ValResult<'a, JsonValue>;
 
     fn validate_str(&'a self, strict: bool, coerce_numbers_to_str: bool) -> ValResult<EitherString<'a>> {
         if strict {
diff --git a/src/input/input_json.rs b/src/input/input_json.rs
index e375f5755..ac552621d 100644
--- a/src/input/input_json.rs
+++ b/src/input/input_json.rs
@@ -1,46 +1,48 @@
 use std::borrow::Cow;
 
+use jiter::{JsonArray, JsonValue};
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyString};
 use speedate::MicrosecondsPrecisionOverflowBehavior;
 use strum::EnumMessage;
 
-use crate::errors::{ErrorType, ErrorTypeDefaults, InputValue, LocItem, ValError, ValResult};
+use crate::errors::{AsLocItem, ErrorType, ErrorTypeDefaults, InputValue, LocItem, ValError, ValResult};
 use crate::validators::decimal::create_decimal;
 
 use super::datetime::{
     bytes_as_date, bytes_as_datetime, bytes_as_time, bytes_as_timedelta, float_as_datetime, float_as_duration,
     float_as_time, int_as_datetime, int_as_duration, int_as_time, EitherDate, EitherDateTime, EitherTime,
 };
-use super::shared::{float_as_int, int_as_bool, map_json_err, str_as_bool, str_as_float, str_as_int, string_to_vec};
+use super::shared::{float_as_int, int_as_bool, map_json_err, str_as_bool, str_as_float, str_as_int};
 use super::{
     BorrowInput, EitherBytes, EitherFloat, EitherInt, EitherString, EitherTimedelta, GenericArguments, GenericIterable,
-    GenericIterator, GenericMapping, Input, JsonArgs, JsonArray, JsonInput,
+    GenericIterator, GenericMapping, Input, JsonArgs,
 };
 
-impl<'a> Input<'a> for JsonInput {
-    /// This is required by since JSON object keys are always strings, I don't think it can be called
-    #[cfg_attr(has_coverage_attribute, coverage(off))]
+/// This is required but since JSON object keys are always strings, I don't think it can be called
+impl AsLocItem for JsonValue {
     fn as_loc_item(&self) -> LocItem {
         match self {
-            JsonInput::Int(i) => (*i).into(),
-            JsonInput::String(s) => s.as_str().into(),
+            JsonValue::Int(i) => (*i).into(),
+            JsonValue::Str(s) => s.as_str().into(),
             v => format!("{v:?}").into(),
         }
     }
+}
 
+impl<'a> Input<'a> for JsonValue {
     fn as_error_value(&'a self) -> InputValue<'a> {
-        // cloning JsonInput is cheap due to use of Arc
+        // cloning JsonValue is cheap due to use of Arc
         InputValue::JsonInput(self.clone())
     }
 
     fn is_none(&self) -> bool {
-        matches!(self, JsonInput::Null)
+        matches!(self, JsonValue::Null)
     }
 
     fn as_kwargs(&'a self, py: Python<'a>) -> Option<&'a PyDict> {
         match self {
-            JsonInput::Object(object) => {
+            JsonValue::Object(object) => {
                 let dict = PyDict::new(py);
                 for (k, v) in object.iter() {
                     dict.set_item(k, v.to_object(py)).unwrap();
@@ -53,15 +55,15 @@ impl<'a> Input<'a> for JsonInput {
 
     fn validate_args(&'a self) -> ValResult<'a, GenericArguments<'a>> {
         match self {
-            JsonInput::Object(object) => Ok(JsonArgs::new(None, Some(object)).into()),
-            JsonInput::Array(array) => Ok(JsonArgs::new(Some(array), None).into()),
+            JsonValue::Object(object) => Ok(JsonArgs::new(None, Some(object)).into()),
+            JsonValue::Array(array) => Ok(JsonArgs::new(Some(array), None).into()),
             _ => Err(ValError::new(ErrorTypeDefaults::ArgumentsType, self)),
         }
     }
 
     fn validate_dataclass_args(&'a self, class_name: &str) -> ValResult<'a, GenericArguments<'a>> {
         match self {
-            JsonInput::Object(object) => Ok(JsonArgs::new(None, Some(object)).into()),
+            JsonValue::Object(object) => Ok(JsonArgs::new(None, Some(object)).into()),
             _ => {
                 let class_name = class_name.to_string();
                 Err(ValError::new(
@@ -75,33 +77,32 @@ impl<'a> Input<'a> for JsonInput {
         }
     }
 
-    fn parse_json(&'a self) -> ValResult<'a, JsonInput> {
+    fn parse_json(&'a self) -> ValResult<'a, JsonValue> {
         match self {
-            JsonInput::String(s) => serde_json::from_str(s.as_str()).map_err(|e| map_json_err(self, e)),
+            JsonValue::Str(s) => JsonValue::parse(s.as_bytes(), true).map_err(|e| map_json_err(self, e)),
             _ => Err(ValError::new(ErrorTypeDefaults::JsonType, self)),
         }
     }
 
     fn strict_str(&'a self) -> ValResult<EitherString<'a>> {
         match self {
-            JsonInput::String(s) => Ok(s.as_str().into()),
+            JsonValue::Str(s) => Ok(s.as_str().into()),
             _ => Err(ValError::new(ErrorTypeDefaults::StringType, self)),
         }
     }
     fn lax_str(&'a self, coerce_numbers_to_str: bool) -> ValResult<EitherString<'a>> {
         match self {
-            JsonInput::String(s) => Ok(s.as_str().into()),
-            JsonInput::BigInt(v) if coerce_numbers_to_str => Ok(v.to_string().into()),
-            JsonInput::Float(v) if coerce_numbers_to_str => Ok(v.to_string().into()),
-            JsonInput::Int(v) if coerce_numbers_to_str => Ok(v.to_string().into()),
-            JsonInput::Uint(v) if coerce_numbers_to_str => Ok(v.to_string().into()),
+            JsonValue::Str(s) => Ok(s.as_str().into()),
+            JsonValue::Int(i) if coerce_numbers_to_str => Ok(i.to_string().into()),
+            JsonValue::BigInt(b) if coerce_numbers_to_str => Ok(b.to_string().into()),
+            JsonValue::Float(f) if coerce_numbers_to_str => Ok(f.to_string().into()),
             _ => Err(ValError::new(ErrorTypeDefaults::StringType, self)),
         }
     }
 
     fn validate_bytes(&'a self, _strict: bool) -> ValResult<EitherBytes<'a>> {
         match self {
-            JsonInput::String(s) => Ok(s.as_bytes().into()),
+            JsonValue::Str(s) => Ok(s.as_bytes().into()),
             _ => Err(ValError::new(ErrorTypeDefaults::BytesType, self)),
         }
     }
@@ -112,16 +113,16 @@ impl<'a> Input<'a> for JsonInput {
 
     fn strict_bool(&self) -> ValResult<bool> {
         match self {
-            JsonInput::Bool(b) => Ok(*b),
+            JsonValue::Bool(b) => Ok(*b),
             _ => Err(ValError::new(ErrorTypeDefaults::BoolType, self)),
         }
     }
     fn lax_bool(&self) -> ValResult<bool> {
         match self {
-            JsonInput::Bool(b) => Ok(*b),
-            JsonInput::String(s) => str_as_bool(self, s),
-            JsonInput::Int(int) => int_as_bool(self, *int),
-            JsonInput::Float(float) => match float_as_int(self, *float) {
+            JsonValue::Bool(b) => Ok(*b),
+            JsonValue::Str(s) => str_as_bool(self, s),
+            JsonValue::Int(int) => int_as_bool(self, *int),
+            JsonValue::Float(float) => match float_as_int(self, *float) {
                 Ok(int) => int
                     .as_bool()
                     .ok_or_else(|| ValError::new(ErrorTypeDefaults::BoolParsing, self)),
@@ -133,60 +134,56 @@ impl<'a> Input<'a> for JsonInput {
 
     fn strict_int(&'a self) -> ValResult<EitherInt<'a>> {
         match self {
-            JsonInput::Int(i) => Ok(EitherInt::I64(*i)),
-            JsonInput::Uint(u) => Ok(EitherInt::U64(*u)),
-            JsonInput::BigInt(b) => Ok(EitherInt::BigInt(b.clone())),
+            JsonValue::Int(i) => Ok(EitherInt::I64(*i)),
+            JsonValue::BigInt(b) => Ok(EitherInt::BigInt(b.clone())),
             _ => Err(ValError::new(ErrorTypeDefaults::IntType, self)),
         }
     }
     fn lax_int(&'a self) -> ValResult<EitherInt<'a>> {
         match self {
-            JsonInput::Bool(b) => match *b {
+            JsonValue::Bool(b) => match *b {
                 true => Ok(EitherInt::I64(1)),
                 false => Ok(EitherInt::I64(0)),
             },
-            JsonInput::Int(i) => Ok(EitherInt::I64(*i)),
-            JsonInput::Uint(u) => Ok(EitherInt::U64(*u)),
-            JsonInput::BigInt(b) => Ok(EitherInt::BigInt(b.clone())),
-            JsonInput::Float(f) => float_as_int(self, *f),
-            JsonInput::String(str) => str_as_int(self, str),
+            JsonValue::Int(i) => Ok(EitherInt::I64(*i)),
+            JsonValue::BigInt(b) => Ok(EitherInt::BigInt(b.clone())),
+            JsonValue::Float(f) => float_as_int(self, *f),
+            JsonValue::Str(str) => str_as_int(self, str),
             _ => Err(ValError::new(ErrorTypeDefaults::IntType, self)),
         }
     }
 
     fn ultra_strict_float(&'a self) -> ValResult<EitherFloat<'a>> {
         match self {
-            JsonInput::Float(f) => Ok(EitherFloat::F64(*f)),
+            JsonValue::Float(f) => Ok(EitherFloat::F64(*f)),
             _ => Err(ValError::new(ErrorTypeDefaults::FloatType, self)),
         }
     }
     fn strict_float(&'a self) -> ValResult<EitherFloat<'a>> {
         match self {
-            JsonInput::Float(f) => Ok(EitherFloat::F64(*f)),
-            JsonInput::Int(i) => Ok(EitherFloat::F64(*i as f64)),
-            JsonInput::Uint(u) => Ok(EitherFloat::F64(*u as f64)),
+            JsonValue::Float(f) => Ok(EitherFloat::F64(*f)),
+            JsonValue::Int(i) => Ok(EitherFloat::F64(*i as f64)),
             _ => Err(ValError::new(ErrorTypeDefaults::FloatType, self)),
         }
     }
     fn lax_float(&'a self) -> ValResult<EitherFloat<'a>> {
         match self {
-            JsonInput::Bool(b) => match *b {
+            JsonValue::Bool(b) => match *b {
                 true => Ok(EitherFloat::F64(1.0)),
                 false => Ok(EitherFloat::F64(0.0)),
             },
-            JsonInput::Float(f) => Ok(EitherFloat::F64(*f)),
-            JsonInput::Int(i) => Ok(EitherFloat::F64(*i as f64)),
-            JsonInput::Uint(u) => Ok(EitherFloat::F64(*u as f64)),
-            JsonInput::String(str) => str_as_float(self, str),
+            JsonValue::Float(f) => Ok(EitherFloat::F64(*f)),
+            JsonValue::Int(i) => Ok(EitherFloat::F64(*i as f64)),
+            JsonValue::Str(str) => str_as_float(self, str),
             _ => Err(ValError::new(ErrorTypeDefaults::FloatType, self)),
         }
     }
 
     fn strict_decimal(&'a self, py: Python<'a>) -> ValResult<&'a PyAny> {
         match self {
-            JsonInput::Float(f) => create_decimal(PyString::new(py, &f.to_string()), self, py),
+            JsonValue::Float(f) => create_decimal(PyString::new(py, &f.to_string()), self, py),
 
-            JsonInput::String(..) | JsonInput::Int(..) | JsonInput::Uint(..) | JsonInput::BigInt(..) => {
+            JsonValue::Str(..) | JsonValue::Int(..) | JsonValue::BigInt(..) => {
                 create_decimal(self.to_object(py).into_ref(py), self, py)
             }
             _ => Err(ValError::new(ErrorTypeDefaults::DecimalType, self)),
@@ -195,7 +192,7 @@ impl<'a> Input<'a> for JsonInput {
 
     fn validate_dict(&'a self, _strict: bool) -> ValResult<GenericMapping<'a>> {
         match self {
-            JsonInput::Object(dict) => Ok(dict.into()),
+            JsonValue::Object(dict) => Ok(dict.into()),
             _ => Err(ValError::new(ErrorTypeDefaults::DictType, self)),
         }
     }
@@ -206,7 +203,7 @@ impl<'a> Input<'a> for JsonInput {
 
     fn validate_list(&'a self, _strict: bool) -> ValResult<GenericIterable<'a>> {
         match self {
-            JsonInput::Array(a) => Ok(GenericIterable::JsonArray(a)),
+            JsonValue::Array(a) => Ok(GenericIterable::JsonArray(a)),
             _ => Err(ValError::new(ErrorTypeDefaults::ListType, self)),
         }
     }
@@ -218,7 +215,7 @@ impl<'a> Input<'a> for JsonInput {
     fn validate_tuple(&'a self, _strict: bool) -> ValResult<GenericIterable<'a>> {
         // just as in set's case, List has to be allowed
         match self {
-            JsonInput::Array(a) => Ok(GenericIterable::JsonArray(a)),
+            JsonValue::Array(a) => Ok(GenericIterable::JsonArray(a)),
             _ => Err(ValError::new(ErrorTypeDefaults::TupleType, self)),
         }
     }
@@ -230,7 +227,7 @@ impl<'a> Input<'a> for JsonInput {
     fn validate_set(&'a self, _strict: bool) -> ValResult<GenericIterable<'a>> {
         // we allow a list here since otherwise it would be impossible to create a set from JSON
         match self {
-            JsonInput::Array(a) => Ok(GenericIterable::JsonArray(a)),
+            JsonValue::Array(a) => Ok(GenericIterable::JsonArray(a)),
             _ => Err(ValError::new(ErrorTypeDefaults::SetType, self)),
         }
     }
@@ -242,7 +239,7 @@ impl<'a> Input<'a> for JsonInput {
     fn validate_frozenset(&'a self, _strict: bool) -> ValResult<GenericIterable<'a>> {
         // we allow a list here since otherwise it would be impossible to create a frozenset from JSON
         match self {
-            JsonInput::Array(a) => Ok(GenericIterable::JsonArray(a)),
+            JsonValue::Array(a) => Ok(GenericIterable::JsonArray(a)),
             _ => Err(ValError::new(ErrorTypeDefaults::FrozenSetType, self)),
         }
     }
@@ -253,20 +250,20 @@ impl<'a> Input<'a> for JsonInput {
 
     fn extract_generic_iterable(&self) -> ValResult<GenericIterable> {
         match self {
-            JsonInput::Array(a) => Ok(GenericIterable::JsonArray(a)),
-            JsonInput::String(s) => Ok(GenericIterable::JsonString(s)),
-            JsonInput::Object(object) => Ok(GenericIterable::JsonObject(object)),
+            JsonValue::Array(a) => Ok(GenericIterable::JsonArray(a)),
+            JsonValue::Str(s) => Ok(GenericIterable::JsonString(s)),
+            JsonValue::Object(object) => Ok(GenericIterable::JsonObject(object)),
             _ => Err(ValError::new(ErrorTypeDefaults::IterableType, self)),
         }
     }
 
     fn validate_iter(&self) -> ValResult<GenericIterator> {
         match self {
-            JsonInput::Array(a) => Ok(a.clone().into()),
-            JsonInput::String(s) => Ok(string_to_vec(s).into()),
-            JsonInput::Object(object) => {
+            JsonValue::Array(a) => Ok(a.clone().into()),
+            JsonValue::Str(s) => Ok(string_to_vec(s).into()),
+            JsonValue::Object(object) => {
                 // return keys iterator to match python's behavior
-                let keys: JsonArray = JsonArray::new(object.keys().map(|k| JsonInput::String(k.clone())).collect());
+                let keys: JsonArray = JsonArray::new(object.keys().map(|k| JsonValue::Str(k.clone())).collect());
                 Ok(keys.into())
             }
             _ => Err(ValError::new(ErrorTypeDefaults::IterableType, self)),
@@ -275,7 +272,7 @@ impl<'a> Input<'a> for JsonInput {
 
     fn validate_date(&self, _strict: bool) -> ValResult<EitherDate> {
         match self {
-            JsonInput::String(v) => bytes_as_date(self, v.as_bytes()),
+            JsonValue::Str(v) => bytes_as_date(self, v.as_bytes()),
             _ => Err(ValError::new(ErrorTypeDefaults::DateType, self)),
         }
     }
@@ -291,16 +288,16 @@ impl<'a> Input<'a> for JsonInput {
         microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
     ) -> ValResult<EitherTime> {
         match self {
-            JsonInput::String(v) => bytes_as_time(self, v.as_bytes(), microseconds_overflow_behavior),
+            JsonValue::Str(v) => bytes_as_time(self, v.as_bytes(), microseconds_overflow_behavior),
             _ => Err(ValError::new(ErrorTypeDefaults::TimeType, self)),
         }
     }
     fn lax_time(&self, microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior) -> ValResult<EitherTime> {
         match self {
-            JsonInput::String(v) => bytes_as_time(self, v.as_bytes(), microseconds_overflow_behavior),
-            JsonInput::Int(v) => int_as_time(self, *v, 0),
-            JsonInput::Float(v) => float_as_time(self, *v),
-            JsonInput::BigInt(_) => Err(ValError::new(
+            JsonValue::Str(v) => bytes_as_time(self, v.as_bytes(), microseconds_overflow_behavior),
+            JsonValue::Int(v) => int_as_time(self, *v, 0),
+            JsonValue::Float(v) => float_as_time(self, *v),
+            JsonValue::BigInt(_) => Err(ValError::new(
                 ErrorType::TimeParsing {
                     error: Cow::Borrowed(
                         speedate::ParseError::TimeTooLarge
@@ -320,7 +317,7 @@ impl<'a> Input<'a> for JsonInput {
         microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
     ) -> ValResult<EitherDateTime> {
         match self {
-            JsonInput::String(v) => bytes_as_datetime(self, v.as_bytes(), microseconds_overflow_behavior),
+            JsonValue::Str(v) => bytes_as_datetime(self, v.as_bytes(), microseconds_overflow_behavior),
             _ => Err(ValError::new(ErrorTypeDefaults::DatetimeType, self)),
         }
     }
@@ -329,9 +326,9 @@ impl<'a> Input<'a> for JsonInput {
         microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
     ) -> ValResult<EitherDateTime> {
         match self {
-            JsonInput::String(v) => bytes_as_datetime(self, v.as_bytes(), microseconds_overflow_behavior),
-            JsonInput::Int(v) => int_as_datetime(self, *v, 0),
-            JsonInput::Float(v) => float_as_datetime(self, *v),
+            JsonValue::Str(v) => bytes_as_datetime(self, v.as_bytes(), microseconds_overflow_behavior),
+            JsonValue::Int(v) => int_as_datetime(self, *v, 0),
+            JsonValue::Float(v) => float_as_datetime(self, *v),
             _ => Err(ValError::new(ErrorTypeDefaults::DatetimeType, self)),
         }
     }
@@ -341,7 +338,7 @@ impl<'a> Input<'a> for JsonInput {
         microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
     ) -> ValResult<EitherTimedelta> {
         match self {
-            JsonInput::String(v) => bytes_as_timedelta(self, v.as_bytes(), microseconds_overflow_behavior),
+            JsonValue::Str(v) => bytes_as_timedelta(self, v.as_bytes(), microseconds_overflow_behavior),
             _ => Err(ValError::new(ErrorTypeDefaults::TimeDeltaType, self)),
         }
     }
@@ -350,29 +347,31 @@ impl<'a> Input<'a> for JsonInput {
         microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
     ) -> ValResult<EitherTimedelta> {
         match self {
-            JsonInput::String(v) => bytes_as_timedelta(self, v.as_bytes(), microseconds_overflow_behavior),
-            JsonInput::Int(v) => Ok(int_as_duration(self, *v)?.into()),
-            JsonInput::Float(v) => Ok(float_as_duration(self, *v)?.into()),
+            JsonValue::Str(v) => bytes_as_timedelta(self, v.as_bytes(), microseconds_overflow_behavior),
+            JsonValue::Int(v) => Ok(int_as_duration(self, *v)?.into()),
+            JsonValue::Float(v) => Ok(float_as_duration(self, *v)?.into()),
             _ => Err(ValError::new(ErrorTypeDefaults::TimeDeltaType, self)),
         }
     }
 }
 
-impl BorrowInput for &'_ JsonInput {
-    type Input<'a> = JsonInput where Self: 'a;
+impl BorrowInput for &'_ JsonValue {
+    type Input<'a> = JsonValue where Self: 'a;
     fn borrow_input(&self) -> &Self::Input<'_> {
         self
     }
 }
 
-/// TODO: it would be good to get JsonInput and StringMapping string variants to go through this
-/// implementation
-/// Required for Dict keys so the string can behave like an Input
-impl<'a> Input<'a> for String {
+impl AsLocItem for String {
     fn as_loc_item(&self) -> LocItem {
         self.to_string().into()
     }
+}
 
+/// TODO: it would be good to get JsonInput and StringMapping string variants to go through this
+/// implementation
+/// Required for JSON Object keys so the string can behave like an Input
+impl<'a> Input<'a> for String {
     fn as_error_value(&'a self) -> InputValue<'a> {
         InputValue::String(self)
     }
@@ -398,8 +397,8 @@ impl<'a> Input<'a> for String {
         ))
     }
 
-    fn parse_json(&'a self) -> ValResult<'a, JsonInput> {
-        serde_json::from_str(self.as_str()).map_err(|e| map_json_err(self, e))
+    fn parse_json(&'a self) -> ValResult<'a, JsonValue> {
+        JsonValue::parse(self.as_bytes(), true).map_err(|e| map_json_err(self, e))
     }
 
     fn strict_str(&'a self) -> ValResult<EitherString<'a>> {
@@ -504,3 +503,7 @@ impl BorrowInput for String {
         self
     }
 }
+
+fn string_to_vec(s: &str) -> JsonArray {
+    JsonArray::new(s.chars().map(|c| JsonValue::Str(c.to_string())).collect())
+}
diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index 33d7ca296..de59ebce0 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -9,9 +9,11 @@ use pyo3::types::{
 #[cfg(not(PyPy))]
 use pyo3::types::{PyDictItems, PyDictKeys, PyDictValues};
 use pyo3::{intern, PyTypeInfo};
+
+use jiter::JsonValue;
 use speedate::MicrosecondsPrecisionOverflowBehavior;
 
-use crate::errors::{ErrorType, ErrorTypeDefaults, InputValue, LocItem, ValError, ValResult};
+use crate::errors::{AsLocItem, ErrorType, ErrorTypeDefaults, InputValue, LocItem, ValError, ValResult};
 use crate::tools::{extract_i64, safe_repr};
 use crate::validators::decimal::{create_decimal, get_decimal_type};
 use crate::{ArgsKwargs, PyMultiHostUrl, PyUrl};
@@ -27,7 +29,7 @@ use super::shared::{
 };
 use super::{
     py_string_str, BorrowInput, EitherBytes, EitherFloat, EitherInt, EitherString, EitherTimedelta, GenericArguments,
-    GenericIterable, GenericIterator, GenericMapping, Input, JsonInput, PyArgs,
+    GenericIterable, GenericIterator, GenericMapping, Input, PyArgs,
 };
 
 #[cfg(not(PyPy))]
@@ -90,7 +92,7 @@ macro_rules! extract_dict_items {
     };
 }
 
-impl<'a> Input<'a> for PyAny {
+impl AsLocItem for PyAny {
     fn as_loc_item(&self) -> LocItem {
         if let Ok(py_str) = self.downcast::<PyString>() {
             py_str.to_string_lossy().as_ref().into()
@@ -100,7 +102,9 @@ impl<'a> Input<'a> for PyAny {
             safe_repr(self).to_string().into()
         }
     }
+}
 
+impl<'a> Input<'a> for PyAny {
     fn as_error_value(&'a self) -> InputValue<'a> {
         InputValue::PyAny(self)
     }
@@ -183,19 +187,20 @@ impl<'a> Input<'a> for PyAny {
         }
     }
 
-    fn parse_json(&'a self) -> ValResult<'a, JsonInput> {
-        if let Ok(py_bytes) = self.downcast::<PyBytes>() {
-            serde_json::from_slice(py_bytes.as_bytes()).map_err(|e| map_json_err(self, e))
+    fn parse_json(&'a self) -> ValResult<'a, JsonValue> {
+        let bytes = if let Ok(py_bytes) = self.downcast::<PyBytes>() {
+            py_bytes.as_bytes()
         } else if let Ok(py_str) = self.downcast::<PyString>() {
             let str = py_string_str(py_str)?;
-            serde_json::from_str(str).map_err(|e| map_json_err(self, e))
+            str.as_bytes()
         } else if let Ok(py_byte_array) = self.downcast::<PyByteArray>() {
             // Safety: from_slice does not run arbitrary Python code and the GIL is held so the
-            // bytes array will not be mutated while from_slice is reading it
-            serde_json::from_slice(unsafe { py_byte_array.as_bytes() }).map_err(|e| map_json_err(self, e))
+            // bytes array will not be mutated while `JsonValue::parse` is reading it
+            unsafe { py_byte_array.as_bytes() }
         } else {
-            Err(ValError::new(ErrorTypeDefaults::JsonType, self))
-        }
+            return Err(ValError::new(ErrorTypeDefaults::JsonType, self));
+        };
+        JsonValue::parse(bytes, true).map_err(|e| map_json_err(self, e))
     }
 
     fn strict_str(&'a self) -> ValResult<EitherString<'a>> {
@@ -210,22 +215,6 @@ impl<'a> Input<'a> for PyAny {
         }
     }
 
-    fn exact_str(&'a self) -> ValResult<EitherString<'a>> {
-        if let Ok(py_str) = PyString::try_from_exact(self) {
-            Ok(EitherString::Py(py_str))
-        } else {
-            Err(ValError::new(ErrorTypeDefaults::IntType, self))
-        }
-    }
-
-    fn exact_int(&'a self) -> ValResult<EitherInt<'a>> {
-        if PyInt::is_exact_type_of(self) {
-            Ok(EitherInt::Py(self))
-        } else {
-            Err(ValError::new(ErrorTypeDefaults::IntType, self))
-        }
-    }
-
     fn lax_str(&'a self, coerce_numbers_to_str: bool) -> ValResult<EitherString<'a>> {
         if let Ok(py_str) = <PyString as PyTryFrom>::try_from_exact(self) {
             Ok(py_str.into())
@@ -352,6 +341,22 @@ impl<'a> Input<'a> for PyAny {
         }
     }
 
+    fn exact_int(&'a self) -> ValResult<EitherInt<'a>> {
+        if PyInt::is_exact_type_of(self) {
+            Ok(EitherInt::Py(self))
+        } else {
+            Err(ValError::new(ErrorTypeDefaults::IntType, self))
+        }
+    }
+
+    fn exact_str(&'a self) -> ValResult<EitherString<'a>> {
+        if let Ok(py_str) = PyString::try_from_exact(self) {
+            Ok(EitherString::Py(py_str))
+        } else {
+            Err(ValError::new(ErrorTypeDefaults::IntType, self))
+        }
+    }
+
     fn ultra_strict_float(&'a self) -> ValResult<EitherFloat<'a>> {
         if self.is_instance_of::<PyInt>() {
             Err(ValError::new(ErrorTypeDefaults::FloatType, self))
diff --git a/src/input/input_string.rs b/src/input/input_string.rs
index 72a32d897..b84908edf 100644
--- a/src/input/input_string.rs
+++ b/src/input/input_string.rs
@@ -1,9 +1,10 @@
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyString};
 
+use jiter::JsonValue;
 use speedate::MicrosecondsPrecisionOverflowBehavior;
 
-use crate::errors::{ErrorTypeDefaults, InputValue, LocItem, ValError, ValResult};
+use crate::errors::{AsLocItem, ErrorTypeDefaults, InputValue, LocItem, ValError, ValResult};
 use crate::input::py_string_str;
 use crate::tools::safe_repr;
 use crate::validators::decimal::create_decimal;
@@ -14,7 +15,7 @@ use super::datetime::{
 use super::shared::{map_json_err, str_as_bool, str_as_float};
 use super::{
     BorrowInput, EitherBytes, EitherFloat, EitherInt, EitherString, EitherTimedelta, GenericArguments, GenericIterable,
-    GenericIterator, GenericMapping, Input, JsonInput,
+    GenericIterator, GenericMapping, Input,
 };
 
 #[derive(Debug)]
@@ -52,14 +53,16 @@ impl<'py> StringMapping<'py> {
     }
 }
 
-impl<'a> Input<'a> for StringMapping<'a> {
+impl AsLocItem for StringMapping<'_> {
     fn as_loc_item(&self) -> LocItem {
         match self {
             Self::String(s) => s.to_string_lossy().as_ref().into(),
             Self::Mapping(d) => safe_repr(d).to_string().into(),
         }
     }
+}
 
+impl<'a> Input<'a> for StringMapping<'a> {
     fn as_error_value(&'a self) -> InputValue<'a> {
         match self {
             Self::String(s) => s.as_error_value(),
@@ -83,11 +86,11 @@ impl<'a> Input<'a> for StringMapping<'a> {
         }
     }
 
-    fn parse_json(&'a self) -> ValResult<'a, JsonInput> {
+    fn parse_json(&'a self) -> ValResult<'a, JsonValue> {
         match self {
             Self::String(s) => {
                 let str = py_string_str(s)?;
-                serde_json::from_str(str).map_err(|e| map_json_err(self, e))
+                JsonValue::parse(str.as_bytes(), true).map_err(|e| map_json_err(self, e))
             }
             Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::JsonType, self)),
         }
diff --git a/src/input/mod.rs b/src/input/mod.rs
index 22d774a8c..13c835f83 100644
--- a/src/input/mod.rs
+++ b/src/input/mod.rs
@@ -7,7 +7,6 @@ mod input_abstract;
 mod input_json;
 mod input_python;
 mod input_string;
-mod parse_json;
 mod return_enums;
 mod shared;
 
@@ -18,7 +17,6 @@ pub(crate) use datetime::{
 };
 pub(crate) use input_abstract::{BorrowInput, Input, InputType};
 pub(crate) use input_string::StringMapping;
-pub(crate) use parse_json::{JsonArray, JsonInput, JsonObject};
 pub(crate) use return_enums::{
     py_string_str, AttributesGenericIterator, DictGenericIterator, EitherBytes, EitherFloat, EitherInt, EitherString,
     GenericArguments, GenericIterable, GenericIterator, GenericMapping, Int, JsonArgs, JsonObjectGenericIterator,
diff --git a/src/input/parse_json.rs b/src/input/parse_json.rs
deleted file mode 100644
index 20a107669..000000000
--- a/src/input/parse_json.rs
+++ /dev/null
@@ -1,222 +0,0 @@
-use std::fmt;
-use std::sync::Arc;
-
-use num_bigint::BigInt;
-use pyo3::prelude::*;
-use pyo3::types::{PyDict, PyList};
-use serde::de::{Deserialize, DeserializeSeed, Error as SerdeError, MapAccess, SeqAccess, Visitor};
-use smallvec::SmallVec;
-
-use crate::lazy_index_map::LazyIndexMap;
-
-/// similar to serde `Value` but with int and float split
-#[derive(Clone, Debug)]
-pub enum JsonInput {
-    Null,
-    Bool(bool),
-    Int(i64),
-    BigInt(BigInt),
-    Uint(u64),
-    Float(f64),
-    String(String),
-    Array(JsonArray),
-    Object(JsonObject),
-}
-pub type JsonArray = Arc<SmallVec<[JsonInput; 8]>>;
-pub type JsonObject = Arc<LazyIndexMap<String, JsonInput>>;
-
-impl ToPyObject for JsonInput {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        match self {
-            Self::Null => py.None(),
-            Self::Bool(b) => b.into_py(py),
-            Self::Int(i) => i.into_py(py),
-            Self::BigInt(b) => b.to_object(py),
-            Self::Uint(i) => i.into_py(py),
-            Self::Float(f) => f.into_py(py),
-            Self::String(s) => s.into_py(py),
-            Self::Array(v) => PyList::new(py, v.iter().map(|v| v.to_object(py))).into_py(py),
-            Self::Object(o) => {
-                let dict = PyDict::new(py);
-                for (k, v) in o.iter() {
-                    dict.set_item(k, v.to_object(py)).unwrap();
-                }
-                dict.into_py(py)
-            }
-        }
-    }
-}
-
-impl<'de> Deserialize<'de> for JsonInput {
-    fn deserialize<D>(deserializer: D) -> Result<JsonInput, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        struct JsonVisitor;
-
-        impl<'de> Visitor<'de> for JsonVisitor {
-            type Value = JsonInput;
-
-            #[cfg_attr(has_coverage_attribute, coverage(off))]
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str("any valid JSON value")
-            }
-
-            fn visit_bool<E>(self, value: bool) -> Result<JsonInput, E> {
-                Ok(JsonInput::Bool(value))
-            }
-
-            fn visit_i64<E>(self, value: i64) -> Result<JsonInput, E> {
-                Ok(JsonInput::Int(value))
-            }
-
-            fn visit_u64<E>(self, value: u64) -> Result<JsonInput, E> {
-                match i64::try_from(value) {
-                    Ok(i) => Ok(JsonInput::Int(i)),
-                    Err(_) => Ok(JsonInput::Uint(value)),
-                }
-            }
-
-            fn visit_f64<E>(self, value: f64) -> Result<JsonInput, E> {
-                Ok(JsonInput::Float(value))
-            }
-
-            fn visit_str<E>(self, value: &str) -> Result<JsonInput, E>
-            where
-                E: SerdeError,
-            {
-                Ok(JsonInput::String(value.to_string()))
-            }
-
-            fn visit_string<E>(self, value: String) -> Result<JsonInput, E> {
-                Ok(JsonInput::String(value))
-            }
-
-            #[cfg_attr(has_coverage_attribute, coverage(off))]
-            fn visit_none<E>(self) -> Result<JsonInput, E> {
-                unreachable!()
-            }
-
-            #[cfg_attr(has_coverage_attribute, coverage(off))]
-            fn visit_some<D>(self, _: D) -> Result<JsonInput, D::Error>
-            where
-                D: serde::Deserializer<'de>,
-            {
-                unreachable!()
-            }
-
-            fn visit_unit<E>(self) -> Result<JsonInput, E> {
-                Ok(JsonInput::Null)
-            }
-
-            fn visit_seq<V>(self, mut visitor: V) -> Result<JsonInput, V::Error>
-            where
-                V: SeqAccess<'de>,
-            {
-                let mut vec = SmallVec::new();
-
-                while let Some(elem) = visitor.next_element()? {
-                    vec.push(elem);
-                }
-
-                Ok(JsonInput::Array(JsonArray::new(vec)))
-            }
-
-            fn visit_map<V>(self, mut visitor: V) -> Result<JsonInput, V::Error>
-            where
-                V: MapAccess<'de>,
-            {
-                const SERDE_JSON_NUMBER: &str = "$serde_json::private::Number";
-                match visitor.next_key_seed(KeyDeserializer)? {
-                    Some(first_key) => {
-                        let mut values = LazyIndexMap::new();
-                        let first_value = visitor.next_value()?;
-
-                        // serde_json will parse arbitrary precision numbers into a map
-                        // structure with a "number" key and a String value
-                        'try_number: {
-                            if first_key == SERDE_JSON_NUMBER {
-                                // Just in case someone tries to actually store that key in a real map,
-                                // keep parsing and continue as a map if so
-
-                                if let Some((key, value)) = visitor.next_entry::<String, JsonInput>()? {
-                                    // Important to preserve order of the keys
-                                    values.insert(first_key, first_value);
-                                    values.insert(key, value);
-                                    break 'try_number;
-                                }
-
-                                if let JsonInput::String(s) = &first_value {
-                                    // Normalize the string to either an int or float
-                                    let normalized = if s.chars().any(|c| c == '.' || c == 'E' || c == 'e') {
-                                        JsonInput::Float(
-                                            s.parse()
-                                                .map_err(|e| V::Error::custom(format!("expected a float: {e}")))?,
-                                        )
-                                    } else if let Ok(i) = s.parse::<i64>() {
-                                        JsonInput::Int(i)
-                                    } else if let Ok(big) = s.parse::<BigInt>() {
-                                        JsonInput::BigInt(big)
-                                    } else {
-                                        // Failed to normalize, just throw it in the map and continue
-                                        values.insert(first_key, first_value);
-                                        break 'try_number;
-                                    };
-
-                                    return Ok(normalized);
-                                };
-                            } else {
-                                values.insert(first_key, first_value);
-                            }
-                        }
-
-                        while let Some((key, value)) = visitor.next_entry()? {
-                            values.insert(key, value);
-                        }
-                        Ok(JsonInput::Object(Arc::new(values)))
-                    }
-                    None => Ok(JsonInput::Object(Arc::new(LazyIndexMap::new()))),
-                }
-            }
-        }
-
-        deserializer.deserialize_any(JsonVisitor)
-    }
-}
-
-struct KeyDeserializer;
-
-impl<'de> DeserializeSeed<'de> for KeyDeserializer {
-    type Value = String;
-
-    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        deserializer.deserialize_str(self)
-    }
-}
-
-impl<'de> Visitor<'de> for KeyDeserializer {
-    type Value = String;
-
-    #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-        formatter.write_str("a string key")
-    }
-
-    fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
-    where
-        E: serde::de::Error,
-    {
-        Ok(s.to_string())
-    }
-
-    #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn visit_string<E>(self, _: String) -> Result<Self::Value, E>
-    where
-        E: serde::de::Error,
-    {
-        unreachable!()
-    }
-}
diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index daa9f39fe..412842a13 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -4,6 +4,7 @@ use std::ops::Rem;
 use std::slice::Iter as SliceIter;
 use std::str::FromStr;
 
+use jiter::{JsonArray, JsonObject, JsonValue};
 use num_bigint::BigInt;
 
 use pyo3::exceptions::PyTypeError;
@@ -26,7 +27,6 @@ use crate::tools::py_err;
 use crate::validators::{CombinedValidator, ValidationState, Validator};
 
 use super::input_string::StringMapping;
-use super::parse_json::{JsonArray, JsonInput, JsonObject};
 use super::{py_error_on_minusone, Input};
 
 /// Container for all the collections (sized iterable containers) types, which
@@ -50,7 +50,7 @@ pub enum GenericIterable<'a> {
     PyByteArray(&'a PyByteArray),
     Sequence(&'a PySequence),
     Iterator(&'a PyIterator),
-    JsonArray(&'a [JsonInput]),
+    JsonArray(&'a [JsonValue]),
     JsonObject(&'a JsonObject),
     JsonString(&'a String),
 }
@@ -573,7 +573,7 @@ impl<'py> Iterator for AttributesGenericIterator<'py> {
 }
 
 pub struct JsonObjectGenericIterator<'py> {
-    object_iter: SliceIter<'py, (String, JsonInput)>,
+    object_iter: SliceIter<'py, (String, JsonValue)>,
 }
 
 impl<'py> JsonObjectGenericIterator<'py> {
@@ -585,7 +585,7 @@ impl<'py> JsonObjectGenericIterator<'py> {
 }
 
 impl<'py> Iterator for JsonObjectGenericIterator<'py> {
-    type Item = ValResult<'py, (&'py String, &'py JsonInput)>;
+    type Item = ValResult<'py, (&'py String, &'py JsonValue)>;
 
     fn next(&mut self) -> Option<Self::Item> {
         self.object_iter.next().map(|(key, value)| Ok((key, value)))
@@ -653,7 +653,7 @@ pub struct GenericJsonIterator {
 }
 
 impl GenericJsonIterator {
-    pub fn next(&mut self, _py: Python) -> PyResult<Option<(&JsonInput, usize)>> {
+    pub fn next(&mut self, _py: Python) -> PyResult<Option<(&JsonValue, usize)>> {
         if self.index < self.array.len() {
             // panic here is impossible due to bounds check above; compiler should be
             // able to optimize it away even
@@ -667,7 +667,7 @@ impl GenericJsonIterator {
     }
 
     pub fn input_as_error_value<'py>(&self, _py: Python<'py>) -> InputValue<'py> {
-        InputValue::JsonInput(JsonInput::Array(self.array.clone()))
+        InputValue::JsonInput(JsonValue::Array(self.array.clone()))
     }
 
     pub fn index(&self) -> usize {
@@ -689,12 +689,12 @@ impl<'a> PyArgs<'a> {
 
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub struct JsonArgs<'a> {
-    pub args: Option<&'a [JsonInput]>,
+    pub args: Option<&'a [JsonValue]>,
     pub kwargs: Option<&'a JsonObject>,
 }
 
 impl<'a> JsonArgs<'a> {
-    pub fn new(args: Option<&'a [JsonInput]>, kwargs: Option<&'a JsonObject>) -> Self {
+    pub fn new(args: Option<&'a [JsonValue]>, kwargs: Option<&'a JsonObject>) -> Self {
         Self { args, kwargs }
     }
 }
diff --git a/src/input/shared.rs b/src/input/shared.rs
index 105da4bcc..718210098 100644
--- a/src/input/shared.rs
+++ b/src/input/shared.rs
@@ -1,12 +1,12 @@
-use num_bigint::BigInt;
 use pyo3::sync::GILOnceCell;
 use pyo3::{intern, Py, PyAny, Python, ToPyObject};
 
+use jiter::JsonValueError;
+use num_bigint::BigInt;
+
 use crate::errors::{ErrorType, ErrorTypeDefaults, ValError, ValResult};
 
-use super::parse_json::{JsonArray, JsonInput};
 use super::{EitherFloat, EitherInt, Input};
-
 static ENUM_META_OBJECT: GILOnceCell<Py<PyAny>> = GILOnceCell::new();
 
 pub fn get_enum_meta_object(py: Python) -> Py<PyAny> {
@@ -20,7 +20,7 @@ pub fn get_enum_meta_object(py: Python) -> Py<PyAny> {
         .clone()
 }
 
-pub fn map_json_err<'a>(input: &'a impl Input<'a>, error: serde_json::Error) -> ValError<'a> {
+pub fn map_json_err<'a>(input: &'a impl Input<'a>, error: JsonValueError) -> ValError<'a> {
     ValError::new(
         ErrorType::JsonInvalid {
             error: error.to_string(),
@@ -164,7 +164,3 @@ pub fn decimal_as_int<'a>(py: Python, input: &'a impl Input<'a>, decimal: &'a Py
     }
     Ok(EitherInt::Py(numerator))
 }
-
-pub fn string_to_vec(s: &str) -> JsonArray {
-    JsonArray::new(s.chars().map(|c| JsonInput::String(c.to_string())).collect())
-}
diff --git a/src/lazy_index_map.rs b/src/lazy_index_map.rs
deleted file mode 100644
index c5621f877..000000000
--- a/src/lazy_index_map.rs
+++ /dev/null
@@ -1,63 +0,0 @@
-use std::borrow::Borrow;
-use std::cmp::{Eq, PartialEq};
-use std::fmt::Debug;
-use std::hash::Hash;
-use std::slice::Iter as SliceIter;
-use std::sync::OnceLock;
-
-use ahash::AHashMap;
-use smallvec::SmallVec;
-
-#[derive(Debug, Clone, Default)]
-pub struct LazyIndexMap<K, V> {
-    vec: SmallVec<[(K, V); 8]>,
-    map: OnceLock<AHashMap<K, usize>>,
-}
-
-/// Like [IndexMap](https://docs.rs/indexmap/latest/indexmap/) but only builds the lookup map when it's needed.
-impl<K, V> LazyIndexMap<K, V>
-where
-    K: Clone + Debug + Eq + Hash,
-    V: Debug,
-{
-    pub fn new() -> Self {
-        Self {
-            vec: SmallVec::new(),
-            map: OnceLock::new(),
-        }
-    }
-
-    pub fn insert(&mut self, key: K, value: V) {
-        if let Some(map) = self.map.get_mut() {
-            map.insert(key.clone(), self.vec.len());
-        }
-        self.vec.push((key, value));
-    }
-
-    pub fn len(&self) -> usize {
-        self.vec.len()
-    }
-
-    pub fn get<Q: ?Sized>(&self, key: &Q) -> Option<&V>
-    where
-        K: Borrow<Q> + PartialEq<Q>,
-        Q: Hash + Eq,
-    {
-        let map = self.map.get_or_init(|| {
-            self.vec
-                .iter()
-                .enumerate()
-                .map(|(index, (key, _))| (key.clone(), index))
-                .collect()
-        });
-        map.get(key).map(|&i| &self.vec[i].1)
-    }
-
-    pub fn keys(&self) -> impl Iterator<Item = &K> {
-        self.vec.iter().map(|(k, _)| k)
-    }
-
-    pub fn iter(&self) -> SliceIter<'_, (K, V)> {
-        self.vec.iter()
-    }
-}
diff --git a/src/lib.rs b/src/lib.rs
index b241cdb8a..f969c0657 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -4,6 +4,8 @@ extern crate core;
 
 use std::sync::OnceLock;
 
+use pyo3::exceptions::PyTypeError;
+use pyo3::types::{PyByteArray, PyBytes, PyString};
 use pyo3::{prelude::*, sync::GILOnceCell};
 
 // parse this first to get access to the contained macro
@@ -15,7 +17,6 @@ mod build_tools;
 mod definitions;
 mod errors;
 mod input;
-mod lazy_index_map;
 mod lookup_key;
 mod recursion_guard;
 mod serializers;
@@ -36,6 +37,19 @@ pub use serializers::{
 };
 pub use validators::{validate_core_schema, PySome, SchemaValidator};
 
+#[pyfunction(signature = (data, *, allow_inf_nan=true))]
+pub fn from_json(py: Python, data: &PyAny, allow_inf_nan: bool) -> PyResult<PyObject> {
+    if let Ok(py_bytes) = data.downcast::<PyBytes>() {
+        jiter::python_parse(py, py_bytes.as_bytes(), allow_inf_nan)
+    } else if let Ok(py_str) = data.downcast::<PyString>() {
+        jiter::python_parse(py, py_str.to_str()?.as_bytes(), allow_inf_nan)
+    } else if let Ok(py_byte_array) = data.downcast::<PyByteArray>() {
+        jiter::python_parse(py, &py_byte_array.to_vec(), allow_inf_nan)
+    } else {
+        Err(PyTypeError::new_err("Expected bytes, bytearray or str"))
+    }
+}
+
 pub fn get_pydantic_core_version() -> &'static str {
     static PYDANTIC_CORE_VERSION: OnceLock<String> = OnceLock::new();
 
@@ -95,6 +109,7 @@ fn _pydantic_core(py: Python, m: &PyModule) -> PyResult<()> {
     m.add_class::<SchemaSerializer>()?;
     m.add_class::<TzInfo>()?;
     m.add_function(wrap_pyfunction!(to_json, m)?)?;
+    m.add_function(wrap_pyfunction!(from_json, m)?)?;
     m.add_function(wrap_pyfunction!(to_jsonable_python, m)?)?;
     m.add_function(wrap_pyfunction!(list_all_errors, m)?)?;
     m.add_function(wrap_pyfunction!(validate_core_schema, m)?)?;
diff --git a/src/lookup_key.rs b/src/lookup_key.rs
index bb7d7e3d7..f833c00af 100644
--- a/src/lookup_key.rs
+++ b/src/lookup_key.rs
@@ -5,9 +5,11 @@ use pyo3::exceptions::{PyAttributeError, PyTypeError};
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList, PyMapping, PyString};
 
+use jiter::{JsonObject, JsonValue};
+
 use crate::build_tools::py_schema_err;
 use crate::errors::{py_err_string, ErrorType, ValError, ValLineError, ValResult};
-use crate::input::{Input, JsonInput, JsonObject, StringMapping};
+use crate::input::{Input, StringMapping};
 use crate::tools::{extract_i64, py_err};
 
 /// Used for getting items from python dicts, python objects, or JSON objects, in different ways
@@ -264,7 +266,7 @@ impl LookupKey {
     pub fn json_get<'data, 's>(
         &'s self,
         dict: &'data JsonObject,
-    ) -> ValResult<'data, Option<(&'s LookupPath, &'data JsonInput)>> {
+    ) -> ValResult<'data, Option<(&'s LookupPath, &'data JsonValue)>> {
         match self {
             Self::Simple { key, path, .. } => match dict.get(key) {
                 Some(value) => Ok(Some((path, value))),
@@ -289,13 +291,13 @@ impl LookupKey {
 
                     // first step is different from the rest as we already know dict is JsonObject
                     // because of above checks, we know that path should have at least one element, hence unwrap
-                    let v: &JsonInput = match path_iter.next().unwrap().json_obj_get(dict) {
+                    let v: &JsonValue = match path_iter.next().unwrap().json_obj_get(dict) {
                         Some(v) => v,
                         None => continue,
                     };
 
                     // similar to above
-                    // iterate over the path and plug each value into the JsonInput from the last step, starting with v
+                    // iterate over the path and plug each value into the JsonValue from the last step, starting with v
                     // from the first step, this could just be a loop but should be somewhat faster with a functional design
                     if let Some(v) = path_iter.try_fold(v, |d, loc| loc.json_get(d)) {
                         // Successfully found an item, return it
@@ -481,10 +483,10 @@ impl PathItem {
         }
     }
 
-    pub fn json_get<'a>(&self, any_json: &'a JsonInput) -> Option<&'a JsonInput> {
+    pub fn json_get<'a>(&self, any_json: &'a JsonValue) -> Option<&'a JsonValue> {
         match any_json {
-            JsonInput::Object(v_obj) => self.json_obj_get(v_obj),
-            JsonInput::Array(v_array) => match self {
+            JsonValue::Object(v_obj) => self.json_obj_get(v_obj),
+            JsonValue::Array(v_array) => match self {
                 Self::Pos(index) => v_array.get(*index),
                 Self::Neg(index) => {
                     if let Some(index) = v_array.len().checked_sub(*index) {
@@ -499,7 +501,7 @@ impl PathItem {
         }
     }
 
-    pub fn json_obj_get<'a>(&self, json_obj: &'a JsonObject) -> Option<&'a JsonInput> {
+    pub fn json_obj_get<'a>(&self, json_obj: &'a JsonObject) -> Option<&'a JsonValue> {
         match self {
             Self::S(key, _) => json_obj.get(key),
             _ => None,
diff --git a/src/validators/arguments.rs b/src/validators/arguments.rs
index 7f406ba16..748b13338 100644
--- a/src/validators/arguments.rs
+++ b/src/validators/arguments.rs
@@ -6,7 +6,7 @@ use ahash::AHashSet;
 
 use crate::build_tools::py_schema_err;
 use crate::build_tools::schema_or_config_same;
-use crate::errors::{ErrorTypeDefaults, ValError, ValLineError, ValResult};
+use crate::errors::{AsLocItem, ErrorTypeDefaults, ValError, ValLineError, ValResult};
 use crate::input::{GenericArguments, Input};
 use crate::lookup_key::LookupKey;
 
diff --git a/src/validators/dataclass.rs b/src/validators/dataclass.rs
index b18faea2c..d93441ce0 100644
--- a/src/validators/dataclass.rs
+++ b/src/validators/dataclass.rs
@@ -7,7 +7,7 @@ use ahash::AHashSet;
 
 use crate::build_tools::py_schema_err;
 use crate::build_tools::{is_strict, schema_or_config_same, ExtraBehavior};
-use crate::errors::{ErrorType, ErrorTypeDefaults, ValError, ValLineError, ValResult};
+use crate::errors::{AsLocItem, ErrorType, ErrorTypeDefaults, ValError, ValLineError, ValResult};
 use crate::input::{BorrowInput, GenericArguments, Input};
 use crate::lookup_key::LookupKey;
 use crate::tools::SchemaDict;
diff --git a/src/validators/dict.rs b/src/validators/dict.rs
index 5026afba3..c7df345ed 100644
--- a/src/validators/dict.rs
+++ b/src/validators/dict.rs
@@ -3,7 +3,7 @@ use pyo3::prelude::*;
 use pyo3::types::PyDict;
 
 use crate::build_tools::is_strict;
-use crate::errors::{ValError, ValLineError, ValResult};
+use crate::errors::{AsLocItem, ValError, ValLineError, ValResult};
 use crate::input::BorrowInput;
 use crate::input::{
     DictGenericIterator, GenericMapping, Input, JsonObjectGenericIterator, MappingGenericIterator,
diff --git a/src/validators/function.rs b/src/validators/function.rs
index adb143696..66bbafbb9 100644
--- a/src/validators/function.rs
+++ b/src/validators/function.rs
@@ -1,16 +1,16 @@
 use std::sync::Arc;
 
-use pyo3::exceptions::{PyAssertionError, PyTypeError, PyValueError};
+use pyo3::exceptions::{PyAssertionError, PyValueError};
 use pyo3::prelude::*;
 use pyo3::types::{PyAny, PyDict, PyString};
 use pyo3::{intern, PyTraverseError, PyVisit};
 
 use crate::errors::{
-    ErrorType, LocItem, PydanticCustomError, PydanticKnownError, PydanticOmit, ValError, ValResult, ValidationError,
+    AsLocItem, ErrorType, PydanticCustomError, PydanticKnownError, PydanticOmit, ValError, ValResult, ValidationError,
 };
 use crate::input::Input;
 use crate::py_gc::PyGcTraverse;
-use crate::tools::{function_name, py_err, safe_repr, SchemaDict};
+use crate::tools::{function_name, safe_repr, SchemaDict};
 use crate::PydanticUseDefault;
 
 use super::generator::InternalValidator;
@@ -406,13 +406,7 @@ struct ValidatorCallable {
 #[pymethods]
 impl ValidatorCallable {
     fn __call__(&mut self, py: Python, input_value: &PyAny, outer_location: Option<&PyAny>) -> PyResult<PyObject> {
-        let outer_location = match outer_location {
-            Some(ol) => match LocItem::try_from(ol) {
-                Ok(ol) => Some(ol),
-                Err(_) => return py_err!(PyTypeError; "outer_location must be a str or int"),
-            },
-            None => None,
-        };
+        let outer_location = outer_location.map(AsLocItem::as_loc_item);
         self.validator.validate(py, input_value, outer_location)
     }
 
@@ -440,13 +434,7 @@ struct AssignmentValidatorCallable {
 #[pymethods]
 impl AssignmentValidatorCallable {
     fn __call__(&mut self, py: Python, input_value: &PyAny, outer_location: Option<&PyAny>) -> PyResult<PyObject> {
-        let outer_location = match outer_location {
-            Some(ol) => match LocItem::try_from(ol) {
-                Ok(ol) => Some(ol),
-                Err(_) => return py_err!(PyTypeError; "outer_location must be a str or int"),
-            },
-            None => None,
-        };
+        let outer_location = outer_location.map(AsLocItem::as_loc_item);
         self.validator.validate_assignment(
             py,
             input_value,
diff --git a/src/validators/model_fields.rs b/src/validators/model_fields.rs
index b79145c97..17ec81670 100644
--- a/src/validators/model_fields.rs
+++ b/src/validators/model_fields.rs
@@ -7,7 +7,7 @@ use ahash::AHashSet;
 
 use crate::build_tools::py_schema_err;
 use crate::build_tools::{is_strict, schema_or_config_same, ExtraBehavior};
-use crate::errors::{ErrorType, ErrorTypeDefaults, ValError, ValLineError, ValResult};
+use crate::errors::{AsLocItem, ErrorType, ErrorTypeDefaults, ValError, ValLineError, ValResult};
 use crate::input::{
     AttributesGenericIterator, BorrowInput, DictGenericIterator, GenericMapping, Input, JsonObjectGenericIterator,
     MappingGenericIterator, StringMappingGenericIterator,
diff --git a/src/validators/typed_dict.rs b/src/validators/typed_dict.rs
index dab492da7..5839959e7 100644
--- a/src/validators/typed_dict.rs
+++ b/src/validators/typed_dict.rs
@@ -8,7 +8,7 @@ use ahash::AHashSet;
 
 use crate::build_tools::py_schema_err;
 use crate::build_tools::{is_strict, schema_or_config, schema_or_config_same, ExtraBehavior};
-use crate::errors::{ErrorTypeDefaults, ValError, ValLineError, ValResult};
+use crate::errors::{AsLocItem, ErrorTypeDefaults, ValError, ValLineError, ValResult};
 use crate::input::{
     AttributesGenericIterator, BorrowInput, DictGenericIterator, GenericMapping, Input, JsonObjectGenericIterator,
     MappingGenericIterator, StringMappingGenericIterator,
diff --git a/src/validators/union.rs b/src/validators/union.rs
index a8bd29d7d..837114408 100644
--- a/src/validators/union.rs
+++ b/src/validators/union.rs
@@ -9,7 +9,7 @@ use smallvec::SmallVec;
 
 use crate::build_tools::py_schema_err;
 use crate::build_tools::{is_strict, schema_or_config};
-use crate::errors::{ErrorType, LocItem, ValError, ValLineError, ValResult};
+use crate::errors::{AsLocItem, ErrorType, ValError, ValLineError, ValResult};
 use crate::input::{GenericMapping, Input};
 use crate::lookup_key::LookupKey;
 use crate::py_gc::PyGcTraverse;
@@ -566,7 +566,7 @@ impl TaggedUnionValidator {
         if let Ok(Some((tag, validator))) = self.lookup.validate(py, tag) {
             return match validator.validate(py, input, state) {
                 Ok(res) => Ok(res),
-                Err(err) => Err(err.with_outer_location(LocItem::try_from(tag.to_object(py).into_ref(py))?)),
+                Err(err) => Err(err.with_outer_location(tag.as_loc_item())),
             };
         }
         match self.custom_error {
diff --git a/tests/test_json.py b/tests/test_json.py
index 9bba05c14..4ef8a1d40 100644
--- a/tests/test_json.py
+++ b/tests/test_json.py
@@ -4,7 +4,7 @@
 from typing import List
 
 import pytest
-from dirty_equals import IsList
+from dirty_equals import IsFloatNan, IsList
 
 import pydantic_core
 from pydantic_core import (
@@ -358,3 +358,10 @@ def test_bad_repr():
         to_json(b)
 
     assert to_json(b, serialize_unknown=True) == b'"<Unserializable BadRepr object>"'
+
+
+def test_inf_nan_allow():
+    v = SchemaValidator(core_schema.float_schema(allow_inf_nan=True))
+    assert v.validate_json('Infinity') == float('inf')
+    assert v.validate_json('-Infinity') == float('-inf')
+    assert v.validate_json('NaN') == IsFloatNan()
diff --git a/tests/validators/test_decimal.py b/tests/validators/test_decimal.py
index 43b3d19b9..b9fabeaed 100644
--- a/tests/validators/test_decimal.py
+++ b/tests/validators/test_decimal.py
@@ -140,7 +140,8 @@ def test_decimal_strict_json(input_value, expected):
             {'ge': 0},
             -0.1,
             Err(
-                'Input should be greater than or equal to 0 [type=greater_than_equal, input_value=-0.1, input_type=float]'
+                'Input should be greater than or equal to 0 '
+                '[type=greater_than_equal, input_value=-0.1, input_type=float]'
             ),
         ),
         ({'gt': 0}, 0.1, Decimal('0.1')),
@@ -150,14 +151,14 @@ def test_decimal_strict_json(input_value, expected):
         ({'le': 0}, 0.1, Err('Input should be less than or equal to 0')),
         ({'lt': 0, 'allow_inf_nan': True}, float('nan'), Err('Input should be less than 0')),
         ({'gt': 0, 'allow_inf_nan': True}, float('inf'), Decimal('inf')),
+        ({'allow_inf_nan': True}, float('-inf'), Decimal('-inf')),
+        ({'allow_inf_nan': True}, float('nan'), FunctionCheck(math.isnan)),
         ({'lt': 0}, 0, Err('Input should be less than 0')),
         ({'lt': 0.123456}, 1, Err('Input should be less than 0.123456')),
     ],
 )
 def test_decimal_kwargs(py_and_json: PyAndJson, kwargs: Dict[str, Any], input_value, expected):
     v = py_and_json({'type': 'decimal', **kwargs})
-    if v.validator_type == 'json' and isinstance(input_value, float) and not math.isfinite(input_value):
-        expected = Err('Invalid JSON')
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_test(input_value)
diff --git a/tests/validators/test_float.py b/tests/validators/test_float.py
index b18181fbb..35b04c3f9 100644
--- a/tests/validators/test_float.py
+++ b/tests/validators/test_float.py
@@ -4,9 +4,9 @@
 from typing import Any, Dict
 
 import pytest
-from dirty_equals import FunctionCheck, IsStr
+from dirty_equals import FunctionCheck, IsFloatNan, IsStr
 
-from pydantic_core import SchemaValidator, ValidationError
+from pydantic_core import SchemaValidator, ValidationError, core_schema
 
 from ..conftest import Err, PyAndJson, plain_repr
 
@@ -92,8 +92,6 @@ def test_float_strict(py_and_json: PyAndJson, input_value, expected):
 )
 def test_float_kwargs(py_and_json: PyAndJson, kwargs: Dict[str, Any], input_value, expected):
     v = py_and_json({'type': 'float', **kwargs})
-    if v.validator_type == 'json' and isinstance(input_value, float) and not math.isfinite(input_value):
-        expected = Err('Invalid JSON')
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_test(input_value)
@@ -376,3 +374,34 @@ def test_string_with_underscores() -> None:
             v.validate_python(edge_case)
         with pytest.raises(ValidationError):
             v.validate_json(f'"{edge_case}"')
+
+
+def test_allow_inf_nan_true_json() -> None:
+    v = SchemaValidator(core_schema.float_schema())
+
+    assert v.validate_json('123') == 123
+    assert v.validate_json('NaN') == IsFloatNan()
+    assert v.validate_json('Infinity') == float('inf')
+    assert v.validate_json('-Infinity') == float('-inf')
+
+
+def test_allow_inf_nan_false_json() -> None:
+    v = SchemaValidator(core_schema.float_schema(), core_schema.CoreConfig(allow_inf_nan=False))
+
+    assert v.validate_json('123') == 123
+    with pytest.raises(ValidationError) as exc_info1:
+        v.validate_json('NaN')
+    # insert_assert(exc_info.value.errors())
+    assert exc_info1.value.errors(include_url=False) == [
+        {'type': 'finite_number', 'loc': (), 'msg': 'Input should be a finite number', 'input': IsFloatNan()}
+    ]
+    with pytest.raises(ValidationError) as exc_info2:
+        v.validate_json('Infinity')
+    assert exc_info2.value.errors(include_url=False) == [
+        {'type': 'finite_number', 'loc': (), 'msg': 'Input should be a finite number', 'input': float('inf')}
+    ]
+    with pytest.raises(ValidationError) as exc_info3:
+        v.validate_json('-Infinity')
+    assert exc_info3.value.errors(include_url=False) == [
+        {'type': 'finite_number', 'loc': (), 'msg': 'Input should be a finite number', 'input': float('-inf')}
+    ]
diff --git a/tests/validators/test_function.py b/tests/validators/test_function.py
index 9f94ceb1b..e5ccba1e3 100644
--- a/tests/validators/test_function.py
+++ b/tests/validators/test_function.py
@@ -289,8 +289,19 @@ def f(input_value, validator, info):
 
     v = SchemaValidator(core_schema.with_info_wrap_validator_function(f, core_schema.int_schema()))
 
-    with pytest.raises(TypeError, match='^outer_location must be a str or int$'):
-        v.validate_python(4)
+    assert v.validate_python(4) == 6
+
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_python('wrong')
+    # insert_assert(exc_info.value.errors(include_url=False))
+    assert exc_info.value.errors(include_url=False) == [
+        {
+            'type': 'int_parsing',
+            'loc': ("('4',)",),
+            'msg': 'Input should be a valid integer, unable to parse string as an integer',
+            'input': 'wrong',
+        }
+    ]
 
 
 def test_function_after():
diff --git a/tests/validators/test_int.py b/tests/validators/test_int.py
index dedc2bd93..61acab7fb 100644
--- a/tests/validators/test_int.py
+++ b/tests/validators/test_int.py
@@ -6,7 +6,7 @@
 import pytest
 from dirty_equals import IsStr
 
-from pydantic_core import SchemaValidator, ValidationError
+from pydantic_core import SchemaValidator, ValidationError, core_schema
 
 from ..conftest import Err, PyAndJson, plain_repr
 
@@ -472,3 +472,27 @@ class PlainEnum(Enum):
     v_lax = v.validate_python(PlainEnum.ONE)
     assert v_lax == 1
     assert type(v_lax) == int
+
+
+def test_allow_inf_nan_true_json() -> None:
+    v = SchemaValidator(core_schema.int_schema(), core_schema.CoreConfig(allow_inf_nan=True))
+
+    assert v.validate_json('123') == 123
+    with pytest.raises(ValidationError, match=r'Input should be a finite number \[type=finite_number'):
+        v.validate_json('NaN')
+    with pytest.raises(ValidationError, match=r'Input should be a finite number \[type=finite_number'):
+        v.validate_json('Infinity')
+    with pytest.raises(ValidationError, match=r'Input should be a finite number \[type=finite_number'):
+        v.validate_json('-Infinity')
+
+
+def test_allow_inf_nan_false_json() -> None:
+    v = SchemaValidator(core_schema.int_schema(), core_schema.CoreConfig(allow_inf_nan=False))
+
+    assert v.validate_json('123') == 123
+    with pytest.raises(ValidationError, match=r'Input should be a finite number \[type=finite_number'):
+        v.validate_json('NaN')
+    with pytest.raises(ValidationError, match=r'Input should be a finite number \[type=finite_number'):
+        v.validate_json('Infinity')
+    with pytest.raises(ValidationError, match=r'Input should be a finite number \[type=finite_number'):
+        v.validate_json('-Infinity')

From 3eeebf37336f189843c472ee1c1b89564b7b2777 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 6 Nov 2023 12:06:54 +0000
Subject: [PATCH 101/550] Bump black from 23.10.0 to 23.10.1 (#1057)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index 79a41f7ea..655ff8bda 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,4 +1,4 @@
-black==23.10.0
+black==23.10.1
 griffe==0.36.9
 pyright==1.1.334
 ruff==0.1.3

From 828eb33fc58d65456dd192e29d0bd4d8631419fd Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 6 Nov 2023 12:11:55 +0000
Subject: [PATCH 102/550] Bump serde_json from 1.0.107 to 1.0.108 (#1058)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index f16b93697..5af1ec727 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -503,9 +503,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.107"
+version = "1.0.108"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6b420ce6e3d8bd882e9b243c6eed35dbc9a6110c9769e74b584e0d68d1f20c65"
+checksum = "3d1c7e3eac408d115102c4c24ad393e0821bb3a5df4d506a80f85f7a742a526b"
 dependencies = [
  "indexmap",
  "itoa",
diff --git a/Cargo.toml b/Cargo.toml
index 211fdfe01..bbeaabeac 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -30,7 +30,7 @@ pyo3 = { version = "0.20.0", features = ["generate-import-lib", "num-bigint"] }
 regex = "1.10.2"
 strum = { version = "0.25.0", features = ["derive"] }
 strum_macros = "0.25.3"
-serde_json = {version = "1.0.107", features = ["arbitrary_precision", "preserve_order"]}
+serde_json = {version = "1.0.108", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.8"
 serde = { version = "1.0.190", features = ["derive"] }
 speedate = "0.12.0"

From d43d0876749df74f9c341bdc91b4c1e47b69cb38 Mon Sep 17 00:00:00 2001
From: Samuel Colvin <s@muelcolvin.com>
Date: Mon, 6 Nov 2023 13:20:14 +0000
Subject: [PATCH 103/550] Uprev to 2.12.0 (#1061)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 5af1ec727..4768d42d5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -321,7 +321,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.11.0"
+version = "2.12.0"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index bbeaabeac..d5b4ca605 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.11.0"
+version = "2.12.0"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From 1cf1c75fac74b77a730d183dec9bc4a6a700fde4 Mon Sep 17 00:00:00 2001
From: Samuel Colvin <s@muelcolvin.com>
Date: Mon, 6 Nov 2023 13:20:36 +0000
Subject: [PATCH 104/550] uprev speedate, prevent - sign as datetime (#1060)

---
 Cargo.lock                        | 4 ++--
 Cargo.toml                        | 2 +-
 tests/validators/test_date.py     | 2 ++
 tests/validators/test_datetime.py | 2 ++
 4 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 4768d42d5..c6deb4246 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -521,9 +521,9 @@ checksum = "942b4a808e05215192e39f4ab80813e599068285906cc91aa64f923db842bd5a"
 
 [[package]]
 name = "speedate"
-version = "0.12.0"
+version = "0.13.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c028e117e67c1f3224f5f834b3e48d4133dc11ec509aa19fdfa6c0987efed332"
+checksum = "242f76c50fd18cbf098607090ade73a08d39cfd84ea835f3796a2c855223b19b"
 dependencies = [
  "strum",
  "strum_macros",
diff --git a/Cargo.toml b/Cargo.toml
index d5b4ca605..242479712 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -33,7 +33,7 @@ strum_macros = "0.25.3"
 serde_json = {version = "1.0.108", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.8"
 serde = { version = "1.0.190", features = ["derive"] }
-speedate = "0.12.0"
+speedate = "0.13.0"
 smallvec = "1.11.1"
 ahash = "0.8.6"
 url = "2.4.1"
diff --git a/tests/validators/test_date.py b/tests/validators/test_date.py
index 5ddde4884..6a552a57b 100644
--- a/tests/validators/test_date.py
+++ b/tests/validators/test_date.py
@@ -64,6 +64,8 @@
             ),
             id='-inf',
         ),
+        pytest.param('-', Err('Input should be a valid date or datetime, input is too short'), id='minus'),
+        pytest.param('+', Err('Input should be a valid date or datetime, input is too short'), id='pus'),
     ],
 )
 def test_date(input_value, expected):
diff --git a/tests/validators/test_datetime.py b/tests/validators/test_datetime.py
index 67581119b..89e9c1c53 100644
--- a/tests/validators/test_datetime.py
+++ b/tests/validators/test_datetime.py
@@ -36,6 +36,8 @@
         (float('nan'), Err('Input should be a valid datetime, NaN values not permitted [type=datetime_parsing,')),
         (float('inf'), Err('Input should be a valid datetime, dates after 9999')),
         (float('-inf'), Err('Input should be a valid datetime, dates before 1600')),
+        ('-', Err('Input should be a valid datetime, input is too short [type=datetime_parsing,')),
+        ('+', Err('Input should be a valid datetime, input is too short [type=datetime_parsing,')),
     ],
 )
 def test_datetime(input_value, expected):

From cb47b966923e8a4c5b9bba9b6f3ccb1818bf2231 Mon Sep 17 00:00:00 2001
From: Samuel Colvin <s@muelcolvin.com>
Date: Mon, 6 Nov 2023 13:27:48 +0000
Subject: [PATCH 105/550] check not type in serialization (#962)

---
 src/serializers/ob_type.rs    | 2 ++
 tests/serializers/test_any.py | 8 ++++++++
 2 files changed, 10 insertions(+)

diff --git a/src/serializers/ob_type.rs b/src/serializers/ob_type.rs
index 109aed3bb..ff43a1065 100644
--- a/src/serializers/ob_type.rs
+++ b/src/serializers/ob_type.rs
@@ -333,6 +333,7 @@ fn is_dataclass(op_value: Option<&PyAny>) -> bool {
         value
             .hasattr(intern!(value.py(), "__dataclass_fields__"))
             .unwrap_or(false)
+            && !value.is_instance_of::<PyType>()
     } else {
         false
     }
@@ -343,6 +344,7 @@ fn is_pydantic_serializable(op_value: Option<&PyAny>) -> bool {
         value
             .hasattr(intern!(value.py(), "__pydantic_serializer__"))
             .unwrap_or(false)
+            && !value.is_instance_of::<PyType>()
     } else {
         false
     }
diff --git a/tests/serializers/test_any.py b/tests/serializers/test_any.py
index 448ca108a..98ec22c1f 100644
--- a/tests/serializers/test_any.py
+++ b/tests/serializers/test_any.py
@@ -505,6 +505,14 @@ class Foo:
     assert s.to_python(Foo(a='hello', b=b'more'), exclude={'a'}) == IsStrictDict()
     assert s.to_json(Foo(a='hello', b=b'more'), exclude={'a'}) == b'{}'
 
+    assert s.to_python(Foo) == Foo
+    with pytest.raises(PydanticSerializationError, match=r"Unable to serialize unknown type: <class 'type'>"):
+        s.to_python(Foo, mode='json')
+    with pytest.raises(PydanticSerializationError, match=r"Unable to serialize unknown type: <class 'type'>"):
+        s.to_json(Foo)
+    assert s.to_python(Foo, mode='json', fallback=lambda x: x.__name__) == 'Foo'
+    assert s.to_json(Foo, fallback=lambda x: x.__name__) == b'"Foo"'
+
 
 def test_dataclass_classvar(any_serializer):
     @dataclasses.dataclass

From 5de6b75b2fbdf6d3cb48e9f59909e07326698f69 Mon Sep 17 00:00:00 2001
From: David Hewitt <mail@davidhewitt.io>
Date: Mon, 6 Nov 2023 18:04:59 +0000
Subject: [PATCH 106/550] reduce dependabot frequency (#1059)

---
 .github/dependabot.yml | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index e9157d2f2..b93ab648d 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -3,14 +3,14 @@ updates:
   - package-ecosystem: "cargo"
     directory: "/"
     schedule:
-      interval: "weekly"
+      interval: "monthly"
 
   - package-ecosystem: "pip"
     directory: "/"
     schedule:
-      interval: "weekly"
+      interval: "monthly"
 
   - package-ecosystem: "github-actions"
     directory: "/"
     schedule:
-      interval: "weekly"
+      interval: "monthly"

From d80c454bbfc30a9aa3ee6d3315a339caf3ef27f6 Mon Sep 17 00:00:00 2001
From: David Hewitt <mail@davidhewitt.io>
Date: Mon, 6 Nov 2023 18:24:51 +0000
Subject: [PATCH 107/550] fix: nan inf float (#1062)

Co-authored-by: JeanArhancet <jean.arhancetebehere@gmail.com>
---
 python/pydantic_core/core_schema.py        |    3 +
 src/errors/validation_exception.rs         |    4 +-
 src/serializers/config.rs                  |   29 +
 src/serializers/errors.rs                  |   27 +-
 src/serializers/mod.rs                     |    1 +
 src/serializers/ser.rs                     | 1299 ++++++++++++++++++++
 src/serializers/shared.rs                  |    7 +-
 src/serializers/type_serializers/float.rs  |  102 ++
 src/serializers/type_serializers/mod.rs    |    1 +
 src/serializers/type_serializers/simple.rs |    1 -
 tests/serializers/test_simple.py           |   27 +
 tests/test_errors.py                       |    2 +-
 tests/validators/test_float.py             |    1 +
 13 files changed, 1496 insertions(+), 8 deletions(-)
 create mode 100644 src/serializers/ser.rs
 create mode 100644 src/serializers/type_serializers/float.rs

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index 40d1eec77..fec3b9966 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -68,6 +68,8 @@ class CoreConfig(TypedDict, total=False):
         allow_inf_nan: Whether to allow infinity and NaN values for float fields. Default is `True`.
         ser_json_timedelta: The serialization option for `timedelta` values. Default is 'iso8601'.
         ser_json_bytes: The serialization option for `bytes` values. Default is 'utf8'.
+        ser_json_inf_nan: The serialization option for infinity and NaN values
+            in float fields. Default is 'null'.
         hide_input_in_errors: Whether to hide input data from `ValidationError` representation.
         validation_error_cause: Whether to add user-python excs to the __cause__ of a ValidationError.
             Requires exceptiongroup backport pre Python 3.11.
@@ -102,6 +104,7 @@ class CoreConfig(TypedDict, total=False):
     # the config options are used to customise serialization to JSON
     ser_json_timedelta: Literal['iso8601', 'float']  # default: 'iso8601'
     ser_json_bytes: Literal['utf8', 'base64', 'hex']  # default: 'utf8'
+    ser_json_inf_nan: Literal['null', 'constants']  # default: 'null'
     # used to hide input data from ValidationError repr
     hide_input_in_errors: bool
     validation_error_cause: bool  # default: False
diff --git a/src/errors/validation_exception.rs b/src/errors/validation_exception.rs
index cb3802d56..d616e3022 100644
--- a/src/errors/validation_exception.rs
+++ b/src/errors/validation_exception.rs
@@ -324,12 +324,12 @@ impl ValidationError {
             Some(indent) => {
                 let indent = vec![b' '; indent];
                 let formatter = PrettyFormatter::with_indent(&indent);
-                let mut ser = serde_json::Serializer::with_formatter(writer, formatter);
+                let mut ser = crate::serializers::ser::PythonSerializer::with_formatter(writer, formatter);
                 serializer.serialize(&mut ser).map_err(json_py_err)?;
                 ser.into_inner()
             }
             None => {
-                let mut ser = serde_json::Serializer::new(writer);
+                let mut ser = crate::serializers::ser::PythonSerializer::new(writer);
                 serializer.serialize(&mut ser).map_err(json_py_err)?;
                 ser.into_inner()
             }
diff --git a/src/serializers/config.rs b/src/serializers/config.rs
index fb65623b7..e83497f64 100644
--- a/src/serializers/config.rs
+++ b/src/serializers/config.rs
@@ -189,3 +189,32 @@ pub fn utf8_py_error(py: Python, err: Utf8Error, data: &[u8]) -> PyErr {
         Err(err) => err,
     }
 }
+
+#[derive(Default, Debug, Clone, PartialEq, Eq)]
+pub(crate) enum InfNanMode {
+    #[default]
+    Null,
+    Constants,
+}
+
+impl FromStr for InfNanMode {
+    type Err = PyErr;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "null" => Ok(Self::Null),
+            "constants" => Ok(Self::Constants),
+            s => py_schema_err!(
+                "Invalid inf_nan serialization mode: `{}`, expected `null` or `constants`",
+                s
+            ),
+        }
+    }
+}
+
+impl FromPyObject<'_> for InfNanMode {
+    fn extract(ob: &'_ PyAny) -> PyResult<Self> {
+        let s = ob.extract::<&str>()?;
+        Self::from_str(s)
+    }
+}
diff --git a/src/serializers/errors.rs b/src/serializers/errors.rs
index ac4ea784f..71a0a024e 100644
--- a/src/serializers/errors.rs
+++ b/src/serializers/errors.rs
@@ -14,8 +14,33 @@ pub(super) fn py_err_se_err<T: ser::Error, E: fmt::Display>(py_error: E) -> T {
     T::custom(py_error.to_string())
 }
 
+#[pyclass(extends=PyValueError, module="pydantic_core._pydantic_core")]
+#[derive(Debug, Clone)]
+pub struct PythonSerializerError {
+    pub message: String,
+}
+
+impl fmt::Display for PythonSerializerError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.message)
+    }
+}
+
+impl std::error::Error for PythonSerializerError {}
+
+impl serde::ser::Error for PythonSerializerError {
+    fn custom<T>(msg: T) -> Self
+    where
+        T: fmt::Display,
+    {
+        PythonSerializerError {
+            message: format!("{msg}"),
+        }
+    }
+}
+
 /// convert a serde serialization error into a `PyErr`
-pub(super) fn se_err_py_err(error: serde_json::Error) -> PyErr {
+pub(super) fn se_err_py_err(error: PythonSerializerError) -> PyErr {
     let s = error.to_string();
     if let Some(msg) = s.strip_prefix(UNEXPECTED_TYPE_SER_MARKER) {
         if msg.is_empty() {
diff --git a/src/serializers/mod.rs b/src/serializers/mod.rs
index 00d70162f..e9208a510 100644
--- a/src/serializers/mod.rs
+++ b/src/serializers/mod.rs
@@ -23,6 +23,7 @@ mod fields;
 mod filter;
 mod infer;
 mod ob_type;
+pub mod ser;
 mod shared;
 mod type_serializers;
 
diff --git a/src/serializers/ser.rs b/src/serializers/ser.rs
new file mode 100644
index 000000000..170cd1849
--- /dev/null
+++ b/src/serializers/ser.rs
@@ -0,0 +1,1299 @@
+use std::{io, num::FpCategory};
+
+use serde::{ser::Impossible, serde_if_integer128, Serialize, Serializer};
+use serde_json::ser::{CompactFormatter, Formatter, PrettyFormatter, State};
+
+use super::errors::PythonSerializerError;
+
+macro_rules! tri {
+    ($e:expr $(,)?) => {
+        match $e {
+            core::result::Result::Ok(val) => val,
+            core::result::Result::Err(err) => return core::result::Result::Err(err),
+        }
+    };
+}
+
+type Result<T> = std::result::Result<T, PythonSerializerError>;
+const TOKEN: &str = "$serde_json::private::Number";
+pub struct PythonSerializer<W, F = CompactFormatter> {
+    writer: W,
+    formatter: F,
+}
+
+impl<W> PythonSerializer<W>
+where
+    W: io::Write,
+{
+    /// Creates a new JSON serializer.
+    #[inline]
+    pub fn new(writer: W) -> Self {
+        PythonSerializer::with_formatter(writer, CompactFormatter)
+    }
+}
+
+impl<'a, W> PythonSerializer<W, PrettyFormatter<'a>>
+where
+    W: io::Write,
+{
+    /// Creates a new JSON pretty print serializer.
+    #[inline]
+    pub fn pretty(writer: W) -> Self {
+        PythonSerializer::with_formatter(writer, PrettyFormatter::new())
+    }
+}
+
+impl<W, F> PythonSerializer<W, F>
+where
+    W: io::Write,
+    F: Formatter,
+{
+    /// Creates a new JSON visitor whose output will be written to the writer
+    /// specified.
+    #[inline]
+    pub fn with_formatter(writer: W, formatter: F) -> Self {
+        PythonSerializer { writer, formatter }
+    }
+
+    /// Unwrap the `Writer` from the `Serializer`.
+    #[inline]
+    pub fn into_inner(self) -> W {
+        self.writer
+    }
+}
+
+impl<'a, W, F> Serializer for &'a mut PythonSerializer<W, F>
+where
+    W: io::Write,
+    F: Formatter,
+{
+    type Ok = ();
+    type Error = PythonSerializerError;
+
+    type SerializeSeq = Compound<'a, W, F>;
+    type SerializeTuple = Compound<'a, W, F>;
+    type SerializeTupleStruct = Compound<'a, W, F>;
+    type SerializeTupleVariant = Compound<'a, W, F>;
+    type SerializeMap = Compound<'a, W, F>;
+    type SerializeStruct = Compound<'a, W, F>;
+    type SerializeStructVariant = Compound<'a, W, F>;
+
+    #[inline]
+    fn serialize_bool(self, value: bool) -> Result<()> {
+        self.formatter
+            .write_bool(&mut self.writer, value)
+            .map_err(|e| PythonSerializerError { message: e.to_string() })
+    }
+
+    #[inline]
+    fn serialize_i8(self, value: i8) -> Result<()> {
+        self.formatter
+            .write_i8(&mut self.writer, value)
+            .map_err(|e| PythonSerializerError { message: e.to_string() })
+    }
+
+    fn serialize_i16(self, value: i16) -> Result<Self::Ok> {
+        self.formatter
+            .write_i16(&mut self.writer, value)
+            .map_err(|e| PythonSerializerError { message: e.to_string() })
+    }
+
+    fn serialize_i32(self, value: i32) -> Result<Self::Ok> {
+        self.formatter
+            .write_i32(&mut self.writer, value)
+            .map_err(|e| PythonSerializerError { message: e.to_string() })
+    }
+
+    fn serialize_i64(self, value: i64) -> Result<Self::Ok> {
+        self.formatter
+            .write_i64(&mut self.writer, value)
+            .map_err(|e| PythonSerializerError { message: e.to_string() })
+    }
+
+    fn serialize_u8(self, value: u8) -> Result<Self::Ok> {
+        self.formatter
+            .write_u8(&mut self.writer, value)
+            .map_err(|e| PythonSerializerError { message: e.to_string() })
+    }
+
+    fn serialize_u16(self, value: u16) -> Result<Self::Ok> {
+        self.formatter
+            .write_u16(&mut self.writer, value)
+            .map_err(|e| PythonSerializerError { message: e.to_string() })
+    }
+
+    fn serialize_u32(self, value: u32) -> Result<Self::Ok> {
+        self.formatter
+            .write_u32(&mut self.writer, value)
+            .map_err(|e| PythonSerializerError { message: e.to_string() })
+    }
+
+    fn serialize_u64(self, value: u64) -> Result<Self::Ok> {
+        self.formatter
+            .write_u64(&mut self.writer, value)
+            .map_err(|e| PythonSerializerError { message: e.to_string() })
+    }
+
+    fn serialize_u128(self, value: u128) -> Result<()> {
+        self.formatter
+            .write_u128(&mut self.writer, value)
+            .map_err(|e| PythonSerializerError { message: e.to_string() })
+    }
+
+    #[inline]
+    fn serialize_f32(self, value: f32) -> Result<()> {
+        match value.classify() {
+            FpCategory::Nan => self
+                .formatter
+                .write_number_str(&mut self.writer, "NaN")
+                .map_err(|e| PythonSerializerError { message: e.to_string() }),
+            FpCategory::Infinite => {
+                let infinity = if value.is_sign_negative() {
+                    "-Infinity"
+                } else {
+                    "Infinity"
+                };
+                self.formatter
+                    .write_number_str(&mut self.writer, infinity)
+                    .map_err(|e| PythonSerializerError { message: e.to_string() })
+            }
+            _ => self
+                .formatter
+                .write_f32(&mut self.writer, value)
+                .map_err(|e| PythonSerializerError { message: e.to_string() }),
+        }
+    }
+
+    fn serialize_f64(self, value: f64) -> Result<Self::Ok> {
+        match value.classify() {
+            FpCategory::Nan => self
+                .formatter
+                .write_number_str(&mut self.writer, "NaN")
+                .map_err(|e| PythonSerializerError { message: e.to_string() }),
+            FpCategory::Infinite => {
+                let infinity = if value.is_sign_negative() {
+                    "-Infinity"
+                } else {
+                    "Infinity"
+                };
+                self.formatter
+                    .write_number_str(&mut self.writer, infinity)
+                    .map_err(|e| PythonSerializerError { message: e.to_string() })
+            }
+            _ => self
+                .formatter
+                .write_f64(&mut self.writer, value)
+                .map_err(|e| PythonSerializerError { message: e.to_string() }),
+        }
+    }
+
+    fn serialize_char(self, value: char) -> Result<Self::Ok> {
+        // A char encoded as UTF-8 takes 4 bytes at most.
+        let mut buf = [0; 4];
+        self.serialize_str(value.encode_utf8(&mut buf))
+    }
+
+    fn serialize_str(self, value: &str) -> Result<Self::Ok> {
+        format_escaped_str(&mut self.writer, &mut self.formatter, value)
+            .map_err(|e| PythonSerializerError { message: e.to_string() })
+    }
+
+    fn serialize_bytes(self, value: &[u8]) -> Result<()> {
+        self.formatter
+            .write_byte_array(&mut self.writer, value)
+            .map_err(|e| PythonSerializerError { message: e.to_string() })
+    }
+
+    fn serialize_none(self) -> Result<Self::Ok> {
+        self.formatter
+            .write_null(&mut self.writer)
+            .map_err(|e| PythonSerializerError { message: e.to_string() })
+    }
+
+    fn serialize_some<T>(self, value: &T) -> Result<Self::Ok>
+    where
+        T: ?Sized + Serialize,
+    {
+        value.serialize(self)
+    }
+
+    fn serialize_unit(self) -> Result<Self::Ok> {
+        self.formatter
+            .write_null(&mut self.writer)
+            .map_err(|e| PythonSerializerError { message: e.to_string() })
+    }
+
+    fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok> {
+        self.serialize_unit()
+    }
+
+    fn serialize_unit_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        variant: &'static str,
+    ) -> Result<Self::Ok> {
+        self.serialize_str(variant)
+    }
+
+    fn serialize_newtype_struct<T: ?Sized>(self, _name: &'static str, value: &T) -> Result<Self::Ok>
+    where
+        T: Serialize,
+    {
+        value.serialize(self)
+    }
+
+    fn serialize_newtype_variant<T: ?Sized>(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        variant: &'static str,
+        value: &T,
+    ) -> Result<Self::Ok>
+    where
+        T: Serialize,
+    {
+        tri!(self
+            .formatter
+            .begin_object(&mut self.writer)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        tri!(self
+            .formatter
+            .begin_object_key(&mut self.writer, true)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        tri!(self.serialize_str(variant));
+        tri!(self
+            .formatter
+            .end_object_key(&mut self.writer)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        tri!(self
+            .formatter
+            .begin_object_value(&mut self.writer)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        tri!(value.serialize(&mut *self));
+        tri!(self
+            .formatter
+            .end_object_value(&mut self.writer)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        self.formatter
+            .end_object(&mut self.writer)
+            .map_err(|e| PythonSerializerError { message: e.to_string() })
+    }
+
+    fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq> {
+        tri!(self
+            .formatter
+            .begin_array(&mut self.writer)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        if len == Some(0) {
+            tri!(self
+                .formatter
+                .end_array(&mut self.writer)
+                .map_err(|e| PythonSerializerError { message: e.to_string() }));
+            Ok(Compound::Map {
+                ser: self,
+                state: State::Empty,
+            })
+        } else {
+            Ok(Compound::Map {
+                ser: self,
+                state: State::First,
+            })
+        }
+    }
+
+    fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple> {
+        self.serialize_seq(Some(len))
+    }
+
+    fn serialize_tuple_struct(self, _name: &'static str, len: usize) -> Result<Self::SerializeTupleStruct> {
+        self.serialize_seq(Some(len))
+    }
+
+    fn serialize_tuple_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        variant: &'static str,
+        len: usize,
+    ) -> Result<Self::SerializeTupleVariant> {
+        tri!(self
+            .formatter
+            .begin_object(&mut self.writer)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        tri!(self
+            .formatter
+            .begin_object_key(&mut self.writer, true)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        tri!(self.serialize_str(variant));
+        tri!(self
+            .formatter
+            .end_object_key(&mut self.writer)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        tri!(self
+            .formatter
+            .begin_object_value(&mut self.writer)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        self.serialize_seq(Some(len))
+    }
+
+    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap> {
+        tri!(self
+            .formatter
+            .begin_object(&mut self.writer)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        if len == Some(0) {
+            tri!(self
+                .formatter
+                .end_object(&mut self.writer)
+                .map_err(|e| PythonSerializerError { message: e.to_string() }));
+            Ok(Compound::Map {
+                ser: self,
+                state: State::Empty,
+            })
+        } else {
+            Ok(Compound::Map {
+                ser: self,
+                state: State::First,
+            })
+        }
+    }
+
+    fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self::SerializeStruct> {
+        match name {
+            TOKEN => Ok(Compound::Number { ser: self }),
+            _ => self.serialize_map(Some(len)),
+        }
+    }
+
+    fn serialize_struct_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        variant: &'static str,
+        len: usize,
+    ) -> Result<Self::SerializeStructVariant> {
+        tri!(self
+            .formatter
+            .begin_object(&mut self.writer)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        tri!(self
+            .formatter
+            .begin_object_key(&mut self.writer, true)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        tri!(self.serialize_str(variant));
+        tri!(self
+            .formatter
+            .end_object_key(&mut self.writer)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        tri!(self
+            .formatter
+            .begin_object_value(&mut self.writer)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        self.serialize_map(Some(len))
+    }
+}
+
+impl<'a, W, F> serde::ser::SerializeSeq for Compound<'a, W, F>
+where
+    W: io::Write,
+    F: Formatter,
+{
+    type Ok = ();
+    type Error = PythonSerializerError;
+
+    #[inline]
+    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
+    where
+        T: ?Sized + Serialize,
+    {
+        match self {
+            Compound::Map { ser, state } => {
+                tri!(ser
+                    .formatter
+                    .begin_array_value(&mut ser.writer, *state == State::First)
+                    .map_err(|e| PythonSerializerError { message: e.to_string() }));
+                *state = State::Rest;
+                tri!(value.serialize(&mut **ser));
+                tri!(ser
+                    .formatter
+                    .end_array_value(&mut ser.writer)
+                    .map_err(|e| PythonSerializerError { message: e.to_string() }));
+                Ok(())
+            }
+            Compound::Number { .. } => unreachable!(),
+        }
+    }
+
+    fn end(self) -> Result<()> {
+        match self {
+            Compound::Map { ser, state } => {
+                match state {
+                    State::Empty => {}
+                    _ => tri!(ser
+                        .formatter
+                        .end_array(&mut ser.writer)
+                        .map_err(|e| PythonSerializerError { message: e.to_string() })),
+                }
+                Ok(())
+            }
+            Compound::Number { .. } => unreachable!(),
+        }
+    }
+}
+
+impl<'a, W, F> serde::ser::SerializeTuple for Compound<'a, W, F>
+where
+    W: io::Write,
+    F: Formatter,
+{
+    type Ok = ();
+    type Error = PythonSerializerError;
+
+    #[inline]
+    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
+    where
+        T: ?Sized + Serialize,
+    {
+        serde::ser::SerializeSeq::serialize_element(self, value)
+    }
+
+    #[inline]
+    fn end(self) -> Result<()> {
+        serde::ser::SerializeSeq::end(self)
+    }
+}
+
+impl<'a, W, F> serde::ser::SerializeTupleStruct for Compound<'a, W, F>
+where
+    W: io::Write,
+    F: Formatter,
+{
+    type Ok = ();
+    type Error = PythonSerializerError;
+
+    #[inline]
+    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
+    where
+        T: ?Sized + Serialize,
+    {
+        serde::ser::SerializeSeq::serialize_element(self, value)
+    }
+
+    #[inline]
+    fn end(self) -> Result<()> {
+        serde::ser::SerializeSeq::end(self)
+    }
+}
+
+impl<'a, W, F> serde::ser::SerializeTupleVariant for Compound<'a, W, F>
+where
+    W: io::Write,
+    F: Formatter,
+{
+    type Ok = ();
+    type Error = PythonSerializerError;
+
+    #[inline]
+    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
+    where
+        T: ?Sized + Serialize,
+    {
+        serde::ser::SerializeSeq::serialize_element(self, value)
+    }
+
+    #[inline]
+    fn end(self) -> Result<()> {
+        match self {
+            Compound::Map { ser, state } => {
+                match state {
+                    State::Empty => {}
+                    _ => tri!(ser
+                        .formatter
+                        .end_array(&mut ser.writer)
+                        .map_err(|e| PythonSerializerError { message: e.to_string() })),
+                }
+                tri!(ser
+                    .formatter
+                    .end_object_value(&mut ser.writer)
+                    .map_err(|e| PythonSerializerError { message: e.to_string() }));
+                tri!(ser
+                    .formatter
+                    .end_object(&mut ser.writer)
+                    .map_err(|e| PythonSerializerError { message: e.to_string() }));
+                Ok(())
+            }
+            Compound::Number { .. } => unreachable!(),
+        }
+    }
+}
+
+impl<'a, W, F> serde::ser::SerializeMap for Compound<'a, W, F>
+where
+    W: io::Write,
+    F: Formatter,
+{
+    type Ok = ();
+    type Error = PythonSerializerError;
+
+    #[inline]
+    fn serialize_key<T>(&mut self, key: &T) -> Result<()>
+    where
+        T: ?Sized + Serialize,
+    {
+        match self {
+            Compound::Map { ser, state } => {
+                tri!(ser
+                    .formatter
+                    .begin_object_key(&mut ser.writer, *state == State::First)
+                    .map_err(|e| PythonSerializerError { message: e.to_string() }));
+                *state = State::Rest;
+
+                tri!(key.serialize(MapKeySerializer { ser: *ser }));
+
+                tri!(ser
+                    .formatter
+                    .end_object_key(&mut ser.writer)
+                    .map_err(|e| PythonSerializerError { message: e.to_string() }));
+                Ok(())
+            }
+            Compound::Number { .. } => unreachable!(),
+        }
+    }
+
+    #[inline]
+    fn serialize_value<T>(&mut self, value: &T) -> Result<()>
+    where
+        T: ?Sized + Serialize,
+    {
+        match self {
+            Compound::Map { ser, .. } => {
+                tri!(ser
+                    .formatter
+                    .begin_object_value(&mut ser.writer)
+                    .map_err(|e| PythonSerializerError { message: e.to_string() }));
+                tri!(value.serialize(&mut **ser));
+                tri!(ser
+                    .formatter
+                    .end_object_value(&mut ser.writer)
+                    .map_err(|e| PythonSerializerError { message: e.to_string() }));
+                Ok(())
+            }
+            Compound::Number { .. } => unreachable!(),
+        }
+    }
+
+    #[inline]
+    fn end(self) -> Result<()> {
+        match self {
+            Compound::Map { ser, state } => {
+                match state {
+                    State::Empty => {}
+                    _ => tri!(ser
+                        .formatter
+                        .end_object(&mut ser.writer)
+                        .map_err(|e| PythonSerializerError { message: e.to_string() })),
+                }
+                Ok(())
+            }
+            Compound::Number { .. } => unreachable!(),
+        }
+    }
+}
+
+impl<'a, W, F> serde::ser::SerializeStruct for Compound<'a, W, F>
+where
+    W: io::Write,
+    F: Formatter,
+{
+    type Ok = ();
+    type Error = PythonSerializerError;
+
+    #[inline]
+    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
+    where
+        T: ?Sized + Serialize,
+    {
+        match self {
+            Compound::Map { .. } => serde::ser::SerializeMap::serialize_entry(self, key, value),
+            Compound::Number { ser, .. } => {
+                if key == TOKEN {
+                    tri!(value.serialize(NumberStrEmitter(ser)));
+                    Ok(())
+                } else {
+                    Err(invalid_number())
+                }
+            }
+        }
+    }
+
+    #[inline]
+    fn end(self) -> Result<()> {
+        match self {
+            Compound::Map { .. } => serde::ser::SerializeMap::end(self),
+            Compound::Number { .. } => Ok(()),
+        }
+    }
+}
+
+impl<'a, W, F> serde::ser::SerializeStructVariant for Compound<'a, W, F>
+where
+    W: io::Write,
+    F: Formatter,
+{
+    type Ok = ();
+    type Error = PythonSerializerError;
+
+    #[inline]
+    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
+    where
+        T: ?Sized + Serialize,
+    {
+        match *self {
+            Compound::Map { .. } => serde::ser::SerializeStruct::serialize_field(self, key, value),
+            Compound::Number { .. } => unreachable!(),
+        }
+    }
+
+    #[inline]
+    fn end(self) -> Result<()> {
+        match self {
+            Compound::Map { ser, state } => {
+                match state {
+                    State::Empty => {}
+                    _ => tri!(ser
+                        .formatter
+                        .end_object(&mut ser.writer)
+                        .map_err(|e| PythonSerializerError { message: e.to_string() })),
+                }
+                tri!(ser
+                    .formatter
+                    .end_object_value(&mut ser.writer)
+                    .map_err(|e| PythonSerializerError { message: e.to_string() }));
+                tri!(ser
+                    .formatter
+                    .end_object(&mut ser.writer)
+                    .map_err(|e| PythonSerializerError { message: e.to_string() }));
+                Ok(())
+            }
+            Compound::Number { .. } => unreachable!(),
+        }
+    }
+}
+
+fn format_escaped_str<W, F>(writer: &mut W, formatter: &mut F, value: &str) -> io::Result<()>
+where
+    W: ?Sized + io::Write,
+    F: ?Sized + Formatter,
+{
+    tri!(formatter.begin_string(writer));
+    tri!(format_escaped_str_contents(writer, formatter, value));
+    formatter.end_string(writer)
+}
+
+fn format_escaped_str_contents<W, F>(writer: &mut W, formatter: &mut F, value: &str) -> io::Result<()>
+where
+    W: ?Sized + io::Write,
+    F: ?Sized + Formatter,
+{
+    let bytes = value.as_bytes();
+
+    let mut start = 0;
+
+    for (i, &byte) in bytes.iter().enumerate() {
+        let escape = ESCAPE[byte as usize];
+        if escape == 0 {
+            continue;
+        }
+
+        if start < i {
+            tri!(formatter.write_string_fragment(writer, &value[start..i]));
+        }
+
+        let char_escape = CharEscape::from_escape_table(escape, byte);
+        tri!(formatter.write_char_escape(writer, char_escape));
+
+        start = i + 1;
+    }
+
+    if start == bytes.len() {
+        return Ok(());
+    }
+
+    formatter.write_string_fragment(writer, &value[start..])
+}
+
+const BB: u8 = b'b'; // \x08
+const TT: u8 = b't'; // \x09
+const NN: u8 = b'n'; // \x0A
+const FF: u8 = b'f'; // \x0C
+const RR: u8 = b'r'; // \x0D
+const QU: u8 = b'"'; // \x22
+const BS: u8 = b'\\'; // \x5C
+const UU: u8 = b'u'; // \x00...\x1F except the ones above
+const __: u8 = 0;
+
+// Lookup table of escape sequences. A value of b'x' at index i means that byte
+// i is escaped as "\x" in JSON. A value of 0 means that byte i is not escaped.
+static ESCAPE: [u8; 256] = [
+    //   1   2   3   4   5   6   7   8   9   A   B   C   D   E   F
+    UU, UU, UU, UU, UU, UU, UU, UU, BB, TT, NN, UU, FF, RR, UU, UU, // 0
+    UU, UU, UU, UU, UU, UU, UU, UU, UU, UU, UU, UU, UU, UU, UU, UU, // 1
+    __, __, QU, __, __, __, __, __, __, __, __, __, __, __, __, __, // 2
+    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 3
+    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 4
+    __, __, __, __, __, __, __, __, __, __, __, __, BS, __, __, __, // 5
+    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 6
+    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 7
+    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 8
+    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // 9
+    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // A
+    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // B
+    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // C
+    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // D
+    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // E
+    __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, __, // F
+];
+
+pub enum Compound<'a, W: 'a, F: 'a> {
+    Map {
+        ser: &'a mut PythonSerializer<W, F>,
+        state: State,
+    },
+    Number {
+        ser: &'a mut PythonSerializer<W, F>,
+    },
+}
+
+/// Represents a character escape code in a type-safe manner.
+pub enum CharEscape {}
+
+impl CharEscape {
+    #[inline]
+    fn from_escape_table(escape: u8, byte: u8) -> serde_json::ser::CharEscape {
+        match escape {
+            self::BB => serde_json::ser::CharEscape::Backspace,
+            self::TT => serde_json::ser::CharEscape::Tab,
+            self::NN => serde_json::ser::CharEscape::LineFeed,
+            self::FF => serde_json::ser::CharEscape::FormFeed,
+            self::RR => serde_json::ser::CharEscape::CarriageReturn,
+            self::QU => serde_json::ser::CharEscape::Quote,
+            self::BS => serde_json::ser::CharEscape::ReverseSolidus,
+            self::UU => serde_json::ser::CharEscape::AsciiControl(byte),
+            _ => unreachable!(),
+        }
+    }
+}
+
+struct MapKeySerializer<'a, W: 'a, F: 'a> {
+    ser: &'a mut PythonSerializer<W, F>,
+}
+
+fn key_must_be_a_string() -> PythonSerializerError {
+    PythonSerializerError {
+        message: "Key must be a string".to_string(),
+    }
+}
+fn invalid_number() -> PythonSerializerError {
+    PythonSerializerError {
+        message: "Invalid Number".to_string(),
+    }
+}
+
+impl<'a, W, F> serde::ser::Serializer for MapKeySerializer<'a, W, F>
+where
+    W: io::Write,
+    F: Formatter,
+{
+    type Ok = ();
+    type Error = PythonSerializerError;
+
+    #[inline]
+    fn serialize_str(self, value: &str) -> Result<()> {
+        self.ser.serialize_str(value)
+    }
+
+    #[inline]
+    fn serialize_unit_variant(self, _name: &'static str, _variant_index: u32, variant: &'static str) -> Result<()> {
+        self.ser.serialize_str(variant)
+    }
+
+    #[inline]
+    fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> Result<()>
+    where
+        T: ?Sized + Serialize,
+    {
+        value.serialize(self)
+    }
+
+    type SerializeSeq = Impossible<(), PythonSerializerError>;
+    type SerializeTuple = Impossible<(), PythonSerializerError>;
+    type SerializeTupleStruct = Impossible<(), PythonSerializerError>;
+    type SerializeTupleVariant = Impossible<(), PythonSerializerError>;
+    type SerializeMap = Impossible<(), PythonSerializerError>;
+    type SerializeStruct = Impossible<(), PythonSerializerError>;
+    type SerializeStructVariant = Impossible<(), PythonSerializerError>;
+
+    fn serialize_bool(self, _value: bool) -> Result<()> {
+        Err(key_must_be_a_string())
+    }
+
+    fn serialize_i8(self, value: i8) -> Result<()> {
+        tri!(self
+            .ser
+            .formatter
+            .begin_string(&mut self.ser.writer)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        tri!(self
+            .ser
+            .formatter
+            .write_i8(&mut self.ser.writer, value)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        tri!(self
+            .ser
+            .formatter
+            .end_string(&mut self.ser.writer)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        Ok(())
+    }
+
+    fn serialize_i16(self, value: i16) -> Result<()> {
+        tri!(self
+            .ser
+            .formatter
+            .begin_string(&mut self.ser.writer)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        tri!(self
+            .ser
+            .formatter
+            .write_i16(&mut self.ser.writer, value)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        tri!(self
+            .ser
+            .formatter
+            .end_string(&mut self.ser.writer)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        Ok(())
+    }
+
+    fn serialize_i32(self, value: i32) -> Result<()> {
+        tri!(self
+            .ser
+            .formatter
+            .begin_string(&mut self.ser.writer)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        tri!(self
+            .ser
+            .formatter
+            .write_i32(&mut self.ser.writer, value)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        tri!(self
+            .ser
+            .formatter
+            .end_string(&mut self.ser.writer)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        Ok(())
+    }
+
+    fn serialize_i64(self, value: i64) -> Result<()> {
+        tri!(self
+            .ser
+            .formatter
+            .begin_string(&mut self.ser.writer)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        tri!(self
+            .ser
+            .formatter
+            .write_i64(&mut self.ser.writer, value)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        tri!(self
+            .ser
+            .formatter
+            .end_string(&mut self.ser.writer)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        Ok(())
+    }
+
+    serde_if_integer128! {
+        fn serialize_i128(self, value: i128) -> Result<()> {
+            tri!(self
+                .ser
+                .formatter
+                .begin_string(&mut self.ser.writer)
+                .map_err(|e| PythonSerializerError { message: e.to_string() }));
+            tri!(self
+                .ser
+                .formatter
+                .write_number_str(&mut self.ser.writer, &value.to_string())
+                .map_err(|e| PythonSerializerError { message: e.to_string() }));
+            tri!(self
+                .ser
+                .formatter
+                .end_string(&mut self.ser.writer)
+                .map_err(|e| PythonSerializerError { message: e.to_string() }));
+            Ok(())
+        }
+    }
+
+    fn serialize_u8(self, value: u8) -> Result<()> {
+        tri!(self
+            .ser
+            .formatter
+            .begin_string(&mut self.ser.writer)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        tri!(self
+            .ser
+            .formatter
+            .write_u8(&mut self.ser.writer, value)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        tri!(self
+            .ser
+            .formatter
+            .end_string(&mut self.ser.writer)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        Ok(())
+    }
+
+    fn serialize_u16(self, value: u16) -> Result<()> {
+        tri!(self
+            .ser
+            .formatter
+            .begin_string(&mut self.ser.writer)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        tri!(self
+            .ser
+            .formatter
+            .write_u16(&mut self.ser.writer, value)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        tri!(self
+            .ser
+            .formatter
+            .end_string(&mut self.ser.writer)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        Ok(())
+    }
+
+    fn serialize_u32(self, value: u32) -> Result<()> {
+        tri!(self
+            .ser
+            .formatter
+            .begin_string(&mut self.ser.writer)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        tri!(self
+            .ser
+            .formatter
+            .write_u32(&mut self.ser.writer, value)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        tri!(self
+            .ser
+            .formatter
+            .end_string(&mut self.ser.writer)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        Ok(())
+    }
+
+    fn serialize_u64(self, value: u64) -> Result<()> {
+        tri!(self
+            .ser
+            .formatter
+            .begin_string(&mut self.ser.writer)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        tri!(self
+            .ser
+            .formatter
+            .write_u64(&mut self.ser.writer, value)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        tri!(self
+            .ser
+            .formatter
+            .end_string(&mut self.ser.writer)
+            .map_err(|e| PythonSerializerError { message: e.to_string() }));
+        Ok(())
+    }
+
+    serde_if_integer128! {
+        fn serialize_u128(self, value: u128) -> Result<()> {
+            tri!(self
+                .ser
+                .formatter
+                .begin_string(&mut self.ser.writer)
+                .map_err(|e| PythonSerializerError { message: e.to_string() }));
+            tri!(self
+                .ser
+                .formatter
+                .write_number_str(&mut self.ser.writer, &value.to_string())
+                .map_err(|e| PythonSerializerError { message: e.to_string() }));
+            tri!(self
+                .ser
+                .formatter
+                .end_string(&mut self.ser.writer)
+                .map_err(|e| PythonSerializerError { message: e.to_string() }));
+            Ok(())
+        }
+    }
+
+    fn serialize_f32(self, _value: f32) -> Result<()> {
+        Err(key_must_be_a_string())
+    }
+
+    fn serialize_f64(self, _value: f64) -> Result<()> {
+        Err(key_must_be_a_string())
+    }
+
+    fn serialize_char(self, value: char) -> Result<()> {
+        self.ser.serialize_str(&value.to_string())
+    }
+
+    fn serialize_bytes(self, _value: &[u8]) -> Result<()> {
+        Err(key_must_be_a_string())
+    }
+
+    fn serialize_unit(self) -> Result<()> {
+        Err(key_must_be_a_string())
+    }
+
+    fn serialize_unit_struct(self, _name: &'static str) -> Result<()> {
+        Err(key_must_be_a_string())
+    }
+
+    fn serialize_newtype_variant<T>(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+        _value: &T,
+    ) -> Result<()>
+    where
+        T: ?Sized + Serialize,
+    {
+        Err(key_must_be_a_string())
+    }
+
+    fn serialize_none(self) -> Result<()> {
+        Err(key_must_be_a_string())
+    }
+
+    fn serialize_some<T>(self, _value: &T) -> Result<()>
+    where
+        T: ?Sized + Serialize,
+    {
+        Err(key_must_be_a_string())
+    }
+
+    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
+        Err(key_must_be_a_string())
+    }
+
+    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
+        Err(key_must_be_a_string())
+    }
+
+    fn serialize_tuple_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeTupleStruct> {
+        Err(key_must_be_a_string())
+    }
+
+    fn serialize_tuple_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeTupleVariant> {
+        Err(key_must_be_a_string())
+    }
+
+    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
+        Err(key_must_be_a_string())
+    }
+
+    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
+        Err(key_must_be_a_string())
+    }
+
+    fn serialize_struct_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeStructVariant> {
+        Err(key_must_be_a_string())
+    }
+
+    fn collect_str<T>(self, value: &T) -> Result<()>
+    where
+        T: ?Sized + std::fmt::Display,
+    {
+        self.ser.collect_str(value)
+    }
+}
+
+struct NumberStrEmitter<'a, W: 'a + io::Write, F: 'a + Formatter>(&'a mut PythonSerializer<W, F>);
+
+impl<'a, W: io::Write, F: Formatter> serde::ser::Serializer for NumberStrEmitter<'a, W, F> {
+    type Ok = ();
+    type Error = PythonSerializerError;
+
+    type SerializeSeq = Impossible<(), PythonSerializerError>;
+    type SerializeTuple = Impossible<(), PythonSerializerError>;
+    type SerializeTupleStruct = Impossible<(), PythonSerializerError>;
+    type SerializeTupleVariant = Impossible<(), PythonSerializerError>;
+    type SerializeMap = Impossible<(), PythonSerializerError>;
+    type SerializeStruct = Impossible<(), PythonSerializerError>;
+    type SerializeStructVariant = Impossible<(), PythonSerializerError>;
+
+    fn serialize_bool(self, _v: bool) -> Result<()> {
+        Err(invalid_number())
+    }
+
+    fn serialize_i8(self, _v: i8) -> Result<()> {
+        Err(invalid_number())
+    }
+
+    fn serialize_i16(self, _v: i16) -> Result<()> {
+        Err(invalid_number())
+    }
+
+    fn serialize_i32(self, _v: i32) -> Result<()> {
+        Err(invalid_number())
+    }
+
+    fn serialize_i64(self, _v: i64) -> Result<()> {
+        Err(invalid_number())
+    }
+
+    serde_if_integer128! {
+        fn serialize_i128(self, _v: i128) -> Result<()> {
+            Err(invalid_number())
+        }
+    }
+
+    fn serialize_u8(self, _v: u8) -> Result<()> {
+        Err(invalid_number())
+    }
+
+    fn serialize_u16(self, _v: u16) -> Result<()> {
+        Err(invalid_number())
+    }
+
+    fn serialize_u32(self, _v: u32) -> Result<()> {
+        Err(invalid_number())
+    }
+
+    fn serialize_u64(self, _v: u64) -> Result<()> {
+        Err(invalid_number())
+    }
+
+    serde_if_integer128! {
+        fn serialize_u128(self, _v: u128) -> Result<()> {
+            Err(invalid_number())
+        }
+    }
+
+    fn serialize_f32(self, _v: f32) -> Result<()> {
+        Err(invalid_number())
+    }
+
+    fn serialize_f64(self, _v: f64) -> Result<()> {
+        Err(invalid_number())
+    }
+
+    fn serialize_char(self, _v: char) -> Result<()> {
+        Err(invalid_number())
+    }
+
+    fn serialize_str(self, value: &str) -> Result<()> {
+        let NumberStrEmitter(serializer) = self;
+        serializer
+            .formatter
+            .write_number_str(&mut serializer.writer, value)
+            .map_err(|e| PythonSerializerError { message: e.to_string() })
+    }
+
+    fn serialize_bytes(self, _value: &[u8]) -> Result<()> {
+        Err(invalid_number())
+    }
+
+    fn serialize_none(self) -> Result<()> {
+        Err(invalid_number())
+    }
+
+    fn serialize_some<T>(self, _value: &T) -> Result<()>
+    where
+        T: ?Sized + Serialize,
+    {
+        Err(invalid_number())
+    }
+
+    fn serialize_unit(self) -> Result<()> {
+        Err(invalid_number())
+    }
+
+    fn serialize_unit_struct(self, _name: &'static str) -> Result<()> {
+        Err(invalid_number())
+    }
+
+    fn serialize_unit_variant(self, _name: &'static str, _variant_index: u32, _variant: &'static str) -> Result<()> {
+        Err(invalid_number())
+    }
+
+    fn serialize_newtype_struct<T>(self, _name: &'static str, _value: &T) -> Result<()>
+    where
+        T: ?Sized + Serialize,
+    {
+        Err(invalid_number())
+    }
+
+    fn serialize_newtype_variant<T>(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+        _value: &T,
+    ) -> Result<()>
+    where
+        T: ?Sized + Serialize,
+    {
+        Err(invalid_number())
+    }
+
+    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq> {
+        Err(invalid_number())
+    }
+
+    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple> {
+        Err(invalid_number())
+    }
+
+    fn serialize_tuple_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeTupleStruct> {
+        Err(invalid_number())
+    }
+
+    fn serialize_tuple_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeTupleVariant> {
+        Err(invalid_number())
+    }
+
+    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap> {
+        Err(invalid_number())
+    }
+
+    fn serialize_struct(self, _name: &'static str, _len: usize) -> Result<Self::SerializeStruct> {
+        Err(invalid_number())
+    }
+
+    fn serialize_struct_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeStructVariant> {
+        Err(invalid_number())
+    }
+}
diff --git a/src/serializers/shared.rs b/src/serializers/shared.rs
index 7c24ff6db..cfccc748a 100644
--- a/src/serializers/shared.rs
+++ b/src/serializers/shared.rs
@@ -15,6 +15,7 @@ use crate::build_tools::py_schema_err;
 use crate::build_tools::py_schema_error_type;
 use crate::definitions::DefinitionsBuilder;
 use crate::py_gc::PyGcTraverse;
+use crate::serializers::ser::PythonSerializer;
 use crate::tools::{py_err, SchemaDict};
 
 use super::errors::se_err_py_err;
@@ -112,7 +113,7 @@ combined_serializer! {
         Nullable: super::type_serializers::nullable::NullableSerializer;
         Int: super::type_serializers::simple::IntSerializer;
         Bool: super::type_serializers::simple::BoolSerializer;
-        Float: super::type_serializers::simple::FloatSerializer;
+        Float: super::type_serializers::float::FloatSerializer;
         Decimal: super::type_serializers::decimal::DecimalSerializer;
         Str: super::type_serializers::string::StrSerializer;
         Bytes: super::type_serializers::bytes::BytesSerializer;
@@ -352,12 +353,12 @@ pub(crate) fn to_json_bytes(
         Some(indent) => {
             let indent = vec![b' '; indent];
             let formatter = PrettyFormatter::with_indent(&indent);
-            let mut ser = serde_json::Serializer::with_formatter(writer, formatter);
+            let mut ser = PythonSerializer::with_formatter(writer, formatter);
             serializer.serialize(&mut ser).map_err(se_err_py_err)?;
             ser.into_inner()
         }
         None => {
-            let mut ser = serde_json::Serializer::new(writer);
+            let mut ser = PythonSerializer::new(writer);
             serializer.serialize(&mut ser).map_err(se_err_py_err)?;
             ser.into_inner()
         }
diff --git a/src/serializers/type_serializers/float.rs b/src/serializers/type_serializers/float.rs
new file mode 100644
index 000000000..23dcacf1a
--- /dev/null
+++ b/src/serializers/type_serializers/float.rs
@@ -0,0 +1,102 @@
+use pyo3::types::PyDict;
+use pyo3::{intern, prelude::*};
+
+use std::borrow::Cow;
+
+use serde::Serializer;
+
+use crate::definitions::DefinitionsBuilder;
+use crate::serializers::config::InfNanMode;
+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,
+};
+
+#[derive(Debug, Clone)]
+pub struct FloatSerializer {
+    inf_nan_mode: InfNanMode,
+}
+
+impl BuildSerializer for FloatSerializer {
+    const EXPECTED_TYPE: &'static str = "float";
+
+    fn build(
+        schema: &PyDict,
+        config: Option<&PyDict>,
+        _definitions: &mut DefinitionsBuilder<CombinedSerializer>,
+    ) -> PyResult<CombinedSerializer> {
+        let inf_nan_mode = config
+            .and_then(|c| c.get_as(intern!(schema.py(), "ser_json_inf_nan")).transpose())
+            .transpose()?
+            .unwrap_or_default();
+        Ok(Self { inf_nan_mode }.into())
+    }
+}
+
+impl_py_gc_traverse!(FloatSerializer {});
+
+impl TypeSerializer for FloatSerializer {
+    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::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::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>> {
+        match extra.ob_type_lookup.is_type(key, ObType::Float) {
+            IsType::Exact | IsType::Subclass => to_str_json_key(key),
+            IsType::False => {
+                extra.warnings.on_fallback_py(self.get_name(), key, extra)?;
+                infer_json_key(key, extra)
+            }
+        }
+    }
+
+    fn serde_serialize<S: Serializer>(
+        &self,
+        value: &PyAny,
+        serializer: S,
+        include: Option<&PyAny>,
+        exclude: Option<&PyAny>,
+        extra: &Extra,
+    ) -> Result<S::Ok, S::Error> {
+        match value.extract::<f64>() {
+            Ok(v) => {
+                if (v.is_nan() || v.is_infinite()) && self.inf_nan_mode == InfNanMode::Null {
+                    serializer.serialize_none()
+                } else {
+                    serializer.serialize_f64(v)
+                }
+            }
+            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
+    }
+}
diff --git a/src/serializers/type_serializers/mod.rs b/src/serializers/type_serializers/mod.rs
index b942b5b86..decb07aaf 100644
--- a/src/serializers/type_serializers/mod.rs
+++ b/src/serializers/type_serializers/mod.rs
@@ -5,6 +5,7 @@ pub mod datetime_etc;
 pub mod decimal;
 pub mod definitions;
 pub mod dict;
+pub mod float;
 pub mod format;
 pub mod function;
 pub mod generator;
diff --git a/src/serializers/type_serializers/simple.rs b/src/serializers/type_serializers/simple.rs
index f0d90c2bf..dafb2b786 100644
--- a/src/serializers/type_serializers/simple.rs
+++ b/src/serializers/type_serializers/simple.rs
@@ -180,4 +180,3 @@ pub(crate) fn bool_json_key(key: &PyAny) -> PyResult<Cow<str>> {
 }
 
 build_simple_serializer!(BoolSerializer, "bool", bool, ObType::Bool, bool_json_key);
-build_simple_serializer!(FloatSerializer, "float", f64, ObType::Float, to_str_json_key);
diff --git a/tests/serializers/test_simple.py b/tests/serializers/test_simple.py
index 9bbaad05b..b63208c07 100644
--- a/tests/serializers/test_simple.py
+++ b/tests/serializers/test_simple.py
@@ -136,3 +136,30 @@ def test_numpy():
     assert type(v) == float
 
     assert s.to_json(numpy.float64(1.0)) == b'1.0'
+
+
+@pytest.mark.parametrize(
+    'value,expected_json,config',
+    [
+        # default values of ser_json_inf_nan
+        (float('inf'), 'null', {}),
+        (float('-inf'), 'null', {}),
+        (float('nan'), 'null', {}),
+        # explicit values of ser_json_inf_nan
+        (float('inf'), 'null', {'ser_json_inf_nan': 'null'}),
+        (float('-inf'), 'null', {'ser_json_inf_nan': 'null'}),
+        (float('nan'), 'null', {'ser_json_inf_nan': 'null'}),
+        (float('inf'), 'Infinity', {'ser_json_inf_nan': 'constants'}),
+        (float('-inf'), '-Infinity', {'ser_json_inf_nan': 'constants'}),
+        (float('nan'), 'NaN', {'ser_json_inf_nan': 'constants'}),
+    ],
+)
+def test_float_inf_and_nan_serializers(value, expected_json, config):
+    s = SchemaSerializer(core_schema.float_schema(), config)
+
+    # Python can represent these values without needing any changes
+    assert s.to_python(value) is value
+    assert s.to_python(value, mode='json') is value
+
+    # Serialized JSON value respects the ser_json_inf_nan setting
+    assert s.to_json(value).decode() == expected_json
diff --git a/tests/test_errors.py b/tests/test_errors.py
index 3683150ec..0d7a966e1 100644
--- a/tests/test_errors.py
+++ b/tests/test_errors.py
@@ -789,7 +789,7 @@ def raise_py_error(v: Any) -> Any:
     with pytest.raises(ValidationError) as exc_info:
         s.validate_python('anything')
 
-    exc = exc_info.value.errors()[0]['ctx']['error']  # type: ignore
+    exc = exc_info.value.errors()[0]['ctx']['error']
     assert isinstance(exc, ValueError)
     assert isinstance(exc.__context__, AssertionError)
 
diff --git a/tests/validators/test_float.py b/tests/validators/test_float.py
index 35b04c3f9..4e3bda0c4 100644
--- a/tests/validators/test_float.py
+++ b/tests/validators/test_float.py
@@ -227,6 +227,7 @@ def test_float_key(py_and_json: PyAndJson):
         ('NaN', True, FunctionCheck(math.isnan)),
         ('NaN', False, Err("Input should be a finite number [type=finite_number, input_value='NaN', input_type=str]")),
         ('+inf', True, FunctionCheck(lambda x: math.isinf(x) and x > 0)),
+        ('inf', True, FunctionCheck(lambda x: math.isinf(x) and x > 0)),
         (
             '+inf',
             False,

From 0c461461668d2630d86e027a087b861cccd5e0ab Mon Sep 17 00:00:00 2001
From: Samuel Colvin <s@muelcolvin.com>
Date: Tue, 7 Nov 2023 13:27:11 +0000
Subject: [PATCH 108/550] PGO build for MacOS M1 (#1063)

Co-authored-by: David Hewitt <mail@davidhewitt.io>
---
 .github/workflows/ci.yml | 74 +++++++++++++++++++++++++++-------------
 Cargo.lock               |  2 +-
 Cargo.toml               |  2 +-
 src/input/input_json.rs  |  2 --
 4 files changed, 53 insertions(+), 27 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 62e998bda..a451eb725 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -70,7 +70,7 @@ jobs:
           - '3.9'
           - '3.10'
           - '3.11'
-          - '3.12-dev'
+          - '3.12'
           - 'pypy3.7'
           - 'pypy3.8'
           - 'pypy3.9'
@@ -389,7 +389,7 @@ jobs:
             interpreter: 3.11 3.12
           - os: macos
             target: aarch64
-            interpreter: 3.7 3.8 3.9 3.10 3.11 3.12 pypy3.8 pypy3.9 pypy3.10
+            interpreter: 3.7 3.8 3.9 pypy3.8 pypy3.9 pypy3.10
           - os: ubuntu
             platform: linux
             target: i686
@@ -465,25 +465,26 @@ jobs:
           path: dist
 
   build-pgo:
-    name: build pgo-optimized on ${{ matrix.platform || matrix.os }} (${{ matrix.interpreter}} - ${{ matrix.target }} - ${{ matrix.manylinux || 'auto' }})
+    name: build pgo-optimized on ${{ matrix.os }} / ${{ matrix.interpreter }}
     # only run on push to main and on release
     if: startsWith(github.ref, 'refs/tags/') || github.ref == 'refs/heads/main' || contains(github.event.pull_request.labels.*.name, 'Full Build')
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu, windows]
-        target: [x86_64]
-        manylinux: [auto]
-        interpreter: ["3.7", "3.8", "3.9", "3.10", "3.11", "3.12-dev", "pypy3.7", "pypy3.8", "pypy3.9", "pypy3.10"]
+        os: [ubuntu-latest, windows-latest, macos-latest-xlarge]
+        interpreter: ['3.7', '3.8', '3.9', '3.10', '3.11', '3.12']
         include:
-          - os: ubuntu
-            platform: linux
-          - os: windows
+          - os: windows-latest
             ls: dir
-          - interpreter: 3.12-dev
-            maturin-interpreter: "3.12"
-
-    runs-on: ${{ matrix.os }}-latest
+        exclude:
+          - os: macos-latest-xlarge
+            interpreter: '3.7'
+          - os: macos-latest-xlarge
+            interpreter: '3.8'
+          - os: macos-latest-xlarge
+            interpreter: '3.9'
+
+    runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v4
 
@@ -491,7 +492,6 @@ jobs:
         uses: actions/setup-python@v4
         with:
           python-version: ${{ matrix.interpreter }}
-          architecture: ${{ matrix.python-architecture || 'x64' }}
 
       - name: install rust stable
         id: rust-toolchain
@@ -504,15 +504,15 @@ jobs:
       # generate self-schema now, so we don't have to do so inside docker in maturin build
       - run: python generate_self_schema.py
 
+      - run: rustc --version --verbose
+
       - name: build initial wheel
         uses: PyO3/maturin-action@v1
         with:
-          target: ${{ matrix.target }}
-          manylinux: ${{ matrix.manylinux || 'auto' }}
           args: >
             --release
             --out pgo-wheel
-            --interpreter ${{ matrix.maturin-interpreter || matrix.interpreter }}
+            --interpreter ${{ matrix.interpreter }}
           rust-toolchain: stable
           docker-options: -e CI
         env:
@@ -536,12 +536,10 @@ jobs:
       - name: build pgo-optimized wheel
         uses: PyO3/maturin-action@v1
         with:
-          target: ${{ matrix.target }}
-          manylinux: ${{ matrix.manylinux || 'auto' }}
           args: >
             --release
             --out dist
-            --interpreter ${{ matrix.maturin-interpreter || matrix.interpreter }}
+            --interpreter ${{ matrix.interpreter }}
           rust-toolchain: stable
           docker-options: -e CI
         env:
@@ -551,7 +549,7 @@ jobs:
 
       - uses: actions/upload-artifact@v3
         with:
-          name: pypi_files
+          name: pypi_files_pgo
           path: dist
 
   inspect-pypi-assets:
@@ -567,7 +565,19 @@ jobs:
           name: pypi_files
           path: dist
 
-      - name: list dist files
+      - name: list dist files before PGO builds
+        run: |
+         ls -lh dist/
+         ls -l dist/
+         echo "`ls dist | wc -l` files"
+
+      - name: get PGO dist artifacts (comes after "get dist artifacts" to so these files override the non-PGO builds)
+        uses: actions/download-artifact@v3
+        with:
+          name: pypi_files_pgo
+          path: dist
+
+      - name: list dist files with PGO builds
         run: |
          ls -lh dist/
          ls -l dist/
@@ -607,6 +617,12 @@ jobs:
           name: pypi_files
           path: dist
 
+      - name: get PGO dist artifacts (comes after "get dist artifacts" to so these files override the non-PGO builds)
+        uses: actions/download-artifact@v3
+        with:
+          name: pypi_files_pgo
+          path: dist
+
       - uses: uraimo/run-on-arch-action@v2.5.1
         name: install & test
         with:
@@ -659,6 +675,12 @@ jobs:
           name: pypi_files
           path: dist
 
+      - name: get PGO dist artifacts (comes after "get dist artifacts" to so these files override the non-PGO builds)
+        uses: actions/download-artifact@v3
+        with:
+          name: pypi_files_pgo
+          path: dist
+
       - run: pip install typing-extensions
       - run: pip install -r tests/requirements.txt
       - run: pip install pydantic-core --no-index --no-deps --find-links dist --force-reinstall
@@ -688,6 +710,12 @@ jobs:
           name: pypi_files
           path: dist
 
+      - name: get PGO dist artifacts (comes after "get dist artifacts" to so these files override the non-PGO builds)
+        uses: actions/download-artifact@v3
+        with:
+          name: pypi_files_pgo
+          path: dist
+
       - run: twine check --strict dist/*
 
       - name: upload to pypi
diff --git a/Cargo.lock b/Cargo.lock
index c6deb4246..13874f1fd 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -321,7 +321,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.12.0"
+version = "2.13.0"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index 242479712..6c1d1d948 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.12.0"
+version = "2.13.0"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"
diff --git a/src/input/input_json.rs b/src/input/input_json.rs
index ac552621d..59c120cd0 100644
--- a/src/input/input_json.rs
+++ b/src/input/input_json.rs
@@ -368,8 +368,6 @@ impl AsLocItem for String {
     }
 }
 
-/// TODO: it would be good to get JsonInput and StringMapping string variants to go through this
-/// implementation
 /// Required for JSON Object keys so the string can behave like an Input
 impl<'a> Input<'a> for String {
     fn as_error_value(&'a self) -> InputValue<'a> {

From d08b4f38c792849fa9da4520ae291944ccdec8e0 Mon Sep 17 00:00:00 2001
From: David Hewitt <mail@davidhewitt.io>
Date: Wed, 8 Nov 2023 21:38:46 +0000
Subject: [PATCH 109/550] run pydantic integration tests with lax xfail (#1054)

---
 .github/workflows/ci.yml | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index a451eb725..fa9dfa0e0 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -214,7 +214,9 @@ jobs:
 
       - run: pdm info && pdm list
         working-directory: pydantic
-      - run: pdm run pytest
+        # Run pytest with lax xfail because we often add tests to pydantic
+        # which xfail on a pending release of pydantic-core
+      - run: pdm run pytest --override-ini=xfail_strict=False
         working-directory: pydantic
 
   lint:

From f409e0013e4f7b1937c2bd14ca877f7d27541be3 Mon Sep 17 00:00:00 2001
From: David Hewitt <mail@davidhewitt.io>
Date: Wed, 8 Nov 2023 21:40:32 +0000
Subject: [PATCH 110/550] replace ultra_strict with new union implementation
 (#867)

Co-authored-by: Samuel Colvin <s@muelcolvin.com>
---
 src/definitions.rs                            |  12 -
 src/input/input_abstract.rs                   | 162 +-----
 src/input/input_json.rs                       | 239 ++++-----
 src/input/input_python.rs                     | 495 +++++++++---------
 src/input/input_string.rs                     |  68 ++-
 src/input/mod.rs                              |   2 +-
 src/input/return_enums.rs                     |  35 +-
 src/validators/any.rs                         |  16 +-
 src/validators/arguments.rs                   |  23 +-
 src/validators/bool.rs                        |  13 +-
 src/validators/bytes.rs                       |  24 +-
 src/validators/call.rs                        |  17 -
 src/validators/callable.rs                    |  12 +-
 src/validators/chain.rs                       |   8 -
 src/validators/custom_error.rs                |   8 -
 src/validators/dataclass.rs                   |  28 +-
 src/validators/date.rs                        |  18 +-
 src/validators/datetime.rs                    |  12 +-
 src/validators/decimal.rs                     |   8 -
 src/validators/definitions.rs                 |  29 -
 src/validators/dict.rs                        |  14 +-
 src/validators/float.rs                       |  22 +-
 src/validators/frozenset.rs                   |  21 +-
 src/validators/function.rs                    |  43 +-
 src/validators/generator.rs                   |  38 +-
 src/validators/int.rs                         |  26 +-
 src/validators/is_instance.rs                 |  11 +-
 src/validators/is_subclass.rs                 |  11 +-
 src/validators/json.rs                        |  18 +-
 src/validators/json_or_python.rs              |  13 +-
 src/validators/lax_or_strict.rs               |  23 +-
 src/validators/list.rs                        |  25 +-
 src/validators/literal.rs                     |  16 +-
 src/validators/mod.rs                         |  27 +-
 src/validators/model.rs                       |  15 +-
 src/validators/model_fields.rs                |  23 +-
 src/validators/none.rs                        |   8 -
 src/validators/nullable.rs                    |   8 -
 src/validators/set.rs                         |  21 +-
 src/validators/string.rs                      |  25 +-
 src/validators/time.rs                        |  12 +-
 src/validators/timedelta.rs                   |  12 +-
 src/validators/tuple.rs                       |  54 +-
 src/validators/typed_dict.rs                  |  18 +-
 src/validators/union.rs                       | 200 +++----
 src/validators/url.rs                         |  35 +-
 src/validators/uuid.rs                        |  18 +-
 src/validators/validation_state.rs            |  39 +-
 src/validators/with_default.rs                |   8 -
 .../validators/test_definitions_recursive.py  |  19 +
 tests/validators/test_union.py                | 298 ++++++++++-
 51 files changed, 1011 insertions(+), 1339 deletions(-)

diff --git a/src/definitions.rs b/src/definitions.rs
index 1eb813015..4627fd2d1 100644
--- a/src/definitions.rs
+++ b/src/definitions.rs
@@ -31,21 +31,9 @@ use crate::{build_tools::py_schema_err, py_gc::PyGcTraverse};
 #[derive(Clone)]
 pub struct Definitions<T>(AHashMap<Arc<String>, Definition<T>>);
 
-impl<T> Definitions<T> {
-    pub fn values(&self) -> impl Iterator<Item = &Definition<T>> {
-        self.0.values()
-    }
-}
-
 /// Internal type which contains a definition to be filled
 pub struct Definition<T>(Arc<DefinitionInner<T>>);
 
-impl<T> Definition<T> {
-    pub fn get(&self) -> Option<&T> {
-        self.0.value.get()
-    }
-}
-
 struct DefinitionInner<T> {
     value: OnceLock<T>,
     name: LazyName,
diff --git a/src/input/input_abstract.rs b/src/input/input_abstract.rs
index 52551ef42..ba6fbd0a1 100644
--- a/src/input/input_abstract.rs
+++ b/src/input/input_abstract.rs
@@ -6,13 +6,13 @@ use pyo3::{intern, prelude::*};
 
 use jiter::JsonValue;
 
-use crate::errors::{AsLocItem, InputValue, ValResult};
+use crate::errors::{AsLocItem, ErrorTypeDefaults, InputValue, ValError, ValResult};
 use crate::tools::py_err;
 use crate::{PyMultiHostUrl, PyUrl};
 
 use super::datetime::{EitherDate, EitherDateTime, EitherTime, EitherTimedelta};
 use super::return_enums::{EitherBytes, EitherInt, EitherString};
-use super::{EitherFloat, GenericArguments, GenericIterable, GenericIterator, GenericMapping};
+use super::{EitherFloat, GenericArguments, GenericIterable, GenericIterator, GenericMapping, ValidationMatch};
 
 #[derive(Debug, Clone, Copy)]
 pub enum InputType {
@@ -48,7 +48,7 @@ impl TryFrom<&str> for InputType {
 /// the convention is to either implement:
 /// * `strict_*` & `lax_*` if they have different behavior
 /// * or, `validate_*` and `strict_*` to just call `validate_*` if the behavior for strict and lax is the same
-pub trait Input<'a>: fmt::Debug + ToPyObject + AsLocItem {
+pub trait Input<'a>: fmt::Debug + ToPyObject + AsLocItem + Sized {
     fn as_error_value(&'a self) -> InputValue<'a>;
 
     fn identity(&self) -> Option<usize> {
@@ -91,85 +91,37 @@ pub trait Input<'a>: fmt::Debug + ToPyObject + AsLocItem {
 
     fn parse_json(&'a self) -> ValResult<'a, JsonValue>;
 
-    fn validate_str(&'a self, strict: bool, coerce_numbers_to_str: bool) -> ValResult<EitherString<'a>> {
-        if strict {
-            self.strict_str()
-        } else {
-            self.lax_str(coerce_numbers_to_str)
-        }
-    }
-    fn strict_str(&'a self) -> ValResult<EitherString<'a>>;
-    #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn lax_str(&'a self, _coerce_numbers_to_str: bool) -> ValResult<EitherString<'a>> {
-        self.strict_str()
-    }
+    fn validate_str(
+        &'a self,
+        strict: bool,
+        coerce_numbers_to_str: bool,
+    ) -> ValResult<ValidationMatch<EitherString<'a>>>;
 
-    fn validate_bytes(&'a self, strict: bool) -> ValResult<EitherBytes<'a>> {
-        if strict {
-            self.strict_bytes()
-        } else {
-            self.lax_bytes()
-        }
-    }
-    fn strict_bytes(&'a self) -> ValResult<EitherBytes<'a>>;
-    #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn lax_bytes(&'a self) -> ValResult<EitherBytes<'a>> {
-        self.strict_bytes()
-    }
+    fn validate_bytes(&'a self, strict: bool) -> ValResult<ValidationMatch<EitherBytes<'a>>>;
 
-    fn validate_bool(&self, strict: bool) -> ValResult<bool> {
-        if strict {
-            self.strict_bool()
-        } else {
-            self.lax_bool()
-        }
-    }
-    fn strict_bool(&self) -> ValResult<bool>;
-    #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn lax_bool(&self) -> ValResult<bool> {
-        self.strict_bool()
-    }
+    fn validate_bool(&self, strict: bool) -> ValResult<'_, ValidationMatch<bool>>;
 
-    fn validate_int(&'a self, strict: bool) -> ValResult<EitherInt<'a>> {
-        if strict {
-            self.strict_int()
-        } else {
-            self.lax_int()
-        }
-    }
-    fn strict_int(&'a self) -> ValResult<EitherInt<'a>>;
-    #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn lax_int(&'a self) -> ValResult<EitherInt<'a>> {
-        self.strict_int()
-    }
+    fn validate_int(&'a self, strict: bool) -> ValResult<'a, ValidationMatch<EitherInt<'a>>>;
 
-    /// Extract an EitherInt from the input, only allowing exact
-    /// matches for an Int (no subclasses)
     fn exact_int(&'a self) -> ValResult<EitherInt<'a>> {
-        self.strict_int()
+        self.validate_int(true).and_then(|val_match| {
+            val_match
+                .require_exact()
+                .ok_or_else(|| ValError::new(ErrorTypeDefaults::IntType, self))
+        })
     }
 
     /// Extract a String from the input, only allowing exact
     /// matches for a String (no subclasses)
     fn exact_str(&'a self) -> ValResult<EitherString<'a>> {
-        self.strict_str()
+        self.validate_str(true, false).and_then(|val_match| {
+            val_match
+                .require_exact()
+                .ok_or_else(|| ValError::new(ErrorTypeDefaults::StringType, self))
+        })
     }
 
-    fn validate_float(&'a self, strict: bool, ultra_strict: bool) -> ValResult<EitherFloat<'a>> {
-        if ultra_strict {
-            self.ultra_strict_float()
-        } else if strict {
-            self.strict_float()
-        } else {
-            self.lax_float()
-        }
-    }
-    fn ultra_strict_float(&'a self) -> ValResult<EitherFloat<'a>>;
-    fn strict_float(&'a self) -> ValResult<EitherFloat<'a>>;
-    #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn lax_float(&'a self) -> ValResult<EitherFloat<'a>> {
-        self.strict_float()
-    }
+    fn validate_float(&'a self, strict: bool) -> ValResult<'a, ValidationMatch<EitherFloat<'a>>>;
 
     fn validate_decimal(&'a self, strict: bool, py: Python<'a>) -> ValResult<&'a PyAny> {
         if strict {
@@ -257,87 +209,25 @@ pub trait Input<'a>: fmt::Debug + ToPyObject + AsLocItem {
 
     fn validate_iter(&self) -> ValResult<GenericIterator>;
 
-    fn validate_date(&self, strict: bool) -> ValResult<EitherDate> {
-        if strict {
-            self.strict_date()
-        } else {
-            self.lax_date()
-        }
-    }
-    fn strict_date(&self) -> ValResult<EitherDate>;
-    #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn lax_date(&self) -> ValResult<EitherDate> {
-        self.strict_date()
-    }
+    fn validate_date(&self, strict: bool) -> ValResult<ValidationMatch<EitherDate>>;
 
     fn validate_time(
         &self,
         strict: bool,
         microseconds_overflow_behavior: speedate::MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<EitherTime> {
-        if strict {
-            self.strict_time(microseconds_overflow_behavior)
-        } else {
-            self.lax_time(microseconds_overflow_behavior)
-        }
-    }
-    fn strict_time(
-        &self,
-        microseconds_overflow_behavior: speedate::MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<EitherTime>;
-    #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn lax_time(
-        &self,
-        microseconds_overflow_behavior: speedate::MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<EitherTime> {
-        self.strict_time(microseconds_overflow_behavior)
-    }
+    ) -> ValResult<ValidationMatch<EitherTime>>;
 
     fn validate_datetime(
         &self,
         strict: bool,
         microseconds_overflow_behavior: speedate::MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<EitherDateTime> {
-        if strict {
-            self.strict_datetime(microseconds_overflow_behavior)
-        } else {
-            self.lax_datetime(microseconds_overflow_behavior)
-        }
-    }
-    fn strict_datetime(
-        &self,
-        microseconds_overflow_behavior: speedate::MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<EitherDateTime>;
-    #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn lax_datetime(
-        &self,
-        microseconds_overflow_behavior: speedate::MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<EitherDateTime> {
-        self.strict_datetime(microseconds_overflow_behavior)
-    }
+    ) -> ValResult<ValidationMatch<EitherDateTime>>;
 
     fn validate_timedelta(
         &self,
         strict: bool,
         microseconds_overflow_behavior: speedate::MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<EitherTimedelta> {
-        if strict {
-            self.strict_timedelta(microseconds_overflow_behavior)
-        } else {
-            self.lax_timedelta(microseconds_overflow_behavior)
-        }
-    }
-    fn strict_timedelta(
-        &self,
-        microseconds_overflow_behavior: speedate::MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<EitherTimedelta>;
-    #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn lax_timedelta(
-        &self,
-        microseconds_overflow_behavior: speedate::MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<EitherTimedelta> {
-        self.strict_timedelta(microseconds_overflow_behavior)
-    }
+    ) -> ValResult<ValidationMatch<EitherTimedelta>>;
 }
 
 /// The problem to solve here is that iterating a `StringMapping` returns an owned
diff --git a/src/input/input_json.rs b/src/input/input_json.rs
index 59c120cd0..0411a25d6 100644
--- a/src/input/input_json.rs
+++ b/src/input/input_json.rs
@@ -13,6 +13,7 @@ use super::datetime::{
     bytes_as_date, bytes_as_datetime, bytes_as_time, bytes_as_timedelta, float_as_datetime, float_as_duration,
     float_as_time, int_as_datetime, int_as_duration, int_as_time, EitherDate, EitherDateTime, EitherTime,
 };
+use super::return_enums::ValidationMatch;
 use super::shared::{float_as_int, int_as_bool, map_json_err, str_as_bool, str_as_float, str_as_int};
 use super::{
     BorrowInput, EitherBytes, EitherFloat, EitherInt, EitherString, EitherTimedelta, GenericArguments, GenericIterable,
@@ -84,97 +85,72 @@ impl<'a> Input<'a> for JsonValue {
         }
     }
 
-    fn strict_str(&'a self) -> ValResult<EitherString<'a>> {
+    fn exact_str(&'a self) -> ValResult<EitherString<'a>> {
         match self {
             JsonValue::Str(s) => Ok(s.as_str().into()),
             _ => Err(ValError::new(ErrorTypeDefaults::StringType, self)),
         }
     }
-    fn lax_str(&'a self, coerce_numbers_to_str: bool) -> ValResult<EitherString<'a>> {
+
+    fn validate_str(
+        &'a self,
+        strict: bool,
+        coerce_numbers_to_str: bool,
+    ) -> ValResult<ValidationMatch<EitherString<'a>>> {
+        // 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
+        // TODO: in V3 we may want to make JSON str always win if in union, for consistency,
+        // see https://github.com/pydantic/pydantic-core/pull/867#discussion_r1386582501
         match self {
-            JsonValue::Str(s) => Ok(s.as_str().into()),
-            JsonValue::Int(i) if coerce_numbers_to_str => Ok(i.to_string().into()),
-            JsonValue::BigInt(b) if coerce_numbers_to_str => Ok(b.to_string().into()),
-            JsonValue::Float(f) if coerce_numbers_to_str => Ok(f.to_string().into()),
+            JsonValue::Str(s) => Ok(ValidationMatch::strict(s.as_str().into())),
+            JsonValue::Int(i) if !strict && coerce_numbers_to_str => Ok(ValidationMatch::lax(i.to_string().into())),
+            JsonValue::BigInt(b) if !strict && coerce_numbers_to_str => Ok(ValidationMatch::lax(b.to_string().into())),
+            JsonValue::Float(f) if !strict && coerce_numbers_to_str => Ok(ValidationMatch::lax(f.to_string().into())),
             _ => Err(ValError::new(ErrorTypeDefaults::StringType, self)),
         }
     }
 
-    fn validate_bytes(&'a self, _strict: bool) -> ValResult<EitherBytes<'a>> {
+    fn validate_bytes(&'a self, _strict: bool) -> ValResult<ValidationMatch<EitherBytes<'a>>> {
         match self {
-            JsonValue::Str(s) => Ok(s.as_bytes().into()),
+            JsonValue::Str(s) => Ok(ValidationMatch::strict(s.as_bytes().into())),
             _ => Err(ValError::new(ErrorTypeDefaults::BytesType, self)),
         }
     }
-    #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn strict_bytes(&'a self) -> ValResult<EitherBytes<'a>> {
-        self.validate_bytes(false)
-    }
 
-    fn strict_bool(&self) -> ValResult<bool> {
+    fn validate_bool(&self, strict: bool) -> ValResult<'_, ValidationMatch<bool>> {
         match self {
-            JsonValue::Bool(b) => Ok(*b),
-            _ => Err(ValError::new(ErrorTypeDefaults::BoolType, self)),
-        }
-    }
-    fn lax_bool(&self) -> ValResult<bool> {
-        match self {
-            JsonValue::Bool(b) => Ok(*b),
-            JsonValue::Str(s) => str_as_bool(self, s),
-            JsonValue::Int(int) => int_as_bool(self, *int),
-            JsonValue::Float(float) => match float_as_int(self, *float) {
+            JsonValue::Bool(b) => Ok(ValidationMatch::exact(*b)),
+            JsonValue::Str(s) if !strict => str_as_bool(self, s).map(ValidationMatch::lax),
+            JsonValue::Int(int) if !strict => int_as_bool(self, *int).map(ValidationMatch::lax),
+            JsonValue::Float(float) if !strict => match float_as_int(self, *float) {
                 Ok(int) => int
                     .as_bool()
-                    .ok_or_else(|| ValError::new(ErrorTypeDefaults::BoolParsing, self)),
+                    .ok_or_else(|| ValError::new(ErrorTypeDefaults::BoolParsing, self))
+                    .map(ValidationMatch::lax),
                 _ => Err(ValError::new(ErrorTypeDefaults::BoolType, self)),
             },
             _ => Err(ValError::new(ErrorTypeDefaults::BoolType, self)),
         }
     }
 
-    fn strict_int(&'a self) -> ValResult<EitherInt<'a>> {
-        match self {
-            JsonValue::Int(i) => Ok(EitherInt::I64(*i)),
-            JsonValue::BigInt(b) => Ok(EitherInt::BigInt(b.clone())),
-            _ => Err(ValError::new(ErrorTypeDefaults::IntType, self)),
-        }
-    }
-    fn lax_int(&'a self) -> ValResult<EitherInt<'a>> {
+    fn validate_int(&'a self, strict: bool) -> ValResult<'a, ValidationMatch<EitherInt<'a>>> {
         match self {
-            JsonValue::Bool(b) => match *b {
-                true => Ok(EitherInt::I64(1)),
-                false => Ok(EitherInt::I64(0)),
-            },
-            JsonValue::Int(i) => Ok(EitherInt::I64(*i)),
-            JsonValue::BigInt(b) => Ok(EitherInt::BigInt(b.clone())),
-            JsonValue::Float(f) => float_as_int(self, *f),
-            JsonValue::Str(str) => str_as_int(self, str),
+            JsonValue::Int(i) => Ok(ValidationMatch::exact(EitherInt::I64(*i))),
+            JsonValue::BigInt(b) => Ok(ValidationMatch::exact(EitherInt::BigInt(b.clone()))),
+            JsonValue::Bool(b) if !strict => Ok(ValidationMatch::lax(EitherInt::I64((*b).into()))),
+            JsonValue::Float(f) if !strict => float_as_int(self, *f).map(ValidationMatch::lax),
+            JsonValue::Str(str) if !strict => str_as_int(self, str).map(ValidationMatch::lax),
             _ => Err(ValError::new(ErrorTypeDefaults::IntType, self)),
         }
     }
 
-    fn ultra_strict_float(&'a self) -> ValResult<EitherFloat<'a>> {
+    fn validate_float(&'a self, strict: bool) -> ValResult<'a, ValidationMatch<EitherFloat<'a>>> {
         match self {
-            JsonValue::Float(f) => Ok(EitherFloat::F64(*f)),
-            _ => Err(ValError::new(ErrorTypeDefaults::FloatType, self)),
-        }
-    }
-    fn strict_float(&'a self) -> ValResult<EitherFloat<'a>> {
-        match self {
-            JsonValue::Float(f) => Ok(EitherFloat::F64(*f)),
-            JsonValue::Int(i) => Ok(EitherFloat::F64(*i as f64)),
-            _ => Err(ValError::new(ErrorTypeDefaults::FloatType, self)),
-        }
-    }
-    fn lax_float(&'a self) -> ValResult<EitherFloat<'a>> {
-        match self {
-            JsonValue::Bool(b) => match *b {
-                true => Ok(EitherFloat::F64(1.0)),
-                false => Ok(EitherFloat::F64(0.0)),
-            },
-            JsonValue::Float(f) => Ok(EitherFloat::F64(*f)),
-            JsonValue::Int(i) => Ok(EitherFloat::F64(*i as f64)),
-            JsonValue::Str(str) => str_as_float(self, str),
+            JsonValue::Float(f) => Ok(ValidationMatch::exact(EitherFloat::F64(*f))),
+            JsonValue::Int(i) => Ok(ValidationMatch::strict(EitherFloat::F64(*i as f64))),
+            JsonValue::Bool(b) if !strict => Ok(ValidationMatch::lax(EitherFloat::F64(if *b { 1.0 } else { 0.0 }))),
+            JsonValue::Str(str) if !strict => str_as_float(self, str).map(ValidationMatch::lax),
             _ => Err(ValError::new(ErrorTypeDefaults::FloatType, self)),
         }
     }
@@ -270,34 +246,24 @@ impl<'a> Input<'a> for JsonValue {
         }
     }
 
-    fn validate_date(&self, _strict: bool) -> ValResult<EitherDate> {
+    fn validate_date(&self, _strict: bool) -> ValResult<ValidationMatch<EitherDate>> {
         match self {
-            JsonValue::Str(v) => bytes_as_date(self, v.as_bytes()),
+            JsonValue::Str(v) => bytes_as_date(self, v.as_bytes()).map(ValidationMatch::strict),
             _ => Err(ValError::new(ErrorTypeDefaults::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_coverage_attribute, coverage(off))]
-    fn strict_date(&self) -> ValResult<EitherDate> {
-        self.validate_date(false)
-    }
-
-    fn strict_time(
+    fn validate_time(
         &self,
+        strict: bool,
         microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<EitherTime> {
+    ) -> ValResult<ValidationMatch<EitherTime>> {
         match self {
-            JsonValue::Str(v) => bytes_as_time(self, v.as_bytes(), microseconds_overflow_behavior),
-            _ => Err(ValError::new(ErrorTypeDefaults::TimeType, self)),
-        }
-    }
-    fn lax_time(&self, microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior) -> ValResult<EitherTime> {
-        match self {
-            JsonValue::Str(v) => bytes_as_time(self, v.as_bytes(), microseconds_overflow_behavior),
-            JsonValue::Int(v) => int_as_time(self, *v, 0),
-            JsonValue::Float(v) => float_as_time(self, *v),
-            JsonValue::BigInt(_) => Err(ValError::new(
+            JsonValue::Str(v) => {
+                bytes_as_time(self, v.as_bytes(), microseconds_overflow_behavior).map(ValidationMatch::strict)
+            }
+            JsonValue::Int(v) if !strict => int_as_time(self, *v, 0).map(ValidationMatch::lax),
+            JsonValue::Float(v) if !strict => float_as_time(self, *v).map(ValidationMatch::lax),
+            JsonValue::BigInt(_) if !strict => Err(ValError::new(
                 ErrorType::TimeParsing {
                     error: Cow::Borrowed(
                         speedate::ParseError::TimeTooLarge
@@ -312,44 +278,36 @@ impl<'a> Input<'a> for JsonValue {
         }
     }
 
-    fn strict_datetime(
-        &self,
-        microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<EitherDateTime> {
-        match self {
-            JsonValue::Str(v) => bytes_as_datetime(self, v.as_bytes(), microseconds_overflow_behavior),
-            _ => Err(ValError::new(ErrorTypeDefaults::DatetimeType, self)),
-        }
-    }
-    fn lax_datetime(
+    fn validate_datetime(
         &self,
-        microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<EitherDateTime> {
+        strict: bool,
+        microseconds_overflow_behavior: speedate::MicrosecondsPrecisionOverflowBehavior,
+    ) -> ValResult<ValidationMatch<EitherDateTime>> {
         match self {
-            JsonValue::Str(v) => bytes_as_datetime(self, v.as_bytes(), microseconds_overflow_behavior),
-            JsonValue::Int(v) => int_as_datetime(self, *v, 0),
-            JsonValue::Float(v) => float_as_datetime(self, *v),
+            JsonValue::Str(v) => {
+                bytes_as_datetime(self, v.as_bytes(), microseconds_overflow_behavior).map(ValidationMatch::strict)
+            }
+            JsonValue::Int(v) if !strict => int_as_datetime(self, *v, 0).map(ValidationMatch::lax),
+            JsonValue::Float(v) if !strict => float_as_datetime(self, *v).map(ValidationMatch::lax),
             _ => Err(ValError::new(ErrorTypeDefaults::DatetimeType, self)),
         }
     }
 
-    fn strict_timedelta(
-        &self,
-        microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<EitherTimedelta> {
-        match self {
-            JsonValue::Str(v) => bytes_as_timedelta(self, v.as_bytes(), microseconds_overflow_behavior),
-            _ => Err(ValError::new(ErrorTypeDefaults::TimeDeltaType, self)),
-        }
-    }
-    fn lax_timedelta(
+    fn validate_timedelta(
         &self,
-        microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<EitherTimedelta> {
+        strict: bool,
+        microseconds_overflow_behavior: speedate::MicrosecondsPrecisionOverflowBehavior,
+    ) -> ValResult<ValidationMatch<EitherTimedelta>> {
         match self {
-            JsonValue::Str(v) => bytes_as_timedelta(self, v.as_bytes(), microseconds_overflow_behavior),
-            JsonValue::Int(v) => Ok(int_as_duration(self, *v)?.into()),
-            JsonValue::Float(v) => Ok(float_as_duration(self, *v)?.into()),
+            JsonValue::Str(v) => {
+                bytes_as_timedelta(self, v.as_bytes(), microseconds_overflow_behavior).map(ValidationMatch::strict)
+            }
+            JsonValue::Int(v) if !strict => {
+                int_as_duration(self, *v).map(|duration| ValidationMatch::lax(duration.into()))
+            }
+            JsonValue::Float(v) if !strict => {
+                float_as_duration(self, *v).map(|duration| ValidationMatch::lax(duration.into()))
+            }
             _ => Err(ValError::new(ErrorTypeDefaults::TimeDeltaType, self)),
         }
     }
@@ -399,30 +357,36 @@ impl<'a> Input<'a> for String {
         JsonValue::parse(self.as_bytes(), true).map_err(|e| map_json_err(self, e))
     }
 
-    fn strict_str(&'a self) -> ValResult<EitherString<'a>> {
-        Ok(self.as_str().into())
+    fn validate_str(
+        &'a self,
+        _strict: bool,
+        _coerce_numbers_to_str: bool,
+    ) -> ValResult<ValidationMatch<EitherString<'a>>> {
+        // 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
+        // TODO: in V3 we may want to make JSON str always win if in union, for consistency,
+        // see https://github.com/pydantic/pydantic-core/pull/867#discussion_r1386582501
+        Ok(ValidationMatch::strict(self.as_str().into()))
     }
 
-    fn strict_bytes(&'a self) -> ValResult<EitherBytes<'a>> {
-        Ok(self.as_bytes().into())
+    fn validate_bytes(&'a self, _strict: bool) -> ValResult<ValidationMatch<EitherBytes<'a>>> {
+        Ok(ValidationMatch::strict(self.as_bytes().into()))
     }
 
-    fn strict_bool(&self) -> ValResult<bool> {
-        str_as_bool(self, self)
+    fn validate_bool(&self, _strict: bool) -> ValResult<'_, ValidationMatch<bool>> {
+        str_as_bool(self, self).map(ValidationMatch::lax)
     }
 
-    fn strict_int(&'a self) -> ValResult<EitherInt<'a>> {
+    fn validate_int(&'a self, _strict: bool) -> ValResult<'a, ValidationMatch<EitherInt<'a>>> {
         match self.parse() {
-            Ok(i) => Ok(EitherInt::I64(i)),
+            Ok(i) => Ok(ValidationMatch::lax(EitherInt::I64(i))),
             Err(_) => Err(ValError::new(ErrorTypeDefaults::IntParsing, self)),
         }
     }
 
-    fn ultra_strict_float(&'a self) -> ValResult<EitherFloat<'a>> {
-        self.strict_float()
-    }
-    fn strict_float(&'a self) -> ValResult<EitherFloat<'a>> {
-        str_as_float(self, self)
+    fn validate_float(&'a self, _strict: bool) -> ValResult<'a, ValidationMatch<EitherFloat<'a>>> {
+        str_as_float(self, self).map(ValidationMatch::lax)
     }
 
     fn strict_decimal(&'a self, py: Python<'a>) -> ValResult<&'a PyAny> {
@@ -462,29 +426,32 @@ impl<'a> Input<'a> for String {
         Ok(string_to_vec(self).into())
     }
 
-    fn strict_date(&self) -> ValResult<EitherDate> {
-        bytes_as_date(self, self.as_bytes())
+    fn validate_date(&self, _strict: bool) -> ValResult<ValidationMatch<EitherDate>> {
+        bytes_as_date(self, self.as_bytes()).map(ValidationMatch::lax)
     }
 
-    fn strict_time(
+    fn validate_time(
         &self,
+        _strict: bool,
         microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<EitherTime> {
-        bytes_as_time(self, self.as_bytes(), microseconds_overflow_behavior)
+    ) -> ValResult<ValidationMatch<EitherTime>> {
+        bytes_as_time(self, self.as_bytes(), microseconds_overflow_behavior).map(ValidationMatch::lax)
     }
 
-    fn strict_datetime(
+    fn validate_datetime(
         &self,
+        _strict: bool,
         microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<EitherDateTime> {
-        bytes_as_datetime(self, self.as_bytes(), microseconds_overflow_behavior)
+    ) -> ValResult<ValidationMatch<EitherDateTime>> {
+        bytes_as_datetime(self, self.as_bytes(), microseconds_overflow_behavior).map(ValidationMatch::lax)
     }
 
-    fn strict_timedelta(
+    fn validate_timedelta(
         &self,
+        _strict: bool,
         microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<EitherTimedelta> {
-        bytes_as_timedelta(self, self.as_bytes(), microseconds_overflow_behavior)
+    ) -> ValResult<ValidationMatch<EitherTimedelta>> {
+        bytes_as_timedelta(self, self.as_bytes(), microseconds_overflow_behavior).map(ValidationMatch::lax)
     }
 }
 
diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index de59ebce0..90d2c2a8b 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -16,6 +16,7 @@ use speedate::MicrosecondsPrecisionOverflowBehavior;
 use crate::errors::{AsLocItem, ErrorType, ErrorTypeDefaults, InputValue, LocItem, ValError, ValResult};
 use crate::tools::{extract_i64, safe_repr};
 use crate::validators::decimal::{create_decimal, get_decimal_type};
+use crate::validators::Exactness;
 use crate::{ArgsKwargs, PyMultiHostUrl, PyUrl};
 
 use super::datetime::{
@@ -23,6 +24,7 @@ use super::datetime::{
     float_as_duration, float_as_time, int_as_datetime, int_as_duration, int_as_time, EitherDate, EitherDateTime,
     EitherTime,
 };
+use super::return_enums::ValidationMatch;
 use super::shared::{
     decimal_as_int, float_as_int, get_enum_meta_object, int_as_bool, map_json_err, str_as_bool, str_as_float,
     str_as_int,
@@ -203,194 +205,185 @@ impl<'a> Input<'a> for PyAny {
         JsonValue::parse(bytes, true).map_err(|e| map_json_err(self, e))
     }
 
-    fn strict_str(&'a self) -> ValResult<EitherString<'a>> {
-        if let Ok(py_str) = PyString::try_from_exact(self) {
-            Ok(py_str.into())
+    fn validate_str(
+        &'a self,
+        strict: bool,
+        coerce_numbers_to_str: bool,
+    ) -> ValResult<ValidationMatch<EitherString<'a>>> {
+        if let Ok(py_str) = self.downcast_exact::<PyString>() {
+            return Ok(ValidationMatch::exact(py_str.into()));
         } else if let Ok(py_str) = self.downcast::<PyString>() {
             // force to a rust string to make sure behavior is consistent whether or not we go via a
             // rust string in StrConstrainedValidator - e.g. to_lower
-            Ok(py_string_str(py_str)?.into())
-        } else {
-            Err(ValError::new(ErrorTypeDefaults::StringType, self))
+            return Ok(ValidationMatch::strict(py_string_str(py_str)?.into()));
+        }
+
+        'lax: {
+            if !strict {
+                return if let Ok(bytes) = self.downcast::<PyBytes>() {
+                    match from_utf8(bytes.as_bytes()) {
+                        Ok(str) => Ok(str.into()),
+                        Err(_) => Err(ValError::new(ErrorTypeDefaults::StringUnicode, self)),
+                    }
+                } else if let Ok(py_byte_array) = self.downcast::<PyByteArray>() {
+                    // Safety: the gil is held while from_utf8 is running so py_byte_array is not mutated,
+                    // and we immediately copy the bytes into a new Python string
+                    match from_utf8(unsafe { py_byte_array.as_bytes() }) {
+                        // Why Python not Rust? to avoid an unnecessary allocation on the Rust side, the
+                        // final output needs to be Python anyway.
+                        Ok(s) => Ok(PyString::new(self.py(), s).into()),
+                        Err(_) => Err(ValError::new(ErrorTypeDefaults::StringUnicode, self)),
+                    }
+                } else if coerce_numbers_to_str && !PyBool::is_exact_type_of(self) && {
+                    let py = self.py();
+                    let decimal_type: Py<PyType> = get_decimal_type(py);
+
+                    // only allow int, float, and decimal (not bool)
+                    self.is_instance_of::<PyInt>()
+                        || self.is_instance_of::<PyFloat>()
+                        || self.is_instance(decimal_type.as_ref(py)).unwrap_or_default()
+                } {
+                    Ok(self.str()?.into())
+                } else if let Some(enum_val) = maybe_as_enum(self) {
+                    Ok(enum_val.str()?.into())
+                } else {
+                    break 'lax;
+                }
+                .map(ValidationMatch::lax);
+            }
         }
+
+        Err(ValError::new(ErrorTypeDefaults::StringType, self))
     }
 
-    fn lax_str(&'a self, coerce_numbers_to_str: bool) -> ValResult<EitherString<'a>> {
+    fn exact_str(&'a self) -> ValResult<EitherString<'a>> {
         if let Ok(py_str) = <PyString as PyTryFrom>::try_from_exact(self) {
-            Ok(py_str.into())
-        } else if let Ok(py_str) = self.downcast::<PyString>() {
-            // force to a rust string to make sure behaviour is consistent whether or not we go via a
-            // rust string in StrConstrainedValidator - e.g. to_lower
-            Ok(py_string_str(py_str)?.into())
-        } else if let Ok(bytes) = self.downcast::<PyBytes>() {
-            let str = match from_utf8(bytes.as_bytes()) {
-                Ok(s) => s,
-                Err(_) => return Err(ValError::new(ErrorTypeDefaults::StringUnicode, self)),
-            };
-            Ok(str.into())
-        } else if let Ok(py_byte_array) = self.downcast::<PyByteArray>() {
-            // Safety: the gil is held while from_utf8 is running so py_byte_array is not mutated,
-            // and we immediately copy the bytes into a new Python string
-            let s = match from_utf8(unsafe { py_byte_array.as_bytes() }) {
-                // Why Python not Rust? to avoid an unnecessary allocation on the Rust side, the
-                // final output needs to be Python anyway.
-                Ok(s) => PyString::new(self.py(), s),
-                Err(_) => return Err(ValError::new(ErrorTypeDefaults::StringUnicode, self)),
-            };
-            Ok(s.into())
-        } else if coerce_numbers_to_str && !PyBool::is_exact_type_of(self) && {
-            let py = self.py();
-            let decimal_type: Py<PyType> = get_decimal_type(py);
-
-            // only allow int, float, and decimal (not bool)
-            self.is_instance_of::<PyInt>()
-                || self.is_instance_of::<PyFloat>()
-                || self.is_instance(decimal_type.as_ref(py)).unwrap_or_default()
-        } {
-            Ok(self.str()?.into())
-        } else if let Some(enum_val) = maybe_as_enum(self) {
-            Ok(enum_val.str()?.into())
+            Ok(EitherString::Py(py_str))
         } else {
-            Err(ValError::new(ErrorTypeDefaults::StringType, self))
+            Err(ValError::new(ErrorTypeDefaults::IntType, self))
         }
     }
 
-    fn strict_bytes(&'a self) -> ValResult<EitherBytes<'a>> {
-        if let Ok(py_bytes) = self.downcast::<PyBytes>() {
-            Ok(py_bytes.into())
+    fn exact_int(&'a self) -> ValResult<EitherInt<'a>> {
+        if PyInt::is_exact_type_of(self) {
+            Ok(EitherInt::Py(self))
         } else {
-            Err(ValError::new(ErrorTypeDefaults::BytesType, self))
+            Err(ValError::new(ErrorTypeDefaults::IntType, self))
         }
     }
 
-    fn lax_bytes(&'a self) -> ValResult<EitherBytes<'a>> {
-        if let Ok(py_bytes) = self.downcast::<PyBytes>() {
-            Ok(py_bytes.into())
-        } else if let Ok(py_str) = self.downcast::<PyString>() {
-            let str = py_string_str(py_str)?;
-            Ok(str.as_bytes().into())
-        } else if let Ok(py_byte_array) = self.downcast::<PyByteArray>() {
-            Ok(py_byte_array.to_vec().into())
-        } else {
-            Err(ValError::new(ErrorTypeDefaults::BytesType, self))
+    fn validate_bytes(&'a self, strict: bool) -> ValResult<ValidationMatch<EitherBytes<'a>>> {
+        if let Ok(py_bytes) = self.downcast_exact::<PyBytes>() {
+            return Ok(ValidationMatch::exact(py_bytes.into()));
+        } else if let Ok(py_bytes) = self.downcast::<PyBytes>() {
+            return Ok(ValidationMatch::strict(py_bytes.into()));
         }
-    }
 
-    fn strict_bool(&self) -> ValResult<bool> {
-        if let Ok(bool) = self.downcast::<PyBool>() {
-            Ok(bool.is_true())
-        } else {
-            Err(ValError::new(ErrorTypeDefaults::BoolType, self))
+        'lax: {
+            if !strict {
+                return if let Ok(py_str) = self.downcast::<PyString>() {
+                    let str = py_string_str(py_str)?;
+                    Ok(str.as_bytes().into())
+                } else if let Ok(py_byte_array) = self.downcast::<PyByteArray>() {
+                    Ok(py_byte_array.to_vec().into())
+                } else {
+                    break 'lax;
+                }
+                .map(ValidationMatch::lax);
+            }
         }
+
+        Err(ValError::new(ErrorTypeDefaults::BytesType, self))
     }
 
-    fn lax_bool(&self) -> ValResult<bool> {
+    fn validate_bool(&self, strict: bool) -> ValResult<'_, ValidationMatch<bool>> {
         if let Ok(bool) = self.downcast::<PyBool>() {
-            Ok(bool.is_true())
-        } else if let Some(cow_str) = maybe_as_string(self, ErrorTypeDefaults::BoolParsing)? {
-            str_as_bool(self, &cow_str)
-        } else if let Ok(int) = extract_i64(self) {
-            int_as_bool(self, int)
-        } else if let Ok(float) = self.extract::<f64>() {
-            match float_as_int(self, float) {
-                Ok(int) => int
-                    .as_bool()
-                    .ok_or_else(|| ValError::new(ErrorTypeDefaults::BoolParsing, self)),
-                _ => Err(ValError::new(ErrorTypeDefaults::BoolType, self)),
+            return Ok(ValidationMatch::exact(bool.is_true()));
+        }
+
+        if !strict {
+            if let Some(cow_str) = maybe_as_string(self, ErrorTypeDefaults::BoolParsing)? {
+                return str_as_bool(self, &cow_str).map(ValidationMatch::lax);
+            } else if let Ok(int) = extract_i64(self) {
+                return int_as_bool(self, int).map(ValidationMatch::lax);
+            } else if let Ok(float) = self.extract::<f64>() {
+                if let Ok(int) = float_as_int(self, float) {
+                    return int
+                        .as_bool()
+                        .ok_or_else(|| ValError::new(ErrorTypeDefaults::BoolParsing, self))
+                        .map(ValidationMatch::lax);
+                };
             }
-        } else {
-            Err(ValError::new(ErrorTypeDefaults::BoolType, self))
         }
+
+        Err(ValError::new(ErrorTypeDefaults::BoolType, self))
     }
 
-    fn strict_int(&'a self) -> ValResult<EitherInt<'a>> {
-        if PyInt::is_exact_type_of(self) {
-            Ok(EitherInt::Py(self))
-        } else if PyInt::is_type_of(self) {
+    fn validate_int(&'a self, strict: bool) -> ValResult<'a, ValidationMatch<EitherInt<'a>>> {
+        if self.is_exact_instance_of::<PyInt>() {
+            return Ok(ValidationMatch::exact(EitherInt::Py(self)));
+        } else if self.is_instance_of::<PyInt>() {
             // bools are a subclass of int, so check for bool type in this specific case
-            if PyBool::is_exact_type_of(self) {
-                Err(ValError::new(ErrorTypeDefaults::IntType, self))
+            let exactness = if self.is_instance_of::<PyBool>() {
+                if strict {
+                    return Err(ValError::new(ErrorTypeDefaults::IntType, self));
+                }
+                Exactness::Lax
             } else {
-                // force to an int to upcast to a pure python int
-                EitherInt::upcast(self)
+                Exactness::Strict
+            };
+
+            // force to an int to upcast to a pure python int
+            return EitherInt::upcast(self).map(|either_int| ValidationMatch::new(either_int, exactness));
+        }
+
+        'lax: {
+            if !strict {
+                return if let Some(cow_str) = maybe_as_string(self, ErrorTypeDefaults::IntParsing)? {
+                    str_as_int(self, &cow_str)
+                } else if self.is_exact_instance_of::<PyFloat>() {
+                    float_as_int(self, self.extract::<f64>()?)
+                } else if let Ok(decimal) = self.strict_decimal(self.py()) {
+                    decimal_as_int(self.py(), self, decimal)
+                } else if let Ok(float) = self.extract::<f64>() {
+                    float_as_int(self, float)
+                } else if let Some(enum_val) = maybe_as_enum(self) {
+                    Ok(EitherInt::Py(enum_val))
+                } else {
+                    break 'lax;
+                }
+                .map(ValidationMatch::lax);
             }
-        } else {
-            Err(ValError::new(ErrorTypeDefaults::IntType, self))
         }
-    }
 
-    fn lax_int(&'a self) -> ValResult<EitherInt<'a>> {
-        if PyInt::is_exact_type_of(self) {
-            Ok(EitherInt::Py(self))
-        } else if let Some(cow_str) = maybe_as_string(self, ErrorTypeDefaults::IntParsing)? {
-            // Try strings before subclasses of int as that will be far more common
-            str_as_int(self, &cow_str)
-        } else if PyInt::is_type_of(self) {
-            // force to an int to upcast to a pure python int to maintain current behaviour
-            EitherInt::upcast(self)
-        } else if PyFloat::is_exact_type_of(self) {
-            float_as_int(self, self.extract::<f64>()?)
-        } else if let Ok(decimal) = self.strict_decimal(self.py()) {
-            decimal_as_int(self.py(), self, decimal)
-        } else if let Ok(float) = self.extract::<f64>() {
-            float_as_int(self, float)
-        } else if let Some(enum_val) = maybe_as_enum(self) {
-            Ok(EitherInt::Py(enum_val))
-        } else {
-            Err(ValError::new(ErrorTypeDefaults::IntType, self))
-        }
+        Err(ValError::new(ErrorTypeDefaults::IntType, self))
     }
 
-    fn exact_int(&'a self) -> ValResult<EitherInt<'a>> {
-        if PyInt::is_exact_type_of(self) {
-            Ok(EitherInt::Py(self))
-        } else {
-            Err(ValError::new(ErrorTypeDefaults::IntType, self))
+    fn validate_float(&'a self, strict: bool) -> ValResult<'a, ValidationMatch<EitherFloat<'a>>> {
+        if let Ok(float) = self.downcast_exact::<PyFloat>() {
+            return Ok(ValidationMatch::exact(EitherFloat::Py(float)));
         }
-    }
 
-    fn exact_str(&'a self) -> ValResult<EitherString<'a>> {
-        if let Ok(py_str) = PyString::try_from_exact(self) {
-            Ok(EitherString::Py(py_str))
-        } else {
-            Err(ValError::new(ErrorTypeDefaults::IntType, self))
+        if !strict {
+            if let Some(cow_str) = maybe_as_string(self, ErrorTypeDefaults::FloatParsing)? {
+                // checking for bytes and string is fast, so do this before isinstance(float)
+                return str_as_float(self, &cow_str).map(ValidationMatch::lax);
+            }
         }
-    }
 
-    fn ultra_strict_float(&'a self) -> ValResult<EitherFloat<'a>> {
-        if self.is_instance_of::<PyInt>() {
-            Err(ValError::new(ErrorTypeDefaults::FloatType, self))
-        } else if let Ok(float) = self.downcast::<PyFloat>() {
-            Ok(EitherFloat::Py(float))
-        } else {
-            Err(ValError::new(ErrorTypeDefaults::FloatType, self))
-        }
-    }
-    fn strict_float(&'a self) -> ValResult<EitherFloat<'a>> {
-        if let Ok(py_float) = self.downcast_exact::<PyFloat>() {
-            Ok(EitherFloat::Py(py_float))
-        } else if let Ok(float) = self.extract::<f64>() {
-            // bools are cast to floats as either 0.0 or 1.0, so check for bool type in this specific case
-            if (float == 0.0 || float == 1.0) && PyBool::is_exact_type_of(self) {
-                Err(ValError::new(ErrorTypeDefaults::FloatType, self))
+        if let Ok(float) = self.extract::<f64>() {
+            let exactness = if self.is_instance_of::<PyBool>() {
+                if strict {
+                    return Err(ValError::new(ErrorTypeDefaults::FloatType, self));
+                }
+                Exactness::Lax
             } else {
-                Ok(EitherFloat::F64(float))
-            }
-        } else {
-            Err(ValError::new(ErrorTypeDefaults::FloatType, self))
+                Exactness::Strict
+            };
+            return Ok(ValidationMatch::new(EitherFloat::F64(float), exactness));
         }
-    }
 
-    fn lax_float(&'a self) -> ValResult<EitherFloat<'a>> {
-        if let Ok(py_float) = self.downcast_exact() {
-            Ok(EitherFloat::Py(py_float))
-        } else if let Some(cow_str) = maybe_as_string(self, ErrorTypeDefaults::FloatParsing)? {
-            str_as_float(self, &cow_str)
-        } else if let Ok(float) = self.extract::<f64>() {
-            Ok(EitherFloat::F64(float))
-        } else {
-            Err(ValError::new(ErrorTypeDefaults::FloatType, self))
-        }
+        Err(ValError::new(ErrorTypeDefaults::FloatType, self))
     }
 
     fn strict_decimal(&'a self, py: Python<'a>) -> ValResult<&'a PyAny> {
@@ -607,128 +600,136 @@ impl<'a> Input<'a> for PyAny {
         }
     }
 
-    fn strict_date(&self) -> ValResult<EitherDate> {
-        if PyDateTime::is_type_of(self) {
-            // have to check if it's a datetime first, otherwise the line below converts to a date
-            Err(ValError::new(ErrorTypeDefaults::DateType, self))
-        } else if let Ok(date) = self.downcast::<PyDate>() {
-            Ok(date.into())
-        } else {
-            Err(ValError::new(ErrorTypeDefaults::DateType, self))
-        }
-    }
-
-    fn lax_date(&self) -> ValResult<EitherDate> {
-        if PyDateTime::is_type_of(self) {
+    fn validate_date(&self, strict: bool) -> ValResult<ValidationMatch<EitherDate>> {
+        if let Ok(date) = self.downcast_exact::<PyDate>() {
+            Ok(ValidationMatch::exact(date.into()))
+        } else if PyDateTime::is_type_of(self) {
             // have to check if it's a datetime first, otherwise the line below converts to a date
             // even if we later try coercion from a datetime, we don't want to return a datetime now
             Err(ValError::new(ErrorTypeDefaults::DateType, self))
         } else if let Ok(date) = self.downcast::<PyDate>() {
-            Ok(date.into())
-        } else if let Ok(py_str) = self.downcast::<PyString>() {
-            let str = py_string_str(py_str)?;
-            bytes_as_date(self, str.as_bytes())
-        } else if let Ok(py_bytes) = self.downcast::<PyBytes>() {
-            bytes_as_date(self, py_bytes.as_bytes())
+            Ok(ValidationMatch::strict(date.into()))
+        } else if let Some(bytes) = {
+            if strict {
+                None
+            } else if let Ok(py_str) = self.downcast::<PyString>() {
+                let str = py_string_str(py_str)?;
+                Some(str.as_bytes())
+            } else if let Ok(py_bytes) = self.downcast::<PyBytes>() {
+                Some(py_bytes.as_bytes())
+            } else {
+                None
+            }
+        } {
+            bytes_as_date(self, bytes).map(ValidationMatch::lax)
         } else {
             Err(ValError::new(ErrorTypeDefaults::DateType, self))
         }
     }
 
-    fn strict_time(
+    fn validate_time(
         &self,
-        _microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<EitherTime> {
-        if let Ok(time) = self.downcast::<PyTime>() {
-            Ok(time.into())
-        } else {
-            Err(ValError::new(ErrorTypeDefaults::TimeType, self))
-        }
-    }
-
-    fn lax_time(&self, microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior) -> ValResult<EitherTime> {
-        if let Ok(time) = self.downcast::<PyTime>() {
-            Ok(time.into())
-        } else if let Ok(py_str) = self.downcast::<PyString>() {
-            let str = py_string_str(py_str)?;
-            bytes_as_time(self, str.as_bytes(), microseconds_overflow_behavior)
-        } else if let Ok(py_bytes) = self.downcast::<PyBytes>() {
-            bytes_as_time(self, py_bytes.as_bytes(), microseconds_overflow_behavior)
-        } else if PyBool::is_exact_type_of(self) {
-            Err(ValError::new(ErrorTypeDefaults::TimeType, self))
-        } else if let Ok(int) = extract_i64(self) {
-            int_as_time(self, int, 0)
-        } else if let Ok(float) = self.extract::<f64>() {
-            float_as_time(self, float)
-        } else {
-            Err(ValError::new(ErrorTypeDefaults::TimeType, self))
+        strict: bool,
+        microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
+    ) -> ValResult<ValidationMatch<EitherTime>> {
+        if let Ok(time) = self.downcast_exact::<PyTime>() {
+            return Ok(ValidationMatch::exact(time.into()));
+        } else if let Ok(time) = self.downcast::<PyTime>() {
+            return Ok(ValidationMatch::strict(time.into()));
+        }
+
+        'lax: {
+            if !strict {
+                return if let Ok(py_str) = self.downcast::<PyString>() {
+                    let str = py_string_str(py_str)?;
+                    bytes_as_time(self, str.as_bytes(), microseconds_overflow_behavior)
+                } else if let Ok(py_bytes) = self.downcast::<PyBytes>() {
+                    bytes_as_time(self, py_bytes.as_bytes(), microseconds_overflow_behavior)
+                } else if PyBool::is_exact_type_of(self) {
+                    Err(ValError::new(ErrorTypeDefaults::TimeType, self))
+                } else if let Ok(int) = extract_i64(self) {
+                    int_as_time(self, int, 0)
+                } else if let Ok(float) = self.extract::<f64>() {
+                    float_as_time(self, float)
+                } else {
+                    break 'lax;
+                }
+                .map(ValidationMatch::lax);
+            }
         }
-    }
 
-    fn strict_datetime(
-        &self,
-        _microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<EitherDateTime> {
-        if let Ok(dt) = self.downcast::<PyDateTime>() {
-            Ok(dt.into())
-        } else {
-            Err(ValError::new(ErrorTypeDefaults::DatetimeType, self))
-        }
+        Err(ValError::new(ErrorTypeDefaults::TimeType, self))
     }
 
-    fn lax_datetime(
+    fn validate_datetime(
         &self,
+        strict: bool,
         microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<EitherDateTime> {
-        if let Ok(dt) = self.downcast::<PyDateTime>() {
-            Ok(dt.into())
-        } else if let Ok(py_str) = self.downcast::<PyString>() {
-            let str = py_string_str(py_str)?;
-            bytes_as_datetime(self, str.as_bytes(), microseconds_overflow_behavior)
-        } else if let Ok(py_bytes) = self.downcast::<PyBytes>() {
-            bytes_as_datetime(self, py_bytes.as_bytes(), microseconds_overflow_behavior)
-        } else if PyBool::is_exact_type_of(self) {
-            Err(ValError::new(ErrorTypeDefaults::DatetimeType, self))
-        } else if let Ok(int) = extract_i64(self) {
-            int_as_datetime(self, int, 0)
-        } else if let Ok(float) = self.extract::<f64>() {
-            float_as_datetime(self, float)
-        } else if let Ok(date) = self.downcast::<PyDate>() {
-            Ok(date_as_datetime(date)?)
-        } else {
-            Err(ValError::new(ErrorTypeDefaults::DatetimeType, self))
+    ) -> ValResult<ValidationMatch<EitherDateTime>> {
+        if let Ok(dt) = self.downcast_exact::<PyDateTime>() {
+            return Ok(ValidationMatch::exact(dt.into()));
+        } else if let Ok(dt) = self.downcast::<PyDateTime>() {
+            return Ok(ValidationMatch::strict(dt.into()));
+        }
+
+        'lax: {
+            if !strict {
+                return if let Ok(py_str) = self.downcast::<PyString>() {
+                    let str = py_string_str(py_str)?;
+                    bytes_as_datetime(self, str.as_bytes(), microseconds_overflow_behavior)
+                } else if let Ok(py_bytes) = self.downcast::<PyBytes>() {
+                    bytes_as_datetime(self, py_bytes.as_bytes(), microseconds_overflow_behavior)
+                } else if PyBool::is_exact_type_of(self) {
+                    Err(ValError::new(ErrorTypeDefaults::DatetimeType, self))
+                } else if let Ok(int) = extract_i64(self) {
+                    int_as_datetime(self, int, 0)
+                } else if let Ok(float) = self.extract::<f64>() {
+                    float_as_datetime(self, float)
+                } else if let Ok(date) = self.downcast::<PyDate>() {
+                    Ok(date_as_datetime(date)?)
+                } else {
+                    break 'lax;
+                }
+                .map(ValidationMatch::lax);
+            }
         }
-    }
 
-    fn strict_timedelta(
-        &self,
-        _microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<EitherTimedelta> {
-        if let Ok(either_dt) = EitherTimedelta::try_from(self) {
-            Ok(either_dt)
-        } else {
-            Err(ValError::new(ErrorTypeDefaults::TimeDeltaType, self))
-        }
+        Err(ValError::new(ErrorTypeDefaults::DatetimeType, self))
     }
 
-    fn lax_timedelta(
+    fn validate_timedelta(
         &self,
+        strict: bool,
         microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<EitherTimedelta> {
+    ) -> ValResult<ValidationMatch<EitherTimedelta>> {
         if let Ok(either_dt) = EitherTimedelta::try_from(self) {
-            Ok(either_dt)
-        } else if let Ok(py_str) = self.downcast::<PyString>() {
-            let str = py_string_str(py_str)?;
-            bytes_as_timedelta(self, str.as_bytes(), microseconds_overflow_behavior)
-        } else if let Ok(py_bytes) = self.downcast::<PyBytes>() {
-            bytes_as_timedelta(self, py_bytes.as_bytes(), microseconds_overflow_behavior)
-        } else if let Ok(int) = extract_i64(self) {
-            Ok(int_as_duration(self, int)?.into())
-        } else if let Ok(float) = self.extract::<f64>() {
-            Ok(float_as_duration(self, float)?.into())
-        } else {
-            Err(ValError::new(ErrorTypeDefaults::TimeDeltaType, self))
+            let exactness = if matches!(either_dt, EitherTimedelta::PyExact(_)) {
+                Exactness::Exact
+            } else {
+                Exactness::Strict
+            };
+            return Ok(ValidationMatch::new(either_dt, exactness));
+        }
+
+        'lax: {
+            if !strict {
+                return if let Ok(py_str) = self.downcast::<PyString>() {
+                    let str = py_string_str(py_str)?;
+                    bytes_as_timedelta(self, str.as_bytes(), microseconds_overflow_behavior)
+                } else if let Ok(py_bytes) = self.downcast::<PyBytes>() {
+                    bytes_as_timedelta(self, py_bytes.as_bytes(), microseconds_overflow_behavior)
+                } else if let Ok(int) = extract_i64(self) {
+                    Ok(int_as_duration(self, int)?.into())
+                } else if let Ok(float) = self.extract::<f64>() {
+                    Ok(float_as_duration(self, float)?.into())
+                } else {
+                    break 'lax;
+                }
+                .map(ValidationMatch::lax);
+            }
         }
+
+        Err(ValError::new(ErrorTypeDefaults::TimeDeltaType, self))
     }
 }
 
diff --git a/src/input/input_string.rs b/src/input/input_string.rs
index b84908edf..e27ef6461 100644
--- a/src/input/input_string.rs
+++ b/src/input/input_string.rs
@@ -15,7 +15,7 @@ use super::datetime::{
 use super::shared::{map_json_err, str_as_bool, str_as_float};
 use super::{
     BorrowInput, EitherBytes, EitherFloat, EitherInt, EitherString, EitherTimedelta, GenericArguments, GenericIterable,
-    GenericIterator, GenericMapping, Input,
+    GenericIterator, GenericMapping, Input, ValidationMatch,
 };
 
 #[derive(Debug)]
@@ -96,54 +96,44 @@ impl<'a> Input<'a> for StringMapping<'a> {
         }
     }
 
-    fn strict_str(&'a self) -> ValResult<EitherString<'a>> {
+    fn validate_str(
+        &'a self,
+        _strict: bool,
+        _coerce_numbers_to_str: bool,
+    ) -> ValResult<ValidationMatch<EitherString<'a>>> {
         match self {
-            Self::String(s) => Ok((*s).into()),
+            Self::String(s) => Ok(ValidationMatch::strict((*s).into())),
             Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::StringType, self)),
         }
     }
 
-    fn strict_bytes(&'a self) -> ValResult<EitherBytes<'a>> {
+    fn validate_bytes(&'a self, _strict: bool) -> ValResult<ValidationMatch<EitherBytes<'a>>> {
         match self {
-            Self::String(s) => py_string_str(s).map(|b| b.as_bytes().into()),
+            Self::String(s) => py_string_str(s).map(|b| ValidationMatch::strict(b.as_bytes().into())),
             Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::BytesType, self)),
         }
     }
 
-    fn lax_bytes(&'a self) -> ValResult<EitherBytes<'a>> {
+    fn validate_bool(&self, _strict: bool) -> ValResult<'_, ValidationMatch<bool>> {
         match self {
-            Self::String(s) => {
-                let str = py_string_str(s)?;
-                Ok(str.as_bytes().into())
-            }
-            Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::BytesType, self)),
-        }
-    }
-
-    fn strict_bool(&self) -> ValResult<bool> {
-        match self {
-            Self::String(s) => str_as_bool(self, py_string_str(s)?),
+            Self::String(s) => str_as_bool(self, py_string_str(s)?).map(ValidationMatch::strict),
             Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::BoolType, self)),
         }
     }
 
-    fn strict_int(&'a self) -> ValResult<EitherInt<'a>> {
+    fn validate_int(&'a self, _strict: bool) -> ValResult<'a, ValidationMatch<EitherInt<'a>>> {
         match self {
             Self::String(s) => match py_string_str(s)?.parse() {
-                Ok(i) => Ok(EitherInt::I64(i)),
+                Ok(i) => Ok(ValidationMatch::strict(EitherInt::I64(i))),
                 Err(_) => Err(ValError::new(ErrorTypeDefaults::IntParsing, self)),
             },
             Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::IntType, self)),
         }
     }
 
-    fn ultra_strict_float(&'a self) -> ValResult<EitherFloat<'a>> {
-        self.strict_float()
-    }
-
-    fn strict_float(&'a self) -> ValResult<EitherFloat<'a>> {
+    fn validate_float(&'a self, _strict: bool) -> ValResult<'a, ValidationMatch<EitherFloat<'a>>> {
         match self {
-            Self::String(s) => str_as_float(self, py_string_str(s)?),
+            Self::String(s) => str_as_float(self, py_string_str(s)?).map(ValidationMatch::strict),
             Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::FloatType, self)),
         }
     }
@@ -186,39 +176,45 @@ impl<'a> Input<'a> for StringMapping<'a> {
         Err(ValError::new(ErrorTypeDefaults::IterableType, self))
     }
 
-    fn strict_date(&self) -> ValResult<EitherDate> {
+    fn validate_date(&self, _strict: bool) -> ValResult<ValidationMatch<EitherDate>> {
         match self {
-            Self::String(s) => bytes_as_date(self, py_string_str(s)?.as_bytes()),
+            Self::String(s) => bytes_as_date(self, py_string_str(s)?.as_bytes()).map(ValidationMatch::strict),
             Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::DateType, self)),
         }
     }
 
-    fn strict_time(
+    fn validate_time(
         &self,
+        _strict: bool,
         microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<EitherTime> {
+    ) -> ValResult<ValidationMatch<EitherTime>> {
         match self {
-            Self::String(s) => bytes_as_time(self, py_string_str(s)?.as_bytes(), microseconds_overflow_behavior),
+            Self::String(s) => bytes_as_time(self, py_string_str(s)?.as_bytes(), microseconds_overflow_behavior)
+                .map(ValidationMatch::strict),
             Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::TimeType, self)),
         }
     }
 
-    fn strict_datetime(
+    fn validate_datetime(
         &self,
+        _strict: bool,
         microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<EitherDateTime> {
+    ) -> ValResult<ValidationMatch<EitherDateTime>> {
         match self {
-            Self::String(s) => bytes_as_datetime(self, py_string_str(s)?.as_bytes(), microseconds_overflow_behavior),
+            Self::String(s) => bytes_as_datetime(self, py_string_str(s)?.as_bytes(), microseconds_overflow_behavior)
+                .map(ValidationMatch::strict),
             Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::DatetimeType, self)),
         }
     }
 
-    fn strict_timedelta(
+    fn validate_timedelta(
         &self,
+        _strict: bool,
         microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<EitherTimedelta> {
+    ) -> ValResult<ValidationMatch<EitherTimedelta>> {
         match self {
-            Self::String(s) => bytes_as_timedelta(self, py_string_str(s)?.as_bytes(), microseconds_overflow_behavior),
+            Self::String(s) => bytes_as_timedelta(self, py_string_str(s)?.as_bytes(), microseconds_overflow_behavior)
+                .map(ValidationMatch::strict),
             Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::TimeDeltaType, self)),
         }
     }
diff --git a/src/input/mod.rs b/src/input/mod.rs
index 13c835f83..d7ca0a5bf 100644
--- a/src/input/mod.rs
+++ b/src/input/mod.rs
@@ -20,7 +20,7 @@ pub(crate) use input_string::StringMapping;
 pub(crate) use return_enums::{
     py_string_str, AttributesGenericIterator, DictGenericIterator, EitherBytes, EitherFloat, EitherInt, EitherString,
     GenericArguments, GenericIterable, GenericIterator, GenericMapping, Int, JsonArgs, JsonObjectGenericIterator,
-    MappingGenericIterator, PyArgs, StringMappingGenericIterator,
+    MappingGenericIterator, PyArgs, StringMappingGenericIterator, ValidationMatch,
 };
 
 // Defined here as it's not exported by pyo3
diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index 412842a13..56c7098df 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -24,11 +24,44 @@ use serde::{ser::Error, Serialize, Serializer};
 
 use crate::errors::{py_err_string, ErrorType, ErrorTypeDefaults, InputValue, ValError, ValLineError, ValResult};
 use crate::tools::py_err;
-use crate::validators::{CombinedValidator, ValidationState, Validator};
+use crate::validators::{CombinedValidator, Exactness, ValidationState, Validator};
 
 use super::input_string::StringMapping;
 use super::{py_error_on_minusone, Input};
 
+pub struct ValidationMatch<T>(T, Exactness);
+
+impl<T> ValidationMatch<T> {
+    pub const fn new(value: T, exactness: Exactness) -> Self {
+        Self(value, exactness)
+    }
+
+    pub const fn exact(value: T) -> Self {
+        Self(value, Exactness::Exact)
+    }
+
+    pub const fn strict(value: T) -> Self {
+        Self(value, Exactness::Strict)
+    }
+
+    pub const fn lax(value: T) -> Self {
+        Self(value, Exactness::Lax)
+    }
+
+    pub fn require_exact(self) -> Option<T> {
+        (self.1 == Exactness::Exact).then_some(self.0)
+    }
+
+    pub fn unpack(self, state: &mut ValidationState) -> T {
+        state.floor_exactness(self.1);
+        self.0
+    }
+
+    pub fn into_inner(self) -> T {
+        self.0
+    }
+}
+
 /// Container for all the collections (sized iterable containers) types, which
 /// can mostly be converted to each other in lax mode.
 /// This mostly matches python's definition of `Collection`.
diff --git a/src/validators/any.rs b/src/validators/any.rs
index 625eb4adf..2fad89091 100644
--- a/src/validators/any.rs
+++ b/src/validators/any.rs
@@ -4,7 +4,9 @@ use pyo3::types::PyDict;
 use crate::errors::ValResult;
 use crate::input::Input;
 
-use super::{validation_state::ValidationState, BuildValidator, CombinedValidator, DefinitionsBuilder, Validator};
+use super::{
+    validation_state::Exactness, BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator,
+};
 
 /// This might seem useless, but it's useful in DictValidator to avoid Option<Validator> a lot
 #[derive(Debug, Clone)]
@@ -29,20 +31,14 @@ impl Validator for AnyValidator {
         &self,
         py: Python<'data>,
         input: &'data impl Input<'data>,
-        _state: &mut ValidationState,
+        state: &mut ValidationState,
     ) -> ValResult<'data, PyObject> {
+        // in a union, Any should be preferred to doing lax coercions
+        state.floor_exactness(Exactness::Strict);
         Ok(input.to_object(py))
     }
 
-    fn different_strict_behavior(&self, _ultra_strict: bool) -> bool {
-        false
-    }
-
     fn get_name(&self) -> &str {
         Self::EXPECTED_TYPE
     }
-
-    fn complete(&self) -> PyResult<()> {
-        Ok(())
-    }
 }
diff --git a/src/validators/arguments.rs b/src/validators/arguments.rs
index 748b13338..7ae65d579 100644
--- a/src/validators/arguments.rs
+++ b/src/validators/arguments.rs
@@ -7,7 +7,7 @@ use ahash::AHashSet;
 use crate::build_tools::py_schema_err;
 use crate::build_tools::schema_or_config_same;
 use crate::errors::{AsLocItem, ErrorTypeDefaults, ValError, ValLineError, ValResult};
-use crate::input::{GenericArguments, Input};
+use crate::input::{GenericArguments, Input, ValidationMatch};
 use crate::lookup_key::LookupKey;
 
 use crate::tools::SchemaDict;
@@ -282,7 +282,7 @@ impl Validator for ArgumentsValidator {
                 if let Some(kwargs) = $args.kwargs {
                     if kwargs.len() > used_kwargs.len() {
                         for (raw_key, value) in kwargs.iter() {
-                            let either_str = match raw_key.strict_str() {
+                            let either_str = match raw_key.validate_str(true, false).map(ValidationMatch::into_inner) {
                                 Ok(k) => k,
                                 Err(ValError::LineErrors(line_errors)) => {
                                     for err in line_errors {
@@ -332,26 +332,7 @@ impl Validator for ArgumentsValidator {
         }
     }
 
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        self.parameters
-            .iter()
-            .any(|p| p.validator.different_strict_behavior(ultra_strict))
-    }
-
     fn get_name(&self) -> &str {
         Self::EXPECTED_TYPE
     }
-
-    fn complete(&self) -> PyResult<()> {
-        self.parameters
-            .iter()
-            .try_for_each(|parameter| parameter.validator.complete())?;
-        if let Some(v) = &self.var_args_validator {
-            v.complete()?;
-        }
-        if let Some(v) = &self.var_kwargs_validator {
-            v.complete()?;
-        };
-        Ok(())
-    }
 }
diff --git a/src/validators/bool.rs b/src/validators/bool.rs
index 3a38cf3e5..bcd48e991 100644
--- a/src/validators/bool.rs
+++ b/src/validators/bool.rs
@@ -38,19 +38,12 @@ impl Validator for BoolValidator {
     ) -> ValResult<'data, PyObject> {
         // TODO in theory this could be quicker if we used PyBool rather than going to a bool
         // and back again, might be worth profiling?
-        let strict = state.strict_or(self.strict);
-        Ok(input.validate_bool(strict)?.into_py(py))
-    }
-
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        !ultra_strict
+        input
+            .validate_bool(state.strict_or(self.strict))
+            .map(|val_match| val_match.unpack(state).into_py(py))
     }
 
     fn get_name(&self) -> &str {
         Self::EXPECTED_TYPE
     }
-
-    fn complete(&self) -> PyResult<()> {
-        Ok(())
-    }
 }
diff --git a/src/validators/bytes.rs b/src/validators/bytes.rs
index fb90187ac..78a8acb24 100644
--- a/src/validators/bytes.rs
+++ b/src/validators/bytes.rs
@@ -46,21 +46,14 @@ impl Validator for BytesValidator {
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
     ) -> ValResult<'data, PyObject> {
-        let either_bytes = input.validate_bytes(state.strict_or(self.strict))?;
-        Ok(either_bytes.into_py(py))
-    }
-
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        !ultra_strict
+        input
+            .validate_bytes(state.strict_or(self.strict))
+            .map(|m| m.unpack(state).into_py(py))
     }
 
     fn get_name(&self) -> &str {
         Self::EXPECTED_TYPE
     }
-
-    fn complete(&self) -> PyResult<()> {
-        Ok(())
-    }
 }
 
 #[derive(Debug, Clone)]
@@ -79,7 +72,7 @@ impl Validator for BytesConstrainedValidator {
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
     ) -> ValResult<'data, PyObject> {
-        let either_bytes = input.validate_bytes(state.strict_or(self.strict))?;
+        let either_bytes = input.validate_bytes(state.strict_or(self.strict))?.unpack(state);
         let len = either_bytes.len()?;
 
         if let Some(min_length) = self.min_length {
@@ -104,21 +97,12 @@ impl Validator for BytesConstrainedValidator {
                 ));
             }
         }
-
         Ok(either_bytes.into_py(py))
     }
 
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        !ultra_strict
-    }
-
     fn get_name(&self) -> &str {
         "constrained-bytes"
     }
-
-    fn complete(&self) -> PyResult<()> {
-        Ok(())
-    }
 }
 
 impl BytesConstrainedValidator {
diff --git a/src/validators/call.rs b/src/validators/call.rs
index eca1f0206..e0649aa53 100644
--- a/src/validators/call.rs
+++ b/src/validators/call.rs
@@ -98,24 +98,7 @@ impl Validator for CallValidator {
         }
     }
 
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        if let Some(return_validator) = &self.return_validator {
-            if return_validator.different_strict_behavior(ultra_strict) {
-                return true;
-            }
-        }
-        self.arguments_validator.different_strict_behavior(ultra_strict)
-    }
-
     fn get_name(&self) -> &str {
         &self.name
     }
-
-    fn complete(&self) -> PyResult<()> {
-        self.arguments_validator.complete()?;
-        match &self.return_validator {
-            Some(v) => v.complete(),
-            None => Ok(()),
-        }
-    }
 }
diff --git a/src/validators/callable.rs b/src/validators/callable.rs
index 83eb37cbe..3075e182e 100644
--- a/src/validators/callable.rs
+++ b/src/validators/callable.rs
@@ -4,6 +4,7 @@ use pyo3::types::PyDict;
 use crate::errors::{ErrorTypeDefaults, ValError, ValResult};
 use crate::input::Input;
 
+use super::validation_state::Exactness;
 use super::{BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
 
 #[derive(Debug, Clone)]
@@ -28,23 +29,16 @@ impl Validator for CallableValidator {
         &self,
         py: Python<'data>,
         input: &'data impl Input<'data>,
-        _state: &mut ValidationState,
+        state: &mut ValidationState,
     ) -> ValResult<'data, PyObject> {
+        state.floor_exactness(Exactness::Lax);
         match input.callable() {
             true => Ok(input.to_object(py)),
             false => Err(ValError::new(ErrorTypeDefaults::CallableType, input)),
         }
     }
 
-    fn different_strict_behavior(&self, _ultra_strict: bool) -> bool {
-        false
-    }
-
     fn get_name(&self) -> &str {
         Self::EXPECTED_TYPE
     }
-
-    fn complete(&self) -> PyResult<()> {
-        Ok(())
-    }
 }
diff --git a/src/validators/chain.rs b/src/validators/chain.rs
index c0f356fa0..d8da86e30 100644
--- a/src/validators/chain.rs
+++ b/src/validators/chain.rs
@@ -83,15 +83,7 @@ impl Validator for ChainValidator {
         steps_iter.try_fold(value, |v, step| step.validate(py, v.into_ref(py), state))
     }
 
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        self.steps.iter().any(|v| v.different_strict_behavior(ultra_strict))
-    }
-
     fn get_name(&self) -> &str {
         &self.name
     }
-
-    fn complete(&self) -> PyResult<()> {
-        self.steps.iter().try_for_each(CombinedValidator::complete)
-    }
 }
diff --git a/src/validators/custom_error.rs b/src/validators/custom_error.rs
index 0d9931c62..4ea31aa5a 100644
--- a/src/validators/custom_error.rs
+++ b/src/validators/custom_error.rs
@@ -99,15 +99,7 @@ impl Validator for CustomErrorValidator {
             .map_err(|_| self.custom_error.as_val_error(input))
     }
 
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        self.validator.different_strict_behavior(ultra_strict)
-    }
-
     fn get_name(&self) -> &str {
         &self.name
     }
-
-    fn complete(&self) -> PyResult<()> {
-        self.validator.complete()
-    }
 }
diff --git a/src/validators/dataclass.rs b/src/validators/dataclass.rs
index d93441ce0..1646f5ea6 100644
--- a/src/validators/dataclass.rs
+++ b/src/validators/dataclass.rs
@@ -8,13 +8,14 @@ use ahash::AHashSet;
 use crate::build_tools::py_schema_err;
 use crate::build_tools::{is_strict, schema_or_config_same, ExtraBehavior};
 use crate::errors::{AsLocItem, ErrorType, ErrorTypeDefaults, ValError, ValLineError, ValResult};
-use crate::input::{BorrowInput, GenericArguments, Input};
+use crate::input::{BorrowInput, GenericArguments, Input, ValidationMatch};
 use crate::lookup_key::LookupKey;
 use crate::tools::SchemaDict;
 use crate::validators::function::convert_err;
 
 use super::arguments::{json_get, json_slice, py_get, py_slice};
 use super::model::{create_class, force_setattr, Revalidate};
+use super::validation_state::Exactness;
 use super::{
     build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, Extra, ValidationState, Validator,
 };
@@ -281,7 +282,7 @@ impl Validator for DataclassArgsValidator {
                         if let Some(kwargs) = $args.kwargs {
                             if kwargs.len() != used_keys.len() {
                                 for (raw_key, value) in kwargs.iter() {
-                                    match raw_key.strict_str() {
+                                    match raw_key.validate_str(true, false).map(ValidationMatch::into_inner) {
                                         Ok(either_str) => {
                                             if !used_keys.contains(either_str.as_cow()?.as_ref()) {
                                                 // Unknown / extra field
@@ -438,19 +439,9 @@ impl Validator for DataclassArgsValidator {
         }
     }
 
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        self.fields
-            .iter()
-            .any(|f| f.validator.different_strict_behavior(ultra_strict))
-    }
-
     fn get_name(&self) -> &str {
         &self.validator_name
     }
-
-    fn complete(&self) -> PyResult<()> {
-        self.fields.iter().try_for_each(|field| field.validator.complete())
-    }
 }
 
 #[derive(Debug)]
@@ -554,6 +545,7 @@ impl Validator for DataclassValidator {
             ))
         } else {
             let val_output = self.validator.validate(py, input, state)?;
+            state.floor_exactness(Exactness::Strict);
             let dc = create_class(self.class.as_ref(py))?;
             self.set_dict_call(py, dc.as_ref(py), val_output, input)?;
             Ok(dc)
@@ -594,21 +586,9 @@ impl Validator for DataclassValidator {
         Ok(obj.to_object(py))
     }
 
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        if ultra_strict {
-            self.validator.different_strict_behavior(ultra_strict)
-        } else {
-            true
-        }
-    }
-
     fn get_name(&self) -> &str {
         &self.name
     }
-
-    fn complete(&self) -> PyResult<()> {
-        self.validator.complete()
-    }
 }
 
 impl DataclassValidator {
diff --git a/src/validators/date.rs b/src/validators/date.rs
index 3549f66f0..7c79101f4 100644
--- a/src/validators/date.rs
+++ b/src/validators/date.rs
@@ -11,6 +11,7 @@ use crate::input::{EitherDate, Input};
 use crate::tools::SchemaDict;
 use crate::validators::datetime::{NowConstraint, NowOp};
 
+use super::Exactness;
 use super::{BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
 
 #[derive(Debug, Clone)]
@@ -46,9 +47,12 @@ impl Validator for DateValidator {
     ) -> ValResult<'data, PyObject> {
         let strict = state.strict_or(self.strict);
         let date = match input.validate_date(strict) {
-            Ok(date) => date,
+            Ok(val_match) => val_match.unpack(state),
             // if the error was a parsing error, in lax mode we allow datetimes at midnight
-            Err(line_errors @ ValError::LineErrors(..)) if !strict => date_from_datetime(input)?.ok_or(line_errors)?,
+            Err(line_errors @ ValError::LineErrors(..)) if !strict => {
+                state.floor_exactness(Exactness::Lax);
+                date_from_datetime(input)?.ok_or(line_errors)?
+            }
             Err(otherwise) => return Err(otherwise),
         };
         if let Some(constraints) = &self.constraints {
@@ -96,17 +100,9 @@ impl Validator for DateValidator {
         Ok(date.try_into_py(py)?)
     }
 
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        !ultra_strict
-    }
-
     fn get_name(&self) -> &str {
         Self::EXPECTED_TYPE
     }
-
-    fn complete(&self) -> PyResult<()> {
-        Ok(())
-    }
 }
 
 /// In lax mode, if the input is not a date, we try parsing the input as a datetime, then check it is an
@@ -115,7 +111,7 @@ impl Validator for DateValidator {
 /// Ok(None) means that this is not relevant to dates (the input was not a datetime nor a string)
 fn date_from_datetime<'data>(input: &'data impl Input<'data>) -> Result<Option<EitherDate<'data>>, ValError<'data>> {
     let either_dt = match input.validate_datetime(false, speedate::MicrosecondsPrecisionOverflowBehavior::Truncate) {
-        Ok(dt) => dt,
+        Ok(val_match) => val_match.into_inner(),
         // if the error was a parsing error, update the error type from DatetimeParsing to DateFromDatetimeParsing
         // and return it
         Err(ValError::LineErrors(mut line_errors)) => {
diff --git a/src/validators/datetime.rs b/src/validators/datetime.rs
index 5f1fc8bef..edbd399e7 100644
--- a/src/validators/datetime.rs
+++ b/src/validators/datetime.rs
@@ -65,7 +65,9 @@ impl Validator for DateTimeValidator {
         state: &mut ValidationState,
     ) -> ValResult<'data, PyObject> {
         let strict = state.strict_or(self.strict);
-        let datetime = input.validate_datetime(strict, self.microseconds_precision)?;
+        let datetime = input
+            .validate_datetime(strict, self.microseconds_precision)?
+            .unpack(state);
         if let Some(constraints) = &self.constraints {
             // if we get an error from as_speedate, it's probably because the input datetime was invalid
             // specifically had an invalid tzinfo, hence here we return a validation error
@@ -125,17 +127,9 @@ impl Validator for DateTimeValidator {
         Ok(datetime.try_into_py(py)?)
     }
 
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        !ultra_strict
-    }
-
     fn get_name(&self) -> &str {
         Self::EXPECTED_TYPE
     }
-
-    fn complete(&self) -> PyResult<()> {
-        Ok(())
-    }
 }
 
 #[derive(Debug, Clone)]
diff --git a/src/validators/decimal.rs b/src/validators/decimal.rs
index eb3141c31..b9435f046 100644
--- a/src/validators/decimal.rs
+++ b/src/validators/decimal.rs
@@ -264,17 +264,9 @@ impl Validator for DecimalValidator {
         Ok(decimal.into())
     }
 
-    fn different_strict_behavior(&self, _ultra_strict: bool) -> bool {
-        true
-    }
-
     fn get_name(&self) -> &str {
         Self::EXPECTED_TYPE
     }
-
-    fn complete(&self) -> PyResult<()> {
-        Ok(())
-    }
 }
 
 pub(crate) fn create_decimal<'a>(
diff --git a/src/validators/definitions.rs b/src/validators/definitions.rs
index 16aea8cd4..979278bb9 100644
--- a/src/validators/definitions.rs
+++ b/src/validators/definitions.rs
@@ -1,7 +1,3 @@
-use std::cell::RefCell;
-
-use ahash::HashSet;
-use ahash::HashSetExt;
 use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList};
@@ -123,32 +119,7 @@ impl Validator for DefinitionRefValidator {
         }
     }
 
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        thread_local! {
-            static RECURSION_SET: RefCell<Option<HashSet<usize>>> = RefCell::new(None);
-        }
-
-        let id = self as *const _ as usize;
-        // have to unwrap here, because we can't return an error from this function, should be okay
-        let validator: &CombinedValidator = self.definition.get().unwrap();
-        if RECURSION_SET.with(
-            |set: &RefCell<Option<std::collections::HashSet<usize, ahash::RandomState>>>| {
-                set.borrow_mut().get_or_insert_with(HashSet::new).insert(id)
-            },
-        ) {
-            let different_strict_behavior = validator.different_strict_behavior(ultra_strict);
-            RECURSION_SET.with(|set| set.borrow_mut().get_or_insert_with(HashSet::new).remove(&id));
-            different_strict_behavior
-        } else {
-            false
-        }
-    }
-
     fn get_name(&self) -> &str {
         self.definition.get_or_init_name(|v| v.get_name().into())
     }
-
-    fn complete(&self) -> PyResult<()> {
-        Ok(())
-    }
 }
diff --git a/src/validators/dict.rs b/src/validators/dict.rs
index c7df345ed..3ac284b2a 100644
--- a/src/validators/dict.rs
+++ b/src/validators/dict.rs
@@ -80,6 +80,7 @@ impl Validator for DictValidator {
                 self.validate_generic_mapping(py, input, DictGenericIterator::new(py_dict)?, state)
             }
             GenericMapping::PyMapping(mapping) => {
+                state.floor_exactness(super::Exactness::Lax);
                 self.validate_generic_mapping(py, input, MappingGenericIterator::new(mapping)?, state)
             }
             GenericMapping::StringMapping(dict) => {
@@ -92,22 +93,9 @@ impl Validator for DictValidator {
         }
     }
 
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        if ultra_strict {
-            self.key_validator.different_strict_behavior(true) || self.value_validator.different_strict_behavior(true)
-        } else {
-            true
-        }
-    }
-
     fn get_name(&self) -> &str {
         &self.name
     }
-
-    fn complete(&self) -> PyResult<()> {
-        self.key_validator.complete()?;
-        self.value_validator.complete()
-    }
 }
 
 impl DictValidator {
diff --git a/src/validators/float.rs b/src/validators/float.rs
index 646d8f4d8..b72ffafc0 100644
--- a/src/validators/float.rs
+++ b/src/validators/float.rs
@@ -70,25 +70,16 @@ impl Validator for FloatValidator {
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
     ) -> ValResult<'data, PyObject> {
-        let strict = state.strict_or(self.strict);
-        let either_float = input.validate_float(strict, state.extra().ultra_strict)?;
+        let either_float = input.validate_float(state.strict_or(self.strict))?.unpack(state);
         if !self.allow_inf_nan && !either_float.as_f64().is_finite() {
             return Err(ValError::new(ErrorTypeDefaults::FiniteNumber, input));
         }
         Ok(either_float.into_py(py))
     }
 
-    fn different_strict_behavior(&self, _ultra_strict: bool) -> bool {
-        true
-    }
-
     fn get_name(&self) -> &str {
         Self::EXPECTED_TYPE
     }
-
-    fn complete(&self) -> PyResult<()> {
-        Ok(())
-    }
 }
 
 #[derive(Debug, Clone)]
@@ -111,8 +102,7 @@ impl Validator for ConstrainedFloatValidator {
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
     ) -> ValResult<'data, PyObject> {
-        let strict = state.strict_or(self.strict);
-        let either_float = input.validate_float(strict, state.extra().ultra_strict)?;
+        let either_float = input.validate_float(state.strict_or(self.strict))?.unpack(state);
         let float: f64 = either_float.as_f64();
         if !self.allow_inf_nan && !float.is_finite() {
             return Err(ValError::new(ErrorTypeDefaults::FiniteNumber, input));
@@ -177,17 +167,9 @@ impl Validator for ConstrainedFloatValidator {
         Ok(either_float.into_py(py))
     }
 
-    fn different_strict_behavior(&self, _ultra_strict: bool) -> bool {
-        true
-    }
-
     fn get_name(&self) -> &str {
         "constrained-float"
     }
-
-    fn complete(&self) -> PyResult<()> {
-        Ok(())
-    }
 }
 
 impl BuildValidator for ConstrainedFloatValidator {
diff --git a/src/validators/frozenset.rs b/src/validators/frozenset.rs
index 4b4cdcb6f..190a8672d 100644
--- a/src/validators/frozenset.rs
+++ b/src/validators/frozenset.rs
@@ -2,8 +2,9 @@ use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyFrozenSet};
 
 use crate::errors::ValResult;
-use crate::input::Input;
+use crate::input::{GenericIterable, Input};
 use crate::tools::SchemaDict;
+use crate::validators::Exactness;
 
 use super::list::min_length_check;
 use super::set::set_build;
@@ -34,6 +35,12 @@ impl Validator for FrozenSetValidator {
         state: &mut ValidationState,
     ) -> ValResult<'data, PyObject> {
         let collection = input.validate_frozenset(state.strict_or(self.strict))?;
+        let exactness = match &collection {
+            GenericIterable::FrozenSet(_) => Exactness::Exact,
+            GenericIterable::Set(_) | GenericIterable::JsonArray(_) => Exactness::Strict,
+            _ => Exactness::Lax,
+        };
+        state.floor_exactness(exactness);
         let f_set = PyFrozenSet::empty(py)?;
         collection.validate_to_set(
             py,
@@ -48,19 +55,7 @@ impl Validator for FrozenSetValidator {
         Ok(f_set.into_py(py))
     }
 
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        if ultra_strict {
-            self.item_validator.different_strict_behavior(true)
-        } else {
-            true
-        }
-    }
-
     fn get_name(&self) -> &str {
         &self.name
     }
-
-    fn complete(&self) -> PyResult<()> {
-        self.item_validator.complete()
-    }
 }
diff --git a/src/validators/function.rs b/src/validators/function.rs
index 66bbafbb9..4c5ad9c29 100644
--- a/src/validators/function.rs
+++ b/src/validators/function.rs
@@ -113,21 +113,9 @@ macro_rules! impl_validator {
                 self._validate(validate, py, obj, state)
             }
 
-            fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-                if ultra_strict {
-                    self.validator.different_strict_behavior(ultra_strict)
-                } else {
-                    true
-                }
-            }
-
             fn get_name(&self) -> &str {
                 &self.name
             }
-
-            fn complete(&self) -> PyResult<()> {
-                self.validator.complete()
-            }
         }
     };
 }
@@ -252,18 +240,9 @@ impl Validator for FunctionPlainValidator {
         r.map_err(|e| convert_err(py, e, input))
     }
 
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        // best guess, should we change this?
-        !ultra_strict
-    }
-
     fn get_name(&self) -> &str {
         &self.name
     }
-
-    fn complete(&self) -> PyResult<()> {
-        Ok(())
-    }
 }
 
 #[derive(Debug)]
@@ -349,12 +328,10 @@ impl Validator for FunctionWrapValidator {
                 self.validation_error_cause,
             ),
         };
-        self._validate(
-            Py::new(py, handler)?.into_ref(py),
-            py,
-            input.to_object(py).into_ref(py),
-            state,
-        )
+        let handler = Py::new(py, handler)?.into_ref(py);
+        let result = self._validate(handler, py, input.to_object(py).into_ref(py), state);
+        state.exactness = handler.borrow_mut().validator.exactness;
+        result
     }
 
     fn validate_assignment<'data>(
@@ -380,21 +357,9 @@ impl Validator for FunctionWrapValidator {
         self._validate(Py::new(py, handler)?.into_ref(py), py, obj, state)
     }
 
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        if ultra_strict {
-            self.validator.different_strict_behavior(ultra_strict)
-        } else {
-            true
-        }
-    }
-
     fn get_name(&self) -> &str {
         &self.name
     }
-
-    fn complete(&self) -> PyResult<()> {
-        self.validator.complete()
-    }
 }
 
 #[pyclass(module = "pydantic_core._pydantic_core")]
diff --git a/src/validators/generator.rs b/src/validators/generator.rs
index 111b5c101..94497d228 100644
--- a/src/validators/generator.rs
+++ b/src/validators/generator.rs
@@ -11,7 +11,9 @@ use crate::tools::SchemaDict;
 use crate::ValidationError;
 
 use super::list::get_items_schema;
-use super::{BuildValidator, CombinedValidator, DefinitionsBuilder, Extra, InputType, ValidationState, Validator};
+use super::{
+    BuildValidator, CombinedValidator, DefinitionsBuilder, Exactness, Extra, InputType, ValidationState, Validator,
+};
 
 #[derive(Debug, Clone)]
 pub struct GeneratorValidator {
@@ -86,24 +88,9 @@ impl Validator for GeneratorValidator {
         Ok(v_iterator.into_py(py))
     }
 
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        if let Some(ref v) = self.item_validator {
-            v.different_strict_behavior(ultra_strict)
-        } else {
-            false
-        }
-    }
-
     fn get_name(&self) -> &str {
         &self.name
     }
-
-    fn complete(&self) -> PyResult<()> {
-        match &self.item_validator {
-            Some(v) => v.complete(),
-            None => Ok(()),
-        }
-    }
 }
 
 #[pyclass(module = "pydantic_core._pydantic_core")]
@@ -226,6 +213,7 @@ pub struct InternalValidator {
     context: Option<PyObject>,
     self_instance: Option<PyObject>,
     recursion_guard: RecursionGuard,
+    pub(crate) exactness: Option<Exactness>,
     validation_mode: InputType,
     hide_input_in_errors: bool,
     validation_error_cause: bool,
@@ -256,6 +244,7 @@ impl InternalValidator {
             context: extra.context.map(|d| d.into_py(py)),
             self_instance: extra.self_instance.map(|d| d.into_py(py)),
             recursion_guard: state.recursion_guard.clone(),
+            exactness: state.exactness,
             validation_mode: extra.input_type,
             hide_input_in_errors,
             validation_error_cause,
@@ -274,13 +263,14 @@ impl InternalValidator {
             input_type: self.validation_mode,
             data: self.data.as_ref().map(|data| data.as_ref(py)),
             strict: self.strict,
-            ultra_strict: false,
             from_attributes: self.from_attributes,
             context: self.context.as_ref().map(|data| data.as_ref(py)),
             self_instance: self.self_instance.as_ref().map(|data| data.as_ref(py)),
         };
         let mut state = ValidationState::new(extra, &mut self.recursion_guard);
-        self.validator
+        state.exactness = self.exactness;
+        let result = self
+            .validator
             .validate_assignment(py, model, field_name, field_value, &mut state)
             .map_err(|e| {
                 ValidationError::from_val_error(
@@ -292,7 +282,9 @@ impl InternalValidator {
                     self.hide_input_in_errors,
                     self.validation_error_cause,
                 )
-            })
+            });
+        self.exactness = state.exactness;
+        result
     }
 
     pub fn validate<'data>(
@@ -305,13 +297,13 @@ impl InternalValidator {
             input_type: self.validation_mode,
             data: self.data.as_ref().map(|data| data.as_ref(py)),
             strict: self.strict,
-            ultra_strict: false,
             from_attributes: self.from_attributes,
             context: self.context.as_ref().map(|data| data.as_ref(py)),
             self_instance: self.self_instance.as_ref().map(|data| data.as_ref(py)),
         };
         let mut state = ValidationState::new(extra, &mut self.recursion_guard);
-        self.validator.validate(py, input, &mut state).map_err(|e| {
+        state.exactness = self.exactness;
+        let result = self.validator.validate(py, input, &mut state).map_err(|e| {
             ValidationError::from_val_error(
                 py,
                 self.name.to_object(py),
@@ -321,7 +313,9 @@ impl InternalValidator {
                 self.hide_input_in_errors,
                 self.validation_error_cause,
             )
-        })
+        });
+        self.exactness = state.exactness;
+        result
     }
 }
 
diff --git a/src/validators/int.rs b/src/validators/int.rs
index 1a807d1ef..dabfb5115 100644
--- a/src/validators/int.rs
+++ b/src/validators/int.rs
@@ -8,8 +8,7 @@ use crate::errors::{ErrorType, ValError, ValResult};
 use crate::input::{Input, Int};
 use crate::tools::SchemaDict;
 
-use super::ValidationState;
-use super::{BuildValidator, CombinedValidator, DefinitionsBuilder, Validator};
+use super::{BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
 
 #[derive(Debug, Clone)]
 pub struct IntValidator {
@@ -50,21 +49,14 @@ impl Validator for IntValidator {
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
     ) -> ValResult<'data, PyObject> {
-        let either_int = input.validate_int(state.strict_or(self.strict))?;
-        Ok(either_int.into_py(py))
-    }
-
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        !ultra_strict
+        input
+            .validate_int(state.strict_or(self.strict))
+            .map(|val_match| val_match.unpack(state).into_py(py))
     }
 
     fn get_name(&self) -> &str {
         Self::EXPECTED_TYPE
     }
-
-    fn complete(&self) -> PyResult<()> {
-        Ok(())
-    }
 }
 
 #[derive(Debug, Clone)]
@@ -86,7 +78,7 @@ impl Validator for ConstrainedIntValidator {
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
     ) -> ValResult<'data, PyObject> {
-        let either_int = input.validate_int(state.strict_or(self.strict))?;
+        let either_int = input.validate_int(state.strict_or(self.strict))?.unpack(state);
         let int_value = either_int.as_int()?;
 
         if let Some(ref multiple_of) = self.multiple_of {
@@ -147,17 +139,9 @@ impl Validator for ConstrainedIntValidator {
         Ok(either_int.into_py(py))
     }
 
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        !ultra_strict
-    }
-
     fn get_name(&self) -> &str {
         "constrained-int"
     }
-
-    fn complete(&self) -> PyResult<()> {
-        Ok(())
-    }
 }
 
 impl ConstrainedIntValidator {
diff --git a/src/validators/is_instance.rs b/src/validators/is_instance.rs
index e64d0717c..189589d6a 100644
--- a/src/validators/is_instance.rs
+++ b/src/validators/is_instance.rs
@@ -8,8 +8,7 @@ use crate::errors::{ErrorType, ValError, ValResult};
 use crate::input::Input;
 use crate::tools::SchemaDict;
 
-use super::ValidationState;
-use super::{BuildValidator, CombinedValidator, DefinitionsBuilder, Validator};
+use super::{BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
 
 #[derive(Debug, Clone)]
 pub struct IsInstanceValidator {
@@ -83,15 +82,7 @@ impl Validator for IsInstanceValidator {
         }
     }
 
-    fn different_strict_behavior(&self, _ultra_strict: bool) -> bool {
-        false
-    }
-
     fn get_name(&self) -> &str {
         &self.name
     }
-
-    fn complete(&self) -> PyResult<()> {
-        Ok(())
-    }
 }
diff --git a/src/validators/is_subclass.rs b/src/validators/is_subclass.rs
index 0866fa1e7..7a89ef36c 100644
--- a/src/validators/is_subclass.rs
+++ b/src/validators/is_subclass.rs
@@ -6,8 +6,7 @@ use crate::errors::{ErrorType, ValError, ValResult};
 use crate::input::Input;
 use crate::tools::SchemaDict;
 
-use super::ValidationState;
-use super::{BuildValidator, CombinedValidator, DefinitionsBuilder, Validator};
+use super::{BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
 
 #[derive(Debug, Clone)]
 pub struct IsSubclassValidator {
@@ -62,15 +61,7 @@ impl Validator for IsSubclassValidator {
         }
     }
 
-    fn different_strict_behavior(&self, _ultra_strict: bool) -> bool {
-        false
-    }
-
     fn get_name(&self) -> &str {
         &self.name
     }
-
-    fn complete(&self) -> PyResult<()> {
-        Ok(())
-    }
 }
diff --git a/src/validators/json.rs b/src/validators/json.rs
index fd832f874..9dfb5fae2 100644
--- a/src/validators/json.rs
+++ b/src/validators/json.rs
@@ -6,8 +6,7 @@ use crate::errors::ValResult;
 use crate::input::Input;
 use crate::tools::SchemaDict;
 
-use super::ValidationState;
-use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, Validator};
+use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
 
 #[derive(Debug)]
 pub struct JsonValidator {
@@ -61,22 +60,7 @@ impl Validator for JsonValidator {
         }
     }
 
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        if let Some(ref v) = self.validator {
-            v.different_strict_behavior(ultra_strict)
-        } else {
-            false
-        }
-    }
-
     fn get_name(&self) -> &str {
         &self.name
     }
-
-    fn complete(&self) -> PyResult<()> {
-        match &self.validator {
-            Some(v) => v.complete(),
-            None => Ok(()),
-        }
-    }
 }
diff --git a/src/validators/json_or_python.rs b/src/validators/json_or_python.rs
index cd952bed1..302cbdaf6 100644
--- a/src/validators/json_or_python.rs
+++ b/src/validators/json_or_python.rs
@@ -7,9 +7,7 @@ use crate::errors::ValResult;
 use crate::input::Input;
 use crate::tools::SchemaDict;
 
-use super::InputType;
-use super::ValidationState;
-use super::{build_validator, BuildValidator, CombinedValidator, Validator};
+use super::{build_validator, BuildValidator, CombinedValidator, InputType, ValidationState, Validator};
 
 #[derive(Debug)]
 pub struct JsonOrPython {
@@ -63,16 +61,7 @@ impl Validator for JsonOrPython {
         }
     }
 
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        self.json.different_strict_behavior(ultra_strict) || self.python.different_strict_behavior(ultra_strict)
-    }
-
     fn get_name(&self) -> &str {
         &self.name
     }
-
-    fn complete(&self) -> PyResult<()> {
-        self.json.complete()?;
-        self.python.complete()
-    }
 }
diff --git a/src/validators/lax_or_strict.rs b/src/validators/lax_or_strict.rs
index b5cec61be..78021cd4c 100644
--- a/src/validators/lax_or_strict.rs
+++ b/src/validators/lax_or_strict.rs
@@ -7,6 +7,7 @@ use crate::errors::ValResult;
 use crate::input::Input;
 use crate::tools::SchemaDict;
 
+use super::Exactness;
 use super::ValidationState;
 use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, Validator};
 
@@ -64,24 +65,20 @@ impl Validator for LaxOrStrictValidator {
         if state.strict_or(self.strict) {
             self.strict_validator.validate(py, input, state)
         } else {
+            // horrible edge case: if doing smart union validation, we need to try the strict validator
+            // anyway and prefer that if it succeeds
+            if state.exactness.is_some() {
+                if let Ok(strict_result) = self.strict_validator.validate(py, input, state) {
+                    return Ok(strict_result);
+                }
+                // this is now known to be not strict
+                state.floor_exactness(Exactness::Lax);
+            }
             self.lax_validator.validate(py, input, state)
         }
     }
 
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        if ultra_strict {
-            self.strict_validator.different_strict_behavior(true)
-        } else {
-            true
-        }
-    }
-
     fn get_name(&self) -> &str {
         &self.name
     }
-
-    fn complete(&self) -> PyResult<()> {
-        self.lax_validator.complete()?;
-        self.strict_validator.complete()
-    }
 }
diff --git a/src/validators/list.rs b/src/validators/list.rs
index c0af5fcb5..b2e0ff116 100644
--- a/src/validators/list.rs
+++ b/src/validators/list.rs
@@ -6,6 +6,7 @@ use pyo3::types::PyDict;
 use crate::errors::ValResult;
 use crate::input::{GenericIterable, Input};
 use crate::tools::SchemaDict;
+use crate::validators::Exactness;
 
 use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
 
@@ -122,6 +123,12 @@ impl Validator for ListValidator {
         state: &mut ValidationState,
     ) -> ValResult<'data, PyObject> {
         let seq = input.validate_list(state.strict_or(self.strict))?;
+        let exactness = match &seq {
+            GenericIterable::List(_) | GenericIterable::JsonArray(_) => Exactness::Exact,
+            GenericIterable::Tuple(_) => Exactness::Strict,
+            _ => Exactness::Lax,
+        };
+        state.floor_exactness(exactness);
 
         let output = match self.item_validator {
             Some(ref v) => seq.validate_to_vec(py, input, self.max_length, "List", v, state)?,
@@ -138,17 +145,6 @@ impl Validator for ListValidator {
         Ok(output.into_py(py))
     }
 
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        if ultra_strict {
-            match self.item_validator {
-                Some(ref v) => v.different_strict_behavior(true),
-                None => false,
-            }
-        } else {
-            true
-        }
-    }
-
     fn get_name(&self) -> &str {
         // The logic here is a little janky, it's done to try to cache the formatted name
         // while also trying to render definitions correctly when possible.
@@ -167,11 +163,4 @@ impl Validator for ListValidator {
             }
         }
     }
-
-    fn complete(&self) -> PyResult<()> {
-        if let Some(v) = &self.item_validator {
-            v.complete()?;
-        }
-        Ok(())
-    }
 }
diff --git a/src/validators/literal.rs b/src/validators/literal.rs
index 19bbe91f5..c9a846695 100644
--- a/src/validators/literal.rs
+++ b/src/validators/literal.rs
@@ -48,8 +48,8 @@ impl<T: Debug> LiteralLookup<T> {
         for (k, v) in expected {
             let id = values.len();
             values.push(v);
-            if let Ok(bool) = k.strict_bool() {
-                if bool {
+            if let Ok(bool) = k.validate_bool(true) {
+                if bool.into_inner() {
                     expected_bool.true_id = Some(id);
                 } else {
                     expected_bool.false_id = Some(id);
@@ -97,8 +97,8 @@ impl<T: Debug> LiteralLookup<T> {
         input: &'data I,
     ) -> ValResult<'data, Option<(&'data I, &T)>> {
         if let Some(expected_bool) = &self.expected_bool {
-            if let Ok(bool_value) = input.strict_bool() {
-                if bool_value {
+            if let Ok(bool_value) = input.validate_bool(true) {
+                if bool_value.into_inner() {
                     if let Some(true_value) = &expected_bool.true_id {
                         return Ok(Some((input, &self.values[*true_value])));
                     }
@@ -198,17 +198,9 @@ impl Validator for LiteralValidator {
         }
     }
 
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        !ultra_strict
-    }
-
     fn get_name(&self) -> &str {
         &self.name
     }
-
-    fn complete(&self) -> PyResult<()> {
-        Ok(())
-    }
 }
 
 pub fn expected_repr_name(mut repr_args: Vec<String>, base_name: &'static str) -> (String, String) {
diff --git a/src/validators/mod.rs b/src/validators/mod.rs
index 2a4cbf165..f541ea45d 100644
--- a/src/validators/mod.rs
+++ b/src/validators/mod.rs
@@ -58,10 +58,9 @@ mod uuid;
 mod validation_state;
 mod with_default;
 
+pub use self::validation_state::{Exactness, ValidationState};
 pub use with_default::DefaultType;
 
-pub use self::validation_state::ValidationState;
-
 #[pyclass(module = "pydantic_core._pydantic_core", name = "Some")]
 pub struct PySome {
     #[pyo3(get)]
@@ -120,10 +119,6 @@ impl SchemaValidator {
 
         let validator = build_validator(schema, config, &mut definitions_builder)?;
         let definitions = definitions_builder.finish()?;
-        validator.complete()?;
-        for val in definitions.values() {
-            val.get().unwrap().complete()?;
-        }
         let py_schema = schema.into_py(py);
         let py_config = match config {
             Some(c) if !c.is_empty() => Some(c.into_py(py)),
@@ -271,7 +266,6 @@ impl SchemaValidator {
             data: None,
             strict,
             from_attributes,
-            ultra_strict: false,
             context,
             self_instance: None,
         };
@@ -290,7 +284,6 @@ impl SchemaValidator {
             data: None,
             strict,
             from_attributes: None,
-            ultra_strict: false,
             context,
             self_instance: None,
         };
@@ -402,10 +395,6 @@ impl<'py> SelfValidator<'py> {
             Err(err) => return py_schema_err!("Error building self-schema:\n  {}", err),
         };
         let definitions = definitions_builder.finish()?;
-        validator.complete()?;
-        for val in definitions.values() {
-            val.get().unwrap().complete()?;
-        }
         Ok(SchemaValidator {
             validator,
             definitions,
@@ -569,8 +558,6 @@ pub struct Extra<'a> {
     pub data: Option<&'a PyDict>,
     /// whether we're in strict or lax mode
     pub strict: Option<bool>,
-    /// whether we're in ultra-strict mode, only used occasionally in unions
-    pub ultra_strict: bool,
     /// Validation time setting of `from_attributes`
     pub from_attributes: Option<bool>,
     /// context used in validator functions
@@ -591,7 +578,6 @@ impl<'a> Extra<'a> {
             input_type,
             data: None,
             strict,
-            ultra_strict: false,
             from_attributes,
             context,
             self_instance,
@@ -600,12 +586,11 @@ impl<'a> Extra<'a> {
 }
 
 impl<'a> Extra<'a> {
-    pub fn as_strict(&self, ultra_strict: bool) -> Self {
+    pub fn as_strict(&self) -> Self {
         Self {
             input_type: self.input_type,
             data: self.data,
             strict: Some(true),
-            ultra_strict,
             from_attributes: self.from_attributes,
             context: self.context,
             self_instance: self.self_instance,
@@ -742,15 +727,7 @@ pub trait Validator: Send + Sync + Debug {
         Err(py_err.into())
     }
 
-    /// whether the validator behaves differently in strict mode, and in ultra strict mode
-    /// implementations should return true if any of their sub-validators return true
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool;
-
     /// `get_name` generally returns `Self::EXPECTED_TYPE` or some other clear identifier of the validator
     /// this is used in the error location in unions, and in the top level message in `ValidationError`
     fn get_name(&self) -> &str;
-
-    /// this method must be implemented for any validator which holds references to other validators,
-    /// it is used by `UnionValidator` to calculate strictness
-    fn complete(&self) -> PyResult<()>;
 }
diff --git a/src/validators/model.rs b/src/validators/model.rs
index 1459f56f5..0299ce5d8 100644
--- a/src/validators/model.rs
+++ b/src/validators/model.rs
@@ -7,6 +7,7 @@ use pyo3::types::{PyDict, PySet, PyString, PyTuple, PyType};
 use pyo3::{ffi, intern};
 
 use super::function::convert_err;
+use super::validation_state::Exactness;
 use super::{
     build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, Extra, ValidationState, Validator,
 };
@@ -143,6 +144,8 @@ impl Validator for ModelValidator {
                 Ok(input.to_object(py))
             }
         } else {
+            // Having to construct a new model is not an exact match
+            state.floor_exactness(Exactness::Strict);
             self.validate_construct(py, input, None, state)
         }
     }
@@ -206,21 +209,9 @@ impl Validator for ModelValidator {
         Ok(model.into_py(py))
     }
 
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        if ultra_strict {
-            self.validator.different_strict_behavior(ultra_strict)
-        } else {
-            true
-        }
-    }
-
     fn get_name(&self) -> &str {
         &self.name
     }
-
-    fn complete(&self) -> PyResult<()> {
-        self.validator.complete()
-    }
 }
 
 impl ModelValidator {
diff --git a/src/validators/model_fields.rs b/src/validators/model_fields.rs
index 17ec81670..a284bd4e9 100644
--- a/src/validators/model_fields.rs
+++ b/src/validators/model_fields.rs
@@ -10,13 +10,14 @@ use crate::build_tools::{is_strict, schema_or_config_same, ExtraBehavior};
 use crate::errors::{AsLocItem, ErrorType, ErrorTypeDefaults, ValError, ValLineError, ValResult};
 use crate::input::{
     AttributesGenericIterator, BorrowInput, DictGenericIterator, GenericMapping, Input, JsonObjectGenericIterator,
-    MappingGenericIterator, StringMappingGenericIterator,
+    MappingGenericIterator, StringMappingGenericIterator, ValidationMatch,
 };
 use crate::lookup_key::LookupKey;
 use crate::tools::SchemaDict;
 
-use super::ValidationState;
-use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, Extra, Validator};
+use super::{
+    build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, Extra, ValidationState, Validator,
+};
 
 use std::ops::ControlFlow;
 
@@ -250,7 +251,7 @@ impl Validator for ModelFieldsValidator {
                     let model_extra_dict = PyDict::new(py);
                     for item_result in <$iter>::new($dict)? {
                         let (raw_key, value) = item_result?;
-                        let either_str = match raw_key.strict_str() {
+                        let either_str = match raw_key.validate_str(true, false).map(ValidationMatch::into_inner) {
                             Ok(k) => k,
                             Err(ValError::LineErrors(line_errors)) => {
                                 for err in line_errors {
@@ -433,21 +434,7 @@ impl Validator for ModelFieldsValidator {
         Ok((new_data.to_object(py), new_extra, fields_set.to_object(py)).to_object(py))
     }
 
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        self.fields
-            .iter()
-            .any(|f| f.validator.different_strict_behavior(ultra_strict))
-    }
-
     fn get_name(&self) -> &str {
         Self::EXPECTED_TYPE
     }
-
-    fn complete(&self) -> PyResult<()> {
-        self.fields.iter().try_for_each(|f| f.validator.complete())?;
-        match &self.extras_validator {
-            Some(v) => v.complete(),
-            None => Ok(()),
-        }
-    }
 }
diff --git a/src/validators/none.rs b/src/validators/none.rs
index f241be9d8..f6891292b 100644
--- a/src/validators/none.rs
+++ b/src/validators/none.rs
@@ -36,15 +36,7 @@ impl Validator for NoneValidator {
         }
     }
 
-    fn different_strict_behavior(&self, _ultra_strict: bool) -> bool {
-        false
-    }
-
     fn get_name(&self) -> &str {
         Self::EXPECTED_TYPE
     }
-
-    fn complete(&self) -> PyResult<()> {
-        Ok(())
-    }
 }
diff --git a/src/validators/nullable.rs b/src/validators/nullable.rs
index 7f4cf19fc..85fbd6c26 100644
--- a/src/validators/nullable.rs
+++ b/src/validators/nullable.rs
@@ -45,15 +45,7 @@ impl Validator for NullableValidator {
         }
     }
 
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        self.validator.different_strict_behavior(ultra_strict)
-    }
-
     fn get_name(&self) -> &str {
         &self.name
     }
-
-    fn complete(&self) -> PyResult<()> {
-        self.validator.complete()
-    }
 }
diff --git a/src/validators/set.rs b/src/validators/set.rs
index 9270ea204..d29c60c3f 100644
--- a/src/validators/set.rs
+++ b/src/validators/set.rs
@@ -2,8 +2,9 @@ use pyo3::prelude::*;
 use pyo3::types::{PyDict, PySet};
 
 use crate::errors::ValResult;
-use crate::input::Input;
+use crate::input::{GenericIterable, Input};
 use crate::tools::SchemaDict;
+use crate::validators::Exactness;
 
 use super::list::min_length_check;
 use super::{BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
@@ -64,25 +65,19 @@ impl Validator for SetValidator {
         state: &mut ValidationState,
     ) -> ValResult<'data, PyObject> {
         let collection = input.validate_set(state.strict_or(self.strict))?;
+        let exactness = match &collection {
+            GenericIterable::Set(_) => Exactness::Exact,
+            GenericIterable::FrozenSet(_) | GenericIterable::JsonArray(_) => Exactness::Strict,
+            _ => Exactness::Lax,
+        };
+        state.floor_exactness(exactness);
         let set = PySet::empty(py)?;
         collection.validate_to_set(py, set, input, self.max_length, "Set", &self.item_validator, state)?;
         min_length_check!(input, "Set", self.min_length, set);
         Ok(set.into_py(py))
     }
 
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        if ultra_strict {
-            self.item_validator.different_strict_behavior(true)
-        } else {
-            true
-        }
-    }
-
     fn get_name(&self) -> &str {
         &self.name
     }
-
-    fn complete(&self) -> PyResult<()> {
-        self.item_validator.complete()
-    }
 }
diff --git a/src/validators/string.rs b/src/validators/string.rs
index 0be51ece8..98d8a9d99 100644
--- a/src/validators/string.rs
+++ b/src/validators/string.rs
@@ -47,21 +47,14 @@ impl Validator for StrValidator {
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
     ) -> ValResult<'data, PyObject> {
-        let either_str = input.validate_str(state.strict_or(self.strict), self.coerce_numbers_to_str)?;
-        Ok(either_str.into_py(py))
-    }
-
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        !ultra_strict
+        input
+            .validate_str(state.strict_or(self.strict), self.coerce_numbers_to_str)
+            .map(|val_match| val_match.unpack(state).into_py(py))
     }
 
     fn get_name(&self) -> &str {
         Self::EXPECTED_TYPE
     }
-
-    fn complete(&self) -> PyResult<()> {
-        Ok(())
-    }
 }
 
 /// Any new properties set here must be reflected in `has_constraints_set`
@@ -86,7 +79,9 @@ impl Validator for StrConstrainedValidator {
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
     ) -> ValResult<'data, PyObject> {
-        let either_str = input.validate_str(state.strict_or(self.strict), self.coerce_numbers_to_str)?;
+        let either_str = input
+            .validate_str(state.strict_or(self.strict), self.coerce_numbers_to_str)?
+            .unpack(state);
         let cow = either_str.as_cow()?;
         let mut str = cow.as_ref();
         if self.strip_whitespace {
@@ -146,17 +141,9 @@ impl Validator for StrConstrainedValidator {
         Ok(py_string.into_py(py))
     }
 
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        !ultra_strict
-    }
-
     fn get_name(&self) -> &str {
         "constrained-str"
     }
-
-    fn complete(&self) -> PyResult<()> {
-        Ok(())
-    }
 }
 
 impl StrConstrainedValidator {
diff --git a/src/validators/time.rs b/src/validators/time.rs
index f5e2be7c7..abf82091f 100644
--- a/src/validators/time.rs
+++ b/src/validators/time.rs
@@ -46,7 +46,9 @@ impl Validator for TimeValidator {
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
     ) -> ValResult<'data, PyObject> {
-        let time = input.validate_time(state.strict_or(self.strict), self.microseconds_precision)?;
+        let time = input
+            .validate_time(state.strict_or(self.strict), self.microseconds_precision)?
+            .unpack(state);
         if let Some(constraints) = &self.constraints {
             let raw_time = time.as_raw()?;
 
@@ -78,17 +80,9 @@ impl Validator for TimeValidator {
         Ok(time.try_into_py(py)?)
     }
 
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        !ultra_strict
-    }
-
     fn get_name(&self) -> &str {
         Self::EXPECTED_TYPE
     }
-
-    fn complete(&self) -> PyResult<()> {
-        Ok(())
-    }
 }
 
 fn convert_pytime(schema: &PyDict, field: &PyString) -> PyResult<Option<Time>> {
diff --git a/src/validators/timedelta.rs b/src/validators/timedelta.rs
index a58d98f7a..f04fef91c 100644
--- a/src/validators/timedelta.rs
+++ b/src/validators/timedelta.rs
@@ -71,7 +71,9 @@ impl Validator for TimeDeltaValidator {
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
     ) -> ValResult<'data, PyObject> {
-        let timedelta = input.validate_timedelta(state.strict_or(self.strict), self.microseconds_precision)?;
+        let timedelta = input
+            .validate_timedelta(state.strict_or(self.strict), self.microseconds_precision)?
+            .unpack(state);
         let py_timedelta = timedelta.try_into_py(py)?;
         if let Some(constraints) = &self.constraints {
             let raw_timedelta = timedelta.to_duration()?;
@@ -101,17 +103,9 @@ impl Validator for TimeDeltaValidator {
         Ok(py_timedelta.into())
     }
 
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        !ultra_strict
-    }
-
     fn get_name(&self) -> &str {
         Self::EXPECTED_TYPE
     }
-
-    fn complete(&self) -> PyResult<()> {
-        Ok(())
-    }
 }
 fn pydelta_to_human_readable(py_delta: &PyDelta) -> String {
     let total_seconds = py_delta.get_seconds();
diff --git a/src/validators/tuple.rs b/src/validators/tuple.rs
index 1b7cf9b00..9513582e5 100644
--- a/src/validators/tuple.rs
+++ b/src/validators/tuple.rs
@@ -6,6 +6,7 @@ use crate::build_tools::is_strict;
 use crate::errors::{ErrorType, ErrorTypeDefaults, ValError, ValLineError, ValResult};
 use crate::input::{GenericIterable, Input};
 use crate::tools::SchemaDict;
+use crate::validators::Exactness;
 
 use super::list::{get_items_schema, min_length_check};
 use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
@@ -51,6 +52,12 @@ impl Validator for TupleVariableValidator {
         state: &mut ValidationState,
     ) -> ValResult<'data, PyObject> {
         let seq = input.validate_tuple(state.strict_or(self.strict))?;
+        let exactness = match &seq {
+            GenericIterable::Tuple(_) | GenericIterable::JsonArray(_) => Exactness::Exact,
+            GenericIterable::List(_) => Exactness::Strict,
+            _ => Exactness::Lax,
+        };
+        state.floor_exactness(exactness);
 
         let output = match self.item_validator {
             Some(ref v) => seq.validate_to_vec(py, input, self.max_length, "Tuple", v, state)?,
@@ -60,27 +67,9 @@ impl Validator for TupleVariableValidator {
         Ok(PyTuple::new(py, &output).into_py(py))
     }
 
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        if ultra_strict {
-            match self.item_validator {
-                Some(ref v) => v.different_strict_behavior(true),
-                None => false,
-            }
-        } else {
-            true
-        }
-    }
-
     fn get_name(&self) -> &str {
         &self.name
     }
-
-    fn complete(&self) -> PyResult<()> {
-        match &self.item_validator {
-            Some(v) => v.complete(),
-            None => Ok(()),
-        }
-    }
 }
 
 #[derive(Debug)]
@@ -199,6 +188,13 @@ impl Validator for TuplePositionalValidator {
         state: &mut ValidationState,
     ) -> ValResult<'data, PyObject> {
         let collection = input.validate_tuple(state.strict_or(self.strict))?;
+        let exactness: crate::validators::Exactness = match &collection {
+            GenericIterable::Tuple(_) | GenericIterable::JsonArray(_) => Exactness::Exact,
+            GenericIterable::List(_) => Exactness::Strict,
+            _ => Exactness::Lax,
+        };
+        state.floor_exactness(exactness);
+
         let actual_length = collection.generic_len();
         let expected_length = if self.extras_validator.is_some() {
             actual_length.unwrap_or(self.items_validators.len())
@@ -238,29 +234,7 @@ impl Validator for TuplePositionalValidator {
         }
     }
 
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        if ultra_strict {
-            if self.items_validators.iter().any(|v| v.different_strict_behavior(true)) {
-                true
-            } else if let Some(ref v) = self.extras_validator {
-                v.different_strict_behavior(true)
-            } else {
-                false
-            }
-        } else {
-            true
-        }
-    }
-
     fn get_name(&self) -> &str {
         &self.name
     }
-
-    fn complete(&self) -> PyResult<()> {
-        self.items_validators.iter().try_for_each(CombinedValidator::complete)?;
-        match &self.extras_validator {
-            Some(v) => v.complete(),
-            None => Ok(()),
-        }
-    }
 }
diff --git a/src/validators/typed_dict.rs b/src/validators/typed_dict.rs
index 5839959e7..f55b7d717 100644
--- a/src/validators/typed_dict.rs
+++ b/src/validators/typed_dict.rs
@@ -11,7 +11,7 @@ use crate::build_tools::{is_strict, schema_or_config, schema_or_config_same, Ext
 use crate::errors::{AsLocItem, ErrorTypeDefaults, ValError, ValLineError, ValResult};
 use crate::input::{
     AttributesGenericIterator, BorrowInput, DictGenericIterator, GenericMapping, Input, JsonObjectGenericIterator,
-    MappingGenericIterator, StringMappingGenericIterator,
+    MappingGenericIterator, StringMappingGenericIterator, ValidationMatch,
 };
 use crate::lookup_key::LookupKey;
 use crate::tools::SchemaDict;
@@ -252,7 +252,7 @@ impl Validator for TypedDictValidator {
                 if let Some(ref mut used_keys) = used_keys {
                     for item_result in <$iter>::new($dict)? {
                         let (raw_key, value) = item_result?;
-                        let either_str = match raw_key.strict_str() {
+                        let either_str = match raw_key.validate_str(true, false).map(ValidationMatch::into_inner) {
                             Ok(k) => k,
                             Err(ValError::LineErrors(line_errors)) => {
                                 for err in line_errors {
@@ -327,21 +327,7 @@ impl Validator for TypedDictValidator {
         }
     }
 
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        self.fields
-            .iter()
-            .any(|f| f.validator.different_strict_behavior(ultra_strict))
-    }
-
     fn get_name(&self) -> &str {
         Self::EXPECTED_TYPE
     }
-
-    fn complete(&self) -> PyResult<()> {
-        self.fields.iter().try_for_each(|f| f.validator.complete())?;
-        match &self.extras_validator {
-            Some(v) => v.complete(),
-            None => Ok(()),
-        }
-    }
 }
diff --git a/src/validators/union.rs b/src/validators/union.rs
index 837114408..0f8fded07 100644
--- a/src/validators/union.rs
+++ b/src/validators/union.rs
@@ -1,6 +1,5 @@
 use std::fmt::Write;
 use std::str::FromStr;
-use std::sync::atomic::{AtomicBool, Ordering};
 
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList, PyString, PyTuple};
@@ -17,48 +16,22 @@ use crate::tools::SchemaDict;
 
 use super::custom_error::CustomError;
 use super::literal::LiteralLookup;
-use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
+use super::{
+    build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, Exactness, ValidationState, Validator,
+};
 
 #[derive(Debug)]
 enum UnionMode {
-    Smart {
-        strict_required: AtomicBool,
-        ultra_strict_required: AtomicBool,
-    },
+    Smart,
     LeftToRight,
 }
 
-impl UnionMode {
-    // construct smart with some default values
-    const fn default_smart() -> Self {
-        Self::Smart {
-            strict_required: AtomicBool::new(true),
-            ultra_strict_required: AtomicBool::new(false),
-        }
-    }
-}
-
-impl Clone for UnionMode {
-    fn clone(&self) -> Self {
-        match self {
-            Self::Smart {
-                strict_required,
-                ultra_strict_required,
-            } => Self::Smart {
-                strict_required: AtomicBool::new(strict_required.load(Ordering::SeqCst)),
-                ultra_strict_required: AtomicBool::new(ultra_strict_required.load(Ordering::SeqCst)),
-            },
-            Self::LeftToRight => Self::LeftToRight,
-        }
-    }
-}
-
 impl FromStr for UnionMode {
     type Err = PyErr;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
         match s {
-            "smart" => Ok(Self::default_smart()),
+            "smart" => Ok(Self::Smart),
             "left_to_right" => Ok(Self::LeftToRight),
             s => py_schema_err!("Invalid union mode: `{}`, expected `smart` or `left_to_right`", s),
         }
@@ -103,7 +76,7 @@ impl BuildValidator for UnionValidator {
         let auto_collapse = || schema.get_as_req(intern!(py, "auto_collapse")).unwrap_or(true);
         let mode = schema
             .get_as::<&str>(intern!(py, "mode"))?
-            .map_or(Ok(UnionMode::default_smart()), UnionMode::from_str)?;
+            .map_or(Ok(UnionMode::Smart), UnionMode::from_str)?;
         match choices.len() {
             0 => py_schema_err!("One or more union choices required"),
             1 if auto_collapse() => Ok(choices.into_iter().next().unwrap().0),
@@ -128,71 +101,74 @@ impl BuildValidator for UnionValidator {
 }
 
 impl UnionValidator {
-    fn validate_smart<'s, 'data>(
-        &'s self,
+    fn validate_smart<'data>(
+        &self,
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-        strict_required: bool,
-        ultra_strict_required: bool,
     ) -> ValResult<'data, PyObject> {
-        if ultra_strict_required {
-            // do an ultra strict check first
-            let state = &mut state.rebind_extra(|extra| {
-                extra.strict = Some(true);
-                extra.ultra_strict = true;
-            });
-            if let Some(res) = self
-                .choices
-                .iter()
-                .map(|(validator, _label)| validator.validate(py, input, state))
-                .find(ValResult::is_ok)
-            {
-                return res;
-            }
-        }
-
+        let old_exactness = state.exactness;
+        let strict = state.strict_or(self.strict);
         let mut errors = MaybeErrors::new(self.custom_error.as_ref());
 
-        if state.strict_or(self.strict) {
-            let state = &mut state.rebind_extra(|extra| extra.strict = Some(true));
-            for (validator, label) in &self.choices {
-                match validator.validate(py, input, state) {
-                    Err(ValError::LineErrors(lines)) => errors.push(validator, label.as_deref(), lines),
-                    otherwise => return otherwise,
-                };
-            }
+        let mut success = None;
 
-            Err(errors.into_val_error(input))
-        } else {
-            if strict_required {
-                // 1st pass: check if the value is an exact instance of one of the Union types,
-                // e.g. use validate in strict mode
-                let state = &mut state.rebind_extra(|extra| extra.strict = Some(true));
-                if let Some(res) = self
-                    .choices
-                    .iter()
-                    .map(|(validator, _label)| validator.validate(py, input, state))
-                    .find(ValResult::is_ok)
-                {
-                    return res;
+        for (choice, label) in &self.choices {
+            let state = &mut state.rebind_extra(|extra| {
+                if strict {
+                    extra.strict = Some(strict);
                 }
+            });
+            state.exactness = Some(Exactness::Exact);
+            let result = choice.validate(py, input, state);
+            match result {
+                Ok(new_success) => match state.exactness {
+                    // exact match, return
+                    Some(Exactness::Exact) => {
+                        return {
+                            // exact match, return, restore any previous exactness
+                            state.exactness = old_exactness;
+                            Ok(new_success)
+                        };
+                    }
+                    _ => {
+                        // success should always have an exactness
+                        debug_assert_ne!(state.exactness, None);
+                        let new_exactness = state.exactness.unwrap_or(Exactness::Lax);
+                        // if the new result has higher exactness than the current success, replace it
+                        if success
+                            .as_ref()
+                            .map_or(true, |(_, current_exactness)| *current_exactness < new_exactness)
+                        {
+                            // TODO: is there a possible optimization here, where once there has
+                            // been one success, we turn on strict mode, to avoid unnecessary
+                            // coercions for further validation?
+                            success = Some((new_success, new_exactness));
+                        }
+                    }
+                },
+                Err(ValError::LineErrors(lines)) => {
+                    // if we don't yet know this validation will succeed, record the error
+                    if success.is_none() {
+                        errors.push(choice, label.as_deref(), lines);
+                    }
+                }
+                otherwise => return otherwise,
             }
+        }
+        state.exactness = old_exactness;
 
-            // 2nd pass: check if the value can be coerced into one of the Union types, e.g. use validate
-            for (validator, label) in &self.choices {
-                match validator.validate(py, input, state) {
-                    Err(ValError::LineErrors(lines)) => errors.push(validator, label.as_deref(), lines),
-                    otherwise => return otherwise,
-                };
-            }
-
-            Err(errors.into_val_error(input))
+        if let Some((success, exactness)) = success {
+            state.floor_exactness(exactness);
+            return Ok(success);
         }
+
+        // no matches, build errors
+        Err(errors.into_val_error(input))
     }
 
-    fn validate_left_to_right<'s, 'data>(
-        &'s self,
+    fn validate_left_to_right<'data>(
+        &self,
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
@@ -232,50 +208,15 @@ impl Validator for UnionValidator {
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
     ) -> ValResult<'data, PyObject> {
-        match &self.mode {
-            UnionMode::Smart {
-                strict_required,
-                ultra_strict_required,
-            } => self.validate_smart(
-                py,
-                input,
-                state,
-                strict_required.load(Ordering::SeqCst),
-                ultra_strict_required.load(Ordering::SeqCst),
-            ),
+        match self.mode {
+            UnionMode::Smart => self.validate_smart(py, input, state),
             UnionMode::LeftToRight => self.validate_left_to_right(py, input, state),
         }
     }
 
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        self.choices
-            .iter()
-            .any(|(v, _)| v.different_strict_behavior(ultra_strict))
-    }
-
     fn get_name(&self) -> &str {
         &self.name
     }
-
-    fn complete(&self) -> PyResult<()> {
-        self.choices.iter().try_for_each(|(v, _)| v.complete())?;
-        if let UnionMode::Smart {
-            strict_required,
-            ultra_strict_required,
-        } = &self.mode
-        {
-            strict_required.store(
-                self.choices.iter().any(|(v, _)| v.different_strict_behavior(false)),
-                Ordering::SeqCst,
-            );
-            ultra_strict_required.store(
-                self.choices.iter().any(|(v, _)| v.different_strict_behavior(true)),
-                Ordering::SeqCst,
-            );
-        }
-
-        Ok(())
-    }
 }
 
 struct ChoiceLineErrors<'a, 'data> {
@@ -494,20 +435,9 @@ impl Validator for TaggedUnionValidator {
         }
     }
 
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        self.lookup
-            .values
-            .iter()
-            .any(|v| v.different_strict_behavior(ultra_strict))
-    }
-
     fn get_name(&self) -> &str {
         &self.name
     }
-
-    fn complete(&self) -> PyResult<()> {
-        self.lookup.values.iter().try_for_each(CombinedValidator::complete)
-    }
 }
 
 impl TaggedUnionValidator {
@@ -519,7 +449,7 @@ impl TaggedUnionValidator {
         let dict = input.strict_dict()?;
         let either_tag = match dict {
             GenericMapping::PyDict(dict) => match dict.get_item(intern!(py, "type"))? {
-                Some(t) => t.strict_str()?,
+                Some(t) => t.validate_str(true, false)?.into_inner(),
                 None => return Err(self.tag_not_found(input)),
             },
             _ => unreachable!(),
@@ -530,7 +460,7 @@ impl TaggedUnionValidator {
         if tag == "function" || tag == "tuple" {
             let mode = match dict {
                 GenericMapping::PyDict(dict) => match dict.get_item(intern!(py, "mode"))? {
-                    Some(m) => Some(m.strict_str()?),
+                    Some(m) => Some(m.validate_str(true, false)?.into_inner()),
                     None => None,
                 },
                 _ => unreachable!(),
diff --git a/src/validators/url.rs b/src/validators/url.rs
index b5fe8bf4c..77f887b7d 100644
--- a/src/validators/url.rs
+++ b/src/validators/url.rs
@@ -16,6 +16,7 @@ use crate::tools::SchemaDict;
 use crate::url::{schema_is_special, PyMultiHostUrl, PyUrl};
 
 use super::literal::expected_repr_name;
+use super::Exactness;
 use super::{BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
 
 type AllowedSchemas = Option<(AHashSet<String>, String)>;
@@ -87,28 +88,25 @@ impl Validator for UrlValidator {
             self.default_port,
             &self.default_path,
         ) {
-            Ok(()) => Ok(PyUrl::new(lib_url).into_py(py)),
+            Ok(()) => {
+                // Lax rather than strict to preserve V2.4 semantic that str wins over url in union
+                state.floor_exactness(Exactness::Lax);
+                Ok(PyUrl::new(lib_url).into_py(py))
+            }
             Err(error_type) => return Err(ValError::new(error_type, input)),
         }
     }
 
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        !ultra_strict
-    }
-
     fn get_name(&self) -> &str {
         &self.name
     }
-
-    fn complete(&self) -> PyResult<()> {
-        Ok(())
-    }
 }
 
 impl UrlValidator {
     fn get_url<'s, 'data>(&'s self, input: &'data impl Input<'data>, strict: bool) -> ValResult<'data, Url> {
         match input.validate_str(strict, false) {
-            Ok(either_str) => {
+            Ok(val_match) => {
+                let either_str = val_match.into_inner();
                 let cow = either_str.as_cow()?;
                 let url_str = cow.as_ref();
 
@@ -223,28 +221,25 @@ impl Validator for MultiHostUrlValidator {
             self.default_port,
             &self.default_path,
         ) {
-            Ok(()) => Ok(multi_url.into_py(py)),
+            Ok(()) => {
+                // Lax rather than strict to preserve V2.4 semantic that str wins over url in union
+                state.floor_exactness(Exactness::Lax);
+                Ok(multi_url.into_py(py))
+            }
             Err(error_type) => return Err(ValError::new(error_type, input)),
         }
     }
 
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        !ultra_strict
-    }
-
     fn get_name(&self) -> &str {
         &self.name
     }
-
-    fn complete(&self) -> PyResult<()> {
-        Ok(())
-    }
 }
 
 impl MultiHostUrlValidator {
     fn get_url<'s, 'data>(&'s self, input: &'data impl Input<'data>, strict: bool) -> ValResult<'data, PyMultiHostUrl> {
         match input.validate_str(strict, false) {
-            Ok(either_str) => {
+            Ok(val_match) => {
+                let either_str = val_match.into_inner();
                 let cow = either_str.as_cow()?;
                 let url_str = cow.as_ref();
 
diff --git a/src/validators/uuid.rs b/src/validators/uuid.rs
index 94d302438..9e4ce9fb5 100644
--- a/src/validators/uuid.rs
+++ b/src/validators/uuid.rs
@@ -13,7 +13,7 @@ use crate::tools::SchemaDict;
 
 use super::model::create_class;
 use super::model::force_setattr;
-use super::{BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
+use super::{BuildValidator, CombinedValidator, DefinitionsBuilder, Exactness, ValidationState, Validator};
 
 const UUID_INT: &str = "int";
 const UUID_IS_SAFE: &str = "is_safe";
@@ -117,22 +117,19 @@ impl Validator for UuidValidator {
                 input,
             ))
         } else {
+            // In python mode this is a coercion, in JSON mode we treat a UUID string as an
+            // exact match
+            if input.is_python() {
+                state.floor_exactness(Exactness::Lax);
+            }
             let uuid = self.get_uuid(input)?;
             self.create_py_uuid(py, class, &uuid)
         }
     }
 
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        !ultra_strict
-    }
-
     fn get_name(&self) -> &str {
         Self::EXPECTED_TYPE
     }
-
-    fn complete(&self) -> PyResult<()> {
-        Ok(())
-    }
 }
 
 impl UuidValidator {
@@ -154,7 +151,8 @@ impl UuidValidator {
             None => {
                 let either_bytes = input
                     .validate_bytes(true)
-                    .map_err(|_| ValError::new(ErrorTypeDefaults::UuidType, input))?;
+                    .map_err(|_| ValError::new(ErrorTypeDefaults::UuidType, input))?
+                    .into_inner();
                 let bytes_slice = either_bytes.as_slice();
                 'parse: {
                     // Try parsing as utf8, but don't care if it fails
diff --git a/src/validators/validation_state.rs b/src/validators/validation_state.rs
index 79ec8b87a..aacd7d2af 100644
--- a/src/validators/validation_state.rs
+++ b/src/validators/validation_state.rs
@@ -2,15 +2,27 @@ use crate::recursion_guard::RecursionGuard;
 
 use super::Extra;
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq, Ord, PartialOrd, Hash)]
+pub enum Exactness {
+    Lax,
+    Strict,
+    Exact,
+}
+
 pub struct ValidationState<'a> {
     pub recursion_guard: &'a mut RecursionGuard,
+    pub exactness: Option<Exactness>,
     // deliberately make Extra readonly
     extra: Extra<'a>,
 }
 
 impl<'a> ValidationState<'a> {
     pub fn new(extra: Extra<'a>, recursion_guard: &'a mut RecursionGuard) -> Self {
-        Self { recursion_guard, extra }
+        Self {
+            recursion_guard, // Don't care about exactness unless doing union validation
+            exactness: None,
+            extra,
+        }
     }
 
     pub fn with_new_extra<'r, R: 'r>(
@@ -22,9 +34,15 @@ impl<'a> ValidationState<'a> {
         // but lifetimes get in a tangle. Maybe someone brave wants to have a go at unpicking lifetimes.
         let mut new_state = ValidationState {
             recursion_guard: self.recursion_guard,
+            exactness: self.exactness,
             extra,
         };
-        f(&mut new_state)
+        let result = f(&mut new_state);
+        match new_state.exactness {
+            Some(exactness) => self.floor_exactness(exactness),
+            None => self.exactness = None,
+        }
+        result
     }
 
     /// Temporarily rebinds the extra field by calling `f` to modify extra.
@@ -47,6 +65,23 @@ impl<'a> ValidationState<'a> {
     pub fn strict_or(&self, default: bool) -> bool {
         self.extra.strict.unwrap_or(default)
     }
+
+    /// Sets the exactness to the lower of the current exactness
+    /// and the given exactness.
+    ///
+    /// This is designed to be used in union validation, where the
+    /// idea is that the "most exact" validation wins.
+    pub fn floor_exactness(&mut self, exactness: Exactness) {
+        match self.exactness {
+            None | Some(Exactness::Lax) => {}
+            Some(Exactness::Strict) => {
+                if exactness == Exactness::Lax {
+                    self.exactness = Some(Exactness::Lax);
+                }
+            }
+            Some(Exactness::Exact) => self.exactness = Some(exactness),
+        }
+    }
 }
 
 pub struct ValidationStateWithReboundExtra<'state, 'a> {
diff --git a/src/validators/with_default.rs b/src/validators/with_default.rs
index 36b275dd1..a06ccd0cd 100644
--- a/src/validators/with_default.rs
+++ b/src/validators/with_default.rs
@@ -182,17 +182,9 @@ impl Validator for WithDefaultValidator {
         }
     }
 
-    fn different_strict_behavior(&self, ultra_strict: bool) -> bool {
-        self.validator.different_strict_behavior(ultra_strict)
-    }
-
     fn get_name(&self) -> &str {
         &self.name
     }
-
-    fn complete(&self) -> PyResult<()> {
-        self.validator.complete()
-    }
 }
 
 impl WithDefaultValidator {
diff --git a/tests/validators/test_definitions_recursive.py b/tests/validators/test_definitions_recursive.py
index 2d676ac17..9f7a93d57 100644
--- a/tests/validators/test_definitions_recursive.py
+++ b/tests/validators/test_definitions_recursive.py
@@ -1085,3 +1085,22 @@ def test_complex_recursive_type() -> None:
             'input': {'a': datetime.date(1992, 12, 11)},
         },
     ]
+
+
+def test_no_exponential_blowup():
+    """See https://github.com/pydantic/pydantic/issues/8049
+
+    There was a performance bug which led to exponential blowup when trying to
+    build a schema with many intermingled recursive definitions.
+    """
+    unions = core_schema.union_schema([core_schema.definition_reference_schema(f'foo_{i}') for i in range(100)])
+
+    schema = core_schema.definitions_schema(
+        core_schema.typed_dict_schema({'x': core_schema.typed_dict_field(unions)}),
+        definitions=[
+            core_schema.typed_dict_schema({'a': core_schema.typed_dict_field(unions)}, ref=f'foo_{i}')
+            for i in range(100)
+        ],
+    )
+
+    SchemaValidator(schema)
diff --git a/tests/validators/test_union.py b/tests/validators/test_union.py
index ad51fb447..503a5f387 100644
--- a/tests/validators/test_union.py
+++ b/tests/validators/test_union.py
@@ -1,3 +1,9 @@
+from dataclasses import dataclass
+from datetime import date, time
+from enum import Enum, IntEnum
+from typing import Any
+from uuid import UUID
+
 import pytest
 from dirty_equals import IsFloat, IsInt
 
@@ -342,9 +348,6 @@ def test_dirty_behaviour():
 
 def test_int_float():
     v = SchemaValidator(core_schema.union_schema([core_schema.int_schema(), core_schema.float_schema()]))
-    assert 'strict_required:true' in plain_repr(v)
-    assert 'ultra_strict_required:true' in plain_repr(v)  # since "float" schema has ultra-strict behaviour
-
     assert v.validate_python(1) == IsInt(approx=1, delta=0)
     assert v.validate_json('1') == IsInt(approx=1, delta=0)
     assert v.validate_python(1.0) == IsFloat(approx=1, delta=0)
@@ -382,17 +385,8 @@ def test_str_float():
     assert v.validate_json('"1"') == '1'
 
 
-def test_strict_check():
-    v = SchemaValidator(core_schema.union_schema([core_schema.int_schema(), core_schema.json_schema()]))
-    assert 'strict_required:true' in plain_repr(v)
-    assert 'ultra_strict_required:false' in plain_repr(v)
-
-
 def test_no_strict_check():
     v = SchemaValidator(core_schema.union_schema([core_schema.is_instance_schema(int), core_schema.json_schema()]))
-    assert 'strict_required:false' in plain_repr(v)
-    assert 'ultra_strict_required:false' in plain_repr(v)
-
     assert v.validate_python(123) == 123
     assert v.validate_python('[1, 2, 3]') == [1, 2, 3]
 
@@ -414,8 +408,6 @@ def test_strict_reference():
             ],
         )
     )
-    assert 'strict_required:true' in plain_repr(v)
-    assert 'ultra_strict_required:true' in plain_repr(v)  # since "float" schema has ultra-strict behaviour
 
     assert repr(v.validate_python((1, 2))) == '(1.0, 2)'
     assert repr(v.validate_python((1.0, (2.0, 3)))) == '(1.0, (2.0, 3))'
@@ -501,3 +493,281 @@ def test_left_to_right_union_strict():
     out = v.validate_python(1)
     assert out == 1.0
     assert isinstance(out, float)
+
+
+def test_union_function_before_called_once():
+    # See https://github.com/pydantic/pydantic/issues/6830 - in particular the
+    # smart union validator used to call `remove_prefix` twice, which is not
+    # ideal from a user perspective.
+    class SpecialValues(str, Enum):
+        DEFAULT = 'default'
+        OTHER = 'other'
+
+    special_values_schema = core_schema.no_info_after_validator_function(SpecialValues, core_schema.str_schema())
+
+    validator_called_count = 0
+
+    def remove_prefix(v: str):
+        nonlocal validator_called_count
+        validator_called_count += 1
+        if v.startswith('uuid::'):
+            return v[6:]
+        return v
+
+    prefixed_uuid_schema = core_schema.no_info_before_validator_function(remove_prefix, core_schema.uuid_schema())
+
+    v = SchemaValidator(core_schema.union_schema([special_values_schema, prefixed_uuid_schema]))
+
+    assert v.validate_python('uuid::12345678-1234-5678-1234-567812345678') == UUID(
+        '12345678-1234-5678-1234-567812345678'
+    )
+    assert validator_called_count == 1
+
+
+@pytest.mark.parametrize(
+    ('schema', 'input_value', 'expected_value'),
+    (
+        (
+            core_schema.uuid_schema(),
+            '12345678-1234-5678-1234-567812345678',
+            UUID('12345678-1234-5678-1234-567812345678'),
+        ),
+        (core_schema.date_schema(), '2020-01-01', date(2020, 1, 1)),
+        (core_schema.time_schema(), '00:00:00', time(0, 0, 0)),
+        # In V2.4 these already returned strings, so we keep this behaviour in V2
+        (core_schema.datetime_schema(), '2020-01-01:00:00:00', '2020-01-01:00:00:00'),
+        (core_schema.url_schema(), 'https://foo.com', 'https://foo.com'),
+        (core_schema.multi_host_url_schema(), 'https://bar.com,foo.com', 'https://bar.com,foo.com'),
+    ),
+)
+def test_smart_union_json_string_types(schema: core_schema.CoreSchema, input_value: str, expected_value: Any):
+    # Many types have to be represented in strings as JSON, we make sure that
+    # when parsing in JSON mode these types are preferred
+    # TODO: in V3 we will make str win in all these cases.
+
+    validator = SchemaValidator(core_schema.union_schema([schema, core_schema.str_schema()]))
+    assert validator.validate_json(f'"{input_value}"') == expected_value
+    # in Python mode the string will be preferred
+    assert validator.validate_python(input_value) == input_value
+
+
+@pytest.mark.parametrize(
+    ('schema', 'input_value'),
+    (
+        pytest.param(
+            core_schema.uuid_schema(),
+            '12345678-1234-5678-1234-567812345678',
+            marks=pytest.mark.xfail(reason='TODO: V3'),
+        ),
+        (core_schema.date_schema(), '2020-01-01'),
+        (core_schema.time_schema(), '00:00:00'),
+        (core_schema.datetime_schema(), '2020-01-01:00:00:00'),
+        (core_schema.url_schema(), 'https://foo.com'),
+        (core_schema.multi_host_url_schema(), 'https://bar.com,foo.com'),
+    ),
+)
+def test_smart_union_json_string_types_str_first(schema: core_schema.CoreSchema, input_value: str):
+    # As above, but reversed order; str should always win
+    validator = SchemaValidator(core_schema.union_schema([core_schema.str_schema(), schema]))
+    assert validator.validate_json(f'"{input_value}"') == input_value
+    assert validator.validate_python(input_value) == input_value
+
+
+def test_smart_union_default_fallback():
+    """Using a default value does not affect the exactness of the smart union match."""
+
+    class ModelA:
+        x: int
+        y: int = 1
+
+    class ModelB:
+        x: int
+
+    schema = core_schema.union_schema(
+        [
+            core_schema.model_schema(
+                ModelA,
+                core_schema.model_fields_schema(
+                    {
+                        'x': core_schema.model_field(core_schema.int_schema()),
+                        'y': core_schema.model_field(
+                            core_schema.with_default_schema(core_schema.int_schema(), default=1)
+                        ),
+                    }
+                ),
+            ),
+            core_schema.model_schema(
+                ModelB, core_schema.model_fields_schema({'x': core_schema.model_field(core_schema.int_schema())})
+            ),
+        ]
+    )
+
+    validator = SchemaValidator(schema)
+
+    result = validator.validate_python({'x': 1})
+    assert isinstance(result, ModelA)
+    assert result.x == 1
+    assert result.y == 1
+
+    # passing a ModelB explicitly will not match the default value
+    b = ModelB()
+    assert validator.validate_python(b) is b
+
+
+def test_smart_union_model_field():
+    class ModelA:
+        x: int
+
+    class ModelB:
+        x: str
+
+    schema = core_schema.union_schema(
+        [
+            core_schema.model_schema(
+                ModelA, core_schema.model_fields_schema({'x': core_schema.model_field(core_schema.int_schema())})
+            ),
+            core_schema.model_schema(
+                ModelB, core_schema.model_fields_schema({'x': core_schema.model_field(core_schema.str_schema())})
+            ),
+        ]
+    )
+
+    validator = SchemaValidator(schema)
+
+    result = validator.validate_python({'x': 1})
+    assert isinstance(result, ModelA)
+    assert result.x == 1
+
+    result = validator.validate_python({'x': '1'})
+    assert isinstance(result, ModelB)
+    assert result.x == '1'
+
+
+def test_smart_union_dataclass_field():
+    @dataclass
+    class ModelA:
+        x: int
+
+    @dataclass
+    class ModelB:
+        x: str
+
+    schema = core_schema.union_schema(
+        [
+            core_schema.dataclass_schema(
+                ModelA,
+                core_schema.dataclass_args_schema(
+                    'ModelA', [core_schema.dataclass_field('x', core_schema.int_schema())]
+                ),
+                ['x'],
+            ),
+            core_schema.dataclass_schema(
+                ModelB,
+                core_schema.dataclass_args_schema(
+                    'ModelB', [core_schema.dataclass_field('x', core_schema.str_schema())]
+                ),
+                ['x'],
+            ),
+        ]
+    )
+
+    validator = SchemaValidator(schema)
+
+    result = validator.validate_python({'x': 1})
+    assert isinstance(result, ModelA)
+    assert result.x == 1
+
+    result = validator.validate_python({'x': '1'})
+    assert isinstance(result, ModelB)
+    assert result.x == '1'
+
+
+def test_smart_union_with_any():
+    """any is preferred over lax validations"""
+
+    # str not coerced to int
+    schema = core_schema.union_schema([core_schema.int_schema(), core_schema.any_schema()])
+    validator = SchemaValidator(schema)
+    assert validator.validate_python('1') == '1'
+
+    # int *is* coerced to float, this is a strict validation
+    schema = core_schema.union_schema([core_schema.float_schema(), core_schema.any_schema()])
+    validator = SchemaValidator(schema)
+    assert repr(validator.validate_python(1)) == '1.0'
+
+
+def test_smart_union_validator_function():
+    """adding a validator function should not change smart union behaviour"""
+
+    inner_schema = core_schema.union_schema([core_schema.int_schema(), core_schema.float_schema()])
+
+    validator = SchemaValidator(inner_schema)
+    assert repr(validator.validate_python(1)) == '1'
+    assert repr(validator.validate_python(1.0)) == '1.0'
+
+    schema = core_schema.union_schema(
+        [core_schema.no_info_after_validator_function(lambda v: v * 2, inner_schema), core_schema.str_schema()]
+    )
+
+    validator = SchemaValidator(schema)
+    assert repr(validator.validate_python(1)) == '2'
+    assert repr(validator.validate_python(1.0)) == '2.0'
+    assert validator.validate_python('1') == '1'
+
+    schema = core_schema.union_schema(
+        [
+            core_schema.no_info_wrap_validator_function(lambda v, handler: handler(v) * 2, inner_schema),
+            core_schema.str_schema(),
+        ]
+    )
+
+    validator = SchemaValidator(schema)
+    assert repr(validator.validate_python(1)) == '2'
+    assert repr(validator.validate_python(1.0)) == '2.0'
+    assert validator.validate_python('1') == '1'
+
+
+def test_smart_union_validator_function_one_arm():
+    """adding a validator function should not change smart union behaviour"""
+
+    schema = core_schema.union_schema(
+        [
+            core_schema.float_schema(),
+            core_schema.no_info_after_validator_function(lambda v: v * 2, core_schema.int_schema()),
+        ]
+    )
+
+    validator = SchemaValidator(schema)
+    assert repr(validator.validate_python(1)) == '2'
+    assert repr(validator.validate_python(1.0)) == '1.0'
+
+    schema = core_schema.union_schema(
+        [
+            core_schema.float_schema(),
+            core_schema.no_info_wrap_validator_function(lambda v, handler: handler(v) * 2, core_schema.int_schema()),
+        ]
+    )
+
+    validator = SchemaValidator(schema)
+    assert repr(validator.validate_python(1)) == '2'
+    assert repr(validator.validate_python(1.0)) == '1.0'
+
+
+def test_int_not_coerced_to_enum():
+    class BinaryEnum(IntEnum):
+        ZERO = 0
+        ONE = 1
+
+    enum_schema = core_schema.lax_or_strict_schema(
+        core_schema.no_info_after_validator_function(BinaryEnum, core_schema.int_schema()),
+        core_schema.is_instance_schema(BinaryEnum),
+    )
+
+    schema = core_schema.union_schema([enum_schema, core_schema.int_schema()])
+
+    validator = SchemaValidator(schema)
+
+    assert validator.validate_python(0) is not BinaryEnum.ZERO
+    assert validator.validate_python(1) is not BinaryEnum.ONE
+    assert validator.validate_python(BinaryEnum.ZERO) is BinaryEnum.ZERO
+    assert validator.validate_python(BinaryEnum.ONE) is BinaryEnum.ONE

From d3416f7bf90ce4b9cc84422c63d77fa4a198c052 Mon Sep 17 00:00:00 2001
From: David Hewitt <mail@davidhewitt.io>
Date: Wed, 8 Nov 2023 21:56:19 +0000
Subject: [PATCH 111/550] bump version to 2.14.0 (#1066)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 13874f1fd..f27eb2fb2 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -321,7 +321,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.13.0"
+version = "2.14.0"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index 6c1d1d948..d2a97ec9b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.13.0"
+version = "2.14.0"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From 5712edfd495629dc3f9e2a52537415a9c02d9461 Mon Sep 17 00:00:00 2001
From: Luca Blight <46580497+Luca-Blight@users.noreply.github.com>
Date: Thu, 9 Nov 2023 04:23:28 -0500
Subject: [PATCH 112/550] Adopt ruff formatter instead of black (ready for
 review) (#1051)

---
 .github/workflows/ci.yml                |  6 +++---
 Makefile                                | 12 ++++++------
 pyproject.toml                          | 11 +++--------
 python/pydantic_core/_pydantic_core.pyi |  1 -
 tests/requirements-linting.txt          |  5 ++---
 tests/serializers/test_functions.py     |  2 +-
 tests/test_errors.py                    |  6 +++---
 tests/validators/test_arguments.py      |  8 ++++----
 tests/validators/test_bool.py           |  2 +-
 tests/validators/test_int.py            |  6 +++---
 tests/validators/test_literal.py        |  2 +-
 tests/validators/test_string.py         |  4 ++--
 tests/validators/test_typed_dict.py     |  6 +++---
 13 files changed, 32 insertions(+), 39 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index fa9dfa0e0..de0e52e7a 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -315,7 +315,7 @@ jobs:
           version: '3.1.32'
           actions-cache-folder: emsdk-cache
 
-      - run: pip install 'maturin>=1,<2' 'black>=22.3.0,<23' typing_extensions
+      - run: pip install 'maturin>=1,<2' 'ruff==0.1.3' typing_extensions
 
       - name: build wheels
         run: make build-wasm
@@ -442,7 +442,7 @@ jobs:
           python-version: '3.11'
           architecture: ${{ matrix.python-architecture || 'x64' }}
 
-      - run: pip install -U twine 'black>=22.3.0,<23' typing_extensions
+      - run: pip install -U twine 'ruff==0.1.3' typing_extensions
 
       # generate self-schema now, so we don't have to do so inside docker in maturin build
       - run: python generate_self_schema.py
@@ -501,7 +501,7 @@ jobs:
         with:
           components: llvm-tools
 
-      - run: pip install -U 'black>=22.3.0,<23' typing_extensions
+      - run: pip install -U 'ruff==0.1.3' typing_extensions
 
       # generate self-schema now, so we don't have to do so inside docker in maturin build
       - run: python generate_self_schema.py
diff --git a/Makefile b/Makefile
index 4e97e6f42..d9e0d0e0a 100644
--- a/Makefile
+++ b/Makefile
@@ -1,6 +1,6 @@
 .DEFAULT_GOAL := all
-black = black python/pydantic_core tests generate_self_schema.py wasm-preview/run_tests.py
-ruff = ruff python/pydantic_core tests generate_self_schema.py wasm-preview/run_tests.py
+sources = python/pydantic_core tests generate_self_schema.py wasm-preview/run_tests.py 
+
 mypy-stubtest = python -m mypy.stubtest pydantic_core._pydantic_core --allowlist .mypy-stubtest-allowlist
 
 # using pip install cargo (via maturin via pip) doesn't get the tty handle
@@ -90,14 +90,14 @@ build-wasm:
 
 .PHONY: format
 format:
-	$(black)
-	$(ruff) --fix --exit-zero
+	ruff --fix $(sources) 
+	ruff format $(sources) 
 	cargo fmt
 
 .PHONY: lint-python
 lint-python:
-	$(ruff)
-	$(black) --check --diff
+	ruff $(sources) 
+	ruff format --check $(sources) 
 	$(mypy-stubtest)
 	griffe dump -f -d google -LWARNING -o/dev/null python/pydantic_core
 
diff --git a/pyproject.toml b/pyproject.toml
index 7afacd57a..a40f160f0 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -57,13 +57,15 @@ features = ["pyo3/extension-module"]
 line-length = 120
 extend-select = ['Q', 'RUF100', 'C90', 'I']
 extend-ignore = [
-    'E501',  # ignore line too long and let black handle it
     'E721',  # using type() instead of isinstance() - we use this in tests
 ]
 flake8-quotes = {inline-quotes = 'single', multiline-quotes = 'double'}
 mccabe = { max-complexity = 13 }
 isort = { known-first-party = ['pydantic_core', 'tests'] }
 
+[tool.ruff.format]
+quote-style = 'single'
+
 [tool.pytest.ini_options]
 testpaths = 'tests'
 log_format = '%(name)s %(levelname)s: %(message)s'
@@ -97,13 +99,6 @@ exclude_lines = [
     '@overload',
 ]
 
-[tool.black]
-color = true
-line-length = 120
-target-version = ['py37', 'py38', 'py39', 'py310']
-skip-string-normalization = true
-skip-magic-trailing-comma = true
-
 # configuring https://github.com/pydantic/hooky
 [tool.hooky]
 assignees = ['samuelcolvin', 'adriangb', 'dmontagu', 'davidhewitt', 'lig']
diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index f28b7a12a..b452d2f17 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -847,7 +847,6 @@ def list_all_errors() -> list[ErrorTypeInfo]:
     Returns:
         A list of `ErrorTypeInfo` typed dicts.
     """
-
 @final
 class TzInfo(datetime.tzinfo):
     def tzname(self, _dt: datetime.datetime | None) -> str | None: ...
diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index 655ff8bda..332398740 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,5 +1,4 @@
-black==23.10.1
-griffe==0.36.9
-pyright==1.1.334
+griffe==0.36.7
+pyright==1.1.332
 ruff==0.1.3
 mypy==1.6.1
diff --git a/tests/serializers/test_functions.py b/tests/serializers/test_functions.py
index 318254602..8851a7d36 100644
--- a/tests/serializers/test_functions.py
+++ b/tests/serializers/test_functions.py
@@ -228,7 +228,7 @@ def append_args(value, info):
         'exclude_defaults=False, exclude_none=False, round_trip=False)'
     )
     assert s.to_json(123) == (
-        b'"123 info=SerializationInfo(include=None, exclude=None, mode=\'json\', by_alias=True, exclude_unset=False, '
+        b"\"123 info=SerializationInfo(include=None, exclude=None, mode='json', by_alias=True, exclude_unset=False, "
         b'exclude_defaults=False, exclude_none=False, round_trip=False)"'
     )
 
diff --git a/tests/test_errors.py b/tests/test_errors.py
index 0d7a966e1..05815aec5 100644
--- a/tests/test_errors.py
+++ b/tests/test_errors.py
@@ -1050,9 +1050,9 @@ def test_loc_with_dots(pydantic_version):
     ]
     # insert_assert(str(exc_info.value))
     assert str(exc_info.value) == (
-        "1 validation error for typed-dict\n"
-        "`foo.bar`.0\n"
-        "  Input should be a valid integer, unable to parse string as an integer "
+        '1 validation error for typed-dict\n'
+        '`foo.bar`.0\n'
+        '  Input should be a valid integer, unable to parse string as an integer '
         "[type=int_parsing, input_value='x', input_type=str]\n"
         f'    For further information visit https://errors.pydantic.dev/{pydantic_version}/v/int_parsing'
     )
diff --git a/tests/validators/test_arguments.py b/tests/validators/test_arguments.py
index 4ef581b47..4cf1d3ad2 100644
--- a/tests/validators/test_arguments.py
+++ b/tests/validators/test_arguments.py
@@ -1009,11 +1009,11 @@ def test_error_display(pydantic_version):
     ]
     # insert_assert(str(exc_info.value))
     assert str(exc_info.value) == (
-        "1 validation error for arguments\n"
-        "b\n"
-        "  Missing required argument [type=missing_argument, "
+        '1 validation error for arguments\n'
+        'b\n'
+        '  Missing required argument [type=missing_argument, '
         "input_value=ArgsKwargs((), {'a': 1}), input_type=ArgsKwargs]\n"
-        f"    For further information visit https://errors.pydantic.dev/{pydantic_version}/v/missing_argument"
+        f'    For further information visit https://errors.pydantic.dev/{pydantic_version}/v/missing_argument'
     )
     # insert_assert(exc_info.value.json(include_url=False))
     assert exc_info.value.json(include_url=False) == (
diff --git a/tests/validators/test_bool.py b/tests/validators/test_bool.py
index e71d41cb1..3ac900701 100644
--- a/tests/validators/test_bool.py
+++ b/tests/validators/test_bool.py
@@ -63,7 +63,7 @@ def test_bool_error(pydantic_version):
         '1 validation error for bool\n'
         '  Input should be a valid boolean, '
         "unable to interpret input [type=bool_parsing, input_value='wrong', input_type=str]\n"
-        f"    For further information visit https://errors.pydantic.dev/{pydantic_version}/v/bool_parsing"
+        f'    For further information visit https://errors.pydantic.dev/{pydantic_version}/v/bool_parsing'
     )
     assert exc_info.value.errors(include_url=False) == [
         {
diff --git a/tests/validators/test_int.py b/tests/validators/test_int.py
index 61acab7fb..80dd1cf73 100644
--- a/tests/validators/test_int.py
+++ b/tests/validators/test_int.py
@@ -357,10 +357,10 @@ def test_too_long(pydantic_version):
     ]
     # insert_assert(repr(exc_info.value))
     assert repr(exc_info.value) == (
-        "1 validation error for int\n"
-        "  Unable to parse input string as an integer, exceeded maximum size "
+        '1 validation error for int\n'
+        '  Unable to parse input string as an integer, exceeded maximum size '
         "[type=int_parsing_size, input_value='111111111111111111111111...11111111111111111111111', input_type=str]\n"
-        f"    For further information visit https://errors.pydantic.dev/{pydantic_version}/v/int_parsing_size"
+        f'    For further information visit https://errors.pydantic.dev/{pydantic_version}/v/int_parsing_size'
     )
 
 
diff --git a/tests/validators/test_literal.py b/tests/validators/test_literal.py
index e1397aeea..d294f866c 100644
--- a/tests/validators/test_literal.py
+++ b/tests/validators/test_literal.py
@@ -78,7 +78,7 @@
         pytest.param(
             ['a', 'b'],
             'c',
-            Err("Input should be 'a' or 'b' [type=literal_error, input_value=\'c\', input_type=str]"),
+            Err("Input should be 'a' or 'b' [type=literal_error, input_value='c', input_type=str]"),
             id='wrong-multiple-str',
         ),
         ([1, '1'], 1, 1),
diff --git a/tests/validators/test_string.py b/tests/validators/test_string.py
index bc2102de2..22bcd5445 100644
--- a/tests/validators/test_string.py
+++ b/tests/validators/test_string.py
@@ -346,9 +346,9 @@ def test_backtracking_regex_rust_unsupported(mode) -> None:
             SchemaValidator(core_schema.str_schema(pattern=pattern), core_schema.CoreConfig(regex_engine='rust-regex'))
 
     assert exc_info.value.args[0] == (
-        'Error building \"str\" validator:\n'
+        'Error building "str" validator:\n'
         '  SchemaError: regex parse error:\n'
-        '    r(#*)\".*?\"\\1\n'
+        '    r(#*)".*?"\\1\n'
         '              ^^\n'
         'error: backreferences are not supported'
     )
diff --git a/tests/validators/test_typed_dict.py b/tests/validators/test_typed_dict.py
index 5f0729d25..8fb25cff6 100644
--- a/tests/validators/test_typed_dict.py
+++ b/tests/validators/test_typed_dict.py
@@ -107,10 +107,10 @@ def test_missing_error(pydantic_version):
         v.validate_python({'field_a': b'abc'})
     # insert_assert(str(exc_info.value))
     assert str(exc_info.value) == (
-        "1 validation error for typed-dict\n"
-        "field_b\n"
+        '1 validation error for typed-dict\n'
+        'field_b\n'
         "  Field required [type=missing, input_value={'field_a': b'abc'}, input_type=dict]\n"
-        f"    For further information visit https://errors.pydantic.dev/{pydantic_version}/v/missing"
+        f'    For further information visit https://errors.pydantic.dev/{pydantic_version}/v/missing'
     )
 
 

From b27455eb90fcc18d4c728c87a8da39bd133e3e97 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 9 Nov 2023 09:32:24 +0000
Subject: [PATCH 113/550] Bump ruff from 0.1.3 to 0.1.5 (#1067)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: David Hewitt <mail@davidhewitt.io>
---
 tests/requirements-linting.txt | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index 332398740..38eacfdbc 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,4 +1,4 @@
-griffe==0.36.7
-pyright==1.1.332
-ruff==0.1.3
+griffe==0.36.9
+pyright==1.1.334
+ruff==0.1.5
 mypy==1.6.1

From 4c2ea59573bfc2dba2bb260e49e8b5c003bfcc95 Mon Sep 17 00:00:00 2001
From: David Hewitt <mail@davidhewitt.io>
Date: Thu, 9 Nov 2023 12:20:27 +0000
Subject: [PATCH 114/550] Restore manylinux-compatible PGO builds (#1068)

---
 .github/workflows/ci.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index de0e52e7a..5a2b01049 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -511,6 +511,7 @@ jobs:
       - name: build initial wheel
         uses: PyO3/maturin-action@v1
         with:
+          manylinux: auto
           args: >
             --release
             --out pgo-wheel
@@ -538,6 +539,7 @@ jobs:
       - name: build pgo-optimized wheel
         uses: PyO3/maturin-action@v1
         with:
+          manylinux: auto
           args: >
             --release
             --out dist

From fbae08ce88deb6b78a688bd4948a812389bf1d27 Mon Sep 17 00:00:00 2001
From: David Hewitt <mail@davidhewitt.io>
Date: Thu, 9 Nov 2023 12:33:49 +0000
Subject: [PATCH 115/550] Bump version to 2.14.1 (#1069)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index f27eb2fb2..e00130f7d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -321,7 +321,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.14.0"
+version = "2.14.1"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index d2a97ec9b..f7c859534 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.14.0"
+version = "2.14.1"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From baed94340599a03332ac856b5d32e0b7087309b4 Mon Sep 17 00:00:00 2001
From: Samuel Colvin <s@muelcolvin.com>
Date: Thu, 9 Nov 2023 15:49:55 +0000
Subject: [PATCH 116/550] Fix invalid link in docstring (#1070)

---
 python/pydantic_core/_pydantic_core.pyi | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index b452d2f17..4c99a4d61 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -389,7 +389,7 @@ def from_json(data: str | bytes | bytearray, *, allow_inf_nan: bool = True) -> A
     """
     Deserialize JSON data to a Python object.
 
-    This is effectively a faster version of [`json.loads()`][json.loads].
+    This is effectively a faster version of `json.loads()`.
 
     Arguments:
         data: The JSON data to deserialize.

From a35b1829cd999628587f19b152bf4c5ab4a8101b Mon Sep 17 00:00:00 2001
From: David Hewitt <mail@davidhewitt.io>
Date: Tue, 14 Nov 2023 14:12:20 +0000
Subject: [PATCH 117/550] restore pypy builds for x86_64 (#1072)

---
 .github/workflows/ci.yml | 117 ++++++++++++++++++++-------------------
 1 file changed, 61 insertions(+), 56 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 5a2b01049..bb0918f8a 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -365,74 +365,73 @@ jobs:
           path: dist
 
   build:
-    name: build on ${{ matrix.platform || matrix.os }} (${{ matrix.target }} - ${{ matrix.manylinux || 'auto' }})
+    name: build on ${{ matrix.os }} (${{ matrix.target }} - ${{ matrix.interpreter || 'all' }}${{ matrix.os == 'linux' && format(' - {0}', matrix.manylinux == 'auto' && 'manylinux' || matrix.manylinux) || '' }})
     # only run on push to main and on release
     if: startsWith(github.ref, 'refs/tags/') || github.ref == 'refs/heads/main' || contains(github.event.pull_request.labels.*.name, 'Full Build')
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu, macos, windows]
+        os: [linux, macos, windows]
         target: [x86_64, aarch64]
         manylinux: [auto]
         include:
-          - os: ubuntu
-            platform: linux
-          - os: windows
-            ls: dir
-            interpreter: 3.7 3.8 3.9 3.10 3.11 3.12 pypy3.8 pypy3.9 pypy3.10
-          - os: windows
-            ls: dir
-            target: i686
-            python-architecture: x86
-            interpreter: 3.7 3.8 3.9 3.10 3.11 3.12
-          - os: windows
-            ls: dir
-            target: aarch64
-            interpreter: 3.11 3.12
-          - os: macos
-            target: aarch64
-            interpreter: 3.7 3.8 3.9 pypy3.8 pypy3.9 pypy3.10
-          - os: ubuntu
-            platform: linux
+          # manylinux for various platforms, plus x86_64 pypy
+          - os: linux
+            manylinux: auto
             target: i686
-          - os: ubuntu
-            platform: linux
+          - os: linux
+            manylinux: auto
             target: aarch64
-
-          - os: ubuntu
-            platform: linux
+          - os: linux
+            manylinux: auto
             target: armv7
             interpreter: 3.7 3.8 3.9 3.10 3.11 3.12
-          # musllinux
-          - os: ubuntu
-            platform: linux
-            target: x86_64
-            manylinux: musllinux_1_1
-          - os: ubuntu
-            platform: linux
-            target: aarch64
-            manylinux: musllinux_1_1
-          - os: ubuntu
-            platform: linux
+          - os: linux
+            manylinux: auto
             target: ppc64le
             interpreter: 3.7 3.8 3.9 3.10 3.11 3.12
-          - os: ubuntu
-            platform: linux
+          - os: linux
+            manylinux: auto
             target: s390x
             interpreter: 3.7 3.8 3.9 3.10 3.11 3.12
-        exclude:
-          # Optimized PGO builds for x86_64 manylinux and windows follow a different matrix,
-          # maybe in future maturin-action can support this automatically
-          - os: ubuntu
-            target: x86_64
+          - os: linux
             manylinux: auto
+            target: x86_64
+            interpreter: pypy3.7 pypy3.8 pypy3.9 pypy3.10
+
+          # musllinux
+          - os: linux
+            manylinux: musllinux_1_1
+            target: x86_64
+          - os: linux
+            manylinux: musllinux_1_1
+            target: aarch64
+
+          # macos;
+          # all versions x86_64
+          # arm pypy and older pythons which can't be run on the arm hardware for PGO
+          - os: macos
+            target: x86_64
+          - os: macos
+            target: aarch64
+            interpreter: 3.7 3.8 3.9 pypy3.8 pypy3.9 pypy3.10
+
+          # windows;
+          # x86_64 pypy builds are not PGO optimized
+          # i686 not supported by pypy
+          # aarch64 only 3.11 and up, also not PGO optimized
           - os: windows
             target: x86_64
-          # Windows on arm64 only supports Python 3.11+
+            interpreter: pypy3.8 pypy3.9 pypy3.10
+          - os: windows
+            target: i686
+            python-architecture: x86
+            interpreter: 3.7 3.8 3.9 3.10 3.11 3.12
           - os: windows
             target: aarch64
+            interpreter: 3.11 3.12
 
-    runs-on: ${{ matrix.os }}-latest
+    runs-on: ${{ (matrix.os == 'linux' && 'ubuntu') || matrix.os }}-latest
     steps:
       - uses: actions/checkout@v4
 
@@ -451,13 +450,12 @@ jobs:
         uses: PyO3/maturin-action@v1
         with:
           target: ${{ matrix.target }}
-          manylinux: ${{ matrix.manylinux || 'auto' }}
-          container: ${{ matrix.container }}
-          args: --release --out dist --interpreter ${{ matrix.interpreter || '3.7 3.8 3.9 3.10 3.11 3.12 pypy3.7 pypy3.8 pypy3.9 pypy3.10' }} ${{ matrix.extra-build-args }}
+          manylinux: ${{ matrix.manylinux == 'manylinux' && 'auto' || matrix.manylinux }}
+          args: --release --out dist --interpreter ${{ matrix.interpreter || '3.7 3.8 3.9 3.10 3.11 3.12 pypy3.7 pypy3.8 pypy3.9 pypy3.10' }}
           rust-toolchain: stable
           docker-options: -e CI
 
-      - run: ${{ matrix.ls || 'ls -lh' }} dist/
+      - run: ${{ (matrix.os == 'windows' && 'dir') || 'ls -lh' }} dist/
 
       - run: twine check --strict dist/*
 
@@ -473,20 +471,27 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-latest, windows-latest, macos-latest-xlarge]
+        os: [linux, windows, macos]
         interpreter: ['3.7', '3.8', '3.9', '3.10', '3.11', '3.12']
         include:
-          - os: windows-latest
+          # standard runners with override for macos arm
+          - os: linux
+            runs-on: ubuntu-latest
+          - os: windows
             ls: dir
+            runs-on: windows-latest
+          - os: macos
+            runs-on: macos-latest-xlarge
         exclude:
-          - os: macos-latest-xlarge
+          # macos arm only supported from 3.10 and up
+          - os: macos
             interpreter: '3.7'
-          - os: macos-latest-xlarge
+          - os: macos
             interpreter: '3.8'
-          - os: macos-latest-xlarge
+          - os: macos
             interpreter: '3.9'
 
-    runs-on: ${{ matrix.os }}
+    runs-on: ${{ matrix.runs-on }}
     steps:
       - uses: actions/checkout@v4
 

From 439eeacd70b9f87ab36da35def6b9e9854b03672 Mon Sep 17 00:00:00 2001
From: Arthur Pastel <arthur.pastel@gmail.com>
Date: Tue, 14 Nov 2023 15:17:19 +0100
Subject: [PATCH 118/550] Bump python version for benchmarks (#1064)

---
 .github/workflows/codspeed.yml | 8 +++++---
 Cargo.toml                     | 5 +++++
 2 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/codspeed.yml b/.github/workflows/codspeed.yml
index 32bc83a1e..b01d4ff7e 100644
--- a/.github/workflows/codspeed.yml
+++ b/.github/workflows/codspeed.yml
@@ -18,7 +18,7 @@ jobs:
 
       - uses: actions/setup-python@v4
         with:
-          python-version: '3.10'
+          python-version: '3.12'
 
       - uses: actions/cache@v3
         id: cache-py
@@ -48,10 +48,12 @@ jobs:
 
       - name: cache rust
         uses: Swatinem/rust-cache@v2
+        with:
+          key: v1
 
       - name: Compile pydantic-core for profiling
         run: |
-          pip install -e . --config-settings=build-args='--verbose' -v
+          pip install -e . --config-settings=build-args='--verbose --profile codspeed' -v
         env:
           CONST_RANDOM_SEED: 0 # Fix the compile time RNG seed
           RUSTFLAGS: "-Cprofile-generate=${{ github.workspace }}/profdata"
@@ -64,7 +66,7 @@ jobs:
 
       - name: Compile pydantic-core for benchmarking
         run: |
-          pip install -e . --config-settings=build-args='--verbose' -v
+          pip install -e . --config-settings=build-args='--verbose --profile codspeed' -v
         env:
           CONST_RANDOM_SEED: 0 # Fix the compile time RNG seed
           RUSTFLAGS: "-Cprofile-use=${{ github.workspace }}/merged.profdata"
diff --git a/Cargo.toml b/Cargo.toml
index f7c859534..120b8496d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -63,6 +63,11 @@ strip = true
 debug = true
 strip = false
 
+[profile.codspeed]
+inherits = "release"
+debug = true
+strip = false
+
 [dev-dependencies]
 pyo3 = { version = "0.20.0", features = ["auto-initialize"] }
 

From b18f4f95a5c852fb7e97a81a11e67bae31c58e0a Mon Sep 17 00:00:00 2001
From: David Hewitt <mail@davidhewitt.io>
Date: Tue, 14 Nov 2023 14:26:12 +0000
Subject: [PATCH 119/550] bump version to 2.14.2 (#1073)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index e00130f7d..244ec1cda 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -321,7 +321,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.14.1"
+version = "2.14.2"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index 120b8496d..e938382e4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.14.1"
+version = "2.14.2"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From 73b118444cde9b14578f87fc866cf4271c8ab512 Mon Sep 17 00:00:00 2001
From: Samuel Colvin <s@muelcolvin.com>
Date: Tue, 14 Nov 2023 17:38:48 +0000
Subject: [PATCH 120/550] uprev to 2.24.3

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 244ec1cda..40ca98e4d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -321,7 +321,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.14.2"
+version = "2.14.3"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index e938382e4..39da916f5 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.14.2"
+version = "2.14.3"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From 3fea8332ed300c5439acde2f92e8c66f2ff5b42b Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Wed, 15 Nov 2023 13:46:01 -0600
Subject: [PATCH 121/550] Fix bug re `custom_init` on members of `Union`
 (#1076)

---
 src/validators/model.rs             |  5 +++-
 tests/validators/test_model_init.py | 45 +++++++++++++++++++++++++++++
 2 files changed, 49 insertions(+), 1 deletion(-)

diff --git a/src/validators/model.rs b/src/validators/model.rs
index 0299ce5d8..a571ccd9e 100644
--- a/src/validators/model.rs
+++ b/src/validators/model.rs
@@ -257,7 +257,10 @@ impl ModelValidator {
             // this work with from_attributes, and would essentially allow you to
             // handle init vars by adding them to the __init__ signature.
             if let Some(kwargs) = input.as_kwargs(py) {
-                return Ok(self.class.call(py, (), Some(kwargs))?);
+                return self
+                    .class
+                    .call(py, (), Some(kwargs))
+                    .map_err(|e| convert_err(py, e, input));
             }
         }
 
diff --git a/tests/validators/test_model_init.py b/tests/validators/test_model_init.py
index 5521f8da4..b0c28dc86 100644
--- a/tests/validators/test_model_init.py
+++ b/tests/validators/test_model_init.py
@@ -479,3 +479,48 @@ def _wrap_validator(cls, v, validator, info):
     gc.collect()
 
     assert ref() is None
+
+
+def test_model_custom_init_with_union() -> None:
+    class A:
+        def __init__(self, **kwargs):
+            assert 'a' in kwargs
+            self.a = kwargs.get('a')
+
+    class B:
+        def __init__(self, **kwargs):
+            assert 'b' in kwargs
+            self.b = kwargs.get('b')
+
+    schema = {
+        'type': 'union',
+        'choices': [
+            {
+                'type': 'model',
+                'cls': A,
+                'schema': {
+                    'type': 'model-fields',
+                    'fields': {'a': {'type': 'model-field', 'schema': {'type': 'bool'}}},
+                    'model_name': 'A',
+                },
+                'custom_init': True,
+                'ref': '__main__.A:4947206928',
+            },
+            {
+                'type': 'model',
+                'cls': B,
+                'schema': {
+                    'type': 'model-fields',
+                    'fields': {'b': {'type': 'model-field', 'schema': {'type': 'bool'}}},
+                    'model_name': 'B',
+                },
+                'custom_init': True,
+                'ref': '__main__.B:4679932848',
+            },
+        ],
+    }
+
+    validator = SchemaValidator(schema)
+
+    assert validator.validate_python({'a': False}).a is False
+    assert validator.validate_python({'b': True}).b is True

From 203b395fe0d09d8c30c37462c46192b96e6dac00 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Thu, 16 Nov 2023 10:14:31 -0600
Subject: [PATCH 122/550] Fix validation of `Literal` from JSON keys when used
 as `dict` key (#1075)

Co-authored-by: David Montague <35119617+dmontagu@users.noreply.github.com>
---
 src/validators/literal.rs | 16 +++++++++++++---
 tests/test.rs             | 33 ++++++++++++++++++++++++++++++++-
 2 files changed, 45 insertions(+), 4 deletions(-)

diff --git a/src/validators/literal.rs b/src/validators/literal.rs
index c9a846695..686920cca 100644
--- a/src/validators/literal.rs
+++ b/src/validators/literal.rs
@@ -9,7 +9,7 @@ use pyo3::{intern, PyTraverseError, PyVisit};
 
 use crate::build_tools::{py_schema_err, py_schema_error_type};
 use crate::errors::{ErrorType, ValError, ValResult};
-use crate::input::Input;
+use crate::input::{Input, ValidationMatch};
 use crate::py_gc::PyGcTraverse;
 use crate::tools::SchemaDict;
 
@@ -116,8 +116,18 @@ impl<T: Debug> LiteralLookup<T> {
             }
         }
         if let Some(expected_strings) = &self.expected_str {
-            // dbg!(expected_strings);
-            if let Ok(either_str) = input.exact_str() {
+            let validation_result = if input.is_python() {
+                input.exact_str()
+            } else {
+                // Strings coming from JSON are treated as "strict" but not "exact" for reasons
+                // of parsing types like UUID; see the implementation of `validate_str` for Json
+                // inputs for justification. We might change that eventually, but for now we need
+                // to work around this when loading from JSON
+                // V3 TODO: revisit making this "exact" for JSON inputs
+                input.validate_str(true, false).map(ValidationMatch::into_inner)
+            };
+
+            if let Ok(either_str) = validation_result {
                 let cow = either_str.as_cow()?;
                 if let Some(id) = expected_strings.get(cow.as_ref()) {
                     return Ok(Some((input, &self.values[*id])));
diff --git a/tests/test.rs b/tests/test.rs
index 348520435..4b0918d40 100644
--- a/tests/test.rs
+++ b/tests/test.rs
@@ -1,6 +1,6 @@
 #[cfg(test)]
 mod tests {
-    use _pydantic_core::SchemaSerializer;
+    use _pydantic_core::{SchemaSerializer, SchemaValidator};
     use pyo3::prelude::*;
     use pyo3::types::PyDict;
 
@@ -86,4 +86,35 @@ a = A()
             assert_eq!(serialized, b"{\"b\":\"b\"}");
         });
     }
+
+    #[test]
+    fn test_literal_schema() {
+        Python::with_gil(|py| {
+            let code = r#"
+schema = {
+    "type": "dict",
+    "keys_schema": {
+        "type": "literal",
+        "expected": ["a", "b"],
+    },
+    "values_schema": {
+        "type": "str",
+    },
+    "strict": False,
+}
+json_input = '{"a": "something"}'
+            "#;
+            let locals = PyDict::new(py);
+            py.run(code, None, Some(locals)).unwrap();
+            let schema: &PyDict = locals.get_item("schema").unwrap().unwrap().extract().unwrap();
+            let json_input: &PyAny = locals.get_item("json_input").unwrap().unwrap().extract().unwrap();
+            let binding = SchemaValidator::py_new(py, schema, None)
+                .unwrap()
+                .validate_json(py, json_input, None, None, None)
+                .unwrap();
+            let validation_result: &PyAny = binding.extract(py).unwrap();
+            let repr = format!("{}", validation_result.repr().unwrap());
+            assert_eq!(repr, "{'a': 'something'}");
+        });
+    }
 }

From 2f0c8c27fe8475fe55ca4326aee8ba462ad6fb4e Mon Sep 17 00:00:00 2001
From: David Hewitt <mail@davidhewitt.io>
Date: Fri, 17 Nov 2023 09:38:38 +0000
Subject: [PATCH 123/550] Update ci for Rust 1.74 (#1079)

---
 Cargo.toml    |  4 ++++
 Makefile      | 12 +++++-------
 tests/test.rs |  4 ++--
 3 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 39da916f5..861473953 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -75,3 +75,7 @@ pyo3 = { version = "0.20.0", features = ["auto-initialize"] }
 version_check = "0.9.4"
 # used where logic has to be version/distribution specific, e.g. pypy
 pyo3-build-config = { version = "0.20.0" }
+
+[lints.clippy]
+dbg_macro = "warn"
+print_stdout = "warn"
diff --git a/Makefile b/Makefile
index d9e0d0e0a..e477cf767 100644
--- a/Makefile
+++ b/Makefile
@@ -1,5 +1,5 @@
 .DEFAULT_GOAL := all
-sources = python/pydantic_core tests generate_self_schema.py wasm-preview/run_tests.py 
+sources = python/pydantic_core tests generate_self_schema.py wasm-preview/run_tests.py
 
 mypy-stubtest = python -m mypy.stubtest pydantic_core._pydantic_core --allowlist .mypy-stubtest-allowlist
 
@@ -90,14 +90,14 @@ build-wasm:
 
 .PHONY: format
 format:
-	ruff --fix $(sources) 
-	ruff format $(sources) 
+	ruff --fix $(sources)
+	ruff format $(sources)
 	cargo fmt
 
 .PHONY: lint-python
 lint-python:
-	ruff $(sources) 
-	ruff format --check $(sources) 
+	ruff $(sources)
+	ruff format --check $(sources)
 	$(mypy-stubtest)
 	griffe dump -f -d google -LWARNING -o/dev/null python/pydantic_core
 
@@ -109,8 +109,6 @@ lint-rust:
 	cargo clippy --tests -- \
 		-D warnings \
 		-W clippy::pedantic \
-		-W clippy::dbg_macro \
-		-W clippy::print_stdout \
 		-A clippy::cast-possible-truncation \
 		-A clippy::cast-possible-wrap \
 		-A clippy::cast-precision-loss \
diff --git a/tests/test.rs b/tests/test.rs
index 4b0918d40..e0b76a4d8 100644
--- a/tests/test.rs
+++ b/tests/test.rs
@@ -22,7 +22,7 @@ mod tests {
             //         'type': 'function-wrap',
             //         'function': lambda: None,
             //     },
-            let code = r#"{
+            let code = r"{
                 'type': 'definitions',
                 'schema': {'type': 'definition-ref', 'schema_ref': 'C-ref'},
                 'definitions': [
@@ -44,7 +44,7 @@ mod tests {
                         },
                     },
                 ]
-            }"#;
+            }";
             let schema: &PyDict = py.eval(code, None, None).unwrap().extract().unwrap();
             SchemaSerializer::py_new(py, schema, None).unwrap();
         });

From ca83d24736816ea9e862b7804b32f63e1312bb06 Mon Sep 17 00:00:00 2001
From: Viicos <65306057+Viicos@users.noreply.github.com>
Date: Fri, 17 Nov 2023 10:49:11 +0100
Subject: [PATCH 124/550] Fix validation of negative floats when using
 `multiple_of` (#1077)

Co-authored-by: David Hewitt <mail@davidhewitt.io>
---
 src/validators/float.rs          | 2 +-
 tests/validators/test_decimal.py | 1 +
 tests/validators/test_float.py   | 1 +
 3 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/validators/float.rs b/src/validators/float.rs
index b72ffafc0..126e539c2 100644
--- a/src/validators/float.rs
+++ b/src/validators/float.rs
@@ -109,7 +109,7 @@ impl Validator for ConstrainedFloatValidator {
         }
         if let Some(multiple_of) = self.multiple_of {
             let rem = float % multiple_of;
-            let threshold = float / 1e9;
+            let threshold = float.abs() / 1e9;
             if rem.abs() > threshold && (rem - multiple_of).abs() > threshold {
                 return Err(ValError::new(
                     ErrorType::MultipleOf {
diff --git a/tests/validators/test_decimal.py b/tests/validators/test_decimal.py
index b9fabeaed..69cd52738 100644
--- a/tests/validators/test_decimal.py
+++ b/tests/validators/test_decimal.py
@@ -188,6 +188,7 @@ def test_decimal_kwargs(py_and_json: PyAndJson, kwargs: Dict[str, Any], input_va
         (0.1, 1, None),
         (0.1, 1.0, None),
         (0.1, int(5e10), None),
+        (2.0, -2.0, None),
     ],
     ids=repr,
 )
diff --git a/tests/validators/test_float.py b/tests/validators/test_float.py
index 4e3bda0c4..56c03d40e 100644
--- a/tests/validators/test_float.py
+++ b/tests/validators/test_float.py
@@ -121,6 +121,7 @@ def test_float_kwargs(py_and_json: PyAndJson, kwargs: Dict[str, Any], input_valu
         (0.1, 1, None),
         (0.1, 1.0, None),
         (0.1, int(5e10), None),
+        (2.0, -2.0, None),
     ],
     ids=repr,
 )

From 223aa278499481c6830e3c4a3dd6a1d75a9e15f2 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Fri, 17 Nov 2023 09:19:05 -0600
Subject: [PATCH 125/550] uprev: 2.14.4 (#1081)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 40ca98e4d..249fdfbf9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -321,7 +321,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.14.3"
+version = "2.14.4"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index 861473953..87a2f2282 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.14.3"
+version = "2.14.4"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From 14c2971729b0f8354ca7da8894b7371146ce30cd Mon Sep 17 00:00:00 2001
From: David Hewitt <mail@davidhewitt.io>
Date: Fri, 17 Nov 2023 19:56:55 +0000
Subject: [PATCH 126/550] Fix bug with UUID validation from json with a wrap
 validator (#1080)

---
 src/input/input_abstract.rs          |  2 +-
 src/validators/dataclass.rs          |  3 ++-
 src/validators/uuid.rs               |  8 +++++---
 tests/validators/test_dataclasses.py | 21 +++++++++++++++++++++
 tests/validators/test_uuid.py        | 15 ++++++++++++++-
 5 files changed, 43 insertions(+), 6 deletions(-)

diff --git a/src/input/input_abstract.rs b/src/input/input_abstract.rs
index ba6fbd0a1..765ede739 100644
--- a/src/input/input_abstract.rs
+++ b/src/input/input_abstract.rs
@@ -14,7 +14,7 @@ use super::datetime::{EitherDate, EitherDateTime, EitherTime, EitherTimedelta};
 use super::return_enums::{EitherBytes, EitherInt, EitherString};
 use super::{EitherFloat, GenericArguments, GenericIterable, GenericIterator, GenericMapping, ValidationMatch};
 
-#[derive(Debug, Clone, Copy)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum InputType {
     Python,
     Json,
diff --git a/src/validators/dataclass.rs b/src/validators/dataclass.rs
index 1646f5ea6..4140b1b26 100644
--- a/src/validators/dataclass.rs
+++ b/src/validators/dataclass.rs
@@ -8,6 +8,7 @@ use ahash::AHashSet;
 use crate::build_tools::py_schema_err;
 use crate::build_tools::{is_strict, schema_or_config_same, ExtraBehavior};
 use crate::errors::{AsLocItem, ErrorType, ErrorTypeDefaults, ValError, ValLineError, ValResult};
+use crate::input::InputType;
 use crate::input::{BorrowInput, GenericArguments, Input, ValidationMatch};
 use crate::lookup_key::LookupKey;
 use crate::tools::SchemaDict;
@@ -535,7 +536,7 @@ impl Validator for DataclassValidator {
             } else {
                 Ok(input.to_object(py))
             }
-        } else if state.strict_or(self.strict) && input.is_python() {
+        } else if state.strict_or(self.strict) && state.extra().input_type == InputType::Python {
             Err(ValError::new(
                 ErrorType::DataclassExactType {
                     class_name: self.get_name().to_string(),
diff --git a/src/validators/uuid.rs b/src/validators/uuid.rs
index 9e4ce9fb5..3324d5ea1 100644
--- a/src/validators/uuid.rs
+++ b/src/validators/uuid.rs
@@ -9,6 +9,7 @@ use uuid::Uuid;
 use crate::build_tools::is_strict;
 use crate::errors::{ErrorType, ErrorTypeDefaults, ValError, ValResult};
 use crate::input::Input;
+use crate::input::InputType;
 use crate::tools::SchemaDict;
 
 use super::model::create_class;
@@ -108,7 +109,7 @@ impl Validator for UuidValidator {
                 }
             }
             Ok(py_input.to_object(py))
-        } else if state.strict_or(self.strict) && input.is_python() {
+        } else if state.strict_or(self.strict) && state.extra().input_type == InputType::Python {
             Err(ValError::new(
                 ErrorType::IsInstanceOf {
                     class: class.name().unwrap_or("UUID").to_string(),
@@ -118,8 +119,9 @@ impl Validator for UuidValidator {
             ))
         } else {
             // In python mode this is a coercion, in JSON mode we treat a UUID string as an
-            // exact match
-            if input.is_python() {
+            // exact match.
+            // TODO V3: we might want to remove the JSON special case
+            if state.extra().input_type == InputType::Python {
                 state.floor_exactness(Exactness::Lax);
             }
             let uuid = self.get_uuid(input)?;
diff --git a/tests/validators/test_dataclasses.py b/tests/validators/test_dataclasses.py
index 9c2b93dfe..94bf7fd65 100644
--- a/tests/validators/test_dataclasses.py
+++ b/tests/validators/test_dataclasses.py
@@ -1510,6 +1510,27 @@ def test_dataclass_json():
     ]
 
 
+def test_dataclass_wrap_json():
+    # https://github.com/pydantic/pydantic/issues/8147
+    schema = core_schema.no_info_wrap_validator_function(
+        lambda v, handler: handler(v),
+        core_schema.dataclass_schema(
+            FooDataclass,
+            core_schema.dataclass_args_schema(
+                'FooDataclass',
+                [
+                    core_schema.dataclass_field(name='a', schema=core_schema.str_schema()),
+                    core_schema.dataclass_field(name='b', schema=core_schema.bool_schema()),
+                ],
+            ),
+            ['a', 'b'],
+        ),
+    )
+    v = SchemaValidator(schema)
+    assert v.validate_json('{"a": "hello", "b": true}') == FooDataclass(a='hello', b=True)
+    assert v.validate_json('{"a": "hello", "b": true}', strict=True) == FooDataclass(a='hello', b=True)
+
+
 @pytest.mark.xfail(
     condition=platform.python_implementation() == 'PyPy', reason='https://foss.heptapod.net/pypy/pypy/-/issues/3899'
 )
diff --git a/tests/validators/test_uuid.py b/tests/validators/test_uuid.py
index 9afe2d2b8..9b4ef60cf 100644
--- a/tests/validators/test_uuid.py
+++ b/tests/validators/test_uuid.py
@@ -4,7 +4,7 @@
 
 import pytest
 
-from pydantic_core import SchemaValidator, ValidationError
+from pydantic_core import SchemaValidator, ValidationError, core_schema
 
 from ..conftest import Err, PyAndJson
 
@@ -197,3 +197,16 @@ def test_uuid_copy():
     assert repr(output) == "UUID('a6cc5730-2261-11ee-9c43-2eb5a363657c')"
     assert c == output
     assert isinstance(output, UUID)
+
+
+def test_uuid_wrap_json():
+    # https://github.com/pydantic/pydantic/issues/8147
+    schema = core_schema.no_info_wrap_validator_function(lambda v, handler: handler(v), core_schema.uuid_schema())
+    v = SchemaValidator(schema)
+
+    assert v.validate_python(UUID('a6cc5730-2261-11ee-9c43-2eb5a363657c'), strict=True) == UUID(
+        'a6cc5730-2261-11ee-9c43-2eb5a363657c'
+    )
+    assert v.validate_json('"a6cc5730-2261-11ee-9c43-2eb5a363657c"', strict=True) == UUID(
+        'a6cc5730-2261-11ee-9c43-2eb5a363657c'
+    )

From 2bb53d869b034ee6d6496bdd104e8377bc71c722 Mon Sep 17 00:00:00 2001
From: David Hewitt <mail@davidhewitt.io>
Date: Mon, 20 Nov 2023 15:52:43 +0000
Subject: [PATCH 127/550] move all clippy lints into `[lints.clippy]` table
 (#1083)

Co-authored-by: David Hewitt <mail@davidhewitt.dev>
---
 Cargo.toml | 27 +++++++++++++++++++++++++++
 Makefile   | 27 +--------------------------
 2 files changed, 28 insertions(+), 26 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 87a2f2282..512d98908 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -79,3 +79,30 @@ pyo3-build-config = { version = "0.20.0" }
 [lints.clippy]
 dbg_macro = "warn"
 print_stdout = "warn"
+
+# in general we lint against the pedantic group, but we will whitelist
+# certain lints which we don't want to enforce (for now)
+pedantic = { level = "warn", priority = -1 }
+cast_possible_truncation = "allow"
+cast_possible_wrap = "allow"
+cast_precision_loss = "allow"
+cast_sign_loss = "allow"
+doc_markdown = "allow"
+float_cmp = "allow"
+fn_params_excessive_bools = "allow"
+if_not_else = "allow"
+manual_let_else = "allow"
+match_bool = "allow"
+match_same_arms = "allow"
+missing_errors_doc = "allow"
+missing_panics_doc = "allow"
+module_name_repetitions = "allow"
+must_use_candidate = "allow"
+needless_pass_by_value = "allow"
+similar_names = "allow"
+single_match_else = "allow"
+struct_excessive_bools = "allow"
+too_many_lines = "allow"
+unnecessary_wraps = "allow"
+unused_self = "allow"
+used_underscore_binding = "allow"
diff --git a/Makefile b/Makefile
index e477cf767..e1f0bc607 100644
--- a/Makefile
+++ b/Makefile
@@ -106,32 +106,7 @@ lint-rust:
 	cargo fmt --version
 	cargo fmt --all -- --check
 	cargo clippy --version
-	cargo clippy --tests -- \
-		-D warnings \
-		-W clippy::pedantic \
-		-A clippy::cast-possible-truncation \
-		-A clippy::cast-possible-wrap \
-		-A clippy::cast-precision-loss \
-		-A clippy::cast-sign-loss \
-		-A clippy::doc-markdown \
-		-A clippy::float-cmp \
-		-A clippy::fn-params-excessive-bools \
-		-A clippy::if-not-else \
-		-A clippy::manual-let-else \
-		-A clippy::match-bool \
-		-A clippy::match-same-arms \
-		-A clippy::missing-errors-doc \
-		-A clippy::missing-panics-doc \
-		-A clippy::module-name-repetitions \
-		-A clippy::must-use-candidate \
-		-A clippy::needless-pass-by-value \
-		-A clippy::similar-names \
-		-A clippy::single-match-else \
-		-A clippy::struct-excessive-bools \
-		-A clippy::too-many-lines \
-		-A clippy::unnecessary-wraps \
-		-A clippy::unused-self \
-		-A clippy::used-underscore-binding
+	cargo clippy --tests -- -D warnings
 
 .PHONY: lint
 lint: lint-python lint-rust

From be9c21c9fc64b5341c9e1fb4674239b8db9709db Mon Sep 17 00:00:00 2001
From: David Hewitt <mail@davidhewitt.dev>
Date: Tue, 21 Nov 2023 07:17:23 +0000
Subject: [PATCH 128/550] Remove lifetime from errors (#1084)

---
 src/errors/line_error.rs           | 83 ++++++++++++------------------
 src/errors/mod.rs                  |  2 +-
 src/errors/validation_exception.rs | 20 +++----
 src/errors/value_exception.rs      |  7 +--
 src/input/datetime.rs              | 10 ++--
 src/input/input_abstract.rs        | 22 ++++----
 src/input/input_json.rs            | 46 +++++++++++------
 src/input/input_python.rs          | 22 +++++---
 src/input/input_string.rs          | 20 +++----
 src/input/return_enums.rs          | 52 +++++++++----------
 src/input/shared.rs                | 14 ++---
 src/lookup_key.rs                  | 19 +++----
 src/validators/any.rs              |  2 +-
 src/validators/arguments.rs        |  2 +-
 src/validators/bool.rs             |  2 +-
 src/validators/bytes.rs            |  4 +-
 src/validators/call.rs             |  2 +-
 src/validators/callable.rs         |  2 +-
 src/validators/chain.rs            |  2 +-
 src/validators/custom_error.rs     |  5 +-
 src/validators/dataclass.rs        | 21 ++++----
 src/validators/date.rs             |  4 +-
 src/validators/datetime.rs         |  4 +-
 src/validators/decimal.rs          | 18 ++-----
 src/validators/definitions.rs      |  4 +-
 src/validators/dict.rs             | 21 ++++----
 src/validators/float.rs            |  4 +-
 src/validators/frozenset.rs        |  2 +-
 src/validators/function.rs         | 24 ++++-----
 src/validators/generator.rs        |  2 +-
 src/validators/int.rs              |  4 +-
 src/validators/is_instance.rs      |  2 +-
 src/validators/is_subclass.rs      |  2 +-
 src/validators/json.rs             |  4 +-
 src/validators/json_or_python.rs   |  2 +-
 src/validators/lax_or_strict.rs    |  2 +-
 src/validators/list.rs             |  2 +-
 src/validators/literal.rs          |  4 +-
 src/validators/mod.rs              | 12 ++---
 src/validators/model.rs            | 10 ++--
 src/validators/model_fields.rs     | 22 ++++----
 src/validators/none.rs             |  2 +-
 src/validators/nullable.rs         |  2 +-
 src/validators/set.rs              |  2 +-
 src/validators/string.rs           |  4 +-
 src/validators/time.rs             |  2 +-
 src/validators/timedelta.rs        |  2 +-
 src/validators/tuple.rs            |  8 +--
 src/validators/typed_dict.rs       | 17 +++---
 src/validators/union.rs            | 28 +++++-----
 src/validators/url.rs              | 24 ++++-----
 src/validators/uuid.rs             |  6 +--
 src/validators/with_default.rs     |  8 +--
 53 files changed, 294 insertions(+), 319 deletions(-)

diff --git a/src/errors/line_error.rs b/src/errors/line_error.rs
index 3ee4c7894..f5fa11b70 100644
--- a/src/errors/line_error.rs
+++ b/src/errors/line_error.rs
@@ -9,44 +9,54 @@ use crate::input::Input;
 use super::location::{LocItem, Location};
 use super::types::ErrorType;
 
-pub type ValResult<'a, T> = Result<T, ValError<'a>>;
+pub type ValResult<T> = Result<T, ValError>;
+
+pub trait AsErrorValue {
+    fn as_error_value(&self) -> InputValue;
+}
+
+impl<'a, T: Input<'a>> AsErrorValue for T {
+    fn as_error_value(&self) -> InputValue {
+        Input::as_error_value(self)
+    }
+}
 
 #[cfg_attr(debug_assertions, derive(Debug))]
-pub enum ValError<'a> {
-    LineErrors(Vec<ValLineError<'a>>),
+pub enum ValError {
+    LineErrors(Vec<ValLineError>),
     InternalErr(PyErr),
     Omit,
     UseDefault,
 }
 
-impl<'a> From<PyErr> for ValError<'a> {
+impl From<PyErr> for ValError {
     fn from(py_err: PyErr) -> Self {
         Self::InternalErr(py_err)
     }
 }
 
-impl<'a> From<PyDowncastError<'_>> for ValError<'a> {
+impl From<PyDowncastError<'_>> for ValError {
     fn from(py_downcast: PyDowncastError) -> Self {
         Self::InternalErr(PyTypeError::new_err(py_downcast.to_string()))
     }
 }
 
-impl<'a> From<Vec<ValLineError<'a>>> for ValError<'a> {
-    fn from(line_errors: Vec<ValLineError<'a>>) -> Self {
+impl From<Vec<ValLineError>> for ValError {
+    fn from(line_errors: Vec<ValLineError>) -> Self {
         Self::LineErrors(line_errors)
     }
 }
 
-impl<'a> ValError<'a> {
-    pub fn new(error_type: ErrorType, input: &'a impl Input<'a>) -> ValError<'a> {
+impl ValError {
+    pub fn new(error_type: ErrorType, input: &impl AsErrorValue) -> ValError {
         Self::LineErrors(vec![ValLineError::new(error_type, input)])
     }
 
-    pub fn new_with_loc(error_type: ErrorType, input: &'a impl Input<'a>, loc: impl Into<LocItem>) -> ValError<'a> {
+    pub fn new_with_loc(error_type: ErrorType, input: &impl AsErrorValue, loc: impl Into<LocItem>) -> ValError {
         Self::LineErrors(vec![ValLineError::new_with_loc(error_type, input, loc)])
     }
 
-    pub fn new_custom_input(error_type: ErrorType, input_value: InputValue<'a>) -> ValError<'a> {
+    pub fn new_custom_input(error_type: ErrorType, input_value: InputValue) -> ValError {
         Self::LineErrors(vec![ValLineError::new_custom_input(error_type, input_value)])
     }
 
@@ -62,31 +72,21 @@ impl<'a> ValError<'a> {
             other => other,
         }
     }
-
-    /// a bit like clone but change the lifetime to match py
-    pub fn into_owned(self, py: Python<'_>) -> ValError<'_> {
-        match self {
-            ValError::LineErrors(errors) => errors.into_iter().map(|e| e.into_owned(py)).collect::<Vec<_>>().into(),
-            ValError::InternalErr(err) => ValError::InternalErr(err),
-            ValError::Omit => ValError::Omit,
-            ValError::UseDefault => ValError::UseDefault,
-        }
-    }
 }
 
 /// A `ValLineError` is a single error that occurred during validation which is converted to a `PyLineError`
 /// to eventually form a `ValidationError`.
 /// I don't like the name `ValLineError`, but it's the best I could come up with (for now).
 #[cfg_attr(debug_assertions, derive(Debug))]
-pub struct ValLineError<'a> {
+pub struct ValLineError {
     pub error_type: ErrorType,
     // location is reversed so that adding an "outer" location item is pushing, it's reversed before showing to the user
     pub location: Location,
-    pub input_value: InputValue<'a>,
+    pub input_value: InputValue,
 }
 
-impl<'a> ValLineError<'a> {
-    pub fn new(error_type: ErrorType, input: &'a impl Input<'a>) -> ValLineError<'a> {
+impl ValLineError {
+    pub fn new(error_type: ErrorType, input: &impl AsErrorValue) -> ValLineError {
         Self {
             error_type,
             input_value: input.as_error_value(),
@@ -94,7 +94,7 @@ impl<'a> ValLineError<'a> {
         }
     }
 
-    pub fn new_with_loc(error_type: ErrorType, input: &'a impl Input<'a>, loc: impl Into<LocItem>) -> ValLineError<'a> {
+    pub fn new_with_loc(error_type: ErrorType, input: &impl AsErrorValue, loc: impl Into<LocItem>) -> ValLineError {
         Self {
             error_type,
             input_value: input.as_error_value(),
@@ -102,7 +102,7 @@ impl<'a> ValLineError<'a> {
         }
     }
 
-    pub fn new_with_full_loc(error_type: ErrorType, input: &'a impl Input<'a>, location: Location) -> ValLineError<'a> {
+    pub fn new_with_full_loc(error_type: ErrorType, input: &impl AsErrorValue, location: Location) -> ValLineError {
         Self {
             error_type,
             input_value: input.as_error_value(),
@@ -110,7 +110,7 @@ impl<'a> ValLineError<'a> {
         }
     }
 
-    pub fn new_custom_input(error_type: ErrorType, input_value: InputValue<'a>) -> ValLineError<'a> {
+    pub fn new_custom_input(error_type: ErrorType, input_value: InputValue) -> ValLineError {
         Self {
             error_type,
             input_value,
@@ -130,35 +130,20 @@ impl<'a> ValLineError<'a> {
         self.error_type = error_type;
         self
     }
-
-    /// a bit like clone but change the lifetime to match py, used by ValError.into_owned above
-    pub fn into_owned(self, py: Python<'_>) -> ValLineError<'_> {
-        ValLineError {
-            error_type: self.error_type,
-            input_value: match self.input_value {
-                InputValue::PyAny(input) => InputValue::PyAny(input.to_object(py).into_ref(py)),
-                InputValue::JsonInput(input) => InputValue::JsonInput(input),
-                InputValue::String(input) => InputValue::PyAny(input.to_object(py).into_ref(py)),
-            },
-            location: self.location,
-        }
-    }
 }
 
 #[cfg_attr(debug_assertions, derive(Debug))]
 #[derive(Clone)]
-pub enum InputValue<'a> {
-    PyAny(&'a PyAny),
-    JsonInput(JsonValue),
-    String(&'a str),
+pub enum InputValue {
+    Python(PyObject),
+    Json(JsonValue),
 }
 
-impl<'a> ToPyObject for InputValue<'a> {
+impl ToPyObject for InputValue {
     fn to_object(&self, py: Python) -> PyObject {
         match self {
-            Self::PyAny(input) => input.into_py(py),
-            Self::JsonInput(input) => input.to_object(py),
-            Self::String(input) => input.into_py(py),
+            Self::Python(input) => input.clone_ref(py),
+            Self::Json(input) => input.to_object(py),
         }
     }
 }
diff --git a/src/errors/mod.rs b/src/errors/mod.rs
index bfc5b4329..131e54177 100644
--- a/src/errors/mod.rs
+++ b/src/errors/mod.rs
@@ -6,7 +6,7 @@ mod types;
 mod validation_exception;
 mod value_exception;
 
-pub use self::line_error::{InputValue, ValError, ValLineError, ValResult};
+pub use self::line_error::{AsErrorValue, InputValue, ValError, ValLineError, ValResult};
 pub use self::location::{AsLocItem, LocItem};
 pub use self::types::{list_all_errors, ErrorType, ErrorTypeDefaults, Number};
 pub use self::validation_exception::ValidationError;
diff --git a/src/errors/validation_exception.rs b/src/errors/validation_exception.rs
index d616e3022..91ef60a0d 100644
--- a/src/errors/validation_exception.rs
+++ b/src/errors/validation_exception.rs
@@ -225,12 +225,8 @@ fn get_url_prefix(py: Python, include_url: bool) -> Option<&str> {
 
 // used to convert a validation error back to ValError for wrap functions
 impl ValidationError {
-    pub(crate) fn into_val_error(self, py: Python<'_>) -> ValError<'_> {
-        self.line_errors
-            .into_iter()
-            .map(|e| e.into_val_line_error(py))
-            .collect::<Vec<_>>()
-            .into()
+    pub(crate) fn into_val_error(self) -> ValError {
+        self.line_errors.into_iter().map(Into::into).collect::<Vec<_>>().into()
     }
 }
 
@@ -416,7 +412,7 @@ pub struct PyLineError {
     input_value: PyObject,
 }
 
-impl<'a> IntoPy<PyLineError> for ValLineError<'a> {
+impl IntoPy<PyLineError> for ValLineError {
     fn into_py(self, py: Python<'_>) -> PyLineError {
         PyLineError {
             error_type: self.error_type,
@@ -426,13 +422,13 @@ impl<'a> IntoPy<PyLineError> for ValLineError<'a> {
     }
 }
 
-impl PyLineError {
+impl From<PyLineError> for ValLineError {
     /// Used to extract line errors from a validation error for wrap functions
-    fn into_val_line_error(self, py: Python<'_>) -> ValLineError<'_> {
+    fn from(other: PyLineError) -> ValLineError {
         ValLineError {
-            error_type: self.error_type,
-            location: self.location,
-            input_value: InputValue::PyAny(self.input_value.into_ref(py)),
+            error_type: other.error_type,
+            location: other.location,
+            input_value: InputValue::Python(other.input_value),
         }
     }
 }
diff --git a/src/errors/value_exception.rs b/src/errors/value_exception.rs
index 7bc7e5227..a88610eef 100644
--- a/src/errors/value_exception.rs
+++ b/src/errors/value_exception.rs
@@ -2,9 +2,10 @@ use pyo3::exceptions::{PyException, PyValueError};
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyString};
 
-use crate::input::{Input, InputType};
+use crate::input::InputType;
 use crate::tools::extract_i64;
 
+use super::line_error::AsErrorValue;
 use super::{ErrorType, ValError};
 
 #[pyclass(extends=PyException, module="pydantic_core._pydantic_core")]
@@ -105,7 +106,7 @@ impl PydanticCustomError {
 }
 
 impl PydanticCustomError {
-    pub fn into_val_error<'a>(self, input: &'a impl Input<'a>) -> ValError<'a> {
+    pub fn into_val_error(self, input: &impl AsErrorValue) -> ValError {
         let error_type = ErrorType::CustomError {
             error_type: self.error_type,
             message_template: self.message_template,
@@ -184,7 +185,7 @@ impl PydanticKnownError {
 }
 
 impl PydanticKnownError {
-    pub fn into_val_error<'a>(self, input: &'a impl Input<'a>) -> ValError<'a> {
+    pub fn into_val_error(self, input: &impl AsErrorValue) -> ValError {
         ValError::new(self.error_type, input)
     }
 }
diff --git a/src/input/datetime.rs b/src/input/datetime.rs
index b89b76c1e..0a3cdf929 100644
--- a/src/input/datetime.rs
+++ b/src/input/datetime.rs
@@ -286,7 +286,7 @@ impl<'a> EitherDateTime<'a> {
     }
 }
 
-pub fn bytes_as_date<'a>(input: &'a impl Input<'a>, bytes: &[u8]) -> ValResult<'a, EitherDate<'a>> {
+pub fn bytes_as_date<'a>(input: &'a impl Input<'a>, bytes: &[u8]) -> ValResult<EitherDate<'a>> {
     match Date::parse_bytes(bytes) {
         Ok(date) => Ok(date.into()),
         Err(err) => Err(ValError::new(
@@ -303,7 +303,7 @@ pub fn bytes_as_time<'a>(
     input: &'a impl Input<'a>,
     bytes: &[u8],
     microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
-) -> ValResult<'a, EitherTime<'a>> {
+) -> ValResult<EitherTime<'a>> {
     match Time::parse_bytes_with_config(
         bytes,
         &TimeConfig {
@@ -326,7 +326,7 @@ pub fn bytes_as_datetime<'a, 'b>(
     input: &'a impl Input<'a>,
     bytes: &'b [u8],
     microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
-) -> ValResult<'a, EitherDateTime<'a>> {
+) -> ValResult<EitherDateTime<'a>> {
     match DateTime::parse_bytes_with_config(
         bytes,
         &TimeConfig {
@@ -455,7 +455,7 @@ pub fn float_as_time<'a>(input: &'a impl Input<'a>, timestamp: f64) -> ValResult
     int_as_time(input, timestamp.floor() as i64, microseconds.round() as u32)
 }
 
-fn map_timedelta_err<'a>(input: &'a impl Input<'a>, err: ParseError) -> ValError<'a> {
+fn map_timedelta_err<'a>(input: &'a impl Input<'a>, err: ParseError) -> ValError {
     ValError::new(
         ErrorType::TimeDeltaParsing {
             error: Cow::Borrowed(err.get_documentation().unwrap_or_default()),
@@ -469,7 +469,7 @@ pub fn bytes_as_timedelta<'a, 'b>(
     input: &'a impl Input<'a>,
     bytes: &'b [u8],
     microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
-) -> ValResult<'a, EitherTimedelta<'a>> {
+) -> ValResult<EitherTimedelta<'a>> {
     match Duration::parse_bytes_with_config(
         bytes,
         &TimeConfig {
diff --git a/src/input/input_abstract.rs b/src/input/input_abstract.rs
index 765ede739..ceb0495a9 100644
--- a/src/input/input_abstract.rs
+++ b/src/input/input_abstract.rs
@@ -49,7 +49,7 @@ impl TryFrom<&str> for InputType {
 /// * `strict_*` & `lax_*` if they have different behavior
 /// * or, `validate_*` and `strict_*` to just call `validate_*` if the behavior for strict and lax is the same
 pub trait Input<'a>: fmt::Debug + ToPyObject + AsLocItem + Sized {
-    fn as_error_value(&'a self) -> InputValue<'a>;
+    fn as_error_value(&self) -> InputValue;
 
     fn identity(&self) -> Option<usize> {
         None
@@ -85,11 +85,11 @@ pub trait Input<'a>: fmt::Debug + ToPyObject + AsLocItem + Sized {
         false
     }
 
-    fn validate_args(&'a self) -> ValResult<'a, GenericArguments<'a>>;
+    fn validate_args(&'a self) -> ValResult<GenericArguments<'a>>;
 
-    fn validate_dataclass_args(&'a self, dataclass_name: &str) -> ValResult<'a, GenericArguments<'a>>;
+    fn validate_dataclass_args(&'a self, dataclass_name: &str) -> ValResult<GenericArguments<'a>>;
 
-    fn parse_json(&'a self) -> ValResult<'a, JsonValue>;
+    fn parse_json(&'a self) -> ValResult<JsonValue>;
 
     fn validate_str(
         &'a self,
@@ -99,9 +99,9 @@ pub trait Input<'a>: fmt::Debug + ToPyObject + AsLocItem + Sized {
 
     fn validate_bytes(&'a self, strict: bool) -> ValResult<ValidationMatch<EitherBytes<'a>>>;
 
-    fn validate_bool(&self, strict: bool) -> ValResult<'_, ValidationMatch<bool>>;
+    fn validate_bool(&self, strict: bool) -> ValResult<ValidationMatch<bool>>;
 
-    fn validate_int(&'a self, strict: bool) -> ValResult<'a, ValidationMatch<EitherInt<'a>>>;
+    fn validate_int(&'a self, strict: bool) -> ValResult<ValidationMatch<EitherInt<'a>>>;
 
     fn exact_int(&'a self) -> ValResult<EitherInt<'a>> {
         self.validate_int(true).and_then(|val_match| {
@@ -121,7 +121,7 @@ pub trait Input<'a>: fmt::Debug + ToPyObject + AsLocItem + Sized {
         })
     }
 
-    fn validate_float(&'a self, strict: bool) -> ValResult<'a, ValidationMatch<EitherFloat<'a>>>;
+    fn validate_float(&'a self, strict: bool) -> ValResult<ValidationMatch<EitherFloat<'a>>>;
 
     fn validate_decimal(&'a self, strict: bool, py: Python<'a>) -> ValResult<&'a PyAny> {
         if strict {
@@ -230,15 +230,11 @@ pub trait Input<'a>: fmt::Debug + ToPyObject + AsLocItem + Sized {
     ) -> ValResult<ValidationMatch<EitherTimedelta>>;
 }
 
-/// The problem to solve here is that iterating a `StringMapping` returns an owned
-/// `StringMapping`, but all the other iterators return references. By introducing
+/// The problem to solve here is that iterating collections often returns owned
+/// values, but inputs are usually taken by reference. By introducing
 /// this trait we abstract over whether the return value from the iterator is owned
 /// or borrowed; all we care about is that we can borrow it again with `borrow_input`
 /// for some lifetime 'a.
-///
-/// This lifetime `'a` is shorter than the original lifetime `'data` of the input,
-/// which is only a problem in error branches. To resolve we have to call `into_owned`
-/// to extend out the lifetime to match the original input.
 pub trait BorrowInput {
     type Input<'a>: Input<'a>
     where
diff --git a/src/input/input_json.rs b/src/input/input_json.rs
index 0411a25d6..3e94adad6 100644
--- a/src/input/input_json.rs
+++ b/src/input/input_json.rs
@@ -31,10 +31,16 @@ impl AsLocItem for JsonValue {
     }
 }
 
+impl AsLocItem for &JsonValue {
+    fn as_loc_item(&self) -> LocItem {
+        AsLocItem::as_loc_item(*self)
+    }
+}
+
 impl<'a> Input<'a> for JsonValue {
-    fn as_error_value(&'a self) -> InputValue<'a> {
+    fn as_error_value(&self) -> InputValue {
         // cloning JsonValue is cheap due to use of Arc
-        InputValue::JsonInput(self.clone())
+        InputValue::Json(self.clone())
     }
 
     fn is_none(&self) -> bool {
@@ -54,7 +60,7 @@ impl<'a> Input<'a> for JsonValue {
         }
     }
 
-    fn validate_args(&'a self) -> ValResult<'a, GenericArguments<'a>> {
+    fn validate_args(&'a self) -> ValResult<GenericArguments<'a>> {
         match self {
             JsonValue::Object(object) => Ok(JsonArgs::new(None, Some(object)).into()),
             JsonValue::Array(array) => Ok(JsonArgs::new(Some(array), None).into()),
@@ -62,7 +68,7 @@ impl<'a> Input<'a> for JsonValue {
         }
     }
 
-    fn validate_dataclass_args(&'a self, class_name: &str) -> ValResult<'a, GenericArguments<'a>> {
+    fn validate_dataclass_args(&'a self, class_name: &str) -> ValResult<GenericArguments<'a>> {
         match self {
             JsonValue::Object(object) => Ok(JsonArgs::new(None, Some(object)).into()),
             _ => {
@@ -78,7 +84,7 @@ impl<'a> Input<'a> for JsonValue {
         }
     }
 
-    fn parse_json(&'a self) -> ValResult<'a, JsonValue> {
+    fn parse_json(&'a self) -> ValResult<JsonValue> {
         match self {
             JsonValue::Str(s) => JsonValue::parse(s.as_bytes(), true).map_err(|e| map_json_err(self, e)),
             _ => Err(ValError::new(ErrorTypeDefaults::JsonType, self)),
@@ -118,7 +124,7 @@ impl<'a> Input<'a> for JsonValue {
         }
     }
 
-    fn validate_bool(&self, strict: bool) -> ValResult<'_, ValidationMatch<bool>> {
+    fn validate_bool(&self, strict: bool) -> ValResult<ValidationMatch<bool>> {
         match self {
             JsonValue::Bool(b) => Ok(ValidationMatch::exact(*b)),
             JsonValue::Str(s) if !strict => str_as_bool(self, s).map(ValidationMatch::lax),
@@ -134,7 +140,7 @@ impl<'a> Input<'a> for JsonValue {
         }
     }
 
-    fn validate_int(&'a self, strict: bool) -> ValResult<'a, ValidationMatch<EitherInt<'a>>> {
+    fn validate_int(&'a self, strict: bool) -> ValResult<ValidationMatch<EitherInt<'a>>> {
         match self {
             JsonValue::Int(i) => Ok(ValidationMatch::exact(EitherInt::I64(*i))),
             JsonValue::BigInt(b) => Ok(ValidationMatch::exact(EitherInt::BigInt(b.clone()))),
@@ -145,7 +151,7 @@ impl<'a> Input<'a> for JsonValue {
         }
     }
 
-    fn validate_float(&'a self, strict: bool) -> ValResult<'a, ValidationMatch<EitherFloat<'a>>> {
+    fn validate_float(&'a self, strict: bool) -> ValResult<ValidationMatch<EitherFloat<'a>>> {
         match self {
             JsonValue::Float(f) => Ok(ValidationMatch::exact(EitherFloat::F64(*f))),
             JsonValue::Int(i) => Ok(ValidationMatch::strict(EitherFloat::F64(*i as f64))),
@@ -326,10 +332,18 @@ impl AsLocItem for String {
     }
 }
 
+impl AsLocItem for &String {
+    fn as_loc_item(&self) -> LocItem {
+        AsLocItem::as_loc_item(*self)
+    }
+}
+
 /// Required for JSON Object keys so the string can behave like an Input
 impl<'a> Input<'a> for String {
-    fn as_error_value(&'a self) -> InputValue<'a> {
-        InputValue::String(self)
+    fn as_error_value(&self) -> InputValue {
+        // Justification for the clone: this is on the error pathway and we are generally ok
+        // with errors having a performance penalty
+        InputValue::Json(JsonValue::Str(self.clone()))
     }
 
     fn as_kwargs(&'a self, _py: Python<'a>) -> Option<&'a PyDict> {
@@ -337,12 +351,12 @@ impl<'a> Input<'a> for String {
     }
 
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn validate_args(&'a self) -> ValResult<'a, GenericArguments<'a>> {
+    fn validate_args(&'a self) -> ValResult<GenericArguments<'a>> {
         Err(ValError::new(ErrorTypeDefaults::ArgumentsType, self))
     }
 
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn validate_dataclass_args(&'a self, class_name: &str) -> ValResult<'a, GenericArguments<'a>> {
+    fn validate_dataclass_args(&'a self, class_name: &str) -> ValResult<GenericArguments<'a>> {
         let class_name = class_name.to_string();
         Err(ValError::new(
             ErrorType::DataclassType {
@@ -353,7 +367,7 @@ impl<'a> Input<'a> for String {
         ))
     }
 
-    fn parse_json(&'a self) -> ValResult<'a, JsonValue> {
+    fn parse_json(&'a self) -> ValResult<JsonValue> {
         JsonValue::parse(self.as_bytes(), true).map_err(|e| map_json_err(self, e))
     }
 
@@ -374,18 +388,18 @@ impl<'a> Input<'a> for String {
         Ok(ValidationMatch::strict(self.as_bytes().into()))
     }
 
-    fn validate_bool(&self, _strict: bool) -> ValResult<'_, ValidationMatch<bool>> {
+    fn validate_bool(&self, _strict: bool) -> ValResult<ValidationMatch<bool>> {
         str_as_bool(self, self).map(ValidationMatch::lax)
     }
 
-    fn validate_int(&'a self, _strict: bool) -> ValResult<'a, ValidationMatch<EitherInt<'a>>> {
+    fn validate_int(&'a self, _strict: bool) -> ValResult<ValidationMatch<EitherInt<'a>>> {
         match self.parse() {
             Ok(i) => Ok(ValidationMatch::lax(EitherInt::I64(i))),
             Err(_) => Err(ValError::new(ErrorTypeDefaults::IntParsing, self)),
         }
     }
 
-    fn validate_float(&'a self, _strict: bool) -> ValResult<'a, ValidationMatch<EitherFloat<'a>>> {
+    fn validate_float(&'a self, _strict: bool) -> ValResult<ValidationMatch<EitherFloat<'a>>> {
         str_as_float(self, self).map(ValidationMatch::lax)
     }
 
diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index 90d2c2a8b..ba42abbb8 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -106,9 +106,15 @@ impl AsLocItem for PyAny {
     }
 }
 
+impl AsLocItem for &'_ PyAny {
+    fn as_loc_item(&self) -> LocItem {
+        AsLocItem::as_loc_item(*self)
+    }
+}
+
 impl<'a> Input<'a> for PyAny {
-    fn as_error_value(&'a self) -> InputValue<'a> {
-        InputValue::PyAny(self)
+    fn as_error_value(&self) -> InputValue {
+        InputValue::Python(self.into())
     }
 
     fn identity(&self) -> Option<usize> {
@@ -154,7 +160,7 @@ impl<'a> Input<'a> for PyAny {
         self.is_callable()
     }
 
-    fn validate_args(&'a self) -> ValResult<'a, GenericArguments<'a>> {
+    fn validate_args(&'a self) -> ValResult<GenericArguments<'a>> {
         if let Ok(dict) = self.downcast::<PyDict>() {
             Ok(PyArgs::new(None, Some(dict)).into())
         } else if let Ok(args_kwargs) = self.extract::<ArgsKwargs>() {
@@ -170,7 +176,7 @@ impl<'a> Input<'a> for PyAny {
         }
     }
 
-    fn validate_dataclass_args(&'a self, class_name: &str) -> ValResult<'a, GenericArguments<'a>> {
+    fn validate_dataclass_args(&'a self, class_name: &str) -> ValResult<GenericArguments<'a>> {
         if let Ok(dict) = self.downcast::<PyDict>() {
             Ok(PyArgs::new(None, Some(dict)).into())
         } else if let Ok(args_kwargs) = self.extract::<ArgsKwargs>() {
@@ -189,7 +195,7 @@ impl<'a> Input<'a> for PyAny {
         }
     }
 
-    fn parse_json(&'a self) -> ValResult<'a, JsonValue> {
+    fn parse_json(&'a self) -> ValResult<JsonValue> {
         let bytes = if let Ok(py_bytes) = self.downcast::<PyBytes>() {
             py_bytes.as_bytes()
         } else if let Ok(py_str) = self.downcast::<PyString>() {
@@ -296,7 +302,7 @@ impl<'a> Input<'a> for PyAny {
         Err(ValError::new(ErrorTypeDefaults::BytesType, self))
     }
 
-    fn validate_bool(&self, strict: bool) -> ValResult<'_, ValidationMatch<bool>> {
+    fn validate_bool(&self, strict: bool) -> ValResult<ValidationMatch<bool>> {
         if let Ok(bool) = self.downcast::<PyBool>() {
             return Ok(ValidationMatch::exact(bool.is_true()));
         }
@@ -319,7 +325,7 @@ impl<'a> Input<'a> for PyAny {
         Err(ValError::new(ErrorTypeDefaults::BoolType, self))
     }
 
-    fn validate_int(&'a self, strict: bool) -> ValResult<'a, ValidationMatch<EitherInt<'a>>> {
+    fn validate_int(&'a self, strict: bool) -> ValResult<ValidationMatch<EitherInt<'a>>> {
         if self.is_exact_instance_of::<PyInt>() {
             return Ok(ValidationMatch::exact(EitherInt::Py(self)));
         } else if self.is_instance_of::<PyInt>() {
@@ -359,7 +365,7 @@ impl<'a> Input<'a> for PyAny {
         Err(ValError::new(ErrorTypeDefaults::IntType, self))
     }
 
-    fn validate_float(&'a self, strict: bool) -> ValResult<'a, ValidationMatch<EitherFloat<'a>>> {
+    fn validate_float(&'a self, strict: bool) -> ValResult<ValidationMatch<EitherFloat<'a>>> {
         if let Ok(float) = self.downcast_exact::<PyFloat>() {
             return Ok(ValidationMatch::exact(EitherFloat::Py(float)));
         }
diff --git a/src/input/input_string.rs b/src/input/input_string.rs
index e27ef6461..290247617 100644
--- a/src/input/input_string.rs
+++ b/src/input/input_string.rs
@@ -34,7 +34,7 @@ impl<'py> ToPyObject for StringMapping<'py> {
 }
 
 impl<'py> StringMapping<'py> {
-    pub fn new_key(py_key: &'py PyAny) -> ValResult<'py, StringMapping> {
+    pub fn new_key(py_key: &'py PyAny) -> ValResult<StringMapping> {
         if let Ok(py_str) = py_key.downcast::<PyString>() {
             Ok(Self::String(py_str))
         } else {
@@ -42,7 +42,7 @@ impl<'py> StringMapping<'py> {
         }
     }
 
-    pub fn new_value(py_value: &'py PyAny) -> ValResult<'py, Self> {
+    pub fn new_value(py_value: &'py PyAny) -> ValResult<Self> {
         if let Ok(py_str) = py_value.downcast::<PyString>() {
             Ok(Self::String(py_str))
         } else if let Ok(value) = py_value.downcast::<PyDict>() {
@@ -63,10 +63,10 @@ impl AsLocItem for StringMapping<'_> {
 }
 
 impl<'a> Input<'a> for StringMapping<'a> {
-    fn as_error_value(&'a self) -> InputValue<'a> {
+    fn as_error_value(&self) -> InputValue {
         match self {
             Self::String(s) => s.as_error_value(),
-            Self::Mapping(d) => InputValue::PyAny(d),
+            Self::Mapping(d) => d.as_error_value(),
         }
     }
 
@@ -74,19 +74,19 @@ impl<'a> Input<'a> for StringMapping<'a> {
         None
     }
 
-    fn validate_args(&'a self) -> ValResult<'a, GenericArguments<'a>> {
+    fn validate_args(&'a self) -> ValResult<GenericArguments<'a>> {
         // do we want to support this?
         Err(ValError::new(ErrorTypeDefaults::ArgumentsType, self))
     }
 
-    fn validate_dataclass_args(&'a self, _dataclass_name: &str) -> ValResult<'a, GenericArguments<'a>> {
+    fn validate_dataclass_args(&'a self, _dataclass_name: &str) -> ValResult<GenericArguments<'a>> {
         match self {
             StringMapping::String(_) => Err(ValError::new(ErrorTypeDefaults::ArgumentsType, self)),
             StringMapping::Mapping(m) => Ok(GenericArguments::StringMapping(m)),
         }
     }
 
-    fn parse_json(&'a self) -> ValResult<'a, JsonValue> {
+    fn parse_json(&'a self) -> ValResult<JsonValue> {
         match self {
             Self::String(s) => {
                 let str = py_string_str(s)?;
@@ -114,14 +114,14 @@ impl<'a> Input<'a> for StringMapping<'a> {
         }
     }
 
-    fn validate_bool(&self, _strict: bool) -> ValResult<'_, ValidationMatch<bool>> {
+    fn validate_bool(&self, _strict: bool) -> ValResult<ValidationMatch<bool>> {
         match self {
             Self::String(s) => str_as_bool(self, py_string_str(s)?).map(ValidationMatch::strict),
             Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::BoolType, self)),
         }
     }
 
-    fn validate_int(&'a self, _strict: bool) -> ValResult<'a, ValidationMatch<EitherInt<'a>>> {
+    fn validate_int(&'a self, _strict: bool) -> ValResult<ValidationMatch<EitherInt<'a>>> {
         match self {
             Self::String(s) => match py_string_str(s)?.parse() {
                 Ok(i) => Ok(ValidationMatch::strict(EitherInt::I64(i))),
@@ -131,7 +131,7 @@ impl<'a> Input<'a> for StringMapping<'a> {
         }
     }
 
-    fn validate_float(&'a self, _strict: bool) -> ValResult<'a, ValidationMatch<EitherFloat<'a>>> {
+    fn validate_float(&'a self, _strict: bool) -> ValResult<ValidationMatch<EitherFloat<'a>>> {
         match self {
             Self::String(s) => str_as_float(self, py_string_str(s)?).map(ValidationMatch::strict),
             Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::FloatType, self)),
diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index 56c7098df..fa70880ca 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -153,7 +153,7 @@ impl<'a, INPUT: Input<'a>> MaxLengthCheck<'a, INPUT> {
         }
     }
 
-    fn incr(&mut self) -> ValResult<'a, ()> {
+    fn incr(&mut self) -> ValResult<()> {
         if let Some(max_length) = self.max_length {
             self.current_length += 1;
             if self.current_length > max_length {
@@ -193,7 +193,7 @@ fn validate_iter_to_vec<'a, 's>(
     mut max_length_check: MaxLengthCheck<'a, impl Input<'a>>,
     validator: &'s CombinedValidator,
     state: &mut ValidationState,
-) -> ValResult<'a, Vec<PyObject>> {
+) -> ValResult<Vec<PyObject>> {
     let mut output: Vec<PyObject> = Vec::with_capacity(capacity);
     let mut errors: Vec<ValLineError> = Vec::new();
     for (index, item_result) in iter.enumerate() {
@@ -259,7 +259,7 @@ fn validate_iter_to_set<'a, 's>(
     max_length: Option<usize>,
     validator: &'s CombinedValidator,
     state: &mut ValidationState,
-) -> ValResult<'a, ()> {
+) -> ValResult<()> {
     let mut errors: Vec<ValLineError> = Vec::new();
     for (index, item_result) in iter.enumerate() {
         let item = item_result.map_err(|e| any_next_error!(py, e, input, index))?;
@@ -303,7 +303,7 @@ fn no_validator_iter_to_vec<'a, 's>(
     input: &'a (impl Input<'a> + 'a),
     iter: impl Iterator<Item = PyResult<&'a (impl Input<'a> + 'a)>>,
     mut max_length_check: MaxLengthCheck<'a, impl Input<'a>>,
-) -> ValResult<'a, Vec<PyObject>> {
+) -> ValResult<Vec<PyObject>> {
     iter.enumerate()
         .map(|(index, result)| {
             let v = result.map_err(|e| any_next_error!(py, e, input, index))?;
@@ -348,7 +348,7 @@ impl<'a> GenericIterable<'a> {
         field_type: &'static str,
         validator: &'s CombinedValidator,
         state: &mut ValidationState,
-    ) -> ValResult<'a, Vec<PyObject>> {
+    ) -> ValResult<Vec<PyObject>> {
         let actual_length = self.generic_len();
         let capacity = actual_length.unwrap_or(DEFAULT_CAPACITY);
         let max_length_check = MaxLengthCheck::new(max_length, field_type, input, actual_length);
@@ -381,7 +381,7 @@ impl<'a> GenericIterable<'a> {
         field_type: &'static str,
         validator: &'s CombinedValidator,
         state: &mut ValidationState,
-    ) -> ValResult<'a, ()> {
+    ) -> ValResult<()> {
         macro_rules! validate_set {
             ($iter:expr) => {
                 validate_iter_to_set(py, set, $iter, input, field_type, max_length, validator, state)
@@ -406,7 +406,7 @@ impl<'a> GenericIterable<'a> {
         input: &'a impl Input<'a>,
         field_type: &'static str,
         max_length: Option<usize>,
-    ) -> ValResult<'a, Vec<PyObject>> {
+    ) -> ValResult<Vec<PyObject>> {
         let actual_length = self.generic_len();
         let max_length_check = MaxLengthCheck::new(max_length, field_type, input, actual_length);
 
@@ -456,13 +456,13 @@ pub struct DictGenericIterator<'py> {
 }
 
 impl<'py> DictGenericIterator<'py> {
-    pub fn new(dict: &'py PyDict) -> ValResult<'py, Self> {
+    pub fn new(dict: &'py PyDict) -> ValResult<Self> {
         Ok(Self { dict_iter: dict.iter() })
     }
 }
 
 impl<'py> Iterator for DictGenericIterator<'py> {
-    type Item = ValResult<'py, (&'py PyAny, &'py PyAny)>;
+    type Item = ValResult<(&'py PyAny, &'py PyAny)>;
 
     fn next(&mut self) -> Option<Self::Item> {
         self.dict_iter.next().map(Ok)
@@ -475,7 +475,7 @@ pub struct MappingGenericIterator<'py> {
     iter: &'py PyIterator,
 }
 
-fn mapping_err<'py>(err: PyErr, py: Python<'py>, input: &'py impl Input<'py>) -> ValError<'py> {
+fn mapping_err<'py>(err: PyErr, py: Python<'py>, input: &'py impl Input<'py>) -> ValError {
     ValError::new(
         ErrorType::MappingType {
             error: py_err_string(py, err).into(),
@@ -486,7 +486,7 @@ fn mapping_err<'py>(err: PyErr, py: Python<'py>, input: &'py impl Input<'py>) ->
 }
 
 impl<'py> MappingGenericIterator<'py> {
-    pub fn new(mapping: &'py PyMapping) -> ValResult<'py, Self> {
+    pub fn new(mapping: &'py PyMapping) -> ValResult<Self> {
         let py = mapping.py();
         let input: &PyAny = mapping;
         let iter = mapping
@@ -501,7 +501,7 @@ impl<'py> MappingGenericIterator<'py> {
 const MAPPING_TUPLE_ERROR: &str = "Mapping items must be tuples of (key, value) pairs";
 
 impl<'py> Iterator for MappingGenericIterator<'py> {
-    type Item = ValResult<'py, (&'py PyAny, &'py PyAny)>;
+    type Item = ValResult<(&'py PyAny, &'py PyAny)>;
 
     fn next(&mut self) -> Option<Self::Item> {
         Some(match self.iter.next()? {
@@ -524,14 +524,14 @@ pub struct StringMappingGenericIterator<'py> {
 }
 
 impl<'py> StringMappingGenericIterator<'py> {
-    pub fn new(dict: &'py PyDict) -> ValResult<'py, Self> {
+    pub fn new(dict: &'py PyDict) -> ValResult<Self> {
         Ok(Self { dict_iter: dict.iter() })
     }
 }
 
 impl<'py> Iterator for StringMappingGenericIterator<'py> {
     // key (the first member of the tuple could be a simple String)
-    type Item = ValResult<'py, (StringMapping<'py>, StringMapping<'py>)>;
+    type Item = ValResult<(StringMapping<'py>, StringMapping<'py>)>;
 
     fn next(&mut self) -> Option<Self::Item> {
         match self.dict_iter.next() {
@@ -558,7 +558,7 @@ pub struct AttributesGenericIterator<'py> {
 }
 
 impl<'py> AttributesGenericIterator<'py> {
-    pub fn new(py_any: &'py PyAny) -> ValResult<'py, Self> {
+    pub fn new(py_any: &'py PyAny) -> ValResult<Self> {
         Ok(Self {
             object: py_any,
             attributes_iterator: py_any.dir().into_iter(),
@@ -567,7 +567,7 @@ impl<'py> AttributesGenericIterator<'py> {
 }
 
 impl<'py> Iterator for AttributesGenericIterator<'py> {
-    type Item = ValResult<'py, (&'py PyAny, &'py PyAny)>;
+    type Item = ValResult<(&'py PyAny, &'py PyAny)>;
 
     fn next(&mut self) -> Option<Self::Item> {
         // loop until we find an attribute who's name does not start with underscore,
@@ -610,7 +610,7 @@ pub struct JsonObjectGenericIterator<'py> {
 }
 
 impl<'py> JsonObjectGenericIterator<'py> {
-    pub fn new(json_object: &'py JsonObject) -> ValResult<'py, Self> {
+    pub fn new(json_object: &'py JsonObject) -> ValResult<Self> {
         Ok(Self {
             object_iter: json_object.iter(),
         })
@@ -618,7 +618,7 @@ impl<'py> JsonObjectGenericIterator<'py> {
 }
 
 impl<'py> Iterator for JsonObjectGenericIterator<'py> {
-    type Item = ValResult<'py, (&'py String, &'py JsonValue)>;
+    type Item = ValResult<(&'py String, &'py JsonValue)>;
 
     fn next(&mut self) -> Option<Self::Item> {
         self.object_iter.next().map(|(key, value)| Ok((key, value)))
@@ -670,8 +670,8 @@ impl GenericPyIterator {
         }
     }
 
-    pub fn input_as_error_value<'py>(&self, py: Python<'py>) -> InputValue<'py> {
-        InputValue::PyAny(self.obj.clone_ref(py).into_ref(py))
+    pub fn input_as_error_value(&self, py: Python<'_>) -> InputValue {
+        InputValue::Python(self.obj.clone_ref(py))
     }
 
     pub fn index(&self) -> usize {
@@ -699,8 +699,8 @@ impl GenericJsonIterator {
         }
     }
 
-    pub fn input_as_error_value<'py>(&self, _py: Python<'py>) -> InputValue<'py> {
-        InputValue::JsonInput(JsonValue::Array(self.array.clone()))
+    pub fn input_as_error_value(&self, _py: Python<'_>) -> InputValue {
+        InputValue::Json(JsonValue::Array(self.array.clone()))
     }
 
     pub fn index(&self) -> usize {
@@ -758,7 +758,7 @@ pub enum EitherString<'a> {
 }
 
 impl<'a> EitherString<'a> {
-    pub fn as_cow(&self) -> ValResult<'a, Cow<str>> {
+    pub fn as_cow(&self) -> ValResult<Cow<str>> {
         match self {
             Self::Cow(data) => Ok(data.clone()),
             Self::Py(py_str) => Ok(Cow::Borrowed(py_string_str(py_str)?)),
@@ -800,7 +800,7 @@ impl<'a> IntoPy<PyObject> for EitherString<'a> {
 pub fn py_string_str(py_str: &PyString) -> ValResult<&str> {
     py_str
         .to_str()
-        .map_err(|_| ValError::new_custom_input(ErrorTypeDefaults::StringUnicode, InputValue::PyAny(py_str as &PyAny)))
+        .map_err(|_| ValError::new_custom_input(ErrorTypeDefaults::StringUnicode, InputValue::Python(py_str.into())))
 }
 
 #[cfg_attr(debug_assertions, derive(Debug))]
@@ -870,7 +870,7 @@ impl<'a> EitherInt<'a> {
             Ok(Self::BigInt(big_int))
         }
     }
-    pub fn into_i64(self, py: Python<'a>) -> ValResult<'a, i64> {
+    pub fn into_i64(self, py: Python<'a>) -> ValResult<i64> {
         match self {
             EitherInt::I64(i) => Ok(i),
             EitherInt::U64(u) => match i64::try_from(u) {
@@ -893,7 +893,7 @@ impl<'a> EitherInt<'a> {
         }
     }
 
-    pub fn as_int(&self) -> ValResult<'a, Int> {
+    pub fn as_int(&self) -> ValResult<Int> {
         match self {
             EitherInt::I64(i) => Ok(Int::I64(*i)),
             EitherInt::U64(u) => match i64::try_from(*u) {
diff --git a/src/input/shared.rs b/src/input/shared.rs
index 718210098..647bce8a3 100644
--- a/src/input/shared.rs
+++ b/src/input/shared.rs
@@ -20,7 +20,7 @@ pub fn get_enum_meta_object(py: Python) -> Py<PyAny> {
         .clone()
 }
 
-pub fn map_json_err<'a>(input: &'a impl Input<'a>, error: JsonValueError) -> ValError<'a> {
+pub fn map_json_err<'a>(input: &'a impl Input<'a>, error: JsonValueError) -> ValError {
     ValError::new(
         ErrorType::JsonInvalid {
             error: error.to_string(),
@@ -30,7 +30,7 @@ pub fn map_json_err<'a>(input: &'a impl Input<'a>, error: JsonValueError) -> Val
     )
 }
 
-pub fn str_as_bool<'a>(input: &'a impl Input<'a>, str: &str) -> ValResult<'a, bool> {
+pub fn str_as_bool<'a>(input: &'a impl Input<'a>, str: &str) -> ValResult<bool> {
     if str == "0"
         || str.eq_ignore_ascii_case("f")
         || str.eq_ignore_ascii_case("n")
@@ -52,7 +52,7 @@ pub fn str_as_bool<'a>(input: &'a impl Input<'a>, str: &str) -> ValResult<'a, bo
     }
 }
 
-pub fn int_as_bool<'a>(input: &'a impl Input<'a>, int: i64) -> ValResult<'a, bool> {
+pub fn int_as_bool<'a>(input: &'a impl Input<'a>, int: i64) -> ValResult<bool> {
     if int == 0 {
         Ok(false)
     } else if int == 1 {
@@ -82,7 +82,7 @@ fn strip_underscores(s: &str) -> Option<String> {
 /// max length of the input is 4300, see
 /// https://docs.python.org/3/whatsnew/3.11.html#other-cpython-implementation-changes and
 /// https://github.com/python/cpython/issues/95778 for more info in that length bound
-pub fn str_as_int<'s, 'l>(input: &'s impl Input<'s>, str: &'l str) -> ValResult<'s, EitherInt<'s>> {
+pub fn str_as_int<'s, 'l>(input: &'s impl Input<'s>, str: &'l str) -> ValResult<EitherInt<'s>> {
     let len = str.len();
     if len > 4300 {
         Err(ValError::new(ErrorTypeDefaults::IntParsingSize, input))
@@ -106,7 +106,7 @@ pub fn str_as_int<'s, 'l>(input: &'s impl Input<'s>, str: &'l str) -> ValResult<
 }
 
 /// parse a float as a float
-pub fn str_as_float<'s, 'l>(input: &'s impl Input<'s>, str: &'l str) -> ValResult<'s, EitherFloat<'s>> {
+pub fn str_as_float<'s, 'l>(input: &'s impl Input<'s>, str: &'l str) -> ValResult<EitherFloat<'s>> {
     match str.parse() {
         Ok(float) => Ok(EitherFloat::F64(float)),
         Err(_) => match strip_underscores(str).and_then(|stripped| stripped.parse().ok()) {
@@ -140,7 +140,7 @@ fn strip_decimal_zeros(s: &str) -> Option<&str> {
     None
 }
 
-pub fn float_as_int<'a>(input: &'a impl Input<'a>, float: f64) -> ValResult<'a, EitherInt<'a>> {
+pub fn float_as_int<'a>(input: &'a impl Input<'a>, float: f64) -> ValResult<EitherInt<'a>> {
     if float.is_infinite() || float.is_nan() {
         Err(ValError::new(ErrorTypeDefaults::FiniteNumber, input))
     } else if float % 1.0 != 0.0 {
@@ -152,7 +152,7 @@ pub fn float_as_int<'a>(input: &'a impl Input<'a>, float: f64) -> ValResult<'a,
     }
 }
 
-pub fn decimal_as_int<'a>(py: Python, input: &'a impl Input<'a>, decimal: &'a PyAny) -> ValResult<'a, EitherInt<'a>> {
+pub fn decimal_as_int<'a>(py: Python, input: &'a impl Input<'a>, decimal: &'a PyAny) -> ValResult<EitherInt<'a>> {
     if !decimal.call_method0(intern!(py, "is_finite"))?.extract::<bool>()? {
         return Err(ValError::new(ErrorTypeDefaults::FiniteNumber, input));
     }
diff --git a/src/lookup_key.rs b/src/lookup_key.rs
index f833c00af..21b584690 100644
--- a/src/lookup_key.rs
+++ b/src/lookup_key.rs
@@ -111,7 +111,7 @@ impl LookupKey {
     pub fn py_get_dict_item<'data, 's>(
         &'s self,
         dict: &'data PyDict,
-    ) -> ValResult<'data, Option<(&'s LookupPath, &'data PyAny)>> {
+    ) -> ValResult<Option<(&'s LookupPath, &'data PyAny)>> {
         match self {
             Self::Simple { py_key, path, .. } => match dict.get_item(py_key)? {
                 Some(value) => Ok(Some((path, value))),
@@ -148,7 +148,7 @@ impl LookupKey {
     pub fn py_get_string_mapping_item<'data, 's>(
         &'s self,
         dict: &'data PyDict,
-    ) -> ValResult<'data, Option<(&'s LookupPath, StringMapping<'data>)>> {
+    ) -> ValResult<Option<(&'s LookupPath, StringMapping<'data>)>> {
         if let Some((path, py_any)) = self.py_get_dict_item(dict)? {
             let value = StringMapping::new_value(py_any)?;
             Ok(Some((path, value)))
@@ -160,7 +160,7 @@ impl LookupKey {
     pub fn py_get_mapping_item<'data, 's>(
         &'s self,
         dict: &'data PyMapping,
-    ) -> ValResult<'data, Option<(&'s LookupPath, &'data PyAny)>> {
+    ) -> ValResult<Option<(&'s LookupPath, &'data PyAny)>> {
         match self {
             Self::Simple { py_key, path, .. } => match dict.get_item(py_key) {
                 Ok(value) => Ok(Some((path, value))),
@@ -198,7 +198,7 @@ impl LookupKey {
         &'s self,
         obj: &'data PyAny,
         kwargs: Option<&'data PyDict>,
-    ) -> ValResult<'data, Option<(&'s LookupPath, &'data PyAny)>> {
+    ) -> ValResult<Option<(&'s LookupPath, &'data PyAny)>> {
         match self._py_get_attr(obj, kwargs) {
             Ok(v) => Ok(v),
             Err(err) => {
@@ -266,7 +266,7 @@ impl LookupKey {
     pub fn json_get<'data, 's>(
         &'s self,
         dict: &'data JsonObject,
-    ) -> ValResult<'data, Option<(&'s LookupPath, &'data JsonValue)>> {
+    ) -> ValResult<Option<(&'s LookupPath, &'data JsonValue)>> {
         match self {
             Self::Simple { key, path, .. } => match dict.get(key) {
                 Some(value) => Ok(Some((path, value))),
@@ -316,7 +316,7 @@ impl LookupKey {
         input: &'d impl Input<'d>,
         loc_by_alias: bool,
         field_name: &str,
-    ) -> ValLineError<'d> {
+    ) -> ValLineError {
         if loc_by_alias {
             let lookup_path = match self {
                 Self::Simple { path, .. } => path,
@@ -369,12 +369,7 @@ impl LookupPath {
         }
     }
 
-    pub fn apply_error_loc<'a>(
-        &self,
-        mut line_error: ValLineError<'a>,
-        loc_by_alias: bool,
-        field_name: &str,
-    ) -> ValLineError<'a> {
+    pub fn apply_error_loc(&self, mut line_error: ValLineError, loc_by_alias: bool, field_name: &str) -> ValLineError {
         if loc_by_alias {
             for path_item in self.iter().rev() {
                 line_error = line_error.with_outer_location(path_item.clone().into());
diff --git a/src/validators/any.rs b/src/validators/any.rs
index 2fad89091..244117a01 100644
--- a/src/validators/any.rs
+++ b/src/validators/any.rs
@@ -32,7 +32,7 @@ impl Validator for AnyValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         // in a union, Any should be preferred to doing lax coercions
         state.floor_exactness(Exactness::Strict);
         Ok(input.to_object(py))
diff --git a/src/validators/arguments.rs b/src/validators/arguments.rs
index 7ae65d579..0405d54e5 100644
--- a/src/validators/arguments.rs
+++ b/src/validators/arguments.rs
@@ -166,7 +166,7 @@ impl Validator for ArgumentsValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let args = input.validate_args()?;
 
         let mut output_args: Vec<PyObject> = Vec::with_capacity(self.positional_params_count);
diff --git a/src/validators/bool.rs b/src/validators/bool.rs
index bcd48e991..b2bb35e5d 100644
--- a/src/validators/bool.rs
+++ b/src/validators/bool.rs
@@ -35,7 +35,7 @@ impl Validator for BoolValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         // TODO in theory this could be quicker if we used PyBool rather than going to a bool
         // and back again, might be worth profiling?
         input
diff --git a/src/validators/bytes.rs b/src/validators/bytes.rs
index 78a8acb24..9dd07d7d3 100644
--- a/src/validators/bytes.rs
+++ b/src/validators/bytes.rs
@@ -45,7 +45,7 @@ impl Validator for BytesValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         input
             .validate_bytes(state.strict_or(self.strict))
             .map(|m| m.unpack(state).into_py(py))
@@ -71,7 +71,7 @@ impl Validator for BytesConstrainedValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let either_bytes = input.validate_bytes(state.strict_or(self.strict))?.unpack(state);
         let len = either_bytes.len()?;
 
diff --git a/src/validators/call.rs b/src/validators/call.rs
index e0649aa53..d43df4984 100644
--- a/src/validators/call.rs
+++ b/src/validators/call.rs
@@ -77,7 +77,7 @@ impl Validator for CallValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let args = self.arguments_validator.validate(py, input, state)?;
 
         let return_value = if let Ok((args, kwargs)) = args.extract::<(&PyTuple, &PyDict)>(py) {
diff --git a/src/validators/callable.rs b/src/validators/callable.rs
index 3075e182e..e05c99b12 100644
--- a/src/validators/callable.rs
+++ b/src/validators/callable.rs
@@ -30,7 +30,7 @@ impl Validator for CallableValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         state.floor_exactness(Exactness::Lax);
         match input.callable() {
             true => Ok(input.to_object(py)),
diff --git a/src/validators/chain.rs b/src/validators/chain.rs
index d8da86e30..299801dea 100644
--- a/src/validators/chain.rs
+++ b/src/validators/chain.rs
@@ -75,7 +75,7 @@ impl Validator for ChainValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let mut steps_iter = self.steps.iter();
         let first_step = steps_iter.next().unwrap();
         let value = first_step.validate(py, input, state)?;
diff --git a/src/validators/custom_error.rs b/src/validators/custom_error.rs
index 4ea31aa5a..ec0af567a 100644
--- a/src/validators/custom_error.rs
+++ b/src/validators/custom_error.rs
@@ -3,6 +3,7 @@ use pyo3::prelude::*;
 use pyo3::types::PyDict;
 
 use crate::build_tools::py_schema_err;
+use crate::errors::AsErrorValue;
 use crate::errors::{ErrorType, PydanticCustomError, PydanticKnownError, ValError, ValResult};
 use crate::input::Input;
 use crate::tools::SchemaDict;
@@ -49,7 +50,7 @@ impl CustomError {
         }
     }
 
-    pub fn as_val_error<'a>(&self, input: &'a impl Input<'a>) -> ValError<'a> {
+    pub fn as_val_error(&self, input: &impl AsErrorValue) -> ValError {
         match self {
             CustomError::KnownError(ref known_error) => known_error.clone().into_val_error(input),
             CustomError::Custom(ref custom_error) => custom_error.clone().into_val_error(input),
@@ -93,7 +94,7 @@ impl Validator for CustomErrorValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         self.validator
             .validate(py, input, state)
             .map_err(|_| self.custom_error.as_val_error(input))
diff --git a/src/validators/dataclass.rs b/src/validators/dataclass.rs
index 4140b1b26..dbbfc5ee2 100644
--- a/src/validators/dataclass.rs
+++ b/src/validators/dataclass.rs
@@ -144,7 +144,7 @@ impl Validator for DataclassArgsValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let args = input.validate_dataclass_args(&self.dataclass_name)?;
 
         let output_dict = PyDict::new(py);
@@ -202,8 +202,7 @@ impl Validator for DataclassArgsValidator {
                                             ErrorTypeDefaults::MultipleArgumentValues,
                                             kw_value,
                                             field.name.clone(),
-                                        )
-                                        .into_owned(py),
+                                        ),
                                     );
                                 }
                                 // found a positional argument, validate it
@@ -226,10 +225,9 @@ impl Validator for DataclassArgsValidator {
                                             errors.extend(line_errors.into_iter().map(|err| {
                                                 lookup_path
                                                     .apply_error_loc(err, self.loc_by_alias, &field.name)
-                                                    .into_owned(py)
                                             }));
                                         }
-                                        Err(err) => return Err(err.into_owned(py)),
+                                        Err(err) => return Err(err),
                                     }
                                 }
                                 // found neither, check if there is a default value, otherwise error
@@ -294,8 +292,7 @@ impl Validator for DataclassArgsValidator {
                                                                 ErrorTypeDefaults::UnexpectedKeywordArgument,
                                                                 value,
                                                                 raw_key.as_loc_item(),
-                                                            )
-                                                            .into_owned(py),
+                                                            ),
                                                         );
                                                     }
                                                     ExtraBehavior::Ignore => {}
@@ -375,7 +372,7 @@ impl Validator for DataclassArgsValidator {
         field_name: &'data str,
         field_value: &'data PyAny,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let dict: &PyDict = obj.downcast()?;
 
         let ok = |output: PyObject| {
@@ -518,7 +515,7 @@ impl Validator for DataclassValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         if let Some(self_instance) = state.extra().self_instance {
             // in the case that self_instance is Some, we're calling validation from within `BaseModel.__init__`
             return self.validate_init(py, self_instance, input, state);
@@ -560,7 +557,7 @@ impl Validator for DataclassValidator {
         field_name: &'data str,
         field_value: &'data PyAny,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         if self.frozen {
             return Err(ValError::new(ErrorTypeDefaults::FrozenInstance, field_value));
         }
@@ -600,7 +597,7 @@ impl DataclassValidator {
         self_instance: &'s PyAny,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         // we need to set `self_instance` to None for nested validators as we don't want to operate on the self_instance
         // instance anymore
         let state = &mut state.rebind_extra(|extra| extra.self_instance = None);
@@ -627,7 +624,7 @@ impl DataclassValidator {
         dc: &PyAny,
         val_output: PyObject,
         input: &'data impl Input<'data>,
-    ) -> ValResult<'data, ()> {
+    ) -> ValResult<()> {
         let (dc_dict, post_init_kwargs): (&PyAny, &PyAny) = val_output.extract(py)?;
         if self.slots {
             let dc_dict: &PyDict = dc_dict.downcast()?;
diff --git a/src/validators/date.rs b/src/validators/date.rs
index 7c79101f4..2329dcf2a 100644
--- a/src/validators/date.rs
+++ b/src/validators/date.rs
@@ -44,7 +44,7 @@ impl Validator for DateValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let strict = state.strict_or(self.strict);
         let date = match input.validate_date(strict) {
             Ok(val_match) => val_match.unpack(state),
@@ -109,7 +109,7 @@ impl Validator for DateValidator {
 /// "exact date", e.g. has a zero time component.
 ///
 /// Ok(None) means that this is not relevant to dates (the input was not a datetime nor a string)
-fn date_from_datetime<'data>(input: &'data impl Input<'data>) -> Result<Option<EitherDate<'data>>, ValError<'data>> {
+fn date_from_datetime<'data>(input: &'data impl Input<'data>) -> Result<Option<EitherDate<'data>>, ValError> {
     let either_dt = match input.validate_datetime(false, speedate::MicrosecondsPrecisionOverflowBehavior::Truncate) {
         Ok(val_match) => val_match.into_inner(),
         // if the error was a parsing error, update the error type from DatetimeParsing to DateFromDatetimeParsing
diff --git a/src/validators/datetime.rs b/src/validators/datetime.rs
index edbd399e7..156fad699 100644
--- a/src/validators/datetime.rs
+++ b/src/validators/datetime.rs
@@ -63,7 +63,7 @@ impl Validator for DateTimeValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let strict = state.strict_or(self.strict);
         let datetime = input
             .validate_datetime(strict, self.microseconds_precision)?
@@ -263,7 +263,7 @@ impl TZConstraint {
         }
     }
 
-    pub(super) fn tz_check<'d>(&self, tz_offset: Option<i32>, input: &'d impl Input<'d>) -> ValResult<'d, ()> {
+    pub(super) fn tz_check<'d>(&self, tz_offset: Option<i32>, input: &'d impl Input<'d>) -> ValResult<()> {
         match (self, tz_offset) {
             (TZConstraint::Aware(_), None) => return Err(ValError::new(ErrorTypeDefaults::TimezoneAware, input)),
             (TZConstraint::Aware(Some(tz_expected)), Some(tz_actual)) => {
diff --git a/src/validators/decimal.rs b/src/validators/decimal.rs
index b9435f046..85f81a38e 100644
--- a/src/validators/decimal.rs
+++ b/src/validators/decimal.rs
@@ -83,11 +83,7 @@ impl_py_gc_traverse!(DecimalValidator {
     gt
 });
 
-fn extract_decimal_digits_info<'data>(
-    decimal: &PyAny,
-    normalized: bool,
-    py: Python<'data>,
-) -> ValResult<'data, (u64, u64)> {
+fn extract_decimal_digits_info(decimal: &PyAny, normalized: bool, py: Python<'_>) -> ValResult<(u64, u64)> {
     let mut normalized_decimal: Option<&PyAny> = None;
     if normalized {
         normalized_decimal = Some(decimal.call_method0(intern!(py, "normalize")).unwrap_or(decimal));
@@ -124,7 +120,7 @@ impl Validator for DecimalValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let decimal = input.validate_decimal(state.strict_or(self.strict), py)?;
 
         if !self.allow_inf_nan || self.check_digits {
@@ -269,11 +265,7 @@ impl Validator for DecimalValidator {
     }
 }
 
-pub(crate) fn create_decimal<'a>(
-    arg: &'a PyAny,
-    input: &'a impl Input<'a>,
-    py: Python<'a>,
-) -> ValResult<'a, &'a PyAny> {
+pub(crate) fn create_decimal<'a>(arg: &'a PyAny, input: &'a impl Input<'a>, py: Python<'a>) -> ValResult<&'a PyAny> {
     let decimal_type_obj: Py<PyType> = get_decimal_type(py);
     decimal_type_obj
         .call1(py, (arg,))
@@ -293,10 +285,10 @@ pub(crate) fn create_decimal<'a>(
 
 fn handle_decimal_new_error<'a>(
     py: Python<'a>,
-    input: InputValue<'a>,
+    input: InputValue,
     error: PyErr,
     decimal_exception: &'a PyAny,
-) -> ValError<'a> {
+) -> ValError {
     if error.matches(py, decimal_exception) {
         ValError::new_custom_input(ErrorTypeDefaults::DecimalParsing, input)
     } else if error.matches(py, PyTypeError::type_object(py)) {
diff --git a/src/validators/definitions.rs b/src/validators/definitions.rs
index 979278bb9..7297bd27a 100644
--- a/src/validators/definitions.rs
+++ b/src/validators/definitions.rs
@@ -72,7 +72,7 @@ impl Validator for DefinitionRefValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let validator = self.definition.get().unwrap();
         if let Some(id) = input.identity() {
             if state.recursion_guard.contains_or_insert(id, self.definition.id()) {
@@ -99,7 +99,7 @@ impl Validator for DefinitionRefValidator {
         field_name: &'data str,
         field_value: &'data PyAny,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let validator = self.definition.get().unwrap();
         if let Some(id) = obj.identity() {
             if state.recursion_guard.contains_or_insert(id, self.definition.id()) {
diff --git a/src/validators/dict.rs b/src/validators/dict.rs
index 3ac284b2a..d6507e8e9 100644
--- a/src/validators/dict.rs
+++ b/src/validators/dict.rs
@@ -72,7 +72,7 @@ impl Validator for DictValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let strict = state.strict_or(self.strict);
         let dict = input.validate_dict(strict)?;
         match dict {
@@ -103,9 +103,9 @@ impl DictValidator {
         &'s self,
         py: Python<'data>,
         input: &'data impl Input<'data>,
-        mapping_iter: impl Iterator<Item = ValResult<'data, (impl BorrowInput + 'data, impl BorrowInput + 'data)>>,
+        mapping_iter: impl Iterator<Item = ValResult<(impl BorrowInput + AsLocItem + 'data, impl BorrowInput + 'data)>>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let output = PyDict::new(py);
         let mut errors: Vec<ValLineError> = Vec::new();
 
@@ -113,34 +113,31 @@ impl DictValidator {
         let value_validator = self.value_validator.as_ref();
         for item_result in mapping_iter {
             let (key, value) = item_result?;
-            let key = key.borrow_input();
-            let value = value.borrow_input();
-            let output_key = match key_validator.validate(py, key, state) {
+            let output_key = match key_validator.validate(py, key.borrow_input(), state) {
                 Ok(value) => Some(value),
                 Err(ValError::LineErrors(line_errors)) => {
                     for err in line_errors {
                         // these are added in reverse order so [key] is shunted along by the second call
                         errors.push(
                             err.with_outer_location("[key]".into())
-                                .with_outer_location(key.as_loc_item())
-                                .into_owned(py),
+                                .with_outer_location(key.as_loc_item()),
                         );
                     }
                     None
                 }
                 Err(ValError::Omit) => continue,
-                Err(err) => return Err(err.into_owned(py)),
+                Err(err) => return Err(err),
             };
-            let output_value = match value_validator.validate(py, value, state) {
+            let output_value = match value_validator.validate(py, value.borrow_input(), state) {
                 Ok(value) => Some(value),
                 Err(ValError::LineErrors(line_errors)) => {
                     for err in line_errors {
-                        errors.push(err.with_outer_location(key.as_loc_item()).into_owned(py));
+                        errors.push(err.with_outer_location(key.as_loc_item()));
                     }
                     None
                 }
                 Err(ValError::Omit) => continue,
-                Err(err) => return Err(err.into_owned(py)),
+                Err(err) => return Err(err),
             };
             if let (Some(key), Some(value)) = (output_key, output_value) {
                 output.set_item(key, value)?;
diff --git a/src/validators/float.rs b/src/validators/float.rs
index 126e539c2..9bb293964 100644
--- a/src/validators/float.rs
+++ b/src/validators/float.rs
@@ -69,7 +69,7 @@ impl Validator for FloatValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let either_float = input.validate_float(state.strict_or(self.strict))?.unpack(state);
         if !self.allow_inf_nan && !either_float.as_f64().is_finite() {
             return Err(ValError::new(ErrorTypeDefaults::FiniteNumber, input));
@@ -101,7 +101,7 @@ impl Validator for ConstrainedFloatValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let either_float = input.validate_float(state.strict_or(self.strict))?.unpack(state);
         let float: f64 = either_float.as_f64();
         if !self.allow_inf_nan && !float.is_finite() {
diff --git a/src/validators/frozenset.rs b/src/validators/frozenset.rs
index 190a8672d..ceb60eb9d 100644
--- a/src/validators/frozenset.rs
+++ b/src/validators/frozenset.rs
@@ -33,7 +33,7 @@ impl Validator for FrozenSetValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let collection = input.validate_frozenset(state.strict_or(self.strict))?;
         let exactness = match &collection {
             GenericIterable::FrozenSet(_) => Exactness::Exact,
diff --git a/src/validators/function.rs b/src/validators/function.rs
index 4c5ad9c29..e7134ab29 100644
--- a/src/validators/function.rs
+++ b/src/validators/function.rs
@@ -94,7 +94,7 @@ macro_rules! impl_validator {
                 py: Python<'data>,
                 input: &'data impl Input<'data>,
                 state: &mut ValidationState<'_>,
-            ) -> ValResult<'data, PyObject> {
+            ) -> ValResult<PyObject> {
                 let validate = |v, s: &mut ValidationState<'_>| self.validator.validate(py, v, s);
                 self._validate(validate, py, input, state)
             }
@@ -105,7 +105,7 @@ macro_rules! impl_validator {
                 field_name: &'data str,
                 field_value: &'data PyAny,
                 state: &mut ValidationState,
-            ) -> ValResult<'data, PyObject> {
+            ) -> ValResult<PyObject> {
                 let validate = move |v, s: &mut ValidationState<'_>| {
                     self.validator
                         .validate_assignment(py, v, field_name, field_value, s)
@@ -135,11 +135,11 @@ impl_build!(FunctionBeforeValidator, "function-before");
 impl FunctionBeforeValidator {
     fn _validate<'s, 'data>(
         &'s self,
-        call: impl FnOnce(&'data PyAny, &mut ValidationState<'_>) -> ValResult<'data, PyObject>,
+        call: impl FnOnce(&'data PyAny, &mut ValidationState<'_>) -> ValResult<PyObject>,
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &'s mut ValidationState<'_>,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let r = if self.info_arg {
             let info = ValidationInfo::new(py, state.extra(), &self.config, self.field_name.clone());
             self.func.call1(py, (input.to_object(py), info))
@@ -168,11 +168,11 @@ impl_build!(FunctionAfterValidator, "function-after");
 impl FunctionAfterValidator {
     fn _validate<'s, 'data, I: Input<'data>>(
         &'s self,
-        call: impl FnOnce(&'data I, &mut ValidationState<'_>) -> ValResult<'data, PyObject>,
+        call: impl FnOnce(&'data I, &mut ValidationState<'_>) -> ValResult<PyObject>,
         py: Python<'data>,
         input: &'data I,
         state: &mut ValidationState<'_>,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let v = call(input, state)?;
         let r = if self.info_arg {
             let info = ValidationInfo::new(py, state.extra(), &self.config, self.field_name.clone());
@@ -230,7 +230,7 @@ impl Validator for FunctionPlainValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let r = if self.info_arg {
             let info = ValidationInfo::new(py, state.extra(), &self.config, self.field_name.clone());
             self.func.call1(py, (input.to_object(py), info))
@@ -294,7 +294,7 @@ impl FunctionWrapValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let r = if self.info_arg {
             let info = ValidationInfo::new(py, state.extra(), &self.config, self.field_name.clone());
             self.func.call1(py, (input.to_object(py), handler, info))
@@ -317,7 +317,7 @@ impl Validator for FunctionWrapValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let handler = ValidatorCallable {
             validator: InternalValidator::new(
                 py,
@@ -341,7 +341,7 @@ impl Validator for FunctionWrapValidator {
         field_name: &'data str,
         field_value: &'data PyAny,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let handler = AssignmentValidatorCallable {
             validator: InternalValidator::new(
                 py,
@@ -438,7 +438,7 @@ macro_rules! py_err_string {
 
 /// Only `ValueError` (including `PydanticCustomError` and `ValidationError`) and `AssertionError` are considered
 /// as validation errors, `TypeError` is now considered as a runtime error to catch errors in function signatures
-pub fn convert_err<'a>(py: Python<'a>, err: PyErr, input: &'a impl Input<'a>) -> ValError<'a> {
+pub fn convert_err<'a>(py: Python<'a>, err: PyErr, input: &'a impl Input<'a>) -> ValError {
     if err.is_instance_of::<PyValueError>(py) {
         let error_value = err.value(py);
         if let Ok(pydantic_value_error) = error_value.extract::<PydanticCustomError>() {
@@ -446,7 +446,7 @@ pub fn convert_err<'a>(py: Python<'a>, err: PyErr, input: &'a impl Input<'a>) ->
         } else if let Ok(pydantic_error_type) = error_value.extract::<PydanticKnownError>() {
             pydantic_error_type.into_val_error(input)
         } else if let Ok(validation_error) = err.value(py).extract::<ValidationError>() {
-            validation_error.into_val_error(py)
+            validation_error.into_val_error()
         } else {
             py_err_string!(py, err, error_value, ValueError, input)
         }
diff --git a/src/validators/generator.rs b/src/validators/generator.rs
index 94497d228..3b5fedd97 100644
--- a/src/validators/generator.rs
+++ b/src/validators/generator.rs
@@ -64,7 +64,7 @@ impl Validator for GeneratorValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let iterator = input.validate_iter()?;
         let validator = self.item_validator.as_ref().map(|v| {
             InternalValidator::new(
diff --git a/src/validators/int.rs b/src/validators/int.rs
index dabfb5115..a72afcb0e 100644
--- a/src/validators/int.rs
+++ b/src/validators/int.rs
@@ -48,7 +48,7 @@ impl Validator for IntValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         input
             .validate_int(state.strict_or(self.strict))
             .map(|val_match| val_match.unpack(state).into_py(py))
@@ -77,7 +77,7 @@ impl Validator for ConstrainedIntValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let either_int = input.validate_int(state.strict_or(self.strict))?.unpack(state);
         let int_value = either_int.as_int()?;
 
diff --git a/src/validators/is_instance.rs b/src/validators/is_instance.rs
index 189589d6a..8355710d9 100644
--- a/src/validators/is_instance.rs
+++ b/src/validators/is_instance.rs
@@ -61,7 +61,7 @@ impl Validator for IsInstanceValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         _state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         if !input.is_python() {
             return Err(ValError::InternalErr(PyNotImplementedError::new_err(
                 "Cannot check isinstance when validating from json, \
diff --git a/src/validators/is_subclass.rs b/src/validators/is_subclass.rs
index 7a89ef36c..e20a5c291 100644
--- a/src/validators/is_subclass.rs
+++ b/src/validators/is_subclass.rs
@@ -48,7 +48,7 @@ impl Validator for IsSubclassValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         _state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         match input.input_is_subclass(self.class.as_ref(py))? {
             true => Ok(input.to_object(py)),
             false => Err(ValError::new(
diff --git a/src/validators/json.rs b/src/validators/json.rs
index 9dfb5fae2..7ce1f9e29 100644
--- a/src/validators/json.rs
+++ b/src/validators/json.rs
@@ -49,12 +49,12 @@ impl Validator for JsonValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let json_value = input.parse_json()?;
         match self.validator {
             Some(ref validator) => match validator.validate(py, &json_value, state) {
                 Ok(v) => Ok(v),
-                Err(err) => Err(err.into_owned(py)),
+                Err(err) => Err(err),
             },
             None => Ok(json_value.to_object(py)),
         }
diff --git a/src/validators/json_or_python.rs b/src/validators/json_or_python.rs
index 302cbdaf6..7cdb10adf 100644
--- a/src/validators/json_or_python.rs
+++ b/src/validators/json_or_python.rs
@@ -54,7 +54,7 @@ impl Validator for JsonOrPython {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         match state.extra().input_type {
             InputType::Python => self.python.validate(py, input, state),
             _ => self.json.validate(py, input, state),
diff --git a/src/validators/lax_or_strict.rs b/src/validators/lax_or_strict.rs
index 78021cd4c..c130cc83a 100644
--- a/src/validators/lax_or_strict.rs
+++ b/src/validators/lax_or_strict.rs
@@ -61,7 +61,7 @@ impl Validator for LaxOrStrictValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         if state.strict_or(self.strict) {
             self.strict_validator.validate(py, input, state)
         } else {
diff --git a/src/validators/list.rs b/src/validators/list.rs
index b2e0ff116..1a8ecb134 100644
--- a/src/validators/list.rs
+++ b/src/validators/list.rs
@@ -121,7 +121,7 @@ impl Validator for ListValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let seq = input.validate_list(state.strict_or(self.strict))?;
         let exactness = match &seq {
             GenericIterable::List(_) | GenericIterable::JsonArray(_) => Exactness::Exact,
diff --git a/src/validators/literal.rs b/src/validators/literal.rs
index 686920cca..0f1caf601 100644
--- a/src/validators/literal.rs
+++ b/src/validators/literal.rs
@@ -95,7 +95,7 @@ impl<T: Debug> LiteralLookup<T> {
         &self,
         py: Python<'data>,
         input: &'data I,
-    ) -> ValResult<'data, Option<(&'data I, &T)>> {
+    ) -> ValResult<Option<(&'data I, &T)>> {
         if let Some(expected_bool) = &self.expected_bool {
             if let Ok(bool_value) = input.validate_bool(true) {
                 if bool_value.into_inner() {
@@ -195,7 +195,7 @@ impl Validator for LiteralValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         _state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         match self.lookup.validate(py, input)? {
             Some((_, v)) => Ok(v.clone()),
             None => Err(ValError::new(
diff --git a/src/validators/mod.rs b/src/validators/mod.rs
index f541ea45d..ee95fa799 100644
--- a/src/validators/mod.rs
+++ b/src/validators/mod.rs
@@ -330,7 +330,7 @@ impl SchemaValidator {
         context: Option<&'data PyAny>,
         self_instance: Option<&PyAny>,
         recursion_guard: &'data mut RecursionGuard,
-    ) -> ValResult<'data, PyObject>
+    ) -> ValResult<PyObject>
     where
         's: 'data,
     {
@@ -701,15 +701,15 @@ pub trait Validator: Send + Sync + Debug {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject>;
+    ) -> ValResult<PyObject>;
 
     /// Get a default value, currently only used by `WithDefaultValidator`
-    fn default_value<'data>(
+    fn default_value(
         &self,
-        _py: Python<'data>,
+        _py: Python<'_>,
         _outer_loc: Option<impl Into<LocItem>>,
         _state: &mut ValidationState,
-    ) -> ValResult<'data, Option<PyObject>> {
+    ) -> ValResult<Option<PyObject>> {
         Ok(None)
     }
 
@@ -722,7 +722,7 @@ pub trait Validator: Send + Sync + Debug {
         _field_name: &'data str,
         _field_value: &'data PyAny,
         _state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let py_err = PyTypeError::new_err(format!("validate_assignment is not supported for {}", self.get_name()));
         Err(py_err.into())
     }
diff --git a/src/validators/model.rs b/src/validators/model.rs
index a571ccd9e..6f810d10e 100644
--- a/src/validators/model.rs
+++ b/src/validators/model.rs
@@ -109,7 +109,7 @@ impl Validator for ModelValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         if let Some(self_instance) = state.extra().self_instance {
             // in the case that self_instance is Some, we're calling validation from within `BaseModel.__init__`
             return self.validate_init(py, self_instance, input, state);
@@ -157,7 +157,7 @@ impl Validator for ModelValidator {
         field_name: &'data str,
         field_value: &'data PyAny,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         if self.frozen {
             return Err(ValError::new(ErrorTypeDefaults::FrozenInstance, field_value));
         } else if self.root_model {
@@ -222,7 +222,7 @@ impl ModelValidator {
         self_instance: &'s PyAny,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         // we need to set `self_instance` to None for nested validators as we don't want to operate on self_instance
         // anymore
         let state = &mut state.rebind_extra(|extra| extra.self_instance = None);
@@ -249,7 +249,7 @@ impl ModelValidator {
         input: &'data impl Input<'data>,
         existing_fields_set: Option<&'data PyAny>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         if self.custom_init {
             // If we wanted, we could introspect the __init__ signature, and store the
             // keyword arguments and types, and create a validator for them.
@@ -291,7 +291,7 @@ impl ModelValidator {
         instance: PyObject,
         input: &'data impl Input<'data>,
         extra: &Extra,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         if let Some(ref post_init) = self.post_init {
             instance
                 .call_method1(py, post_init.as_ref(py), (extra.context,))
diff --git a/src/validators/model_fields.rs b/src/validators/model_fields.rs
index a284bd4e9..f603c7b22 100644
--- a/src/validators/model_fields.rs
+++ b/src/validators/model_fields.rs
@@ -123,7 +123,7 @@ impl Validator for ModelFieldsValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let strict = state.strict_or(self.strict);
         let from_attributes = state.extra().from_attributes.unwrap_or(self.from_attributes);
 
@@ -205,11 +205,11 @@ impl Validator for ModelFieldsValidator {
                                     for err in line_errors {
                                         errors.push(
                                             lookup_path.apply_error_loc(err, self.loc_by_alias, &field.name)
-                                            .into_owned(py)
+
                                         );
                                     }
                                 }
-                                Err(err) => return ControlFlow::Break(err.into_owned(py)),
+                                Err(err) => return ControlFlow::Break(err),
                             }
                             continue;
                         }
@@ -258,14 +258,14 @@ impl Validator for ModelFieldsValidator {
                                     errors.push(
                                         err.with_outer_location(raw_key.as_loc_item())
                                             .with_type(ErrorTypeDefaults::InvalidKey)
-                                            .into_owned(py)
+
                                     );
                                 }
                                 continue;
                             }
-                            Err(err) => return Err(err.into_owned(py)),
+                            Err(err) => return Err(err),
                         };
-                        let cow = either_str.as_cow().map_err(|err| err.into_owned(py))?;
+                        let cow = either_str.as_cow().map_err(|err| err)?;
                         if used_keys.contains(cow.as_ref()) {
                             continue;
                         }
@@ -280,7 +280,7 @@ impl Validator for ModelFieldsValidator {
                                         value,
                                         raw_key.as_loc_item(),
                                     )
-                                    .into_owned(py)
+
                                 );
                             }
                             ExtraBehavior::Ignore => {}
@@ -294,10 +294,10 @@ impl Validator for ModelFieldsValidator {
                                         }
                                         Err(ValError::LineErrors(line_errors)) => {
                                             for err in line_errors {
-                                                errors.push(err.with_outer_location(raw_key.as_loc_item()).into_owned(py));
+                                                errors.push(err.with_outer_location(raw_key.as_loc_item()));
                                             }
                                         }
-                                        Err(err) => return Err(err.into_owned(py)),
+                                        Err(err) => return Err(err),
                                     }
                                 } else {
                                     model_extra_dict.set_item(py_key, value.to_object(py))?;
@@ -342,7 +342,7 @@ impl Validator for ModelFieldsValidator {
         field_name: &'data str,
         field_value: &'data PyAny,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let dict: &PyDict = obj.downcast()?;
 
         let get_updated_dict = |output: PyObject| {
@@ -350,7 +350,7 @@ impl Validator for ModelFieldsValidator {
             Ok(dict)
         };
 
-        let prepare_result = |result: ValResult<'data, PyObject>| match result {
+        let prepare_result = |result: ValResult<PyObject>| match result {
             Ok(output) => get_updated_dict(output),
             Err(ValError::LineErrors(line_errors)) => {
                 let errors = line_errors
diff --git a/src/validators/none.rs b/src/validators/none.rs
index f6891292b..c014c1218 100644
--- a/src/validators/none.rs
+++ b/src/validators/none.rs
@@ -29,7 +29,7 @@ impl Validator for NoneValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         _state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         match input.is_none() {
             true => Ok(py.None()),
             false => Err(ValError::new(ErrorTypeDefaults::NoneRequired, input)),
diff --git a/src/validators/nullable.rs b/src/validators/nullable.rs
index 85fbd6c26..7e5c68d03 100644
--- a/src/validators/nullable.rs
+++ b/src/validators/nullable.rs
@@ -38,7 +38,7 @@ impl Validator for NullableValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         match input.is_none() {
             true => Ok(py.None()),
             false => self.validator.validate(py, input, state),
diff --git a/src/validators/set.rs b/src/validators/set.rs
index d29c60c3f..38f21a026 100644
--- a/src/validators/set.rs
+++ b/src/validators/set.rs
@@ -63,7 +63,7 @@ impl Validator for SetValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let collection = input.validate_set(state.strict_or(self.strict))?;
         let exactness = match &collection {
             GenericIterable::Set(_) => Exactness::Exact,
diff --git a/src/validators/string.rs b/src/validators/string.rs
index 98d8a9d99..a8d66a42e 100644
--- a/src/validators/string.rs
+++ b/src/validators/string.rs
@@ -46,7 +46,7 @@ impl Validator for StrValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         input
             .validate_str(state.strict_or(self.strict), self.coerce_numbers_to_str)
             .map(|val_match| val_match.unpack(state).into_py(py))
@@ -78,7 +78,7 @@ impl Validator for StrConstrainedValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let either_str = input
             .validate_str(state.strict_or(self.strict), self.coerce_numbers_to_str)?
             .unpack(state);
diff --git a/src/validators/time.rs b/src/validators/time.rs
index abf82091f..687e01eaf 100644
--- a/src/validators/time.rs
+++ b/src/validators/time.rs
@@ -45,7 +45,7 @@ impl Validator for TimeValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let time = input
             .validate_time(state.strict_or(self.strict), self.microseconds_precision)?
             .unpack(state);
diff --git a/src/validators/timedelta.rs b/src/validators/timedelta.rs
index f04fef91c..326a279e8 100644
--- a/src/validators/timedelta.rs
+++ b/src/validators/timedelta.rs
@@ -70,7 +70,7 @@ impl Validator for TimeDeltaValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let timedelta = input
             .validate_timedelta(state.strict_or(self.strict), self.microseconds_precision)?
             .unpack(state);
diff --git a/src/validators/tuple.rs b/src/validators/tuple.rs
index 9513582e5..af134c8ee 100644
--- a/src/validators/tuple.rs
+++ b/src/validators/tuple.rs
@@ -50,7 +50,7 @@ impl Validator for TupleVariableValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let seq = input.validate_tuple(state.strict_or(self.strict))?;
         let exactness = match &seq {
             GenericIterable::Tuple(_) | GenericIterable::JsonArray(_) => Exactness::Exact,
@@ -118,12 +118,12 @@ fn validate_tuple_positional<'s, 'data, T: Iterator<Item = PyResult<&'data I>>,
     input: &'data impl Input<'data>,
     state: &mut ValidationState,
     output: &mut Vec<PyObject>,
-    errors: &mut Vec<ValLineError<'data>>,
+    errors: &mut Vec<ValLineError>,
     extras_validator: &Option<Box<CombinedValidator>>,
     items_validators: &[CombinedValidator],
     collection_iter: &mut T,
     actual_length: Option<usize>,
-) -> ValResult<'data, ()> {
+) -> ValResult<()> {
     for (index, validator) in items_validators.iter().enumerate() {
         match collection_iter.next() {
             Some(result) => match validator.validate(py, result?, state) {
@@ -186,7 +186,7 @@ impl Validator for TuplePositionalValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let collection = input.validate_tuple(state.strict_or(self.strict))?;
         let exactness: crate::validators::Exactness = match &collection {
             GenericIterable::Tuple(_) | GenericIterable::JsonArray(_) => Exactness::Exact,
diff --git a/src/validators/typed_dict.rs b/src/validators/typed_dict.rs
index f55b7d717..95cd19133 100644
--- a/src/validators/typed_dict.rs
+++ b/src/validators/typed_dict.rs
@@ -148,7 +148,7 @@ impl Validator for TypedDictValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let strict = state.strict_or(self.strict);
         let dict = input.validate_dict(strict)?;
 
@@ -205,11 +205,10 @@ impl Validator for TypedDictValidator {
                                         errors.push(
                                             lookup_path
                                             .apply_error_loc(err, self.loc_by_alias, &field.name)
-                                            .into_owned(py)
                                         );
                                     }
                                 }
-                                Err(err) => return ControlFlow::Break(err.into_owned(py)),
+                                Err(err) => return ControlFlow::Break(err),
                             }
                             continue;
                         }
@@ -259,14 +258,14 @@ impl Validator for TypedDictValidator {
                                     errors.push(
                                         err.with_outer_location(raw_key.as_loc_item())
                                             .with_type(ErrorTypeDefaults::InvalidKey)
-                                            .into_owned(py)
+
                                     );
                                 }
                                 continue;
                             }
-                            Err(err) => return Err(err.into_owned(py)),
+                            Err(err) => return Err(err),
                         };
-                        let cow = either_str.as_cow().map_err(|err| err.into_owned(py))?;
+                        let cow = either_str.as_cow().map_err(|err| err)?;
                         if used_keys.contains(cow.as_ref()) {
                             continue;
                         }
@@ -281,7 +280,7 @@ impl Validator for TypedDictValidator {
                                         value,
                                         raw_key.as_loc_item(),
                                     )
-                                    .into_owned(py)
+
                                 );
                             }
                             ExtraBehavior::Ignore => {}
@@ -297,11 +296,11 @@ impl Validator for TypedDictValidator {
                                                 errors.push(
                                                     err
                                                     .with_outer_location(raw_key.as_loc_item())
-                                                    .into_owned(py)
+
                                                 );
                                             }
                                         }
-                                        Err(err) => return Err(err.into_owned(py)),
+                                        Err(err) => return Err(err),
                                     }
                                 } else {
                                     output_dict.set_item(py_key, value.to_object(py))?;
diff --git a/src/validators/union.rs b/src/validators/union.rs
index 0f8fded07..0148e1287 100644
--- a/src/validators/union.rs
+++ b/src/validators/union.rs
@@ -106,7 +106,7 @@ impl UnionValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let old_exactness = state.exactness;
         let strict = state.strict_or(self.strict);
         let mut errors = MaybeErrors::new(self.custom_error.as_ref());
@@ -172,7 +172,7 @@ impl UnionValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let mut errors = MaybeErrors::new(self.custom_error.as_ref());
 
         let mut rebound_state;
@@ -207,7 +207,7 @@ impl Validator for UnionValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         match self.mode {
             UnionMode::Smart => self.validate_smart(py, input, state),
             UnionMode::LeftToRight => self.validate_left_to_right(py, input, state),
@@ -219,18 +219,18 @@ impl Validator for UnionValidator {
     }
 }
 
-struct ChoiceLineErrors<'a, 'data> {
+struct ChoiceLineErrors<'a> {
     choice: &'a CombinedValidator,
     label: Option<&'a str>,
-    line_errors: Vec<ValLineError<'data>>,
+    line_errors: Vec<ValLineError>,
 }
 
-enum MaybeErrors<'a, 'data> {
+enum MaybeErrors<'a> {
     Custom(&'a CustomError),
-    Errors(SmallVec<[ChoiceLineErrors<'a, 'data>; 4]>),
+    Errors(SmallVec<[ChoiceLineErrors<'a>; 4]>),
 }
 
-impl<'a, 'data> MaybeErrors<'a, 'data> {
+impl<'a> MaybeErrors<'a> {
     fn new(custom_error: Option<&'a CustomError>) -> Self {
         match custom_error {
             Some(custom_error) => Self::Custom(custom_error),
@@ -238,7 +238,7 @@ impl<'a, 'data> MaybeErrors<'a, 'data> {
         }
     }
 
-    fn push(&mut self, choice: &'a CombinedValidator, label: Option<&'a str>, line_errors: Vec<ValLineError<'data>>) {
+    fn push(&mut self, choice: &'a CombinedValidator, label: Option<&'a str>, line_errors: Vec<ValLineError>) {
         match self {
             Self::Custom(_) => {}
             Self::Errors(errors) => errors.push(ChoiceLineErrors {
@@ -249,7 +249,7 @@ impl<'a, 'data> MaybeErrors<'a, 'data> {
         }
     }
 
-    fn into_val_error(self, input: &'data impl Input<'data>) -> ValError<'data> {
+    fn into_val_error<'i>(self, input: &impl Input<'i>) -> ValError {
         match self {
             Self::Custom(custom_error) => custom_error.as_val_error(input),
             Self::Errors(errors) => ValError::LineErrors(
@@ -395,7 +395,7 @@ impl Validator for TaggedUnionValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         match self.discriminator {
             Discriminator::LookupKey(ref lookup_key) => {
                 macro_rules! find_validator {
@@ -445,7 +445,7 @@ impl TaggedUnionValidator {
         &'s self,
         py: Python<'data>,
         input: &'data impl Input<'data>,
-    ) -> ValResult<'data, &'data PyString> {
+    ) -> ValResult<&'data PyString> {
         let dict = input.strict_dict()?;
         let either_tag = match dict {
             GenericMapping::PyDict(dict) => match dict.get_item(intern!(py, "type"))? {
@@ -492,7 +492,7 @@ impl TaggedUnionValidator {
         tag: &'data PyAny,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         if let Ok(Some((tag, validator))) = self.lookup.validate(py, tag) {
             return match validator.validate(py, input, state) {
                 Ok(res) => Ok(res),
@@ -513,7 +513,7 @@ impl TaggedUnionValidator {
         }
     }
 
-    fn tag_not_found<'s, 'data>(&'s self, input: &'data impl Input<'data>) -> ValError<'data> {
+    fn tag_not_found<'s, 'data>(&'s self, input: &'data impl Input<'data>) -> ValError {
         match self.custom_error {
             Some(ref custom_error) => custom_error.as_val_error(input),
             None => ValError::new(
diff --git a/src/validators/url.rs b/src/validators/url.rs
index 77f887b7d..ba0d4cd4d 100644
--- a/src/validators/url.rs
+++ b/src/validators/url.rs
@@ -65,7 +65,7 @@ impl Validator for UrlValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let mut lib_url = self.get_url(input, state.strict_or(self.strict))?;
 
         if let Some((ref allowed_schemes, ref expected_schemes_repr)) = self.allowed_schemes {
@@ -93,7 +93,7 @@ impl Validator for UrlValidator {
                 state.floor_exactness(Exactness::Lax);
                 Ok(PyUrl::new(lib_url).into_py(py))
             }
-            Err(error_type) => return Err(ValError::new(error_type, input)),
+            Err(error_type) => Err(ValError::new(error_type, input)),
         }
     }
 
@@ -103,7 +103,7 @@ impl Validator for UrlValidator {
 }
 
 impl UrlValidator {
-    fn get_url<'s, 'data>(&'s self, input: &'data impl Input<'data>, strict: bool) -> ValResult<'data, Url> {
+    fn get_url<'s, 'data>(&'s self, input: &'data impl Input<'data>, strict: bool) -> ValResult<Url> {
         match input.validate_str(strict, false) {
             Ok(val_match) => {
                 let either_str = val_match.into_inner();
@@ -133,7 +133,7 @@ impl UrlValidator {
         }
     }
 
-    fn check_length<'s, 'data>(&self, input: &'data impl Input<'data>, url_str: &str) -> ValResult<'data, ()> {
+    fn check_length<'s, 'data>(&self, input: &'data impl Input<'data>, url_str: &str) -> ValResult<()> {
         if let Some(max_length) = self.max_length {
             if url_str.len() > max_length {
                 return Err(ValError::new(
@@ -199,7 +199,7 @@ impl Validator for MultiHostUrlValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let mut multi_url = self.get_url(input, state.strict_or(self.strict))?;
 
         if let Some((ref allowed_schemes, ref expected_schemes_repr)) = self.allowed_schemes {
@@ -226,7 +226,7 @@ impl Validator for MultiHostUrlValidator {
                 state.floor_exactness(Exactness::Lax);
                 Ok(multi_url.into_py(py))
             }
-            Err(error_type) => return Err(ValError::new(error_type, input)),
+            Err(error_type) => Err(ValError::new(error_type, input)),
         }
     }
 
@@ -236,7 +236,7 @@ impl Validator for MultiHostUrlValidator {
 }
 
 impl MultiHostUrlValidator {
-    fn get_url<'s, 'data>(&'s self, input: &'data impl Input<'data>, strict: bool) -> ValResult<'data, PyMultiHostUrl> {
+    fn get_url<'s, 'data>(&'s self, input: &'data impl Input<'data>, strict: bool) -> ValResult<PyMultiHostUrl> {
         match input.validate_str(strict, false) {
             Ok(val_match) => {
                 let either_str = val_match.into_inner();
@@ -264,7 +264,7 @@ impl MultiHostUrlValidator {
         }
     }
 
-    fn check_length<'s, 'data, F>(&self, input: &'data impl Input<'data>, func: F) -> ValResult<'data, ()>
+    fn check_length<'s, 'data, F>(&self, input: &'data impl Input<'data>, func: F) -> ValResult<()>
     where
         F: FnOnce() -> usize,
     {
@@ -287,7 +287,7 @@ fn parse_multihost_url<'url, 'input>(
     url_str: &'url str,
     input: &'input impl Input<'input>,
     strict: bool,
-) -> ValResult<'input, PyMultiHostUrl> {
+) -> ValResult<PyMultiHostUrl> {
     macro_rules! parsing_err {
         ($parse_error:expr) => {
             Err(ValError::new(
@@ -402,11 +402,7 @@ fn parse_multihost_url<'url, 'input>(
     }
 }
 
-fn parse_url<'url, 'input>(
-    url_str: &'url str,
-    input: &'input impl Input<'input>,
-    strict: bool,
-) -> ValResult<'input, Url> {
+fn parse_url<'url, 'input>(url_str: &'url str, input: &'input impl Input<'input>, strict: bool) -> ValResult<Url> {
     if url_str.is_empty() {
         return Err(ValError::new(
             ErrorType::UrlParsing {
diff --git a/src/validators/uuid.rs b/src/validators/uuid.rs
index 3324d5ea1..4cfd7a272 100644
--- a/src/validators/uuid.rs
+++ b/src/validators/uuid.rs
@@ -90,7 +90,7 @@ impl Validator for UuidValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         let class = get_uuid_type(py)?;
         if let Some(py_input) = input.input_is_instance(class) {
             if let Some(expected_version) = self.version {
@@ -135,7 +135,7 @@ impl Validator for UuidValidator {
 }
 
 impl UuidValidator {
-    fn get_uuid<'s, 'data>(&'s self, input: &'data impl Input<'data>) -> ValResult<'data, Uuid> {
+    fn get_uuid<'s, 'data>(&'s self, input: &'data impl Input<'data>) -> ValResult<Uuid> {
         let uuid = match input.exact_str().ok() {
             Some(either_string) => {
                 let cow = either_string.as_cow()?;
@@ -198,7 +198,7 @@ impl UuidValidator {
     ///
     /// This implementation does not use the Python `__init__` function to speed up the process,
     /// as the `__init__` function in the Python `uuid` module performs extensive checks.
-    fn create_py_uuid<'py>(&self, py: Python<'py>, py_type: &PyType, uuid: &Uuid) -> ValResult<'py, Py<PyAny>> {
+    fn create_py_uuid(&self, py: Python<'_>, py_type: &PyType, uuid: &Uuid) -> ValResult<Py<PyAny>> {
         let class = create_class(py_type)?;
         let dc = class.as_ref(py);
         let int = uuid.as_u128();
diff --git a/src/validators/with_default.rs b/src/validators/with_default.rs
index a06ccd0cd..443c0e271 100644
--- a/src/validators/with_default.rs
+++ b/src/validators/with_default.rs
@@ -131,7 +131,7 @@ impl Validator for WithDefaultValidator {
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, PyObject> {
+    ) -> ValResult<PyObject> {
         if input.to_object(py).is(&PydanticUndefinedType::py_undefined()) {
             Ok(self.default_value(py, None::<usize>, state)?.unwrap())
         } else {
@@ -149,12 +149,12 @@ impl Validator for WithDefaultValidator {
         }
     }
 
-    fn default_value<'data>(
+    fn default_value(
         &self,
-        py: Python<'data>,
+        py: Python<'_>,
         outer_loc: Option<impl Into<LocItem>>,
         state: &mut ValidationState,
-    ) -> ValResult<'data, Option<PyObject>> {
+    ) -> ValResult<Option<PyObject>> {
         match self.default.default_value(py)? {
             Some(stored_dft) => {
                 let dft: Py<PyAny> = if self.copy_default {

From 7634e5e74a26c10d5d2b5c6a39017ea576a5d94d Mon Sep 17 00:00:00 2001
From: Marius Lie Winger <89073985+mariuswinger@users.noreply.github.com>
Date: Tue, 21 Nov 2023 15:27:01 +0100
Subject: [PATCH 129/550] Fix typo in is_instance_schema docstring (#1087)

---
 python/pydantic_core/core_schema.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index fec3b9966..c097d740e 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -1196,7 +1196,7 @@ def is_instance_schema(
     serialization: SerSchema | None = None,
 ) -> IsInstanceSchema:
     """
-    Returns a schema that checks if a value is an instance of a class, equivalent to python's `isinstnace` method, e.g.:
+    Returns a schema that checks if a value is an instance of a class, equivalent to python's `isinstance` method, e.g.:
 
     ```py
     from pydantic_core import SchemaValidator, core_schema

From 3d3f40610ce49586c4e865b82db1544dd1ffb061 Mon Sep 17 00:00:00 2001
From: David Hewitt <mail@davidhewitt.dev>
Date: Tue, 21 Nov 2023 16:30:32 +0000
Subject: [PATCH 130/550] Don't build dummy objects when populating
 `ObTypeLookup` (#1086)

---
 src/serializers/ob_type.rs | 37 +++++++++++++++++--------------------
 1 file changed, 17 insertions(+), 20 deletions(-)

diff --git a/src/serializers/ob_type.rs b/src/serializers/ob_type.rs
index ff43a1065..7493d5abd 100644
--- a/src/serializers/ob_type.rs
+++ b/src/serializers/ob_type.rs
@@ -59,29 +59,26 @@ pub enum IsType {
 
 impl ObTypeLookup {
     fn new(py: Python) -> Self {
-        let lib_url = url::Url::parse("https://example.com").unwrap();
         Self {
             none: py.None().as_ref(py).get_type_ptr() as usize,
-            int: 0i32.into_py(py).as_ref(py).get_type_ptr() as usize,
-            bool: true.into_py(py).as_ref(py).get_type_ptr() as usize,
-            float: 0f32.into_py(py).as_ref(py).get_type_ptr() as usize,
-            list: PyList::empty(py).get_type_ptr() as usize,
-            dict: PyDict::new(py).get_type_ptr() as usize,
+            int: PyInt::type_object_raw(py) as usize,
+            bool: PyBool::type_object_raw(py) as usize,
+            float: PyFloat::type_object_raw(py) as usize,
+            list: PyList::type_object_raw(py) as usize,
+            dict: PyDict::type_object_raw(py) as usize,
             decimal_object: py.import("decimal").unwrap().getattr("Decimal").unwrap().to_object(py),
-            string: PyString::new(py, "s").get_type_ptr() as usize,
-            bytes: PyBytes::new(py, b"s").get_type_ptr() as usize,
-            bytearray: PyByteArray::new(py, b"s").get_type_ptr() as usize,
-            tuple: PyTuple::empty(py).get_type_ptr() as usize,
-            set: PySet::empty(py).unwrap().get_type_ptr() as usize,
-            frozenset: PyFrozenSet::empty(py).unwrap().get_type_ptr() as usize,
-            datetime: PyDateTime::new(py, 2000, 1, 1, 0, 0, 0, 0, None)
-                .unwrap()
-                .get_type_ptr() as usize,
-            date: PyDate::new(py, 2000, 1, 1).unwrap().get_type_ptr() as usize,
-            time: PyTime::new(py, 0, 0, 0, 0, None).unwrap().get_type_ptr() as usize,
-            timedelta: PyDelta::new(py, 0, 0, 0, false).unwrap().get_type_ptr() as usize,
-            url: PyUrl::new(lib_url.clone()).into_py(py).as_ref(py).get_type_ptr() as usize,
-            multi_host_url: PyMultiHostUrl::new(lib_url, None).into_py(py).as_ref(py).get_type_ptr() as usize,
+            string: PyString::type_object_raw(py) as usize,
+            bytes: PyBytes::type_object_raw(py) as usize,
+            bytearray: PyByteArray::type_object_raw(py) as usize,
+            tuple: PyTuple::type_object_raw(py) as usize,
+            set: PySet::type_object_raw(py) as usize,
+            frozenset: PyFrozenSet::type_object_raw(py) as usize,
+            datetime: PyDateTime::type_object_raw(py) as usize,
+            date: PyDate::type_object_raw(py) as usize,
+            time: PyTime::type_object_raw(py) as usize,
+            timedelta: PyDelta::type_object_raw(py) as usize,
+            url: PyUrl::type_object_raw(py) as usize,
+            multi_host_url: PyMultiHostUrl::type_object_raw(py) as usize,
             enum_object: py.import("enum").unwrap().getattr("Enum").unwrap().to_object(py),
             generator_object: py
                 .import("types")

From a7739ec8681bd5fe5d31be37b11cef482a05ccfb Mon Sep 17 00:00:00 2001
From: David Hewitt <mail@davidhewitt.dev>
Date: Tue, 21 Nov 2023 16:53:43 +0000
Subject: [PATCH 131/550] Remove needless uses of `PyString::intern` (#1088)

---
 src/lookup_key.rs                             | 20 +++++++------------
 src/serializers/type_serializers/dataclass.rs |  2 +-
 src/validators/arguments.rs                   |  2 +-
 src/validators/dataclass.rs                   |  2 +-
 src/validators/model.rs                       |  2 +-
 src/validators/model_fields.rs                |  2 +-
 src/validators/typed_dict.rs                  |  2 +-
 7 files changed, 13 insertions(+), 19 deletions(-)

diff --git a/src/lookup_key.rs b/src/lookup_key.rs
index 21b584690..e145c1f41 100644
--- a/src/lookup_key.rs
+++ b/src/lookup_key.rs
@@ -51,12 +51,6 @@ impl fmt::Display for LookupKey {
     }
 }
 
-macro_rules! py_string {
-    ($py:ident, $str:expr) => {
-        PyString::intern($py, $str).into()
-    };
-}
-
 impl LookupKey {
     pub fn from_py(py: Python, value: &PyAny, alt_alias: Option<&str>) -> PyResult<Self> {
         if let Ok(alias_py) = value.downcast::<PyString>() {
@@ -67,7 +61,7 @@ impl LookupKey {
                     py_key1: alias_py.into_py(py),
                     path1: LookupPath::from_str(py, alias, Some(alias_py)),
                     key2: alt_alias.to_string(),
-                    py_key2: py_string!(py, alt_alias),
+                    py_key2: PyString::new(py, alt_alias).into(),
                     path2: LookupPath::from_str(py, alt_alias, None),
                 }),
                 None => Ok(Self::simple(py, alias, Some(alias_py))),
@@ -98,12 +92,12 @@ impl LookupKey {
 
     fn simple(py: Python, key: &str, opt_py_key: Option<&PyString>) -> Self {
         let py_key = match opt_py_key {
-            Some(py_key) => py_key.into_py(py),
-            None => py_string!(py, key),
+            Some(py_key) => py_key,
+            None => PyString::new(py, key),
         };
         Self::Simple {
             key: key.to_string(),
-            py_key,
+            py_key: py_key.into(),
             path: LookupPath::from_str(py, key, opt_py_key),
         }
     }
@@ -348,10 +342,10 @@ impl fmt::Display for LookupPath {
 impl LookupPath {
     fn from_str(py: Python, key: &str, py_key: Option<&PyString>) -> Self {
         let py_key = match py_key {
-            Some(py_key) => py_key.into_py(py),
-            None => py_string!(py, key),
+            Some(py_key) => py_key,
+            None => PyString::new(py, key),
         };
-        Self(vec![PathItem::S(key.to_string(), py_key)])
+        Self(vec![PathItem::S(key.to_string(), py_key.into())])
     }
 
     fn from_list(obj: &PyAny) -> PyResult<LookupPath> {
diff --git a/src/serializers/type_serializers/dataclass.rs b/src/serializers/type_serializers/dataclass.rs
index 787e267dd..a82643186 100644
--- a/src/serializers/type_serializers/dataclass.rs
+++ b/src/serializers/type_serializers/dataclass.rs
@@ -39,7 +39,7 @@ impl BuildSerializer for DataclassArgsBuilder {
             let field_info: &PyDict = item.downcast()?;
             let name: String = field_info.get_as_req(intern!(py, "name"))?;
 
-            let key_py: Py<PyString> = PyString::intern(py, &name).into_py(py);
+            let key_py: Py<PyString> = PyString::new(py, &name).into_py(py);
 
             if field_info.get_as(intern!(py, "serialization_exclude"))? == Some(true) {
                 fields.insert(name, SerField::new(py, key_py, None, None, true));
diff --git a/src/validators/arguments.rs b/src/validators/arguments.rs
index 0405d54e5..aaf5afb6b 100644
--- a/src/validators/arguments.rs
+++ b/src/validators/arguments.rs
@@ -73,7 +73,7 @@ impl BuildValidator for ArgumentsValidator {
                     }
                     None => Some(LookupKey::from_string(py, &name)),
                 };
-                kwarg_key = Some(PyString::intern(py, &name).into());
+                kwarg_key = Some(PyString::new(py, &name).into());
             }
 
             let schema: &PyAny = arg.get_as_req(intern!(py, "schema"))?;
diff --git a/src/validators/dataclass.rs b/src/validators/dataclass.rs
index dbbfc5ee2..986556b66 100644
--- a/src/validators/dataclass.rs
+++ b/src/validators/dataclass.rs
@@ -477,7 +477,7 @@ impl BuildValidator for DataclassValidator {
         let validator = build_validator(sub_schema, config, definitions)?;
 
         let post_init = if schema.get_as::<bool>(intern!(py, "post_init"))?.unwrap_or(false) {
-            Some(PyString::intern(py, "__post_init__").into_py(py))
+            Some(PyString::new(py, "__post_init__").into_py(py))
         } else {
             None
         };
diff --git a/src/validators/model.rs b/src/validators/model.rs
index 6f810d10e..1831d2fde 100644
--- a/src/validators/model.rs
+++ b/src/validators/model.rs
@@ -89,7 +89,7 @@ impl BuildValidator for ModelValidator {
             class: class.into(),
             post_init: schema
                 .get_as::<&str>(intern!(py, "post_init"))?
-                .map(|s| PyString::intern(py, s).into_py(py)),
+                .map(|s| PyString::new(py, s).into_py(py)),
             frozen: schema.get_as(intern!(py, "frozen"))?.unwrap_or(false),
             custom_init: schema.get_as(intern!(py, "custom_init"))?.unwrap_or(false),
             root_model: schema.get_as(intern!(py, "root_model"))?.unwrap_or(false),
diff --git a/src/validators/model_fields.rs b/src/validators/model_fields.rs
index f603c7b22..c73a2821d 100644
--- a/src/validators/model_fields.rs
+++ b/src/validators/model_fields.rs
@@ -93,7 +93,7 @@ impl BuildValidator for ModelFieldsValidator {
             fields.push(Field {
                 name: field_name.to_string(),
                 lookup_key,
-                name_py: PyString::intern(py, field_name).into(),
+                name_py: PyString::new(py, field_name).into(),
                 validator,
                 frozen: field_info.get_as::<bool>(intern!(py, "frozen"))?.unwrap_or(false),
             });
diff --git a/src/validators/typed_dict.rs b/src/validators/typed_dict.rs
index 95cd19133..d2fc00ec7 100644
--- a/src/validators/typed_dict.rs
+++ b/src/validators/typed_dict.rs
@@ -120,7 +120,7 @@ impl BuildValidator for TypedDictValidator {
             fields.push(TypedDictField {
                 name: field_name.to_string(),
                 lookup_key,
-                name_py: PyString::intern(py, field_name).into(),
+                name_py: PyString::new(py, field_name).into(),
                 validator,
                 required,
             });

From 3840e006bfa7be234f4d1ce20becacbf57231d83 Mon Sep 17 00:00:00 2001
From: Adam Johnson <me@adamj.eu>
Date: Tue, 21 Nov 2023 22:23:20 +0000
Subject: [PATCH 132/550] Correct deprecation message for
 general_after_validator_function (#1090)

---
 python/pydantic_core/core_schema.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index c097d740e..daed22d48 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -3862,7 +3862,7 @@ def field_after_validator_function(function: WithInfoValidatorFunction, field_na
 @deprecated('`general_after_validator_function` is deprecated, use `with_info_after_validator_function` instead.')
 def general_after_validator_function(*args, **kwargs):
     warnings.warn(
-        '`with_info_after_validator_function` is deprecated, use `with_info_after_validator_function` instead.',
+        '`general_after_validator_function` is deprecated, use `with_info_after_validator_function` instead.',
         DeprecationWarning,
     )
     return with_info_after_validator_function(*args, **kwargs)

From 5b63e7a89df6d48ca0b48b4a885c96f7c2cfd413 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Wed, 22 Nov 2023 03:29:18 -0600
Subject: [PATCH 133/550] Avoid using `?` with `get_item` to handle unhashable
 inputs properly (#1089)

Co-authored-by: Samuel Colvin <s@muelcolvin.com>
---
 src/validators/literal.rs      |  5 ++++-
 tests/validators/test_union.py | 32 ++++++++++++++++++++++++++++++++
 2 files changed, 36 insertions(+), 1 deletion(-)

diff --git a/src/validators/literal.rs b/src/validators/literal.rs
index 0f1caf601..9f8c25e0f 100644
--- a/src/validators/literal.rs
+++ b/src/validators/literal.rs
@@ -136,7 +136,10 @@ impl<T: Debug> LiteralLookup<T> {
         }
         // must be an enum or bytes
         if let Some(expected_py) = &self.expected_py {
-            if let Some(v) = expected_py.as_ref(py).get_item(input)? {
+            // We don't use ? to unpack the result of `get_item` in the next line because unhashable
+            // inputs will produce a TypeError, which in this case we just want to treat equivalently
+            // to a failed lookup
+            if let Ok(Some(v)) = expected_py.as_ref(py).get_item(input) {
                 let id: usize = v.extract().unwrap();
                 return Ok(Some((input, &self.values[id])));
             }
diff --git a/tests/validators/test_union.py b/tests/validators/test_union.py
index 503a5f387..42c542000 100644
--- a/tests/validators/test_union.py
+++ b/tests/validators/test_union.py
@@ -771,3 +771,35 @@ class BinaryEnum(IntEnum):
     assert validator.validate_python(1) is not BinaryEnum.ONE
     assert validator.validate_python(BinaryEnum.ZERO) is BinaryEnum.ZERO
     assert validator.validate_python(BinaryEnum.ONE) is BinaryEnum.ONE
+
+
+def test_model_and_literal_union() -> None:
+    # see https://github.com/pydantic/pydantic/issues/8183
+    class ModelA:
+        pass
+
+    validator = SchemaValidator(
+        {
+            'type': 'union',
+            'choices': [
+                {
+                    'type': 'model',
+                    'cls': ModelA,
+                    'schema': {
+                        'type': 'model-fields',
+                        'fields': {
+                            'a': {'type': 'model-field', 'schema': {'type': 'int'}},
+                        },
+                    },
+                },
+                {'type': 'literal', 'expected': [True]},
+            ],
+        }
+    )
+
+    # validation against Literal[True] fails bc of the unhashable dict
+    # A ValidationError is raised, not a ValueError, which allows the validation against the union to continue
+    m = validator.validate_python({'a': 42})
+    assert isinstance(m, ModelA)
+    assert m.a == 42
+    assert validator.validate_python(True) is True

From c7daf167140460244c9287c557cd20d1d9ca89d8 Mon Sep 17 00:00:00 2001
From: Samuel Colvin <s@muelcolvin.com>
Date: Mon, 27 Nov 2023 11:16:13 +0000
Subject: [PATCH 134/550] support newest jiter behaviour (#1092)

Co-authored-by: David Hewitt <mail@davidhewitt.dev>
---
 Cargo.lock                              |  4 +-
 Cargo.toml                              |  3 +-
 python/pydantic_core/_pydantic_core.pyi |  4 +-
 src/input/input_abstract.rs             |  4 --
 src/input/input_json.rs                 | 13 +-----
 src/input/input_python.rs               | 20 +---------
 src/input/input_string.rs               | 13 +-----
 src/input/shared.rs                     | 13 +-----
 src/lib.rs                              | 22 +++++-----
 src/validators/json.rs                  | 53 +++++++++++++++++++++----
 src/validators/mod.rs                   | 51 ++++++++++++++----------
 tests/validators/test_json.py           | 18 +++++----
 12 files changed, 105 insertions(+), 113 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 249fdfbf9..2ba82639c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -138,9 +138,9 @@ checksum = "62b02a5381cc465bd3041d84623d0fa3b66738b52b8e2fc3bab8ad63ab032f4a"
 
 [[package]]
 name = "jiter"
-version = "0.0.4"
+version = "0.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b27d419c535bf7b50ad355278b1159cbf0cc8d507ea003d625b17bf0375720b8"
+checksum = "e184598fea113663dd78e33a24ad3a1e7ba8ceedf71effb7406b3f2eccb63ed1"
 dependencies = [
  "ahash",
  "lexical-core",
diff --git a/Cargo.toml b/Cargo.toml
index 512d98908..20f4b79b8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -43,8 +43,7 @@ base64 = "0.21.5"
 num-bigint = "0.4.4"
 python3-dll-a = "0.2.7"
 uuid = "1.5.0"
-jiter = {version = "0.0.4", features = ["python"]}
-#jiter = {path = "../jiter", features = ["python"]}
+jiter = {version = "0.0.5", features = ["python"]}
 
 [lib]
 name = "_pydantic_core"
diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index 4c99a4d61..382a6c804 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -385,7 +385,7 @@ def to_json(
        JSON bytes.
     """
 
-def from_json(data: str | bytes | bytearray, *, allow_inf_nan: bool = True) -> Any:
+def from_json(data: str | bytes | bytearray, *, allow_inf_nan: bool = True, cache_strings: bool = True) -> Any:
     """
     Deserialize JSON data to a Python object.
 
@@ -394,6 +394,8 @@ def from_json(data: str | bytes | bytearray, *, allow_inf_nan: bool = True) -> A
     Arguments:
         data: The JSON data to deserialize.
         allow_inf_nan: Whether to allow `Infinity`, `-Infinity` and `NaN` values as `json.loads()` does by default.
+        cache_strings: Whether to cache strings to avoid constructing new Python objects,
+            this should have a significant impact on performance while increasing memory usage slightly.
 
     Raises:
         ValueError: If deserialization fails.
diff --git a/src/input/input_abstract.rs b/src/input/input_abstract.rs
index ceb0495a9..8229677b6 100644
--- a/src/input/input_abstract.rs
+++ b/src/input/input_abstract.rs
@@ -4,8 +4,6 @@ use pyo3::exceptions::PyValueError;
 use pyo3::types::{PyDict, PyType};
 use pyo3::{intern, prelude::*};
 
-use jiter::JsonValue;
-
 use crate::errors::{AsLocItem, ErrorTypeDefaults, InputValue, ValError, ValResult};
 use crate::tools::py_err;
 use crate::{PyMultiHostUrl, PyUrl};
@@ -89,8 +87,6 @@ pub trait Input<'a>: fmt::Debug + ToPyObject + AsLocItem + Sized {
 
     fn validate_dataclass_args(&'a self, dataclass_name: &str) -> ValResult<GenericArguments<'a>>;
 
-    fn parse_json(&'a self) -> ValResult<JsonValue>;
-
     fn validate_str(
         &'a self,
         strict: bool,
diff --git a/src/input/input_json.rs b/src/input/input_json.rs
index 3e94adad6..195f9caba 100644
--- a/src/input/input_json.rs
+++ b/src/input/input_json.rs
@@ -14,7 +14,7 @@ use super::datetime::{
     float_as_time, int_as_datetime, int_as_duration, int_as_time, EitherDate, EitherDateTime, EitherTime,
 };
 use super::return_enums::ValidationMatch;
-use super::shared::{float_as_int, int_as_bool, map_json_err, str_as_bool, str_as_float, str_as_int};
+use super::shared::{float_as_int, int_as_bool, str_as_bool, str_as_float, str_as_int};
 use super::{
     BorrowInput, EitherBytes, EitherFloat, EitherInt, EitherString, EitherTimedelta, GenericArguments, GenericIterable,
     GenericIterator, GenericMapping, Input, JsonArgs,
@@ -84,13 +84,6 @@ impl<'a> Input<'a> for JsonValue {
         }
     }
 
-    fn parse_json(&'a self) -> ValResult<JsonValue> {
-        match self {
-            JsonValue::Str(s) => JsonValue::parse(s.as_bytes(), true).map_err(|e| map_json_err(self, e)),
-            _ => Err(ValError::new(ErrorTypeDefaults::JsonType, self)),
-        }
-    }
-
     fn exact_str(&'a self) -> ValResult<EitherString<'a>> {
         match self {
             JsonValue::Str(s) => Ok(s.as_str().into()),
@@ -367,10 +360,6 @@ impl<'a> Input<'a> for String {
         ))
     }
 
-    fn parse_json(&'a self) -> ValResult<JsonValue> {
-        JsonValue::parse(self.as_bytes(), true).map_err(|e| map_json_err(self, e))
-    }
-
     fn validate_str(
         &'a self,
         _strict: bool,
diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index ba42abbb8..5d4d4826c 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -10,7 +10,6 @@ use pyo3::types::{
 use pyo3::types::{PyDictItems, PyDictKeys, PyDictValues};
 use pyo3::{intern, PyTypeInfo};
 
-use jiter::JsonValue;
 use speedate::MicrosecondsPrecisionOverflowBehavior;
 
 use crate::errors::{AsLocItem, ErrorType, ErrorTypeDefaults, InputValue, LocItem, ValError, ValResult};
@@ -26,8 +25,7 @@ use super::datetime::{
 };
 use super::return_enums::ValidationMatch;
 use super::shared::{
-    decimal_as_int, float_as_int, get_enum_meta_object, int_as_bool, map_json_err, str_as_bool, str_as_float,
-    str_as_int,
+    decimal_as_int, float_as_int, get_enum_meta_object, int_as_bool, str_as_bool, str_as_float, str_as_int,
 };
 use super::{
     py_string_str, BorrowInput, EitherBytes, EitherFloat, EitherInt, EitherString, EitherTimedelta, GenericArguments,
@@ -195,22 +193,6 @@ impl<'a> Input<'a> for PyAny {
         }
     }
 
-    fn parse_json(&'a self) -> ValResult<JsonValue> {
-        let bytes = if let Ok(py_bytes) = self.downcast::<PyBytes>() {
-            py_bytes.as_bytes()
-        } else if let Ok(py_str) = self.downcast::<PyString>() {
-            let str = py_string_str(py_str)?;
-            str.as_bytes()
-        } else if let Ok(py_byte_array) = self.downcast::<PyByteArray>() {
-            // Safety: from_slice does not run arbitrary Python code and the GIL is held so the
-            // bytes array will not be mutated while `JsonValue::parse` is reading it
-            unsafe { py_byte_array.as_bytes() }
-        } else {
-            return Err(ValError::new(ErrorTypeDefaults::JsonType, self));
-        };
-        JsonValue::parse(bytes, true).map_err(|e| map_json_err(self, e))
-    }
-
     fn validate_str(
         &'a self,
         strict: bool,
diff --git a/src/input/input_string.rs b/src/input/input_string.rs
index 290247617..0c2c9a8ca 100644
--- a/src/input/input_string.rs
+++ b/src/input/input_string.rs
@@ -1,7 +1,6 @@
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyString};
 
-use jiter::JsonValue;
 use speedate::MicrosecondsPrecisionOverflowBehavior;
 
 use crate::errors::{AsLocItem, ErrorTypeDefaults, InputValue, LocItem, ValError, ValResult};
@@ -12,7 +11,7 @@ use crate::validators::decimal::create_decimal;
 use super::datetime::{
     bytes_as_date, bytes_as_datetime, bytes_as_time, bytes_as_timedelta, EitherDate, EitherDateTime, EitherTime,
 };
-use super::shared::{map_json_err, str_as_bool, str_as_float};
+use super::shared::{str_as_bool, str_as_float};
 use super::{
     BorrowInput, EitherBytes, EitherFloat, EitherInt, EitherString, EitherTimedelta, GenericArguments, GenericIterable,
     GenericIterator, GenericMapping, Input, ValidationMatch,
@@ -86,16 +85,6 @@ impl<'a> Input<'a> for StringMapping<'a> {
         }
     }
 
-    fn parse_json(&'a self) -> ValResult<JsonValue> {
-        match self {
-            Self::String(s) => {
-                let str = py_string_str(s)?;
-                JsonValue::parse(str.as_bytes(), true).map_err(|e| map_json_err(self, e))
-            }
-            Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::JsonType, self)),
-        }
-    }
-
     fn validate_str(
         &'a self,
         _strict: bool,
diff --git a/src/input/shared.rs b/src/input/shared.rs
index 647bce8a3..591c5abfc 100644
--- a/src/input/shared.rs
+++ b/src/input/shared.rs
@@ -1,10 +1,9 @@
 use pyo3::sync::GILOnceCell;
 use pyo3::{intern, Py, PyAny, Python, ToPyObject};
 
-use jiter::JsonValueError;
 use num_bigint::BigInt;
 
-use crate::errors::{ErrorType, ErrorTypeDefaults, ValError, ValResult};
+use crate::errors::{ErrorTypeDefaults, ValError, ValResult};
 
 use super::{EitherFloat, EitherInt, Input};
 static ENUM_META_OBJECT: GILOnceCell<Py<PyAny>> = GILOnceCell::new();
@@ -20,16 +19,6 @@ pub fn get_enum_meta_object(py: Python) -> Py<PyAny> {
         .clone()
 }
 
-pub fn map_json_err<'a>(input: &'a impl Input<'a>, error: JsonValueError) -> ValError {
-    ValError::new(
-        ErrorType::JsonInvalid {
-            error: error.to_string(),
-            context: None,
-        },
-        input,
-    )
-}
-
 pub fn str_as_bool<'a>(input: &'a impl Input<'a>, str: &str) -> ValResult<bool> {
     if str == "0"
         || str.eq_ignore_ascii_case("f")
diff --git a/src/lib.rs b/src/lib.rs
index f969c0657..de4a6d9bd 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -5,7 +5,6 @@ extern crate core;
 use std::sync::OnceLock;
 
 use pyo3::exceptions::PyTypeError;
-use pyo3::types::{PyByteArray, PyBytes, PyString};
 use pyo3::{prelude::*, sync::GILOnceCell};
 
 // parse this first to get access to the contained macro
@@ -37,17 +36,16 @@ pub use serializers::{
 };
 pub use validators::{validate_core_schema, PySome, SchemaValidator};
 
-#[pyfunction(signature = (data, *, allow_inf_nan=true))]
-pub fn from_json(py: Python, data: &PyAny, allow_inf_nan: bool) -> PyResult<PyObject> {
-    if let Ok(py_bytes) = data.downcast::<PyBytes>() {
-        jiter::python_parse(py, py_bytes.as_bytes(), allow_inf_nan)
-    } else if let Ok(py_str) = data.downcast::<PyString>() {
-        jiter::python_parse(py, py_str.to_str()?.as_bytes(), allow_inf_nan)
-    } else if let Ok(py_byte_array) = data.downcast::<PyByteArray>() {
-        jiter::python_parse(py, &py_byte_array.to_vec(), allow_inf_nan)
-    } else {
-        Err(PyTypeError::new_err("Expected bytes, bytearray or str"))
-    }
+use crate::input::Input;
+
+#[pyfunction(signature = (data, *, allow_inf_nan=true, cache_strings=true))]
+pub fn from_json(py: Python, data: &PyAny, allow_inf_nan: bool, cache_strings: bool) -> PyResult<PyObject> {
+    let v_match = data
+        .validate_bytes(false)
+        .map_err(|_| PyTypeError::new_err("Expected bytes, bytearray or str"))?;
+    let json_either_bytes = v_match.into_inner();
+    let json_bytes = json_either_bytes.as_slice();
+    jiter::python_parse(py, json_bytes, allow_inf_nan, cache_strings).map_err(|e| jiter::map_json_error(json_bytes, &e))
 }
 
 pub fn get_pydantic_core_version() -> &'static str {
diff --git a/src/validators/json.rs b/src/validators/json.rs
index 7ce1f9e29..44250ef9d 100644
--- a/src/validators/json.rs
+++ b/src/validators/json.rs
@@ -2,8 +2,10 @@ use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
 
-use crate::errors::ValResult;
-use crate::input::Input;
+use jiter::JsonValue;
+
+use crate::errors::{ErrorType, ErrorTypeDefaults, ValError, ValLineError, ValResult};
+use crate::input::{EitherBytes, Input, ValidationMatch};
 use crate::tools::SchemaDict;
 
 use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
@@ -50,13 +52,19 @@ impl Validator for JsonValidator {
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
-        let json_value = input.parse_json()?;
+        let v_match = validate_json_bytes(input)?;
+        let json_either_bytes = v_match.unpack(state);
+        let json_bytes = json_either_bytes.as_slice();
         match self.validator {
-            Some(ref validator) => match validator.validate(py, &json_value, state) {
-                Ok(v) => Ok(v),
-                Err(err) => Err(err),
-            },
-            None => Ok(json_value.to_object(py)),
+            Some(ref validator) => {
+                let json_value = JsonValue::parse(json_bytes, true).map_err(|e| map_json_err(input, e, json_bytes))?;
+                validator.validate(py, &json_value, state)
+            }
+            None => {
+                let obj =
+                    jiter::python_parse(py, json_bytes, true, true).map_err(|e| map_json_err(input, e, json_bytes))?;
+                Ok(obj)
+            }
         }
     }
 
@@ -64,3 +72,32 @@ impl Validator for JsonValidator {
         &self.name
     }
 }
+
+pub fn validate_json_bytes<'data>(input: &'data impl Input<'data>) -> ValResult<ValidationMatch<EitherBytes<'data>>> {
+    match input.validate_bytes(false) {
+        Ok(v_match) => Ok(v_match),
+        Err(ValError::LineErrors(e)) => Err(ValError::LineErrors(
+            e.into_iter().map(map_bytes_error).collect::<Vec<_>>(),
+        )),
+        Err(e) => Err(e),
+    }
+}
+
+fn map_bytes_error(line_error: ValLineError) -> ValLineError {
+    match line_error.error_type {
+        ErrorType::BytesType { .. } => {
+            ValLineError::new_custom_input(ErrorTypeDefaults::JsonType, line_error.input_value)
+        }
+        _ => line_error,
+    }
+}
+
+pub fn map_json_err<'a>(input: &'a impl Input<'a>, error: jiter::JsonError, json_bytes: &[u8]) -> ValError {
+    ValError::new(
+        ErrorType::JsonInvalid {
+            error: error.description(json_bytes),
+            context: None,
+        },
+        input,
+    )
+}
diff --git a/src/validators/mod.rs b/src/validators/mod.rs
index ee95fa799..7809b1ee3 100644
--- a/src/validators/mod.rs
+++ b/src/validators/mod.rs
@@ -171,7 +171,6 @@ impl SchemaValidator {
             from_attributes,
             context,
             self_instance,
-            &mut RecursionGuard::default(),
         )
         .map_err(|e| self.prepare_validation_err(py, e, InputType::Python))
     }
@@ -194,7 +193,6 @@ impl SchemaValidator {
             from_attributes,
             context,
             self_instance,
-            &mut RecursionGuard::default(),
         ) {
             Ok(_) => Ok(true),
             Err(ValError::InternalErr(err)) => Err(err),
@@ -213,22 +211,18 @@ impl SchemaValidator {
         context: Option<&PyAny>,
         self_instance: Option<&PyAny>,
     ) -> PyResult<PyObject> {
-        let recursion_guard = &mut RecursionGuard::default();
-        match input.parse_json() {
-            Ok(input) => self
-                ._validate(
-                    py,
-                    &input,
-                    InputType::Json,
-                    strict,
-                    None,
-                    context,
-                    self_instance,
-                    recursion_guard,
-                )
-                .map_err(|e| self.prepare_validation_err(py, e, InputType::Json)),
-            Err(err) => Err(self.prepare_validation_err(py, err, InputType::Json)),
-        }
+        let r = match json::validate_json_bytes(input) {
+            Ok(v_match) => self._validate_json(
+                py,
+                input,
+                v_match.into_inner().as_slice(),
+                strict,
+                context,
+                self_instance,
+            ),
+            Err(err) => Err(err),
+        };
+        r.map_err(|e| self.prepare_validation_err(py, e, InputType::Json))
     }
 
     #[pyo3(signature = (input, *, strict=None, context=None))]
@@ -242,8 +236,7 @@ impl SchemaValidator {
         let t = InputType::String;
         let string_mapping = StringMapping::new_value(input).map_err(|e| self.prepare_validation_err(py, e, t))?;
 
-        let recursion_guard = &mut RecursionGuard::default();
-        match self._validate(py, &string_mapping, t, strict, None, context, None, recursion_guard) {
+        match self._validate(py, &string_mapping, t, strict, None, context, None) {
             Ok(r) => Ok(r),
             Err(e) => Err(self.prepare_validation_err(py, e, t)),
         }
@@ -329,18 +322,32 @@ impl SchemaValidator {
         from_attributes: Option<bool>,
         context: Option<&'data PyAny>,
         self_instance: Option<&PyAny>,
-        recursion_guard: &'data mut RecursionGuard,
     ) -> ValResult<PyObject>
     where
         's: 'data,
     {
+        let mut recursion_guard = RecursionGuard::default();
         let mut state = ValidationState::new(
             Extra::new(strict, from_attributes, context, self_instance, input_type),
-            recursion_guard,
+            &mut recursion_guard,
         );
         self.validator.validate(py, input, &mut state)
     }
 
+    fn _validate_json(
+        &self,
+        py: Python,
+        input: &PyAny,
+        json_data: &[u8],
+        strict: Option<bool>,
+        context: Option<&PyAny>,
+        self_instance: Option<&PyAny>,
+    ) -> ValResult<PyObject> {
+        let json_value =
+            jiter::JsonValue::parse(json_data, true).map_err(|e| json::map_json_err(input, e, json_data))?;
+        self._validate(py, &json_value, InputType::Json, strict, None, context, self_instance)
+    }
+
     fn prepare_validation_err(&self, py: Python, error: ValError, input_type: InputType) -> PyErr {
         ValidationError::from_val_error(
             py,
diff --git a/tests/validators/test_json.py b/tests/validators/test_json.py
index d8666d335..228d18e55 100644
--- a/tests/validators/test_json.py
+++ b/tests/validators/test_json.py
@@ -48,36 +48,40 @@ def test_any(py_and_json: PyAndJson, input_value, expected):
 @pytest.mark.parametrize(
     'input_value,expected',
     [
-        ('{"a": 1}', {'a': 1}),
-        (b'{"a": 1}', {'a': 1}),
-        (
+        pytest.param('{"a": 1}', {'a': 1}, id='str'),
+        pytest.param(b'{"a": 1}', {'a': 1}, id='bytes'),
+        pytest.param(
             '🐈 Hello \ud800World',
             Err(
                 'Input should be a valid string, unable to parse raw data as a unicode string '
                 "[type=string_unicode, input_value='🐈 Hello \\ud800World', input_type=str]"
             ),
+            id='str_unicode',
         ),
-        (bytearray(b'{"a": 1}'), {'a': 1}),
-        (
+        pytest.param(bytearray(b'{"a": 1}'), {'a': 1}, id='bytearray'),
+        pytest.param(
             'xx',
             Err(
                 'Invalid JSON: expected value at line 1 column 1 '
                 "[type=json_invalid, input_value='xx', input_type=str]"
             ),
+            id='str_invalid',
         ),
-        (
+        pytest.param(
             b'xx',
             Err(
                 'Invalid JSON: expected value at line 1 column 1 '
                 "[type=json_invalid, input_value=b'xx', input_type=bytes]"
             ),
+            id='bytes_invalid',
         ),
-        (
+        pytest.param(
             bytearray(b'xx'),
             Err(
                 'Invalid JSON: expected value at line 1 column 1 '
                 "[type=json_invalid, input_value=bytearray(b'xx'), input_type=bytearray]"
             ),
+            id='bytearray_invalid',
         ),
     ],
 )

From 3b6344e9a956f3a4df3c5766ea21995a6cd1432b Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Wed, 29 Nov 2023 11:16:46 -0600
Subject: [PATCH 135/550] Fixing `exclude_none` for json serialization of
 `computed_field`s (#1098)

---
 src/serializers/computed_fields.rs | 4 ++++
 tests/serializers/test_model.py    | 4 +++-
 2 files changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/serializers/computed_fields.rs b/src/serializers/computed_fields.rs
index 8a1f041ae..6f4553069 100644
--- a/src/serializers/computed_fields.rs
+++ b/src/serializers/computed_fields.rs
@@ -73,6 +73,10 @@ impl ComputedFields {
         }
         for computed_field in &self.0 {
             let property_name_py = computed_field.property_name_py.as_ref(model.py());
+            let value = model.getattr(property_name_py).map_err(py_err_se_err)?;
+            if extra.exclude_none && value.is_none() {
+                return Ok(());
+            }
             if let Some((next_include, next_exclude)) = filter
                 .key_filter(property_name_py, include, exclude)
                 .map_err(py_err_se_err)?
diff --git a/tests/serializers/test_model.py b/tests/serializers/test_model.py
index 32ecd3c1a..4249c3015 100644
--- a/tests/serializers/test_model.py
+++ b/tests/serializers/test_model.py
@@ -608,7 +608,7 @@ def volume(self) -> int:
     assert s.to_json(Model(3, 4)) == b'{"width":3,"height":4,"Area":12,"volume":48}'
 
 
-def test_computed_field_to_python_exclude_none():
+def test_computed_field_exclude_none():
     @dataclasses.dataclass
     class Model:
         width: int
@@ -646,6 +646,8 @@ def volume(self) -> None:
         'volume': None,
     }
     assert s.to_python(Model(3, 4), mode='json', exclude_none=True) == {'width': 3, 'height': 4, 'Area': 12}
+    assert s.to_json(Model(3, 4), exclude_none=False) == b'{"width":3,"height":4,"Area":12,"volume":null}'
+    assert s.to_json(Model(3, 4), exclude_none=True) == b'{"width":3,"height":4,"Area":12}'
 
 
 @pytest.mark.skipif(cached_property is None, reason='cached_property is not available')

From 5d64894e8dbec8c21dadf2d79c756dcfe4f436a3 Mon Sep 17 00:00:00 2001
From: David Hewitt <mail@davidhewitt.dev>
Date: Wed, 29 Nov 2023 17:25:14 +0000
Subject: [PATCH 136/550] bump pandas tests to run on 3.12 (#1097)

---
 tests/requirements.txt | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/tests/requirements.txt b/tests/requirements.txt
index 66dda075f..67e8e002b 100644
--- a/tests/requirements.txt
+++ b/tests/requirements.txt
@@ -1,8 +1,11 @@
 coverage==7.2.7
 dirty-equals==0.6.0
 hypothesis==6.79.4
+# TODO: remove manual override for dateutil once a version newer than 2.8.2 is
+# released which removes use of deprecated utcfromtimestamp
+git+https://github.com/dateutil/dateutil.git@f2293200747fb03d56c6c5997bfebeabe703576f
 # pandas doesn't offer prebuilt wheels for all versions and platforms we test in CI e.g. aarch64 musllinux
-pandas==2.0.3; python_version >= "3.9" and python_version < "3.12" and implementation_name == "cpython" and platform_machine == 'x86_64'
+pandas==2.1.3; python_version >= "3.9" and python_version < "3.13" and implementation_name == "cpython" and platform_machine == 'x86_64'
 pytest==7.4.3
 # we run codspeed benchmarks on x86_64 CPython (i.e. native github actions architecture)
 pytest-codspeed~=2.2.0; implementation_name == "cpython" and platform_machine == 'x86_64'
@@ -13,5 +16,5 @@ pytest-pretty==1.2.0
 pytest-timeout==2.2.0
 pytz==2023.3.post1
 # numpy doesn't offer prebuilt wheels for all versions and platforms we test in CI e.g. aarch64 musllinux
-numpy==1.25.2; python_version >= "3.9" and python_version < "3.12" and implementation_name == "cpython" and platform_machine == 'x86_64'
+numpy==1.26.2; python_version >= "3.9" and python_version < "3.13" and implementation_name == "cpython" and platform_machine == 'x86_64'
 exceptiongroup==1.1; python_version < "3.11"

From f323e74a50b7951a700bfb526e16d67e75d16072 Mon Sep 17 00:00:00 2001
From: David Montague <35119617+dmontagu@users.noreply.github.com>
Date: Thu, 30 Nov 2023 02:45:46 -0700
Subject: [PATCH 137/550] Fix memory leak caused by not visiting the function
 in a CallValidator during gc (#1100)

---
 src/validators/call.rs | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/validators/call.rs b/src/validators/call.rs
index d43df4984..bf80415af 100644
--- a/src/validators/call.rs
+++ b/src/validators/call.rs
@@ -67,6 +67,7 @@ impl BuildValidator for CallValidator {
 }
 
 impl_py_gc_traverse!(CallValidator {
+    function,
     arguments_validator,
     return_validator
 });

From 7fa450d9666ba37d0c5b48369d844be56598c415 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Andr=C3=A9s=20Sandoval?= <c.andres.sandoval@uptake.com>
Date: Thu, 30 Nov 2023 07:10:39 -0300
Subject: [PATCH 138/550] pass extra argument in arguments validator (#1094)

---
 src/validators/arguments.rs        |  19 +++--
 tests/validators/test_arguments.py | 114 +++++++++++++++--------------
 2 files changed, 71 insertions(+), 62 deletions(-)

diff --git a/src/validators/arguments.rs b/src/validators/arguments.rs
index aaf5afb6b..a605ff999 100644
--- a/src/validators/arguments.rs
+++ b/src/validators/arguments.rs
@@ -5,7 +5,7 @@ use pyo3::types::{PyDict, PyList, PyString, PyTuple};
 use ahash::AHashSet;
 
 use crate::build_tools::py_schema_err;
-use crate::build_tools::schema_or_config_same;
+use crate::build_tools::{schema_or_config_same, ExtraBehavior};
 use crate::errors::{AsLocItem, ErrorTypeDefaults, ValError, ValLineError, ValResult};
 use crate::input::{GenericArguments, Input, ValidationMatch};
 use crate::lookup_key::LookupKey;
@@ -31,6 +31,7 @@ pub struct ArgumentsValidator {
     var_args_validator: Option<Box<CombinedValidator>>,
     var_kwargs_validator: Option<Box<CombinedValidator>>,
     loc_by_alias: bool,
+    extra: ExtraBehavior,
 }
 
 impl BuildValidator for ArgumentsValidator {
@@ -119,6 +120,7 @@ impl BuildValidator for ArgumentsValidator {
                 None => None,
             },
             loc_by_alias: config.get_as(intern!(py, "loc_by_alias"))?.unwrap_or(true),
+            extra: ExtraBehavior::from_schema_or_config(py, schema, config, ExtraBehavior::Forbid)?,
         }
         .into())
     }
@@ -307,15 +309,16 @@ impl Validator for ArgumentsValidator {
                                         Err(err) => return Err(err),
                                     },
                                     None => {
-                                        errors.push(ValLineError::new_with_loc(
-                                            ErrorTypeDefaults::UnexpectedKeywordArgument,
-                                            value,
-                                            raw_key.as_loc_item(),
-                                        ));
+                                        if let ExtraBehavior::Forbid = self.extra {
+                                            errors.push(ValLineError::new_with_loc(
+                                                ErrorTypeDefaults::UnexpectedKeywordArgument,
+                                                value,
+                                                raw_key.as_loc_item(),
+                                            ));
+                                        }
                                     }
                                 }
-                            }
-                        }
+                        }}
                     }
                 }
             }};
diff --git a/tests/validators/test_arguments.py b/tests/validators/test_arguments.py
index 4cf1d3ad2..45ade32e6 100644
--- a/tests/validators/test_arguments.py
+++ b/tests/validators/test_arguments.py
@@ -775,57 +775,57 @@ def test_alias_populate_by_name(py_and_json: PyAndJson, input_value, expected):
         assert v.validate_test(input_value) == expected
 
 
-def validate(function):
-    """
-    a demo validation decorator to test arguments
-    """
-    parameters = signature(function).parameters
-
-    type_hints = get_type_hints(function)
-    mode_lookup = {
-        Parameter.POSITIONAL_ONLY: 'positional_only',
-        Parameter.POSITIONAL_OR_KEYWORD: 'positional_or_keyword',
-        Parameter.KEYWORD_ONLY: 'keyword_only',
-    }
-
-    arguments_schema = []
-    schema = {'type': 'arguments', 'arguments_schema': arguments_schema}
-    for i, (name, p) in enumerate(parameters.items()):
-        if p.annotation is p.empty:
-            annotation = Any
-        else:
-            annotation = type_hints[name]
-
-        assert annotation in (bool, int, float, str, Any), f'schema for {annotation} not implemented'
-        if annotation in (bool, int, float, str):
-            arg_schema = {'type': annotation.__name__}
-        else:
-            assert annotation is Any
-            arg_schema = {'type': 'any'}
-
-        if p.kind in mode_lookup:
-            if p.default is not p.empty:
-                arg_schema = {'type': 'default', 'schema': arg_schema, 'default': p.default}
-            s = {'name': name, 'mode': mode_lookup[p.kind], 'schema': arg_schema}
-            arguments_schema.append(s)
-        elif p.kind == Parameter.VAR_POSITIONAL:
-            schema['var_args_schema'] = arg_schema
-        else:
-            assert p.kind == Parameter.VAR_KEYWORD, p.kind
-            schema['var_kwargs_schema'] = arg_schema
-
-    validator = SchemaValidator(schema)
-
-    @wraps(function)
-    def wrapper(*args, **kwargs):
-        validated_args, validated_kwargs = validator.validate_python(ArgsKwargs(args, kwargs))
-        return function(*validated_args, **validated_kwargs)
-
-    return wrapper
+def validate(config=None):
+    def decorator(function):
+        parameters = signature(function).parameters
+        type_hints = get_type_hints(function)
+        mode_lookup = {
+            Parameter.POSITIONAL_ONLY: 'positional_only',
+            Parameter.POSITIONAL_OR_KEYWORD: 'positional_or_keyword',
+            Parameter.KEYWORD_ONLY: 'keyword_only',
+        }
+
+        arguments_schema = []
+        schema = {'type': 'arguments', 'arguments_schema': arguments_schema}
+        for i, (name, p) in enumerate(parameters.items()):
+            if p.annotation is p.empty:
+                annotation = Any
+            else:
+                annotation = type_hints[name]
+
+            assert annotation in (bool, int, float, str, Any), f'schema for {annotation} not implemented'
+            if annotation in (bool, int, float, str):
+                arg_schema = {'type': annotation.__name__}
+            else:
+                assert annotation is Any
+                arg_schema = {'type': 'any'}
+
+            if p.kind in mode_lookup:
+                if p.default is not p.empty:
+                    arg_schema = {'type': 'default', 'schema': arg_schema, 'default': p.default}
+                s = {'name': name, 'mode': mode_lookup[p.kind], 'schema': arg_schema}
+                arguments_schema.append(s)
+            elif p.kind == Parameter.VAR_POSITIONAL:
+                schema['var_args_schema'] = arg_schema
+            else:
+                assert p.kind == Parameter.VAR_KEYWORD, p.kind
+                schema['var_kwargs_schema'] = arg_schema
+
+        validator = SchemaValidator(schema, config=config)
+
+        @wraps(function)
+        def wrapper(*args, **kwargs):
+            # Validate arguments using the original schema
+            validated_args, validated_kwargs = validator.validate_python(ArgsKwargs(args, kwargs))
+            return function(*validated_args, **validated_kwargs)
+
+        return wrapper
+
+    return decorator
 
 
 def test_function_any():
-    @validate
+    @validate()
     def foobar(a, b, c):
         return a, b, c
 
@@ -842,7 +842,7 @@ def foobar(a, b, c):
 
 
 def test_function_types():
-    @validate
+    @validate()
     def foobar(a: int, b: int, *, c: int):
         return a, b, c
 
@@ -894,8 +894,8 @@ def test_function_positional_only(import_execute):
     # language=Python
     m = import_execute(
         """
-def create_function(validate):
-    @validate
+def create_function(validate, config = None):
+    @validate(config = config)
     def foobar(a: int, b: int, /, c: int):
         return a, b, c
     return foobar
@@ -915,6 +915,12 @@ def foobar(a: int, b: int, /, c: int):
         },
         {'type': 'unexpected_keyword_argument', 'loc': ('b',), 'msg': 'Unexpected keyword argument', 'input': 2},
     ]
+    # Allowing extras using the config
+    foobar = m.create_function(validate, config={'title': 'func', 'extra_fields_behavior': 'allow'})
+    assert foobar('1', '2', c=3, d=4) == (1, 2, 3)
+    # Ignore works similar than allow
+    foobar = m.create_function(validate, config={'title': 'func', 'extra_fields_behavior': 'ignore'})
+    assert foobar('1', '2', c=3, d=4) == (1, 2, 3)
 
 
 @pytest.mark.skipif(sys.version_info < (3, 10), reason='requires python3.10 or higher')
@@ -923,7 +929,7 @@ def test_function_positional_only_default(import_execute):
     m = import_execute(
         """
 def create_function(validate):
-    @validate
+    @validate()
     def foobar(a: int, b: int = 42, /):
         return a, b
     return foobar
@@ -940,7 +946,7 @@ def test_function_positional_kwargs(import_execute):
     m = import_execute(
         """
 def create_function(validate):
-    @validate
+    @validate()
     def foobar(a: int, b: int, /, **kwargs: bool):
         return a, b, kwargs
     return foobar
@@ -953,7 +959,7 @@ def foobar(a: int, b: int, /, **kwargs: bool):
 
 
 def test_function_args_kwargs():
-    @validate
+    @validate()
     def foobar(*args, **kwargs):
         return args, kwargs
 

From a5b390691dff689f9bff590a57420ebed4cd27f3 Mon Sep 17 00:00:00 2001
From: David Montague <35119617+dmontagu@users.noreply.github.com>
Date: Tue, 12 Dec 2023 15:55:08 +0300
Subject: [PATCH 139/550] Use input type json when validating a json schema
 (#1117)

Co-authored-by: sydney-runkle <sydneymarierunkle@gmail.com>
---
 src/validators/json.rs        |  7 +++++--
 tests/validators/test_json.py | 18 ++++++++++++++++++
 2 files changed, 23 insertions(+), 2 deletions(-)

diff --git a/src/validators/json.rs b/src/validators/json.rs
index 44250ef9d..641892364 100644
--- a/src/validators/json.rs
+++ b/src/validators/json.rs
@@ -5,7 +5,7 @@ use pyo3::types::PyDict;
 use jiter::JsonValue;
 
 use crate::errors::{ErrorType, ErrorTypeDefaults, ValError, ValLineError, ValResult};
-use crate::input::{EitherBytes, Input, ValidationMatch};
+use crate::input::{EitherBytes, Input, InputType, ValidationMatch};
 use crate::tools::SchemaDict;
 
 use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
@@ -58,7 +58,10 @@ impl Validator for JsonValidator {
         match self.validator {
             Some(ref validator) => {
                 let json_value = JsonValue::parse(json_bytes, true).map_err(|e| map_json_err(input, e, json_bytes))?;
-                validator.validate(py, &json_value, state)
+                let mut json_state = state.rebind_extra(|e| {
+                    e.input_type = InputType::Json;
+                });
+                validator.validate(py, &json_value, &mut json_state)
             }
             None => {
                 let obj =
diff --git a/tests/validators/test_json.py b/tests/validators/test_json.py
index 228d18e55..9bd553d46 100644
--- a/tests/validators/test_json.py
+++ b/tests/validators/test_json.py
@@ -1,4 +1,5 @@
 import re
+from enum import Enum
 
 import pytest
 
@@ -152,6 +153,23 @@ def test_dict_key(py_and_json: PyAndJson):
     ]
 
 
+def test_enum() -> None:
+    class MyEnum(Enum):
+        a = 'a'
+        b = 'b'
+
+    enum_schema = core_schema.lax_or_strict_schema(
+        core_schema.no_info_after_validator_function(MyEnum, core_schema.str_schema()),
+        core_schema.is_instance_schema(MyEnum),
+    )
+    v = core_schema.json_schema(enum_schema)
+    v = SchemaValidator(v)
+    assert v.validate_python('"a"') == MyEnum.a
+    assert v.validate_python('"b"') == MyEnum.b
+    with pytest.raises(ValidationError):
+        v.validate_python('"c"')
+
+
 def test_any_schema_no_schema():
     v = SchemaValidator(core_schema.json_schema())
     assert 'validator:None' in plain_repr(v)

From dfe5027325d3b2b8f5fdcd1b3a7ee9332deacbdb Mon Sep 17 00:00:00 2001
From: David Hewitt <mail@davidhewitt.dev>
Date: Tue, 12 Dec 2023 14:20:39 +0000
Subject: [PATCH 140/550] Implement pickling for ValidationError (#1119)

---
 src/errors/validation_exception.rs | 14 ++++++++++++++
 tests/test_errors.py               | 15 +++++++++++++++
 2 files changed, 29 insertions(+)

diff --git a/src/errors/validation_exception.rs b/src/errors/validation_exception.rs
index 91ef60a0d..e77b21974 100644
--- a/src/errors/validation_exception.rs
+++ b/src/errors/validation_exception.rs
@@ -341,6 +341,20 @@ impl ValidationError {
     fn __str__(&self, py: Python) -> String {
         self.__repr__(py)
     }
+
+    fn __reduce__(slf: &PyCell<Self>) -> PyResult<(&PyAny, PyObject)> {
+        let py = slf.py();
+        let callable = slf.getattr("from_exception_data")?;
+        let borrow = slf.try_borrow()?;
+        let args = (
+            borrow.title.as_ref(py),
+            borrow.errors(py, include_url_env(py), true, true)?,
+            borrow.input_type.into_py(py),
+            borrow.hide_input,
+        )
+            .into_py(slf.py());
+        Ok((callable, args))
+    }
 }
 
 // TODO: is_utf8_char_boundary, floor_char_boundary and ceil_char_boundary
diff --git a/tests/test_errors.py b/tests/test_errors.py
index 05815aec5..88dcace8f 100644
--- a/tests/test_errors.py
+++ b/tests/test_errors.py
@@ -1,4 +1,5 @@
 import enum
+import pickle
 import re
 import sys
 from decimal import Decimal
@@ -1074,3 +1075,17 @@ def test_hide_input_in_json() -> None:
 
     for error in exc_info.value.errors(include_input=False):
         assert 'input' not in error
+
+
+@pytest.mark.skipif(
+    sys.version_info < (3, 9) and sys.implementation.name == 'pypy',
+    reason='PyPy before 3.9 cannot pickle this correctly',
+)
+def test_validation_error_pickle() -> None:
+    s = SchemaValidator({'type': 'int'})
+    with pytest.raises(ValidationError) as exc_info:
+        s.validate_python('definitely not an int')
+
+    original = exc_info.value
+    roundtripped = pickle.loads(pickle.dumps(original))
+    assert original.errors() == roundtripped.errors()

From cfd1efd8ffa1b686b8d25f4ee858edf69ce99cf2 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 12 Dec 2023 14:30:35 +0000
Subject: [PATCH 141/550] Bump uraimo/run-on-arch-action from 2.5.1 to 2.6.0
 (#1107)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index bb0918f8a..f8d0fa83c 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -632,7 +632,7 @@ jobs:
           name: pypi_files_pgo
           path: dist
 
-      - uses: uraimo/run-on-arch-action@v2.5.1
+      - uses: uraimo/run-on-arch-action@v2.6.0
         name: install & test
         with:
           arch: ${{ matrix.target }}

From c7b6bb2f221033f55bf48c8a3859aa773d26c0a3 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 12 Dec 2023 14:30:49 +0000
Subject: [PATCH 142/550] Bump CodSpeedHQ/action from 1 to 2 (#1108)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/codspeed.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/codspeed.yml b/.github/workflows/codspeed.yml
index b01d4ff7e..697815a16 100644
--- a/.github/workflows/codspeed.yml
+++ b/.github/workflows/codspeed.yml
@@ -72,6 +72,6 @@ jobs:
           RUSTFLAGS: "-Cprofile-use=${{ github.workspace }}/merged.profdata"
 
       - name: Run CodSpeed benchmarks
-        uses: CodSpeedHQ/action@v1
+        uses: CodSpeedHQ/action@v2
         with:
           run: pytest tests/benchmarks/ --codspeed

From af36330f983093de096e1d3e9f8ca7236ad91201 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 12 Dec 2023 14:31:03 +0000
Subject: [PATCH 143/550] Bump mymindstorm/setup-emsdk from 12 to 13 (#1106)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index f8d0fa83c..b1f6c0236 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -307,7 +307,7 @@ jobs:
       - name: cache rust
         uses: Swatinem/rust-cache@v2
 
-      - uses: mymindstorm/setup-emsdk@v12
+      - uses: mymindstorm/setup-emsdk@v13
         with:
           # NOTE!: as per https://github.com/pydantic/pydantic-core/pull/149 this version needs to match the version
           # in node_modules/pyodide/repodata.json, to get the version, run:

From 167a9f1e80b4d681a9bd1d7390503aa742f93bb7 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 12 Dec 2023 14:31:43 +0000
Subject: [PATCH 144/550] Bump griffe from 0.36.9 to 0.38.0 (#1112)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index 38eacfdbc..d2cc86cd9 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,4 +1,4 @@
-griffe==0.36.9
+griffe==0.38.0
 pyright==1.1.334
 ruff==0.1.5
 mypy==1.6.1

From c1b4febcfec3561e0aa464f673f9734c58c44dda Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 12 Dec 2023 14:32:19 +0000
Subject: [PATCH 145/550] Bump ruff from 0.1.5 to 0.1.6 (#1109)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index d2cc86cd9..6bcb6fd93 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,4 +1,4 @@
 griffe==0.38.0
 pyright==1.1.334
-ruff==0.1.5
+ruff==0.1.6
 mypy==1.6.1

From 77068b7c5212e4ed2c20798cc269c5c7a6d6782a Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 12 Dec 2023 14:32:30 +0000
Subject: [PATCH 146/550] Bump uuid from 1.5.0 to 1.6.1 (#1105)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 2ba82639c..349019a9e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -629,9 +629,9 @@ dependencies = [
 
 [[package]]
 name = "uuid"
-version = "1.5.0"
+version = "1.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "88ad59a7560b41a70d191093a945f0b87bc1deeda46fb237479708a1d6b6cdfc"
+checksum = "5e395fcf16a7a3d8127ec99782007af141946b4795001f876d54fb0d55978560"
 
 [[package]]
 name = "version_check"
diff --git a/Cargo.toml b/Cargo.toml
index 20f4b79b8..50fd5b262 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -42,7 +42,7 @@ idna = "0.4.0"
 base64 = "0.21.5"
 num-bigint = "0.4.4"
 python3-dll-a = "0.2.7"
-uuid = "1.5.0"
+uuid = "1.6.1"
 jiter = {version = "0.0.5", features = ["python"]}
 
 [lib]

From 8da73b1aa8a9d0fede10bcb23fe352c37ad199f5 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 12 Dec 2023 14:32:57 +0000
Subject: [PATCH 147/550] Bump url from 2.4.1 to 2.5.0 (#1102)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 26 ++++++++++++++++++--------
 Cargo.toml |  2 +-
 2 files changed, 19 insertions(+), 9 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 349019a9e..4a497db95 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -74,9 +74,9 @@ checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
 
 [[package]]
 name = "form_urlencoded"
-version = "1.2.0"
+version = "1.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a62bc1cf6f830c2ec14a513a9fb124d0a213a629668a4186f329db21fe045652"
+checksum = "e13624c2627564efccf4934284bdd98cbaa14e79b0b5a141218e507b3a823456"
 dependencies = [
  "percent-encoding",
 ]
@@ -114,6 +114,16 @@ dependencies = [
  "unicode-normalization",
 ]
 
+[[package]]
+name = "idna"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "634d9b1461af396cad843f47fdba5597a4f9e6ddd4bfb6ff5d85028c25cb12f6"
+dependencies = [
+ "unicode-bidi",
+ "unicode-normalization",
+]
+
 [[package]]
 name = "indexmap"
 version = "2.0.0"
@@ -306,9 +316,9 @@ dependencies = [
 
 [[package]]
 name = "percent-encoding"
-version = "2.3.0"
+version = "2.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b2a4787296e9989611394c33f193f676704af1686e70b8f8033ab5ba9a35a94"
+checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
 
 [[package]]
 name = "proc-macro2"
@@ -326,7 +336,7 @@ dependencies = [
  "ahash",
  "base64",
  "enum_dispatch",
- "idna",
+ "idna 0.4.0",
  "jiter",
  "num-bigint",
  "pyo3",
@@ -618,12 +628,12 @@ checksum = "c7de7d73e1754487cb58364ee906a499937a0dfabd86bcb980fa99ec8c8fa2ce"
 
 [[package]]
 name = "url"
-version = "2.4.1"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "143b538f18257fac9cad154828a57c6bf5157e1aa604d4816b5995bf6de87ae5"
+checksum = "31e6302e3bb753d46e83516cae55ae196fc0c309407cf11ab35cc51a4c2a4633"
 dependencies = [
  "form_urlencoded",
- "idna",
+ "idna 0.5.0",
  "percent-encoding",
 ]
 
diff --git a/Cargo.toml b/Cargo.toml
index 50fd5b262..11b95455f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -36,7 +36,7 @@ serde = { version = "1.0.190", features = ["derive"] }
 speedate = "0.13.0"
 smallvec = "1.11.1"
 ahash = "0.8.6"
-url = "2.4.1"
+url = "2.5.0"
 # idna is already required by url, added here to be explicit
 idna = "0.4.0"
 base64 = "0.21.5"

From 1e5a4a22e7d2d8d573a3c507a61ffc2e74eccc29 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 12 Dec 2023 14:33:24 +0000
Subject: [PATCH 148/550] Bump smallvec from 1.11.1 to 1.11.2 (#1103)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 4a497db95..658dc1a3a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -525,9 +525,9 @@ dependencies = [
 
 [[package]]
 name = "smallvec"
-version = "1.11.1"
+version = "1.11.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "942b4a808e05215192e39f4ab80813e599068285906cc91aa64f923db842bd5a"
+checksum = "4dccd0940a2dcdf68d092b8cbab7dc0ad8fa938bf95787e1b916b0e3d0e8e970"
 
 [[package]]
 name = "speedate"
diff --git a/Cargo.toml b/Cargo.toml
index 11b95455f..9868be24b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -34,7 +34,7 @@ serde_json = {version = "1.0.108", features = ["arbitrary_precision", "preserve_
 enum_dispatch = "0.3.8"
 serde = { version = "1.0.190", features = ["derive"] }
 speedate = "0.13.0"
-smallvec = "1.11.1"
+smallvec = "1.11.2"
 ahash = "0.8.6"
 url = "2.5.0"
 # idna is already required by url, added here to be explicit

From a5e0e0947277e158e368f5a23333f95bc54231f7 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 12 Dec 2023 14:40:03 +0000
Subject: [PATCH 149/550] Bump serde from 1.0.190 to 1.0.193 (#1104)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 8 ++++----
 Cargo.toml | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 658dc1a3a..7a9d1d17e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -493,18 +493,18 @@ checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
 
 [[package]]
 name = "serde"
-version = "1.0.190"
+version = "1.0.193"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91d3c334ca1ee894a2c6f6ad698fe8c435b76d504b13d436f0685d648d6d96f7"
+checksum = "25dd9975e68d0cb5aa1120c288333fc98731bd1dd12f561e468ea4728c042b89"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.190"
+version = "1.0.193"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67c5609f394e5c2bd7fc51efda478004ea80ef42fee983d5c67a65e34f32c0e3"
+checksum = "43576ca501357b9b071ac53cdc7da8ef0cbd9493d8df094cd821777ea6e894d3"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/Cargo.toml b/Cargo.toml
index 9868be24b..7b61e32bd 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -32,7 +32,7 @@ strum = { version = "0.25.0", features = ["derive"] }
 strum_macros = "0.25.3"
 serde_json = {version = "1.0.108", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.8"
-serde = { version = "1.0.190", features = ["derive"] }
+serde = { version = "1.0.193", features = ["derive"] }
 speedate = "0.13.0"
 smallvec = "1.11.2"
 ahash = "0.8.6"

From 360bd88d74cbd25cc74f5baecdaf241c9ba8510c Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 12 Dec 2023 14:43:04 +0000
Subject: [PATCH 150/550] Bump ruff from 0.1.6 to 0.1.7 (#1121)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index 6bcb6fd93..348697f36 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,4 +1,4 @@
 griffe==0.38.0
 pyright==1.1.334
-ruff==0.1.6
+ruff==0.1.7
 mypy==1.6.1

From bec63dbae945c6d6492810414ba97b44fdbd2000 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 12 Dec 2023 14:49:37 +0000
Subject: [PATCH 151/550] Bump pyright from 1.1.334 to 1.1.339 (#1120)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index 348697f36..c97e47a1b 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,4 +1,4 @@
 griffe==0.38.0
-pyright==1.1.334
+pyright==1.1.339
 ruff==0.1.7
 mypy==1.6.1

From 10ad10f9f1c171e4d8bb5926c6bb2956a1f1e551 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Tue, 19 Dec 2023 09:52:35 -0600
Subject: [PATCH 152/550] Support `yyyy-MM-DD` string for datetimes (#1124)

---
 python/pydantic_core/core_schema.py |  1 +
 src/errors/types.rs                 |  5 +++
 src/validators/datetime.rs          | 57 +++++++++++++++++++++++++++--
 tests/test_errors.py                |  1 +
 tests/test_hypothesis.py            | 10 ++---
 tests/validators/test_datetime.py   | 15 ++++++--
 6 files changed, 77 insertions(+), 12 deletions(-)

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index daed22d48..ee305284a 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -3787,6 +3787,7 @@ def definition_reference_schema(
     'datetime_type',
     'datetime_parsing',
     'datetime_object_invalid',
+    'datetime_from_date_parsing',
     'datetime_past',
     'datetime_future',
     'timezone_naive',
diff --git a/src/errors/types.rs b/src/errors/types.rs
index 5c3fc1a7c..cfa96221e 100644
--- a/src/errors/types.rs
+++ b/src/errors/types.rs
@@ -338,6 +338,9 @@ error_types! {
     DatetimeObjectInvalid {
         error: {ctx_type: String, ctx_fn: field_from_context},
     },
+    DatetimeFromDateParsing {
+        error: {ctx_type: Cow<'static, str>, ctx_fn: cow_field_from_context<String, _>},
+    },
     DatetimePast {},
     DatetimeFuture {},
     // ---------------------
@@ -529,6 +532,7 @@ impl ErrorType {
             Self::DatetimeType {..} => "Input should be a valid datetime",
             Self::DatetimeParsing {..} => "Input should be a valid datetime, {error}",
             Self::DatetimeObjectInvalid {..} => "Invalid datetime object, got {error}",
+            Self::DatetimeFromDateParsing {..} => "Input should be a valid datetime or date, {error}",
             Self::DatetimePast {..} => "Input should be in the past",
             Self::DatetimeFuture {..} => "Input should be in the future",
             Self::TimezoneNaive {..} => "Input should not have timezone info",
@@ -684,6 +688,7 @@ impl ErrorType {
             Self::DateFromDatetimeParsing { error, .. } => render!(tmpl, error),
             Self::TimeParsing { error, .. } => render!(tmpl, error),
             Self::DatetimeParsing { error, .. } => render!(tmpl, error),
+            Self::DatetimeFromDateParsing { error, .. } => render!(tmpl, error),
             Self::DatetimeObjectInvalid { error, .. } => render!(tmpl, error),
             Self::TimezoneOffset {
                 tz_expected, tz_actual, ..
diff --git a/src/validators/datetime.rs b/src/validators/datetime.rs
index 156fad699..8779ea76c 100644
--- a/src/validators/datetime.rs
+++ b/src/validators/datetime.rs
@@ -2,7 +2,7 @@ use pyo3::intern;
 use pyo3::once_cell::GILOnceCell;
 use pyo3::prelude::*;
 use pyo3::types::{PyDateTime, PyDict, PyString};
-use speedate::DateTime;
+use speedate::{DateTime, Time};
 use std::cmp::Ordering;
 use strum::EnumMessage;
 
@@ -13,6 +13,7 @@ use crate::input::{EitherDateTime, Input};
 
 use crate::tools::SchemaDict;
 
+use super::Exactness;
 use super::{BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
 
 #[derive(Debug, Clone)]
@@ -65,9 +66,15 @@ impl Validator for DateTimeValidator {
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         let strict = state.strict_or(self.strict);
-        let datetime = input
-            .validate_datetime(strict, self.microseconds_precision)?
-            .unpack(state);
+        let datetime = match input.validate_datetime(strict, self.microseconds_precision) {
+            Ok(val_match) => val_match.unpack(state),
+            // if the error was a parsing error, in lax mode we allow dates and add the time 00:00:00
+            Err(line_errors @ ValError::LineErrors(..)) if !strict => {
+                state.floor_exactness(Exactness::Lax);
+                datetime_from_date(input)?.ok_or(line_errors)?
+            }
+            Err(otherwise) => return Err(otherwise),
+        };
         if let Some(constraints) = &self.constraints {
             // if we get an error from as_speedate, it's probably because the input datetime was invalid
             // specifically had an invalid tzinfo, hence here we return a validation error
@@ -132,6 +139,48 @@ impl Validator for DateTimeValidator {
     }
 }
 
+/// In lax mode, if the input is not a datetime, we try parsing the input as a date and add the "00:00:00" time.
+///
+/// Ok(None) means that this is not relevant to datetimes (the input was not a date nor a string)
+fn datetime_from_date<'data>(input: &'data impl Input<'data>) -> Result<Option<EitherDateTime<'data>>, ValError> {
+    let either_date = match input.validate_date(false) {
+        Ok(val_match) => val_match.into_inner(),
+        // if the error was a parsing error, update the error type from DateParsing to DatetimeFromDateParsing
+        Err(ValError::LineErrors(mut line_errors)) => {
+            if line_errors.iter_mut().fold(false, |has_parsing_error, line_error| {
+                if let ErrorType::DateParsing { error, .. } = &mut line_error.error_type {
+                    line_error.error_type = ErrorType::DatetimeFromDateParsing {
+                        error: std::mem::take(error),
+                        context: None,
+                    };
+                    true
+                } else {
+                    has_parsing_error
+                }
+            }) {
+                return Err(ValError::LineErrors(line_errors));
+            }
+            return Ok(None);
+        }
+        // for any other error, don't return it
+        Err(_) => return Ok(None),
+    };
+
+    let zero_time = Time {
+        hour: 0,
+        minute: 0,
+        second: 0,
+        microsecond: 0,
+        tz_offset: Some(0),
+    };
+
+    let datetime = DateTime {
+        date: either_date.as_raw()?,
+        time: zero_time,
+    };
+    Ok(Some(EitherDateTime::Raw(datetime)))
+}
+
 #[derive(Debug, Clone)]
 struct DateTimeConstraints {
     le: Option<DateTime>,
diff --git a/tests/test_errors.py b/tests/test_errors.py
index 88dcace8f..fd3f34d8f 100644
--- a/tests/test_errors.py
+++ b/tests/test_errors.py
@@ -332,6 +332,7 @@ def f(input_value, info):
     ('time_parsing', 'Input should be in a valid time format, foobar', {'error': 'foobar'}),
     ('datetime_type', 'Input should be a valid datetime', None),
     ('datetime_parsing', 'Input should be a valid datetime, foobar', {'error': 'foobar'}),
+    ('datetime_from_date_parsing', 'Input should be a valid datetime or date, foobar', {'error': 'foobar'}),
     ('datetime_object_invalid', 'Invalid datetime object, got foobar', {'error': 'foobar'}),
     ('datetime_past', 'Input should be in the past', None),
     ('datetime_future', 'Input should be in the future', None),
diff --git a/tests/test_hypothesis.py b/tests/test_hypothesis.py
index ea0d67f0d..f02d1b3a9 100644
--- a/tests/test_hypothesis.py
+++ b/tests/test_hypothesis.py
@@ -47,12 +47,12 @@ def test_datetime_binary(datetime_schema, data):
     except ValidationError as exc:
         assert exc.errors(include_url=False) == [
             {
-                'type': 'datetime_parsing',
-                'loc': (),
-                'msg': IsStr(regex='Input should be a valid datetime, .+'),
-                'input': IsBytes(),
                 'ctx': {'error': IsStr()},
-            }
+                'input': IsBytes(),
+                'loc': (),
+                'msg': IsStr(regex='Input should be a valid datetime or date, .+'),
+                'type': 'datetime_from_date_parsing',
+            },
         ]
 
 
diff --git a/tests/validators/test_datetime.py b/tests/validators/test_datetime.py
index 89e9c1c53..1d4a216f9 100644
--- a/tests/validators/test_datetime.py
+++ b/tests/validators/test_datetime.py
@@ -19,6 +19,7 @@
     [
         (datetime(2022, 6, 8, 12, 13, 14), datetime(2022, 6, 8, 12, 13, 14)),
         (date(2022, 6, 8), datetime(2022, 6, 8)),
+        ('2022-01-01', datetime(2022, 1, 1, 0, 0, 0, tzinfo=timezone.utc)),
         ('2022-06-08T12:13:14', datetime(2022, 6, 8, 12, 13, 14)),
         ('1000000000000', datetime(2001, 9, 9, 1, 46, 40, tzinfo=timezone.utc)),
         (b'2022-06-08T12:13:14', datetime(2022, 6, 8, 12, 13, 14)),
@@ -36,8 +37,14 @@
         (float('nan'), Err('Input should be a valid datetime, NaN values not permitted [type=datetime_parsing,')),
         (float('inf'), Err('Input should be a valid datetime, dates after 9999')),
         (float('-inf'), Err('Input should be a valid datetime, dates before 1600')),
-        ('-', Err('Input should be a valid datetime, input is too short [type=datetime_parsing,')),
-        ('+', Err('Input should be a valid datetime, input is too short [type=datetime_parsing,')),
+        ('-', Err('Input should be a valid datetime or date, input is too short [type=datetime_from_date_parsing,')),
+        ('+', Err('Input should be a valid datetime or date, input is too short [type=datetime_from_date_parsing,')),
+        (
+            '2022-02-30',
+            Err(
+                'Input should be a valid datetime or date, day value is outside expected range [type=datetime_from_date_parsing,'
+            ),
+        ),
     ],
 )
 def test_datetime(input_value, expected):
@@ -119,7 +126,9 @@ def test_keep_tz_bound():
         (1655205632.331557, datetime(2022, 6, 14, 11, 20, 32, microsecond=331557, tzinfo=timezone.utc)),
         (
             '2022-06-08T12:13:14+24:00',
-            Err('Input should be a valid datetime, timezone offset must be less than 24 hours [type=datetime_parsing,'),
+            Err(
+                'Input should be a valid datetime or date, unexpected extra characters at the end of the input [type=datetime_from_date_parsing,'
+            ),
         ),
         (True, Err('Input should be a valid datetime [type=datetime_type')),
         (None, Err('Input should be a valid datetime [type=datetime_type')),

From ea3ec7ed558d63c59ed572677bb0edcf2fff7a53 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Tue, 19 Dec 2023 17:49:40 +0000
Subject: [PATCH 153/550] Sync 2.14 branch into main (#1127)

Co-authored-by: sydney-runkle <sydneymarierunkle@gmail.com>
Co-authored-by: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Co-authored-by: Samuel Colvin <s@muelcolvin.com>
---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 7a9d1d17e..d65bd9896 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -331,7 +331,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.14.4"
+version = "2.14.5"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index 7b61e32bd..422059b2b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.14.4"
+version = "2.14.5"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From 2cb87a62eb1e5f8c47b1df22ebf28da82aa13836 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Wed, 20 Dec 2023 17:07:17 +0000
Subject: [PATCH 154/550] fix memory leak with recursive definitions creating
 reference cycles (#1125)

---
 src/definitions.rs                            | 94 +++++++++----------
 .../type_serializers/definitions.rs           | 34 ++++---
 src/validators/definitions.rs                 | 64 +++++++------
 3 files changed, 100 insertions(+), 92 deletions(-)

diff --git a/src/definitions.rs b/src/definitions.rs
index 4627fd2d1..46a77196d 100644
--- a/src/definitions.rs
+++ b/src/definitions.rs
@@ -8,7 +8,7 @@ use std::{
     fmt::Debug,
     sync::{
         atomic::{AtomicBool, Ordering},
-        Arc, OnceLock,
+        Arc, OnceLock, Weak,
     },
 };
 
@@ -28,47 +28,50 @@ use crate::{build_tools::py_schema_err, py_gc::PyGcTraverse};
 /// They get indexed by a ReferenceId, which are integer identifiers
 /// that are handed out and managed by DefinitionsBuilder when the Schema{Validator,Serializer}
 /// gets build.
-#[derive(Clone)]
 pub struct Definitions<T>(AHashMap<Arc<String>, Definition<T>>);
 
-/// Internal type which contains a definition to be filled
-pub struct Definition<T>(Arc<DefinitionInner<T>>);
-
-struct DefinitionInner<T> {
-    value: OnceLock<T>,
-    name: LazyName,
+struct Definition<T> {
+    value: Arc<OnceLock<T>>,
+    name: Arc<LazyName>,
 }
 
 /// Reference to a definition.
 pub struct DefinitionRef<T> {
-    name: Arc<String>,
-    value: Definition<T>,
+    reference: Arc<String>,
+    // We use a weak reference to the definition to avoid a reference cycle
+    // when recursive definitions are used.
+    value: Weak<OnceLock<T>>,
+    name: Arc<LazyName>,
 }
 
 // DefinitionRef can always be cloned (#[derive(Clone)] would require T: Clone)
 impl<T> Clone for DefinitionRef<T> {
     fn clone(&self) -> Self {
         Self {
-            name: self.name.clone(),
+            reference: self.reference.clone(),
             value: self.value.clone(),
+            name: self.name.clone(),
         }
     }
 }
 
 impl<T> DefinitionRef<T> {
     pub fn id(&self) -> usize {
-        Arc::as_ptr(&self.value.0) as usize
+        Weak::as_ptr(&self.value) as usize
     }
 
     pub fn get_or_init_name(&self, init: impl FnOnce(&T) -> String) -> &str {
-        match self.value.0.value.get() {
-            Some(value) => self.value.0.name.get_or_init(|| init(value)),
+        let Some(definition) = self.value.upgrade() else {
+            return "...";
+        };
+        match definition.get() {
+            Some(value) => self.name.get_or_init(|| init(value)),
             None => "...",
         }
     }
 
-    pub fn get(&self) -> Option<&T> {
-        self.value.0.value.get()
+    pub fn read<R>(&self, f: impl FnOnce(Option<&T>) -> R) -> R {
+        f(self.value.upgrade().as_ref().and_then(|value| value.get()))
     }
 }
 
@@ -96,15 +99,9 @@ impl<T: Debug> Debug for Definitions<T> {
     }
 }
 
-impl<T> Clone for Definition<T> {
-    fn clone(&self) -> Self {
-        Self(self.0.clone())
-    }
-}
-
 impl<T: Debug> Debug for Definition<T> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        match self.0.value.get() {
+        match self.value.get() {
             Some(value) => value.fmt(f),
             None => "...".fmt(f),
         }
@@ -113,7 +110,7 @@ impl<T: Debug> Debug for Definition<T> {
 
 impl<T: PyGcTraverse> PyGcTraverse for DefinitionRef<T> {
     fn py_gc_traverse(&self, visit: &PyVisit<'_>) -> Result<(), PyTraverseError> {
-        if let Some(value) = self.value.0.value.get() {
+        if let Some(value) = self.value.upgrade().as_ref().and_then(|v| v.get()) {
             value.py_gc_traverse(visit)?;
         }
         Ok(())
@@ -123,7 +120,7 @@ impl<T: PyGcTraverse> PyGcTraverse for DefinitionRef<T> {
 impl<T: PyGcTraverse> PyGcTraverse for Definitions<T> {
     fn py_gc_traverse(&self, visit: &PyVisit<'_>) -> Result<(), PyTraverseError> {
         for value in self.0.values() {
-            if let Some(value) = value.0.value.get() {
+            if let Some(value) = value.value.get() {
                 value.py_gc_traverse(visit)?;
             }
         }
@@ -131,7 +128,7 @@ impl<T: PyGcTraverse> PyGcTraverse for Definitions<T> {
     }
 }
 
-#[derive(Clone, Debug)]
+#[derive(Debug)]
 pub struct DefinitionsBuilder<T> {
     definitions: Definitions<T>,
 }
@@ -148,45 +145,48 @@ impl<T: std::fmt::Debug> DefinitionsBuilder<T> {
         // We either need a String copy or two hashmap lookups
         // Neither is better than the other
         // We opted for the easier outward facing API
-        let name = Arc::new(reference.to_string());
-        let value = match self.definitions.0.entry(name.clone()) {
+        let reference = Arc::new(reference.to_string());
+        let value = match self.definitions.0.entry(reference.clone()) {
             Entry::Occupied(entry) => entry.into_mut(),
-            Entry::Vacant(entry) => entry.insert(Definition(Arc::new(DefinitionInner {
-                value: OnceLock::new(),
-                name: LazyName::new(),
-            }))),
+            Entry::Vacant(entry) => entry.insert(Definition {
+                value: Arc::new(OnceLock::new()),
+                name: Arc::new(LazyName::new()),
+            }),
         };
         DefinitionRef {
-            name,
-            value: value.clone(),
+            reference,
+            value: Arc::downgrade(&value.value),
+            name: value.name.clone(),
         }
     }
 
     /// Add a definition, returning the ReferenceId that maps to it
     pub fn add_definition(&mut self, reference: String, value: T) -> PyResult<DefinitionRef<T>> {
-        let name = Arc::new(reference);
-        let value = match self.definitions.0.entry(name.clone()) {
+        let reference = Arc::new(reference);
+        let value = match self.definitions.0.entry(reference.clone()) {
             Entry::Occupied(entry) => {
                 let definition = entry.into_mut();
-                match definition.0.value.set(value) {
-                    Ok(()) => definition.clone(),
-                    Err(_) => return py_schema_err!("Duplicate ref: `{}`", name),
+                match definition.value.set(value) {
+                    Ok(()) => definition,
+                    Err(_) => return py_schema_err!("Duplicate ref: `{}`", reference),
                 }
             }
-            Entry::Vacant(entry) => entry
-                .insert(Definition(Arc::new(DefinitionInner {
-                    value: OnceLock::from(value),
-                    name: LazyName::new(),
-                })))
-                .clone(),
+            Entry::Vacant(entry) => entry.insert(Definition {
+                value: Arc::new(OnceLock::from(value)),
+                name: Arc::new(LazyName::new()),
+            }),
         };
-        Ok(DefinitionRef { name, value })
+        Ok(DefinitionRef {
+            reference,
+            value: Arc::downgrade(&value.value),
+            name: value.name.clone(),
+        })
     }
 
     /// Consume this Definitions into a vector of items, indexed by each items ReferenceId
     pub fn finish(self) -> PyResult<Definitions<T>> {
         for (reference, def) in &self.definitions.0 {
-            if def.0.value.get().is_none() {
+            if def.value.get().is_none() {
                 return py_schema_err!("Definitions error: definition `{}` was never filled", reference);
             }
         }
diff --git a/src/serializers/type_serializers/definitions.rs b/src/serializers/type_serializers/definitions.rs
index b7bf63365..99dae5bcd 100644
--- a/src/serializers/type_serializers/definitions.rs
+++ b/src/serializers/type_serializers/definitions.rs
@@ -68,15 +68,17 @@ impl TypeSerializer for DefinitionRefSerializer {
         exclude: Option<&PyAny>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
-        let comb_serializer = self.definition.get().unwrap();
-        let value_id = extra.rec_guard.add(value, self.definition.id())?;
-        let r = comb_serializer.to_python(value, include, exclude, extra);
-        extra.rec_guard.pop(value_id, self.definition.id());
-        r
+        self.definition.read(|comb_serializer| {
+            let comb_serializer = comb_serializer.unwrap();
+            let value_id = extra.rec_guard.add(value, self.definition.id())?;
+            let r = comb_serializer.to_python(value, include, exclude, extra);
+            extra.rec_guard.pop(value_id, self.definition.id());
+            r
+        })
     }
 
     fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
-        self.definition.get().unwrap().json_key(key, extra)
+        self.definition.read(|s| s.unwrap().json_key(key, extra))
     }
 
     fn serde_serialize<S: serde::ser::Serializer>(
@@ -87,14 +89,16 @@ impl TypeSerializer for DefinitionRefSerializer {
         exclude: Option<&PyAny>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
-        let comb_serializer = self.definition.get().unwrap();
-        let value_id = extra
-            .rec_guard
-            .add(value, self.definition.id())
-            .map_err(py_err_se_err)?;
-        let r = comb_serializer.serde_serialize(value, serializer, include, exclude, extra);
-        extra.rec_guard.pop(value_id, self.definition.id());
-        r
+        self.definition.read(|comb_serializer| {
+            let comb_serializer = comb_serializer.unwrap();
+            let value_id = extra
+                .rec_guard
+                .add(value, self.definition.id())
+                .map_err(py_err_se_err)?;
+            let r = comb_serializer.serde_serialize(value, serializer, include, exclude, extra);
+            extra.rec_guard.pop(value_id, self.definition.id());
+            r
+        })
     }
 
     fn get_name(&self) -> &str {
@@ -102,6 +106,6 @@ impl TypeSerializer for DefinitionRefSerializer {
     }
 
     fn retry_with_lax_check(&self) -> bool {
-        self.definition.get().unwrap().retry_with_lax_check()
+        self.definition.read(|s| s.unwrap().retry_with_lax_check())
     }
 }
diff --git a/src/validators/definitions.rs b/src/validators/definitions.rs
index 7297bd27a..0b5f78c10 100644
--- a/src/validators/definitions.rs
+++ b/src/validators/definitions.rs
@@ -73,23 +73,25 @@ impl Validator for DefinitionRefValidator {
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
-        let validator = self.definition.get().unwrap();
-        if let Some(id) = input.identity() {
-            if state.recursion_guard.contains_or_insert(id, self.definition.id()) {
-                // we don't remove id here, we leave that to the validator which originally added id to `recursion_guard`
-                Err(ValError::new(ErrorTypeDefaults::RecursionLoop, input))
-            } else {
-                if state.recursion_guard.incr_depth() {
-                    return Err(ValError::new(ErrorTypeDefaults::RecursionLoop, input));
+        self.definition.read(|validator| {
+            let validator = validator.unwrap();
+            if let Some(id) = input.identity() {
+                if state.recursion_guard.contains_or_insert(id, self.definition.id()) {
+                    // we don't remove id here, we leave that to the validator which originally added id to `recursion_guard`
+                    Err(ValError::new(ErrorTypeDefaults::RecursionLoop, input))
+                } else {
+                    if state.recursion_guard.incr_depth() {
+                        return Err(ValError::new(ErrorTypeDefaults::RecursionLoop, input));
+                    }
+                    let output = validator.validate(py, input, state);
+                    state.recursion_guard.remove(id, self.definition.id());
+                    state.recursion_guard.decr_depth();
+                    output
                 }
-                let output = validator.validate(py, input, state);
-                state.recursion_guard.remove(id, self.definition.id());
-                state.recursion_guard.decr_depth();
-                output
+            } else {
+                validator.validate(py, input, state)
             }
-        } else {
-            validator.validate(py, input, state)
-        }
+        })
     }
 
     fn validate_assignment<'data>(
@@ -100,23 +102,25 @@ impl Validator for DefinitionRefValidator {
         field_value: &'data PyAny,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
-        let validator = self.definition.get().unwrap();
-        if let Some(id) = obj.identity() {
-            if state.recursion_guard.contains_or_insert(id, self.definition.id()) {
-                // we don't remove id here, we leave that to the validator which originally added id to `recursion_guard`
-                Err(ValError::new(ErrorTypeDefaults::RecursionLoop, obj))
-            } else {
-                if state.recursion_guard.incr_depth() {
-                    return Err(ValError::new(ErrorTypeDefaults::RecursionLoop, obj));
+        self.definition.read(|validator| {
+            let validator = validator.unwrap();
+            if let Some(id) = obj.identity() {
+                if state.recursion_guard.contains_or_insert(id, self.definition.id()) {
+                    // we don't remove id here, we leave that to the validator which originally added id to `recursion_guard`
+                    Err(ValError::new(ErrorTypeDefaults::RecursionLoop, obj))
+                } else {
+                    if state.recursion_guard.incr_depth() {
+                        return Err(ValError::new(ErrorTypeDefaults::RecursionLoop, obj));
+                    }
+                    let output = validator.validate_assignment(py, obj, field_name, field_value, state);
+                    state.recursion_guard.remove(id, self.definition.id());
+                    state.recursion_guard.decr_depth();
+                    output
                 }
-                let output = validator.validate_assignment(py, obj, field_name, field_value, state);
-                state.recursion_guard.remove(id, self.definition.id());
-                state.recursion_guard.decr_depth();
-                output
+            } else {
+                validator.validate_assignment(py, obj, field_name, field_value, state)
             }
-        } else {
-            validator.validate_assignment(py, obj, field_name, field_value, state)
-        }
+        })
     }
 
     fn get_name(&self) -> &str {

From 5c896fe51be476db62b84d60fc9088f7602344f1 Mon Sep 17 00:00:00 2001
From: David Montague <35119617+dmontagu@users.noreply.github.com>
Date: Thu, 21 Dec 2023 02:07:16 -0700
Subject: [PATCH 155/550] Support indirect definition references (#1130)

---
 python/pydantic_core/core_schema.py  |  7 +++++--
 tests/validators/test_definitions.py | 10 ++++++++++
 2 files changed, 15 insertions(+), 2 deletions(-)

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index ee305284a..5c54d5cc8 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -3576,12 +3576,13 @@ def definitions_schema(schema: CoreSchema, definitions: list[CoreSchema]) -> Def
 class DefinitionReferenceSchema(TypedDict, total=False):
     type: Required[Literal['definition-ref']]
     schema_ref: Required[str]
+    ref: str
     metadata: Any
     serialization: SerSchema
 
 
 def definition_reference_schema(
-    schema_ref: str, metadata: Any = None, serialization: SerSchema | None = None
+    schema_ref: str, ref: str | None = None, metadata: Any = None, serialization: SerSchema | None = None
 ) -> DefinitionReferenceSchema:
     """
     Returns a schema that points to a schema stored in "definitions", this is useful for nested recursive
@@ -3606,7 +3607,9 @@ def definition_reference_schema(
         metadata: Any other information you want to include with the schema, not used by pydantic-core
         serialization: Custom serialization schema
     """
-    return _dict_not_none(type='definition-ref', schema_ref=schema_ref, metadata=metadata, serialization=serialization)
+    return _dict_not_none(
+        type='definition-ref', schema_ref=schema_ref, ref=ref, metadata=metadata, serialization=serialization
+    )
 
 
 MYPY = False
diff --git a/tests/validators/test_definitions.py b/tests/validators/test_definitions.py
index d742da5dd..606c8a6d9 100644
--- a/tests/validators/test_definitions.py
+++ b/tests/validators/test_definitions.py
@@ -140,3 +140,13 @@ def test_use_after():
         )
     )
     assert v.validate_python(['1', '2']) == (1, 2)
+
+
+def test_definition_chain():
+    v = SchemaValidator(
+        core_schema.definitions_schema(
+            core_schema.definition_reference_schema('foo'),
+            [core_schema.definition_reference_schema(ref='foo', schema_ref='bar'), core_schema.int_schema(ref='bar')],
+        ),
+    )
+    assert v.validate_python('1') == 1

From d706aa45a67dd519a363d5c31c9b39c898b68f24 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Thu, 21 Dec 2023 18:42:01 +0000
Subject: [PATCH 156/550] fix "run-on-arch" tests (#1131)

---
 .github/workflows/ci.yml | 4 ++--
 tests/requirements.txt   | 4 +++-
 tests/test_docstrings.py | 4 ++--
 3 files changed, 7 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index b1f6c0236..6075bb9ba 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -643,11 +643,11 @@ jobs:
             if command -v apt-get &> /dev/null; then
               echo "installing python & pip with apt-get..."
               apt-get update
-              apt-get install -y --no-install-recommends python3 python3-pip python3-venv
+              apt-get install -y --no-install-recommends python3 python3-pip python3-venv git
             else
               echo "installing python & pip with apk..."
               apk update
-              apk add python3 py3-pip
+              apk add python3 py3-pip git
             fi
           run: |
             set -x
diff --git a/tests/requirements.txt b/tests/requirements.txt
index 67e8e002b..5e6efed59 100644
--- a/tests/requirements.txt
+++ b/tests/requirements.txt
@@ -9,7 +9,9 @@ pandas==2.1.3; python_version >= "3.9" and python_version < "3.13" and implement
 pytest==7.4.3
 # we run codspeed benchmarks on x86_64 CPython (i.e. native github actions architecture)
 pytest-codspeed~=2.2.0; implementation_name == "cpython" and platform_machine == 'x86_64'
-pytest-examples==0.0.10
+# pytest-examples currently depends on aiohttp via black; we don't want to build
+# it on platforms like aarch64 musllinux in CI
+pytest-examples==0.0.10; implementation_name == "cpython" and platform_machine == 'x86_64'
 pytest-speed==0.3.5
 pytest-mock==3.11.1
 pytest-pretty==1.2.0
diff --git a/tests/test_docstrings.py b/tests/test_docstrings.py
index fb729723f..25f5bf1e4 100644
--- a/tests/test_docstrings.py
+++ b/tests/test_docstrings.py
@@ -12,7 +12,7 @@ def find_examples(*_directories):
         return []
 
 
-@pytest.mark.skipif(sys.platform not in {'linux', 'darwin'}, reason='Only on linux and macos')
+@pytest.mark.skipif(CodeExample is None or sys.platform not in {'linux', 'darwin'}, reason='Only on linux and macos')
 @pytest.mark.parametrize('example', find_examples('python/pydantic_core/core_schema.py'), ids=str)
 def test_docstrings(example: CodeExample, eval_example: EvalExample):
     eval_example.set_config(quotes='single')
@@ -25,7 +25,7 @@ def test_docstrings(example: CodeExample, eval_example: EvalExample):
         eval_example.run_print_check(example)
 
 
-@pytest.mark.skipif(sys.platform not in {'linux', 'darwin'}, reason='Only on linux and macos')
+@pytest.mark.skipif(CodeExample is None or sys.platform not in {'linux', 'darwin'}, reason='Only on linux and macos')
 @pytest.mark.parametrize('example', find_examples('README.md'), ids=str)
 def test_readme(example: CodeExample, eval_example: EvalExample):
     eval_example.set_config(line_length=100, quotes='single')

From 341b1bd8551cd474dc72dd10d53f59ca6373a341 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Mon, 8 Jan 2024 14:25:20 +0000
Subject: [PATCH 157/550] drop Python 3.7, and PyPy 3.7 and 3.8 (#1129)

---
 .github/workflows/ci.yml | 23 +++++++++--------------
 Cargo.lock               |  2 +-
 Cargo.toml               |  2 +-
 README.md                |  2 +-
 generate_self_schema.py  |  2 +-
 pyproject.toml           |  3 +--
 6 files changed, 14 insertions(+), 20 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 6075bb9ba..484713730 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -65,14 +65,11 @@ jobs:
       fail-fast: false
       matrix:
         python-version:
-          - '3.7'
           - '3.8'
           - '3.9'
           - '3.10'
           - '3.11'
           - '3.12'
-          - 'pypy3.7'
-          - 'pypy3.8'
           - 'pypy3.9'
           - 'pypy3.10'
 
@@ -385,19 +382,19 @@ jobs:
           - os: linux
             manylinux: auto
             target: armv7
-            interpreter: 3.7 3.8 3.9 3.10 3.11 3.12
+            interpreter: 3.8 3.9 3.10 3.11 3.12
           - os: linux
             manylinux: auto
             target: ppc64le
-            interpreter: 3.7 3.8 3.9 3.10 3.11 3.12
+            interpreter: 3.8 3.9 3.10 3.11 3.12
           - os: linux
             manylinux: auto
             target: s390x
-            interpreter: 3.7 3.8 3.9 3.10 3.11 3.12
+            interpreter: 3.8 3.9 3.10 3.11 3.12
           - os: linux
             manylinux: auto
             target: x86_64
-            interpreter: pypy3.7 pypy3.8 pypy3.9 pypy3.10
+            interpreter: pypy3.9 pypy3.10
 
           # musllinux
           - os: linux
@@ -414,7 +411,7 @@ jobs:
             target: x86_64
           - os: macos
             target: aarch64
-            interpreter: 3.7 3.8 3.9 pypy3.8 pypy3.9 pypy3.10
+            interpreter: 3.8 3.9 pypy3.9 pypy3.10
 
           # windows;
           # x86_64 pypy builds are not PGO optimized
@@ -422,11 +419,11 @@ jobs:
           # aarch64 only 3.11 and up, also not PGO optimized
           - os: windows
             target: x86_64
-            interpreter: pypy3.8 pypy3.9 pypy3.10
+            interpreter: pypy3.9 pypy3.10
           - os: windows
             target: i686
             python-architecture: x86
-            interpreter: 3.7 3.8 3.9 3.10 3.11 3.12
+            interpreter: 3.8 3.9 3.10 3.11 3.12
           - os: windows
             target: aarch64
             interpreter: 3.11 3.12
@@ -451,7 +448,7 @@ jobs:
         with:
           target: ${{ matrix.target }}
           manylinux: ${{ matrix.manylinux == 'manylinux' && 'auto' || matrix.manylinux }}
-          args: --release --out dist --interpreter ${{ matrix.interpreter || '3.7 3.8 3.9 3.10 3.11 3.12 pypy3.7 pypy3.8 pypy3.9 pypy3.10' }}
+          args: --release --out dist --interpreter ${{ matrix.interpreter || '3.8 3.9 3.10 3.11 3.12 pypy3.9 pypy3.10' }}
           rust-toolchain: stable
           docker-options: -e CI
 
@@ -472,7 +469,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [linux, windows, macos]
-        interpreter: ['3.7', '3.8', '3.9', '3.10', '3.11', '3.12']
+        interpreter: ['3.8', '3.9', '3.10', '3.11', '3.12']
         include:
           # standard runners with override for macos arm
           - os: linux
@@ -484,8 +481,6 @@ jobs:
             runs-on: macos-latest-xlarge
         exclude:
           # macos arm only supported from 3.10 and up
-          - os: macos
-            interpreter: '3.7'
           - os: macos
             interpreter: '3.8'
           - os: macos
diff --git a/Cargo.lock b/Cargo.lock
index d65bd9896..f85c39729 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -331,7 +331,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.14.5"
+version = "2.15.0"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index 422059b2b..2c798fc52 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.14.5"
+version = "2.15.0"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"
diff --git a/README.md b/README.md
index 9b2d9df8f..ec625ad26 100644
--- a/README.md
+++ b/README.md
@@ -71,7 +71,7 @@ except ValidationError as e:
 
 You'll need rust stable [installed](https://rustup.rs/), or rust nightly if you want to generate accurate coverage.
 
-With rust and python 3.7+ installed, compiling pydantic-core should be possible with roughly the following:
+With rust and python 3.8+ installed, compiling pydantic-core should be possible with roughly the following:
 
 ```bash
 # clone this repo or your fork
diff --git a/generate_self_schema.py b/generate_self_schema.py
index 2c190bbad..4e1235b1a 100644
--- a/generate_self_schema.py
+++ b/generate_self_schema.py
@@ -191,7 +191,7 @@ def eval_forward_ref(type_: Any) -> Any:
     try:
         return type_._evaluate(core_schema.__dict__, None, set())
     except TypeError:
-        # for older python (3.7 at least)
+        # for Python 3.8
         return type_._evaluate(core_schema.__dict__, None)
 
 
diff --git a/pyproject.toml b/pyproject.toml
index a40f160f0..5cdbca806 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -7,7 +7,7 @@ build-backend = 'maturin'
 
 [project]
 name = 'pydantic_core'
-requires-python = '>=3.7'
+requires-python = '>=3.8'
 authors = [
     {name = 'Samuel Colvin', email = 's@muelcolvin.com'}
 ]
@@ -16,7 +16,6 @@ classifiers = [
     'Programming Language :: Python',
     'Programming Language :: Python :: 3',
     'Programming Language :: Python :: 3 :: Only',
-    'Programming Language :: Python :: 3.7',
     'Programming Language :: Python :: 3.8',
     'Programming Language :: Python :: 3.9',
     'Programming Language :: Python :: 3.10',

From 1c7554faeefd9db668e7a7535bcac010ae1cf080 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 8 Jan 2024 08:45:49 -0600
Subject: [PATCH 158/550] Bump ahash from 0.8.6 to 0.8.7 (#1135)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 12 ++++++------
 Cargo.toml |  2 +-
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index f85c39729..0618e11cd 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4,9 +4,9 @@ version = 3
 
 [[package]]
 name = "ahash"
-version = "0.8.6"
+version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91429305e9f0a25f6205c5b8e0d2db09e0708a7a6df0f42212bb56c32c8ac97a"
+checksum = "77c3a9648d43b9cd48db467b3f87fdd6e146bcc88ab0180006cef2179fe11d01"
 dependencies = [
  "cfg-if",
  "getrandom",
@@ -714,18 +714,18 @@ checksum = "1a515f5799fe4961cb532f983ce2b23082366b898e52ffbce459c86f67c8378a"
 
 [[package]]
 name = "zerocopy"
-version = "0.7.20"
+version = "0.7.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd66a62464e3ffd4e37bd09950c2b9dd6c4f8767380fabba0d523f9a775bc85a"
+checksum = "74d4d3961e53fa4c9a25a8637fc2bfaf2595b3d3ae34875568a5cf64787716be"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.7.20"
+version = "0.7.32"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "255c4596d41e6916ced49cfafea18727b24d67878fa180ddfd69b9df34fd1726"
+checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/Cargo.toml b/Cargo.toml
index 2c798fc52..95bd03ff2 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -35,7 +35,7 @@ enum_dispatch = "0.3.8"
 serde = { version = "1.0.193", features = ["derive"] }
 speedate = "0.13.0"
 smallvec = "1.11.2"
-ahash = "0.8.6"
+ahash = "0.8.7"
 url = "2.5.0"
 # idna is already required by url, added here to be explicit
 idna = "0.4.0"

From bb9c84156cb808f259d4a3bd68075afd7eaebc9c Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 8 Jan 2024 08:46:19 -0600
Subject: [PATCH 159/550] Bump pytest from 7.4.3 to 7.4.4 (#1143)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements.txt b/tests/requirements.txt
index 5e6efed59..16942c3e5 100644
--- a/tests/requirements.txt
+++ b/tests/requirements.txt
@@ -6,7 +6,7 @@ hypothesis==6.79.4
 git+https://github.com/dateutil/dateutil.git@f2293200747fb03d56c6c5997bfebeabe703576f
 # pandas doesn't offer prebuilt wheels for all versions and platforms we test in CI e.g. aarch64 musllinux
 pandas==2.1.3; python_version >= "3.9" and python_version < "3.13" and implementation_name == "cpython" and platform_machine == 'x86_64'
-pytest==7.4.3
+pytest==7.4.4
 # we run codspeed benchmarks on x86_64 CPython (i.e. native github actions architecture)
 pytest-codspeed~=2.2.0; implementation_name == "cpython" and platform_machine == 'x86_64'
 # pytest-examples currently depends on aiohttp via black; we don't want to build

From be727a9524d91eee444223088942832a0d915bc6 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 8 Jan 2024 08:46:36 -0600
Subject: [PATCH 160/550] Bump actions/setup-python from 4 to 5 (#1138)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/ci.yml       | 24 ++++++++++++------------
 .github/workflows/codspeed.yml |  2 +-
 2 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 484713730..278099172 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -33,7 +33,7 @@ jobs:
       - run: rustup component add llvm-tools-preview
 
       - name: set up python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: '3.11'
 
@@ -87,7 +87,7 @@ jobs:
           key: test-v3
 
       - name: set up python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python-version }}
 
@@ -124,7 +124,7 @@ jobs:
           key: ${{ matrix.os }}-v1
 
       - name: set up python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: '3.11'
 
@@ -155,7 +155,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - name: set up python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python-version }}
 
@@ -188,7 +188,7 @@ jobs:
           path: pydantic-core
 
       - name: set up python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: '3.11'
 
@@ -230,7 +230,7 @@ jobs:
       - name: cache rust
         uses: Swatinem/rust-cache@v2
 
-      - uses: actions/setup-python@v4
+      - uses: actions/setup-python@v5
         with:
           python-version: '3.11'
 
@@ -276,7 +276,7 @@ jobs:
       - name: cache rust
         uses: Swatinem/rust-cache@v2
 
-      - uses: actions/setup-python@v4
+      - uses: actions/setup-python@v5
         with:
           python-version: '3.10'
 
@@ -291,7 +291,7 @@ jobs:
 
       - name: set up python
         id: setup-python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: '3.11'
 
@@ -433,7 +433,7 @@ jobs:
       - uses: actions/checkout@v4
 
       - name: set up python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: '3.11'
           architecture: ${{ matrix.python-architecture || 'x64' }}
@@ -491,7 +491,7 @@ jobs:
       - uses: actions/checkout@v4
 
       - name: set up python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.interpreter }}
 
@@ -669,7 +669,7 @@ jobs:
       - uses: actions/checkout@v4
 
       - name: set up python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: '3.11'
 
@@ -699,7 +699,7 @@ jobs:
       - uses: actions/checkout@v4
 
       - name: set up python
-        uses: actions/setup-python@v4
+        uses: actions/setup-python@v5
         with:
           python-version: '3.10'
 
diff --git a/.github/workflows/codspeed.yml b/.github/workflows/codspeed.yml
index 697815a16..5d69d4d5f 100644
--- a/.github/workflows/codspeed.yml
+++ b/.github/workflows/codspeed.yml
@@ -16,7 +16,7 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - uses: actions/setup-python@v4
+      - uses: actions/setup-python@v5
         with:
           python-version: '3.12'
 

From 5f0ad2c47f635ec275bc920e5608541117cf10cc Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 8 Jan 2024 08:56:00 -0600
Subject: [PATCH 161/550] Bump actions/upload-artifact from 3 to 4 (#1139)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/ci.yml | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 278099172..245dc5dcf 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -329,7 +329,7 @@ jobs:
          ls -lh dist/
          ls -l dist/
 
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         with:
           name: wasm_wheels
           path: dist
@@ -356,7 +356,7 @@ jobs:
           command: sdist
           args: --out dist
           rust-toolchain: stable
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         with:
           name: pypi_files
           path: dist
@@ -456,7 +456,7 @@ jobs:
 
       - run: twine check --strict dist/*
 
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         with:
           name: pypi_files
           path: dist
@@ -551,7 +551,7 @@ jobs:
 
       - run: ${{ matrix.ls || 'ls -lh' }} dist/
 
-      - uses: actions/upload-artifact@v3
+      - uses: actions/upload-artifact@v4
         with:
           name: pypi_files_pgo
           path: dist

From 3757e21806fab2fd92200a5051602a5b497bdc24 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 8 Jan 2024 08:56:21 -0600
Subject: [PATCH 162/550] Bump actions/download-artifact from 3 to 4 (#1137)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/ci.yml | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 245dc5dcf..1bf0698a1 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -564,7 +564,7 @@ jobs:
       - uses: actions/checkout@v4
 
       - name: get dist artifacts
-        uses: actions/download-artifact@v3
+        uses: actions/download-artifact@v4
         with:
           name: pypi_files
           path: dist
@@ -576,7 +576,7 @@ jobs:
          echo "`ls dist | wc -l` files"
 
       - name: get PGO dist artifacts (comes after "get dist artifacts" to so these files override the non-PGO builds)
-        uses: actions/download-artifact@v3
+        uses: actions/download-artifact@v4
         with:
           name: pypi_files_pgo
           path: dist
@@ -616,13 +616,13 @@ jobs:
       - uses: actions/checkout@v4
 
       - name: get dist artifacts
-        uses: actions/download-artifact@v3
+        uses: actions/download-artifact@v4
         with:
           name: pypi_files
           path: dist
 
       - name: get PGO dist artifacts (comes after "get dist artifacts" to so these files override the non-PGO builds)
-        uses: actions/download-artifact@v3
+        uses: actions/download-artifact@v4
         with:
           name: pypi_files_pgo
           path: dist
@@ -674,13 +674,13 @@ jobs:
           python-version: '3.11'
 
       - name: get dist artifacts
-        uses: actions/download-artifact@v3
+        uses: actions/download-artifact@v4
         with:
           name: pypi_files
           path: dist
 
       - name: get PGO dist artifacts (comes after "get dist artifacts" to so these files override the non-PGO builds)
-        uses: actions/download-artifact@v3
+        uses: actions/download-artifact@v4
         with:
           name: pypi_files_pgo
           path: dist
@@ -709,13 +709,13 @@ jobs:
         run: python .github/check_version.py
 
       - name: get dist artifacts
-        uses: actions/download-artifact@v3
+        uses: actions/download-artifact@v4
         with:
           name: pypi_files
           path: dist
 
       - name: get PGO dist artifacts (comes after "get dist artifacts" to so these files override the non-PGO builds)
-        uses: actions/download-artifact@v3
+        uses: actions/download-artifact@v4
         with:
           name: pypi_files_pgo
           path: dist
@@ -729,7 +729,7 @@ jobs:
           TWINE_PASSWORD: ${{ secrets.pypi_token }}
 
       - name: get wasm dist artifacts
-        uses: actions/download-artifact@v3
+        uses: actions/download-artifact@v4
         with:
           name: wasm_wheels
           path: wasm

From 22e5fba2f2f10efc999e6c9c28c3b2a713cf68b8 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 8 Jan 2024 08:56:53 -0600
Subject: [PATCH 163/550] Bump mypy from 1.6.1 to 1.8.0 (#1141)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index c97e47a1b..e1e5e4268 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,4 +1,4 @@
 griffe==0.38.0
 pyright==1.1.339
 ruff==0.1.7
-mypy==1.6.1
+mypy==1.8.0

From ab7dae5593cc7c1a7cd841063b5a94e42c032ed0 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 8 Jan 2024 08:57:13 -0600
Subject: [PATCH 164/550] Bump hypothesis from 6.79.4 to 6.92.5 (#1145)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements.txt b/tests/requirements.txt
index 16942c3e5..01040a24e 100644
--- a/tests/requirements.txt
+++ b/tests/requirements.txt
@@ -1,6 +1,6 @@
 coverage==7.2.7
 dirty-equals==0.6.0
-hypothesis==6.79.4
+hypothesis==6.92.5
 # TODO: remove manual override for dateutil once a version newer than 2.8.2 is
 # released which removes use of deprecated utcfromtimestamp
 git+https://github.com/dateutil/dateutil.git@f2293200747fb03d56c6c5997bfebeabe703576f

From ccf13e26cb49305e20efbb75334237606a825749 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 8 Jan 2024 09:00:01 -0600
Subject: [PATCH 165/550] Bump pyo3 from 0.20.0 to 0.20.1 (#1136)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
---
 Cargo.lock | 20 ++++++++++----------
 Cargo.toml |  6 +++---
 2 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 0618e11cd..a88bed6bb 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -356,9 +356,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.20.0"
+version = "0.20.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "04e8453b658fe480c3e70c8ed4e3d3ec33eb74988bd186561b0cc66b85c3bc4b"
+checksum = "e82ad98ce1991c9c70c3464ba4187337b9c45fcbbb060d46dca15f0c075e14e2"
 dependencies = [
  "cfg-if",
  "indoc",
@@ -374,9 +374,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.20.0"
+version = "0.20.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a96fe70b176a89cff78f2fa7b3c930081e163d5379b4dcdf993e3ae29ca662e5"
+checksum = "5503d0b3aee2c7a8dbb389cd87cd9649f675d4c7f60ca33699a3e3859d81a891"
 dependencies = [
  "once_cell",
  "python3-dll-a",
@@ -385,9 +385,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.20.0"
+version = "0.20.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "214929900fd25e6604661ed9cf349727c8920d47deff196c4e28165a6ef2a96b"
+checksum = "18a79e8d80486a00d11c0dcb27cd2aa17c022cc95c677b461f01797226ba8f41"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -395,9 +395,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.20.0"
+version = "0.20.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dac53072f717aa1bfa4db832b39de8c875b7c7af4f4a6fe93cdbf9264cf8383b"
+checksum = "1f4b0dc7eaa578604fab11c8c7ff8934c71249c61d4def8e272c76ed879f03d4"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -407,9 +407,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.20.0"
+version = "0.20.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7774b5a8282bd4f25f803b1f0d945120be959a36c72e08e7cd031c792fdfd424"
+checksum = "816a4f709e29ddab2e3cdfe94600d554c5556cad0ddfeea95c47b580c3247fa4"
 dependencies = [
  "heck",
  "proc-macro2",
diff --git a/Cargo.toml b/Cargo.toml
index 95bd03ff2..55c3dd129 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -26,7 +26,7 @@ include = [
 ]
 
 [dependencies]
-pyo3 = { version = "0.20.0", features = ["generate-import-lib", "num-bigint"] }
+pyo3 = { version = "0.20.1", features = ["generate-import-lib", "num-bigint"] }
 regex = "1.10.2"
 strum = { version = "0.25.0", features = ["derive"] }
 strum_macros = "0.25.3"
@@ -68,12 +68,12 @@ debug = true
 strip = false
 
 [dev-dependencies]
-pyo3 = { version = "0.20.0", features = ["auto-initialize"] }
+pyo3 = { version = "0.20.1", features = ["auto-initialize"] }
 
 [build-dependencies]
 version_check = "0.9.4"
 # used where logic has to be version/distribution specific, e.g. pypy
-pyo3-build-config = { version = "0.20.0" }
+pyo3-build-config = { version = "0.20.1" }
 
 [lints.clippy]
 dbg_macro = "warn"

From d1e18e4ac19d7f3ccbd0bb013d319ea42ffe015e Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 8 Jan 2024 09:03:01 -0600
Subject: [PATCH 166/550] Bump serde_json from 1.0.108 to 1.0.109 (#1134)

@davidhewitt mentioned that we can ignore these performance regressions for now, as they're caused by "just volatility due to PyO3's internal datastructure" that will soon be reworked.

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index a88bed6bb..b37062696 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -513,9 +513,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.108"
+version = "1.0.109"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d1c7e3eac408d115102c4c24ad393e0821bb3a5df4d506a80f85f7a742a526b"
+checksum = "cb0652c533506ad7a2e353cce269330d6afd8bdfb6d75e0ace5b35aacbd7b9e9"
 dependencies = [
  "indexmap",
  "itoa",
diff --git a/Cargo.toml b/Cargo.toml
index 55c3dd129..f332f1327 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -30,7 +30,7 @@ pyo3 = { version = "0.20.1", features = ["generate-import-lib", "num-bigint"] }
 regex = "1.10.2"
 strum = { version = "0.25.0", features = ["derive"] }
 strum_macros = "0.25.3"
-serde_json = {version = "1.0.108", features = ["arbitrary_precision", "preserve_order"]}
+serde_json = {version = "1.0.109", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.8"
 serde = { version = "1.0.193", features = ["derive"] }
 speedate = "0.13.0"

From 9a2f6204e0f8680421185bf3081ba09b135d9dbf Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 8 Jan 2024 10:08:55 -0600
Subject: [PATCH 167/550] Bump coverage from 7.2.7 to 7.4.0 (#1142)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements.txt b/tests/requirements.txt
index 01040a24e..dc211e9c7 100644
--- a/tests/requirements.txt
+++ b/tests/requirements.txt
@@ -1,4 +1,4 @@
-coverage==7.2.7
+coverage==7.4.0
 dirty-equals==0.6.0
 hypothesis==6.92.5
 # TODO: remove manual override for dateutil once a version newer than 2.8.2 is

From f3d0cc5240101043f755bc65d2b4dbf2b679de6f Mon Sep 17 00:00:00 2001
From: Aarni Koskela <akx@iki.fi>
Date: Mon, 8 Jan 2024 18:36:40 +0200
Subject: [PATCH 168/550] Rework `PYDANTIC_ERRORS_OMIT_URL` to
 `PYDANTIC_ERRORS_INCLUDE_URL` (#1123)

---
 python/pydantic_core/_pydantic_core.pyi | 12 ++++++
 src/errors/validation_exception.rs      | 32 ++++++++++++----
 tests/test_errors.py                    | 50 +++++++++++++++++++++++++
 3 files changed, 86 insertions(+), 8 deletions(-)

diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index 382a6c804..b8c1f4e94 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -787,6 +787,18 @@ class ValidationError(ValueError):
             a JSON string.
         """
 
+    def __repr__(self) -> str:
+        """
+        A string representation of the validation error.
+
+        Whether or not documentation URLs are included in the repr is controlled by the
+        environment variable `PYDANTIC_ERRORS_INCLUDE_URL` being set to `1` or
+        `true`; by default, URLs are shown.
+
+        Due to implementation details, this environment variable can only be set once,
+        before the first validation error is created.
+        """
+
 @final
 class PydanticCustomError(ValueError):
     def __new__(
diff --git a/src/errors/validation_exception.rs b/src/errors/validation_exception.rs
index e77b21974..95090c1ac 100644
--- a/src/errors/validation_exception.rs
+++ b/src/errors/validation_exception.rs
@@ -193,15 +193,31 @@ impl ValidationError {
 
 static URL_ENV_VAR: GILOnceCell<bool> = GILOnceCell::new();
 
-fn _get_include_url_env() -> bool {
-    match std::env::var("PYDANTIC_ERRORS_OMIT_URL") {
-        Ok(val) => val.is_empty(),
-        Err(_) => true,
-    }
-}
-
 fn include_url_env(py: Python) -> bool {
-    *URL_ENV_VAR.get_or_init(py, _get_include_url_env)
+    *URL_ENV_VAR.get_or_init(py, || {
+        // Check the legacy env var first.
+        // Using `var_os` here instead of `var` because we don't care about
+        // the value (or whether we're able to decode it as UTF-8), just
+        // whether it exists (and if it does, whether it's non-empty).
+        match std::env::var_os("PYDANTIC_ERRORS_OMIT_URL") {
+            Some(val) => {
+                // We don't care whether warning succeeded or not, hence the assignment
+                let _ = PyErr::warn(
+                    py,
+                    py.get_type::<pyo3::exceptions::PyDeprecationWarning>(),
+                    "PYDANTIC_ERRORS_OMIT_URL is deprecated, use PYDANTIC_ERRORS_INCLUDE_URL instead",
+                    1,
+                );
+                // If OMIT_URL exists but is empty, we include the URL:
+                val.is_empty()
+            }
+            // If the legacy env var doesn't exist, check the documented one:
+            None => match std::env::var("PYDANTIC_ERRORS_INCLUDE_URL") {
+                Ok(val) => val == "1" || val.to_lowercase() == "true",
+                Err(_) => true,
+            },
+        }
+    })
 }
 
 static URL_PREFIX: GILOnceCell<String> = GILOnceCell::new();
diff --git a/tests/test_errors.py b/tests/test_errors.py
index fd3f34d8f..18821b98c 100644
--- a/tests/test_errors.py
+++ b/tests/test_errors.py
@@ -1,6 +1,8 @@
 import enum
+import os
 import pickle
 import re
+import subprocess
 import sys
 from decimal import Decimal
 from typing import Any, Optional
@@ -1090,3 +1092,51 @@ def test_validation_error_pickle() -> None:
     original = exc_info.value
     roundtripped = pickle.loads(pickle.dumps(original))
     assert original.errors() == roundtripped.errors()
+
+
+@pytest.mark.skipif('PYDANTIC_ERRORS_INCLUDE_URL' in os.environ, reason="can't test when envvar is set")
+def test_errors_include_url() -> None:
+    s = SchemaValidator({'type': 'int'})
+    with pytest.raises(ValidationError) as exc_info:
+        s.validate_python('definitely not an int')
+    assert 'https://errors.pydantic.dev' in repr(exc_info.value)
+
+
+@pytest.mark.skipif(sys.platform == 'emscripten', reason='no subprocesses on emscripten')
+@pytest.mark.parametrize(
+    ('env_var', 'env_var_value', 'expected_to_have_url'),
+    [
+        ('PYDANTIC_ERRORS_INCLUDE_URL', None, True),
+        ('PYDANTIC_ERRORS_INCLUDE_URL', '1', True),
+        ('PYDANTIC_ERRORS_INCLUDE_URL', 'True', True),
+        ('PYDANTIC_ERRORS_INCLUDE_URL', 'no', False),
+        ('PYDANTIC_ERRORS_INCLUDE_URL', '0', False),
+        # Legacy environment variable, will raise a deprecation warning:
+        ('PYDANTIC_ERRORS_OMIT_URL', '1', False),
+        ('PYDANTIC_ERRORS_OMIT_URL', None, True),
+    ],
+)
+def test_errors_include_url_envvar(env_var, env_var_value, expected_to_have_url) -> None:
+    """
+    Test the `PYDANTIC_ERRORS_INCLUDE_URL` environment variable.
+
+    Since it can only be set before `ValidationError.__repr__()` is first called,
+    we need to spawn a subprocess to test it.
+    """
+    code = "import pydantic_core; pydantic_core.SchemaValidator({'type': 'int'}).validate_python('ooo')"
+    env = os.environ.copy()
+    env.pop('PYDANTIC_ERRORS_OMIT_URL', None)  # in case the ambient environment has it set
+    if env_var_value is not None:
+        env[env_var] = env_var_value
+    env['PYTHONDEVMODE'] = '1'  # required to surface the deprecation warning
+    result = subprocess.run(
+        [sys.executable, '-c', code],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.STDOUT,
+        encoding='utf-8',
+        env=env,
+    )
+    assert result.returncode == 1
+    if 'PYDANTIC_ERRORS_OMIT_URL' in env:
+        assert 'PYDANTIC_ERRORS_OMIT_URL is deprecated' in result.stdout
+    assert ('https://errors.pydantic.dev' in result.stdout) == expected_to_have_url

From e3ae7f643a7f8656eafdbb8854aad39ede756309 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Mon, 8 Jan 2024 21:03:27 -0600
Subject: [PATCH 169/550] Support serialization mode specification from model
 config and `SerializationConfig` (#1122)

Co-authored-by: David Hewitt <david.hewitt@pydantic.dev>
---
 python/pydantic_core/_pydantic_core.pyi       |   4 +
 src/errors/validation_exception.rs            |   2 +-
 src/serializers/config.rs                     | 144 ++++++++----------
 src/serializers/extra.rs                      |   4 +-
 src/serializers/infer.rs                      |  11 +-
 src/serializers/mod.rs                        |  10 +-
 src/serializers/type_serializers/bytes.rs     |  17 ++-
 src/serializers/type_serializers/timedelta.rs |  26 ++--
 tests/serializers/test_bytes.py               |  36 ++++-
 9 files changed, 143 insertions(+), 111 deletions(-)

diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index b8c1f4e94..a7b727f86 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -355,6 +355,7 @@ def to_json(
     round_trip: bool = False,
     timedelta_mode: Literal['iso8601', 'float'] = 'iso8601',
     bytes_mode: Literal['utf8', 'base64'] = 'utf8',
+    inf_nan_mode: Literal['null', 'constants'] = 'constants',
     serialize_unknown: bool = False,
     fallback: Callable[[Any], Any] | None = None,
 ) -> bytes:
@@ -373,6 +374,7 @@ def to_json(
         round_trip: Whether to enable serialization and validation round-trip support.
         timedelta_mode: How to serialize `timedelta` objects, either `'iso8601'` or `'float'`.
         bytes_mode: How to serialize `bytes` objects, either `'utf8'` or `'base64'`.
+        inf_nan_mode: How to serialize `Infinity`, `-Infinity` and `NaN` values, either `'null'` or `'constants'`.
         serialize_unknown: Attempt to serialize unknown types, `str(value)` will be used, if that fails
             `"<Unserializable {value_type} object>"` will be used.
         fallback: A function to call when an unknown value is encountered,
@@ -414,6 +416,7 @@ def to_jsonable_python(
     round_trip: bool = False,
     timedelta_mode: Literal['iso8601', 'float'] = 'iso8601',
     bytes_mode: Literal['utf8', 'base64'] = 'utf8',
+    inf_nan_mode: Literal['null', 'constants'] = 'constants',
     serialize_unknown: bool = False,
     fallback: Callable[[Any], Any] | None = None,
 ) -> Any:
@@ -432,6 +435,7 @@ def to_jsonable_python(
         round_trip: Whether to enable serialization and validation round-trip support.
         timedelta_mode: How to serialize `timedelta` objects, either `'iso8601'` or `'float'`.
         bytes_mode: How to serialize `bytes` objects, either `'utf8'` or `'base64'`.
+        inf_nan_mode: How to serialize `Infinity`, `-Infinity` and `NaN` values, either `'null'` or `'constants'`.
         serialize_unknown: Attempt to serialize unknown types, `str(value)` will be used, if that fails
             `"<Unserializable {value_type} object>"` will be used.
         fallback: A function to call when an unknown value is encountered,
diff --git a/src/errors/validation_exception.rs b/src/errors/validation_exception.rs
index 95090c1ac..24626df29 100644
--- a/src/errors/validation_exception.rs
+++ b/src/errors/validation_exception.rs
@@ -319,7 +319,7 @@ impl ValidationError {
         include_context: bool,
         include_input: bool,
     ) -> PyResult<&'py PyString> {
-        let state = SerializationState::new("iso8601", "utf8")?;
+        let state = SerializationState::new("iso8601", "utf8", "constants")?;
         let extra = state.extra(py, &SerMode::Json, true, false, false, true, None);
         let serializer = ValidationErrorSerializer {
             py,
diff --git a/src/serializers/config.rs b/src/serializers/config.rs
index e83497f64..422ee4162 100644
--- a/src/serializers/config.rs
+++ b/src/serializers/config.rs
@@ -15,60 +15,98 @@ use crate::tools::SchemaDict;
 use super::errors::py_err_se_err;
 
 #[derive(Debug, Clone)]
+#[allow(clippy::struct_field_names)]
 pub(crate) struct SerializationConfig {
     pub timedelta_mode: TimedeltaMode,
     pub bytes_mode: BytesMode,
+    pub inf_nan_mode: InfNanMode,
 }
 
 impl SerializationConfig {
     pub fn from_config(config: Option<&PyDict>) -> PyResult<Self> {
         let timedelta_mode = TimedeltaMode::from_config(config)?;
         let bytes_mode = BytesMode::from_config(config)?;
+        let inf_nan_mode = InfNanMode::from_config(config)?;
         Ok(Self {
             timedelta_mode,
             bytes_mode,
+            inf_nan_mode,
         })
     }
 
-    pub fn from_args(timedelta_mode: &str, bytes_mode: &str) -> PyResult<Self> {
+    pub fn from_args(timedelta_mode: &str, bytes_mode: &str, inf_nan_mode: &str) -> PyResult<Self> {
         Ok(Self {
             timedelta_mode: TimedeltaMode::from_str(timedelta_mode)?,
             bytes_mode: BytesMode::from_str(bytes_mode)?,
+            inf_nan_mode: InfNanMode::from_str(inf_nan_mode)?,
         })
     }
 }
 
-#[derive(Default, Debug, Clone)]
-pub(crate) enum TimedeltaMode {
-    #[default]
-    Iso8601,
-    Float,
+pub trait FromConfig {
+    fn from_config(config: Option<&PyDict>) -> PyResult<Self>
+    where
+        Self: Sized;
 }
 
-impl FromStr for TimedeltaMode {
-    type Err = PyErr;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "iso8601" => Ok(Self::Iso8601),
-            "float" => Ok(Self::Float),
-            s => py_schema_err!(
-                "Invalid timedelta serialization mode: `{}`, expected `iso8601` or `float`",
-                s
-            ),
+macro_rules! serialization_mode {
+    ($name:ident, $config_key:expr, $($variant:ident => $value:expr),* $(,)?) => {
+        #[derive(Default, Debug, Clone, PartialEq, Eq)]
+        pub(crate) enum $name {
+            #[default]
+            $($variant,)*
         }
-    }
+
+        impl FromStr for $name {
+            type Err = PyErr;
+
+            fn from_str(s: &str) -> Result<Self, Self::Err> {
+                match s {
+                    $($value => Ok(Self::$variant),)*
+                    s => py_schema_err!(
+                        concat!("Invalid ", stringify!($name), " serialization mode: `{}`, expected ", $($value, " or "),*),
+                        s
+                    ),
+                }
+            }
+        }
+
+        impl FromConfig for $name {
+            fn from_config(config: Option<&PyDict>) -> PyResult<Self> {
+                let Some(config_dict) = config else {
+                    return Ok(Self::default());
+                };
+                let raw_mode = config_dict.get_as::<&str>(intern!(config_dict.py(), $config_key))?;
+                raw_mode.map_or_else(|| Ok(Self::default()), Self::from_str)
+            }
+        }
+
+    };
 }
 
-impl TimedeltaMode {
-    pub fn from_config(config: Option<&PyDict>) -> PyResult<Self> {
-        let Some(config_dict) = config else {
-            return Ok(Self::default());
-        };
-        let raw_mode = config_dict.get_as::<&str>(intern!(config_dict.py(), "ser_json_timedelta"))?;
-        raw_mode.map_or_else(|| Ok(Self::default()), Self::from_str)
-    }
+serialization_mode! {
+    TimedeltaMode,
+    "ser_json_timedelta",
+    Iso8601 => "iso8601",
+    Float => "float",
+}
+
+serialization_mode! {
+    BytesMode,
+    "ser_json_bytes",
+    Utf8 => "utf8",
+    Base64 => "base64",
+    Hex => "hex",
+}
+
+serialization_mode! {
+    InfNanMode,
+    "ser_json_inf_nan",
+    Null => "null",
+    Constants => "constants",
+}
 
+impl TimedeltaMode {
     fn total_seconds(py_timedelta: &PyDelta) -> PyResult<&PyAny> {
         py_timedelta.call_method0(intern!(py_timedelta.py(), "total_seconds"))
     }
@@ -124,39 +162,7 @@ impl TimedeltaMode {
     }
 }
 
-#[derive(Default, Debug, Clone)]
-pub(crate) enum BytesMode {
-    #[default]
-    Utf8,
-    Base64,
-    Hex,
-}
-
-impl FromStr for BytesMode {
-    type Err = PyErr;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "utf8" => Ok(Self::Utf8),
-            "base64" => Ok(Self::Base64),
-            "hex" => Ok(Self::Hex),
-            s => py_schema_err!(
-                "Invalid bytes serialization mode: `{}`, expected `utf8`, `base64` or `hex`",
-                s
-            ),
-        }
-    }
-}
-
 impl BytesMode {
-    pub fn from_config(config: Option<&PyDict>) -> PyResult<Self> {
-        let Some(config_dict) = config else {
-            return Ok(Self::default());
-        };
-        let raw_mode = config_dict.get_as::<&str>(intern!(config_dict.py(), "ser_json_bytes"))?;
-        raw_mode.map_or_else(|| Ok(Self::default()), Self::from_str)
-    }
-
     pub fn bytes_to_string<'py>(&self, py: Python, bytes: &'py [u8]) -> PyResult<Cow<'py, str>> {
         match self {
             Self::Utf8 => from_utf8(bytes)
@@ -190,28 +196,6 @@ pub fn utf8_py_error(py: Python, err: Utf8Error, data: &[u8]) -> PyErr {
     }
 }
 
-#[derive(Default, Debug, Clone, PartialEq, Eq)]
-pub(crate) enum InfNanMode {
-    #[default]
-    Null,
-    Constants,
-}
-
-impl FromStr for InfNanMode {
-    type Err = PyErr;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s {
-            "null" => Ok(Self::Null),
-            "constants" => Ok(Self::Constants),
-            s => py_schema_err!(
-                "Invalid inf_nan serialization mode: `{}`, expected `null` or `constants`",
-                s
-            ),
-        }
-    }
-}
-
 impl FromPyObject<'_> for InfNanMode {
     fn extract(ob: &'_ PyAny) -> PyResult<Self> {
         let s = ob.extract::<&str>()?;
diff --git a/src/serializers/extra.rs b/src/serializers/extra.rs
index 7a9b84704..37307055e 100644
--- a/src/serializers/extra.rs
+++ b/src/serializers/extra.rs
@@ -21,10 +21,10 @@ pub(crate) struct SerializationState {
 }
 
 impl SerializationState {
-    pub fn new(timedelta_mode: &str, bytes_mode: &str) -> PyResult<Self> {
+    pub fn new(timedelta_mode: &str, bytes_mode: &str, inf_nan_mode: &str) -> PyResult<Self> {
         let warnings = CollectWarnings::new(false);
         let rec_guard = SerRecursionGuard::default();
-        let config = SerializationConfig::from_args(timedelta_mode, bytes_mode)?;
+        let config = SerializationConfig::from_args(timedelta_mode, bytes_mode, inf_nan_mode)?;
         Ok(Self {
             warnings,
             rec_guard,
diff --git a/src/serializers/infer.rs b/src/serializers/infer.rs
index 265967c57..13c20062b 100644
--- a/src/serializers/infer.rs
+++ b/src/serializers/infer.rs
@@ -10,6 +10,7 @@ use pyo3::types::{
 use serde::ser::{Error, Serialize, SerializeMap, SerializeSeq, Serializer};
 
 use crate::input::{EitherTimedelta, Int};
+use crate::serializers::config::InfNanMode;
 use crate::serializers::errors::SERIALIZATION_ERR_MARKER;
 use crate::serializers::filter::SchemaFilter;
 use crate::serializers::shared::{PydanticSerializer, TypeSerializer};
@@ -120,10 +121,16 @@ pub(crate) fn infer_to_python_known(
     let value = match extra.mode {
         SerMode::Json => match ob_type {
             // `bool` and `None` can't be subclasses, `ObType::Int`, `ObType::Float`, `ObType::Str` refer to exact types
-            ObType::None | ObType::Bool | ObType::Int | ObType::Float | ObType::Str => value.into_py(py),
+            ObType::None | ObType::Bool | ObType::Int | ObType::Str => value.into_py(py),
             // have to do this to make sure subclasses of for example str are upcast to `str`
             ObType::IntSubclass => extract_i64(value)?.into_py(py),
-            ObType::FloatSubclass => value.extract::<f64>()?.into_py(py),
+            ObType::Float | ObType::FloatSubclass => {
+                let v = value.extract::<f64>()?;
+                if (v.is_nan() || v.is_infinite()) && extra.config.inf_nan_mode == InfNanMode::Null {
+                    return Ok(py.None());
+                }
+                v.into_py(py)
+            }
             ObType::Decimal => value.to_string().into_py(py),
             ObType::StrSubclass => value.extract::<&str>()?.into_py(py),
             ObType::Bytes => extra
diff --git a/src/serializers/mod.rs b/src/serializers/mod.rs
index e9208a510..8159691cb 100644
--- a/src/serializers/mod.rs
+++ b/src/serializers/mod.rs
@@ -213,7 +213,7 @@ impl SchemaSerializer {
 #[pyfunction]
 #[pyo3(signature = (value, *, indent = None, include = None, exclude = None, by_alias = true,
     exclude_none = false, round_trip = false, timedelta_mode = "iso8601", bytes_mode = "utf8",
-    serialize_unknown = false, fallback = None))]
+    inf_nan_mode = "constants", serialize_unknown = false, fallback = None))]
 pub fn to_json(
     py: Python,
     value: &PyAny,
@@ -225,10 +225,11 @@ pub fn to_json(
     round_trip: bool,
     timedelta_mode: &str,
     bytes_mode: &str,
+    inf_nan_mode: &str,
     serialize_unknown: bool,
     fallback: Option<&PyAny>,
 ) -> PyResult<PyObject> {
-    let state = SerializationState::new(timedelta_mode, bytes_mode)?;
+    let state = SerializationState::new(timedelta_mode, bytes_mode, inf_nan_mode)?;
     let extra = state.extra(
         py,
         &SerMode::Json,
@@ -248,7 +249,7 @@ pub fn to_json(
 #[allow(clippy::too_many_arguments)]
 #[pyfunction]
 #[pyo3(signature = (value, *, include = None, exclude = None, by_alias = true, exclude_none = false, round_trip = false,
-    timedelta_mode = "iso8601", bytes_mode = "utf8", serialize_unknown = false, fallback = None))]
+    timedelta_mode = "iso8601", bytes_mode = "utf8", inf_nan_mode = "constants", serialize_unknown = false, fallback = None))]
 pub fn to_jsonable_python(
     py: Python,
     value: &PyAny,
@@ -259,10 +260,11 @@ pub fn to_jsonable_python(
     round_trip: bool,
     timedelta_mode: &str,
     bytes_mode: &str,
+    inf_nan_mode: &str,
     serialize_unknown: bool,
     fallback: Option<&PyAny>,
 ) -> PyResult<PyObject> {
-    let state = SerializationState::new(timedelta_mode, bytes_mode)?;
+    let state = SerializationState::new(timedelta_mode, bytes_mode, inf_nan_mode)?;
     let extra = state.extra(
         py,
         &SerMode::Json,
diff --git a/src/serializers/type_serializers/bytes.rs b/src/serializers/type_serializers/bytes.rs
index 67dbe794b..bd354aa75 100644
--- a/src/serializers/type_serializers/bytes.rs
+++ b/src/serializers/type_serializers/bytes.rs
@@ -4,6 +4,7 @@ use pyo3::prelude::*;
 use pyo3::types::{PyBytes, PyDict};
 
 use crate::definitions::DefinitionsBuilder;
+use crate::serializers::config::{BytesMode, FromConfig};
 
 use super::{
     infer_json_key, infer_serialize, infer_to_python, BuildSerializer, CombinedSerializer, Extra, SerMode,
@@ -11,17 +12,20 @@ use super::{
 };
 
 #[derive(Debug, Clone)]
-pub struct BytesSerializer;
+pub struct BytesSerializer {
+    bytes_mode: BytesMode,
+}
 
 impl BuildSerializer for BytesSerializer {
     const EXPECTED_TYPE: &'static str = "bytes";
 
     fn build(
         _schema: &PyDict,
-        _config: Option<&PyDict>,
+        config: Option<&PyDict>,
         _definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
-        Ok(Self {}.into())
+        let bytes_mode = BytesMode::from_config(config)?;
+        Ok(Self { bytes_mode }.into())
     }
 }
 
@@ -38,8 +42,7 @@ impl TypeSerializer for BytesSerializer {
         let py = value.py();
         match value.downcast::<PyBytes>() {
             Ok(py_bytes) => match extra.mode {
-                SerMode::Json => extra
-                    .config
+                SerMode::Json => self
                     .bytes_mode
                     .bytes_to_string(py, py_bytes.as_bytes())
                     .map(|s| s.into_py(py)),
@@ -54,7 +57,7 @@ impl TypeSerializer for BytesSerializer {
 
     fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
         match key.downcast::<PyBytes>() {
-            Ok(py_bytes) => extra.config.bytes_mode.bytes_to_string(key.py(), py_bytes.as_bytes()),
+            Ok(py_bytes) => self.bytes_mode.bytes_to_string(key.py(), py_bytes.as_bytes()),
             Err(_) => {
                 extra.warnings.on_fallback_py(self.get_name(), key, extra)?;
                 infer_json_key(key, extra)
@@ -71,7 +74,7 @@ impl TypeSerializer for BytesSerializer {
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         match value.downcast::<PyBytes>() {
-            Ok(py_bytes) => extra.config.bytes_mode.serialize_bytes(py_bytes.as_bytes(), serializer),
+            Ok(py_bytes) => self.bytes_mode.serialize_bytes(py_bytes.as_bytes(), serializer),
             Err(_) => {
                 extra.warnings.on_fallback_ser::<S>(self.get_name(), value, extra)?;
                 infer_serialize(value, serializer, include, exclude, extra)
diff --git a/src/serializers/type_serializers/timedelta.rs b/src/serializers/type_serializers/timedelta.rs
index baadbe0aa..042a8ffea 100644
--- a/src/serializers/type_serializers/timedelta.rs
+++ b/src/serializers/type_serializers/timedelta.rs
@@ -5,6 +5,7 @@ use pyo3::types::PyDict;
 
 use crate::definitions::DefinitionsBuilder;
 use crate::input::EitherTimedelta;
+use crate::serializers::config::{FromConfig, TimedeltaMode};
 
 use super::{
     infer_json_key, infer_serialize, infer_to_python, BuildSerializer, CombinedSerializer, Extra, SerMode,
@@ -12,17 +13,20 @@ use super::{
 };
 
 #[derive(Debug, Clone)]
-pub struct TimeDeltaSerializer;
+pub struct TimeDeltaSerializer {
+    timedelta_mode: TimedeltaMode,
+}
 
 impl BuildSerializer for TimeDeltaSerializer {
     const EXPECTED_TYPE: &'static str = "timedelta";
 
     fn build(
         _schema: &PyDict,
-        _config: Option<&PyDict>,
+        config: Option<&PyDict>,
         _definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
-        Ok(Self {}.into())
+        let timedelta_mode = TimedeltaMode::from_config(config)?;
+        Ok(Self { timedelta_mode }.into())
     }
 }
 
@@ -38,10 +42,7 @@ impl TypeSerializer for TimeDeltaSerializer {
     ) -> PyResult<PyObject> {
         match extra.mode {
             SerMode::Json => match EitherTimedelta::try_from(value) {
-                Ok(either_timedelta) => extra
-                    .config
-                    .timedelta_mode
-                    .either_delta_to_json(value.py(), &either_timedelta),
+                Ok(either_timedelta) => self.timedelta_mode.either_delta_to_json(value.py(), &either_timedelta),
                 Err(_) => {
                     extra.warnings.on_fallback_py(self.get_name(), value, extra)?;
                     infer_to_python(value, include, exclude, extra)
@@ -53,7 +54,7 @@ impl TypeSerializer for TimeDeltaSerializer {
 
     fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
         match EitherTimedelta::try_from(key) {
-            Ok(either_timedelta) => extra.config.timedelta_mode.json_key(key.py(), &either_timedelta),
+            Ok(either_timedelta) => self.timedelta_mode.json_key(key.py(), &either_timedelta),
             Err(_) => {
                 extra.warnings.on_fallback_py(self.get_name(), key, extra)?;
                 infer_json_key(key, extra)
@@ -70,12 +71,9 @@ impl TypeSerializer for TimeDeltaSerializer {
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         match EitherTimedelta::try_from(value) {
-            Ok(either_timedelta) => {
-                extra
-                    .config
-                    .timedelta_mode
-                    .timedelta_serialize(value.py(), &either_timedelta, serializer)
-            }
+            Ok(either_timedelta) => self
+                .timedelta_mode
+                .timedelta_serialize(value.py(), &either_timedelta, serializer),
             Err(_) => {
                 extra.warnings.on_fallback_ser::<S>(self.get_name(), value, extra)?;
                 infer_serialize(value, serializer, include, exclude, extra)
diff --git a/tests/serializers/test_bytes.py b/tests/serializers/test_bytes.py
index 13849bed0..cc2d44785 100644
--- a/tests/serializers/test_bytes.py
+++ b/tests/serializers/test_bytes.py
@@ -4,7 +4,7 @@
 
 import pytest
 
-from pydantic_core import PydanticSerializationError, SchemaSerializer, core_schema
+from pydantic_core import PydanticSerializationError, SchemaSerializer, core_schema, to_json
 
 
 def test_bytes():
@@ -126,3 +126,37 @@ def test_any_bytes_base64():
     assert s.to_json(b'foobar') == b'"Zm9vYmFy"'
     assert s.to_json({b'foobar': 123}) == b'{"Zm9vYmFy":123}'
     assert s.to_python({b'foobar': 123}, mode='json') == {'Zm9vYmFy': 123}
+
+
+class BasicModel:
+    def __init__(self, **kwargs):
+        for key, value in kwargs.items():
+            setattr(self, key, value)
+
+
+def test_bytes_mode_set_via_model_config_not_serializer_config():
+    s = SchemaSerializer(
+        core_schema.model_schema(
+            BasicModel,
+            core_schema.model_fields_schema(
+                {
+                    'foo': core_schema.model_field(core_schema.bytes_schema()),
+                }
+            ),
+            config=core_schema.CoreConfig(ser_json_bytes='base64'),
+        )
+    )
+
+    bm = BasicModel(foo=b'foobar')
+    assert s.to_python(bm) == {'foo': b'foobar'}
+    assert s.to_json(bm) == b'{"foo":"Zm9vYmFy"}'
+    assert s.to_python(bm, mode='json') == {'foo': 'Zm9vYmFy'}
+
+    # assert doesn't override serializer config
+    # in V3, we can change the serialization settings provided to to_json to override model config settings,
+    # but that'd be a breaking change
+    BasicModel.__pydantic_serializer__ = s
+    assert to_json(bm, bytes_mode='utf8') == b'{"foo":"Zm9vYmFy"}'
+
+    assert to_json({'foo': b'some bytes'}, bytes_mode='base64') == b'{"foo":"c29tZSBieXRlcw=="}'
+    assert to_json({'bar': bm}, bytes_mode='base64') == b'{"bar":{"foo":"Zm9vYmFy"}}'

From 740e996e7c593eb5fdc60cf71b8643f1d269b17f Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 9 Jan 2024 16:22:54 +0000
Subject: [PATCH 170/550] Bump idna from 0.4.0 to 0.5.0 (#1101)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 14 ++------------
 Cargo.toml |  2 +-
 2 files changed, 3 insertions(+), 13 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index b37062696..2f17cec97 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -104,16 +104,6 @@ version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
 
-[[package]]
-name = "idna"
-version = "0.4.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7d20d6b07bfbc108882d88ed8e37d39636dcc260e15e30c45e6ba089610b917c"
-dependencies = [
- "unicode-bidi",
- "unicode-normalization",
-]
-
 [[package]]
 name = "idna"
 version = "0.5.0"
@@ -336,7 +326,7 @@ dependencies = [
  "ahash",
  "base64",
  "enum_dispatch",
- "idna 0.4.0",
+ "idna",
  "jiter",
  "num-bigint",
  "pyo3",
@@ -633,7 +623,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "31e6302e3bb753d46e83516cae55ae196fc0c309407cf11ab35cc51a4c2a4633"
 dependencies = [
  "form_urlencoded",
- "idna 0.5.0",
+ "idna",
  "percent-encoding",
 ]
 
diff --git a/Cargo.toml b/Cargo.toml
index f332f1327..66a8667e0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -38,7 +38,7 @@ smallvec = "1.11.2"
 ahash = "0.8.7"
 url = "2.5.0"
 # idna is already required by url, added here to be explicit
-idna = "0.4.0"
+idna = "0.5.0"
 base64 = "0.21.5"
 num-bigint = "0.4.4"
 python3-dll-a = "0.2.7"

From a1b934f20753b78ce74364945542a3db8e71969a Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 9 Jan 2024 16:26:45 +0000
Subject: [PATCH 171/550] Bump dirty-equals from 0.6.0 to 0.7.1.post0 (#1111)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements.txt | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/requirements.txt b/tests/requirements.txt
index dc211e9c7..4297177d8 100644
--- a/tests/requirements.txt
+++ b/tests/requirements.txt
@@ -1,5 +1,5 @@
 coverage==7.4.0
-dirty-equals==0.6.0
+dirty-equals==0.7.1.post0
 hypothesis==6.92.5
 # TODO: remove manual override for dateutil once a version newer than 2.8.2 is
 # released which removes use of deprecated utcfromtimestamp

From 4df7624c12b57dc47fe1de72acb2795c1631dbb9 Mon Sep 17 00:00:00 2001
From: David Montague <35119617+dmontagu@users.noreply.github.com>
Date: Tue, 9 Jan 2024 10:41:55 -0700
Subject: [PATCH 172/550] Add unified tuple validator that can handle
 "variadic" tuples via PEP-646 (#865)

---
 generate_self_schema.py                       |   2 +-
 python/pydantic_core/core_schema.py           | 105 +++--
 src/serializers/shared.rs                     |   6 +-
 src/serializers/type_serializers/tuple.rs     | 349 ++++++---------
 src/validators/mod.rs                         |   6 +-
 src/validators/tuple.rs                       | 409 ++++++++++++------
 src/validators/union.rs                       |  22 +-
 tests/benchmarks/complete_schema.py           |  14 +-
 tests/benchmarks/test_micro_benchmarks.py     |   8 +-
 tests/serializers/test_list_tuple.py          |  22 +-
 tests/serializers/test_none.py                |   2 +-
 tests/test_schema_functions.py                |  12 +-
 tests/test_typing.py                          |   4 +-
 .../validators/test_definitions_recursive.py  |   6 +-
 tests/validators/test_frozenset.py            |   4 +-
 tests/validators/test_list.py                 |   4 +-
 tests/validators/test_set.py                  |   4 +-
 tests/validators/test_tuple.py                | 124 +++---
 tests/validators/test_with_default.py         |  18 +-
 19 files changed, 603 insertions(+), 518 deletions(-)

diff --git a/generate_self_schema.py b/generate_self_schema.py
index 4e1235b1a..8d27247d6 100644
--- a/generate_self_schema.py
+++ b/generate_self_schema.py
@@ -142,7 +142,7 @@ def type_dict_schema(  # noqa: C901
                             'type': 'union',
                             'choices': [
                                 schema_ref_validator,
-                                {'type': 'tuple-positional', 'items_schema': [schema_ref_validator, {'type': 'str'}]},
+                                {'type': 'tuple', 'items_schema': [schema_ref_validator, {'type': 'str'}]},
                             ],
                         },
                     }
diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index 5c54d5cc8..44f58c48a 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -1384,16 +1384,7 @@ def list_schema(
     )
 
 
-class TuplePositionalSchema(TypedDict, total=False):
-    type: Required[Literal['tuple-positional']]
-    items_schema: Required[List[CoreSchema]]
-    extras_schema: CoreSchema
-    strict: bool
-    ref: str
-    metadata: Any
-    serialization: IncExSeqOrElseSerSchema
-
-
+# @deprecated('tuple_positional_schema is deprecated. Use pydantic_core.core_schema.tuple_schema instead.')
 def tuple_positional_schema(
     items_schema: list[CoreSchema],
     *,
@@ -1402,7 +1393,7 @@ def tuple_positional_schema(
     ref: str | None = None,
     metadata: Any = None,
     serialization: IncExSeqOrElseSerSchema | None = None,
-) -> TuplePositionalSchema:
+) -> TupleSchema:
     """
     Returns a schema that matches a tuple of schemas, e.g.:
 
@@ -1427,10 +1418,14 @@ def tuple_positional_schema(
         metadata: Any other information you want to include with the schema, not used by pydantic-core
         serialization: Custom serialization schema
     """
-    return _dict_not_none(
-        type='tuple-positional',
+    if extras_schema is not None:
+        variadic_item_index = len(items_schema)
+        items_schema = items_schema + [extras_schema]
+    else:
+        variadic_item_index = None
+    return tuple_schema(
         items_schema=items_schema,
-        extras_schema=extras_schema,
+        variadic_item_index=variadic_item_index,
         strict=strict,
         ref=ref,
         metadata=metadata,
@@ -1438,9 +1433,55 @@ def tuple_positional_schema(
     )
 
 
-class TupleVariableSchema(TypedDict, total=False):
-    type: Required[Literal['tuple-variable']]
-    items_schema: CoreSchema
+# @deprecated('tuple_variable_schema is deprecated. Use pydantic_core.core_schema.tuple_schema instead.')
+def tuple_variable_schema(
+    items_schema: CoreSchema | None = None,
+    *,
+    min_length: int | None = None,
+    max_length: int | None = None,
+    strict: bool | None = None,
+    ref: str | None = None,
+    metadata: Any = None,
+    serialization: IncExSeqOrElseSerSchema | None = None,
+) -> TupleSchema:
+    """
+    Returns a schema that matches a tuple of a given schema, e.g.:
+
+    ```py
+    from pydantic_core import SchemaValidator, core_schema
+
+    schema = core_schema.tuple_variable_schema(
+        items_schema=core_schema.int_schema(), min_length=0, max_length=10
+    )
+    v = SchemaValidator(schema)
+    assert v.validate_python(('1', 2, 3)) == (1, 2, 3)
+    ```
+
+    Args:
+        items_schema: The value must be a tuple with items that match this schema
+        min_length: The value must be a tuple with at least this many items
+        max_length: The value must be a tuple with at most this many items
+        strict: The value must be a tuple with exactly this many items
+        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
+        serialization: Custom serialization schema
+    """
+    return tuple_schema(
+        items_schema=[items_schema or any_schema()],
+        variadic_item_index=0,
+        min_length=min_length,
+        max_length=max_length,
+        strict=strict,
+        ref=ref,
+        metadata=metadata,
+        serialization=serialization,
+    )
+
+
+class TupleSchema(TypedDict, total=False):
+    type: Required[Literal['tuple']]
+    items_schema: Required[List[CoreSchema]]
+    variadic_item_index: int
     min_length: int
     max_length: int
     strict: bool
@@ -1449,41 +1490,45 @@ class TupleVariableSchema(TypedDict, total=False):
     serialization: IncExSeqOrElseSerSchema
 
 
-def tuple_variable_schema(
-    items_schema: CoreSchema | None = None,
+def tuple_schema(
+    items_schema: list[CoreSchema],
     *,
+    variadic_item_index: int | None = None,
     min_length: int | None = None,
     max_length: int | None = None,
     strict: bool | None = None,
     ref: str | None = None,
     metadata: Any = None,
     serialization: IncExSeqOrElseSerSchema | None = None,
-) -> TupleVariableSchema:
+) -> TupleSchema:
     """
-    Returns a schema that matches a tuple of a given schema, e.g.:
+    Returns a schema that matches a tuple of schemas, with an optional variadic item, e.g.:
 
     ```py
     from pydantic_core import SchemaValidator, core_schema
 
-    schema = core_schema.tuple_variable_schema(
-        items_schema=core_schema.int_schema(), min_length=0, max_length=10
+    schema = core_schema.tuple_schema(
+        [core_schema.int_schema(), core_schema.str_schema(), core_schema.float_schema()],
+        variadic_item_index=1,
     )
     v = SchemaValidator(schema)
-    assert v.validate_python(('1', 2, 3)) == (1, 2, 3)
+    assert v.validate_python((1, 'hello', 'world', 1.5)) == (1, 'hello', 'world', 1.5)
     ```
 
     Args:
-        items_schema: The value must be a tuple with items that match this schema
+        items_schema: The value must be a tuple with items that match these schemas
+        variadic_item_index: The index of the schema in `items_schema` to be treated as variadic (following PEP 646)
         min_length: The value must be a tuple with at least this many items
         max_length: The value must be a tuple with at most this many items
         strict: The value must be a tuple with exactly this many items
-        ref: optional unique identifier of the schema, used to reference the schema in other places
+        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
         serialization: Custom serialization schema
     """
     return _dict_not_none(
-        type='tuple-variable',
+        type='tuple',
         items_schema=items_schema,
+        variadic_item_index=variadic_item_index,
         min_length=min_length,
         max_length=max_length,
         strict=strict,
@@ -3634,8 +3679,7 @@ def definition_reference_schema(
         IsSubclassSchema,
         CallableSchema,
         ListSchema,
-        TuplePositionalSchema,
-        TupleVariableSchema,
+        TupleSchema,
         SetSchema,
         FrozenSetSchema,
         GeneratorSchema,
@@ -3689,8 +3733,7 @@ def definition_reference_schema(
     'is-subclass',
     'callable',
     'list',
-    'tuple-positional',
-    'tuple-variable',
+    'tuple',
     'set',
     'frozenset',
     'generator',
diff --git a/src/serializers/shared.rs b/src/serializers/shared.rs
index cfccc748a..11aac037d 100644
--- a/src/serializers/shared.rs
+++ b/src/serializers/shared.rs
@@ -140,8 +140,7 @@ combined_serializer! {
         Union: super::type_serializers::union::UnionSerializer;
         Literal: super::type_serializers::literal::LiteralSerializer;
         Recursive: super::type_serializers::definitions::DefinitionRefSerializer;
-        TuplePositional: super::type_serializers::tuple::TuplePositionalSerializer;
-        TupleVariable: super::type_serializers::tuple::TupleVariableSerializer;
+        Tuple: super::type_serializers::tuple::TupleSerializer;
     }
 }
 
@@ -248,8 +247,7 @@ impl PyGcTraverse for CombinedSerializer {
             CombinedSerializer::Union(inner) => inner.py_gc_traverse(visit),
             CombinedSerializer::Literal(inner) => inner.py_gc_traverse(visit),
             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::Tuple(inner) => inner.py_gc_traverse(visit),
             CombinedSerializer::Uuid(inner) => inner.py_gc_traverse(visit),
         }
     }
diff --git a/src/serializers/type_serializers/tuple.rs b/src/serializers/type_serializers/tuple.rs
index 00c61e250..e5f225c92 100644
--- a/src/serializers/type_serializers/tuple.rs
+++ b/src/serializers/type_serializers/tuple.rs
@@ -2,154 +2,29 @@ use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList, PyTuple};
 use std::borrow::Cow;
+use std::iter;
 
 use serde::ser::SerializeSeq;
 
 use crate::definitions::DefinitionsBuilder;
+use crate::serializers::type_serializers::any::AnySerializer;
 use crate::tools::SchemaDict;
 
-use super::any::AnySerializer;
 use super::{
     infer_json_key, infer_serialize, infer_to_python, py_err_se_err, BuildSerializer, CombinedSerializer, Extra,
     PydanticSerializer, SchemaFilter, SerMode, TypeSerializer,
 };
 
 #[derive(Debug, Clone)]
-pub struct TupleVariableSerializer {
-    item_serializer: Box<CombinedSerializer>,
+pub struct TupleSerializer {
+    serializers: Vec<CombinedSerializer>,
+    variadic_item_index: Option<usize>,
     filter: SchemaFilter<usize>,
     name: String,
 }
 
-impl BuildSerializer for TupleVariableSerializer {
-    const EXPECTED_TYPE: &'static str = "tuple-variable";
-
-    fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
-        definitions: &mut DefinitionsBuilder<CombinedSerializer>,
-    ) -> PyResult<CombinedSerializer> {
-        let py = schema.py();
-        if let Some("positional") = schema.get_as::<&str>(intern!(py, "mode"))? {
-            return TuplePositionalSerializer::build(schema, config, definitions);
-        }
-        let item_serializer = match schema.get_as::<&PyDict>(intern!(py, "items_schema"))? {
-            Some(items_schema) => CombinedSerializer::build(items_schema, config, definitions)?,
-            None => AnySerializer::build(schema, config, definitions)?,
-        };
-        let name = format!("tuple[{}, ...]", item_serializer.get_name());
-        Ok(Self {
-            item_serializer: Box::new(item_serializer),
-            filter: SchemaFilter::from_schema(schema)?,
-            name,
-        }
-        .into())
-    }
-}
-
-impl_py_gc_traverse!(TupleVariableSerializer { item_serializer });
-
-impl TypeSerializer for TupleVariableSerializer {
-    fn to_python(
-        &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
-        extra: &Extra,
-    ) -> PyResult<PyObject> {
-        match value.downcast::<PyTuple>() {
-            Ok(py_tuple) => {
-                let py = value.py();
-                let item_serializer = self.item_serializer.as_ref();
-
-                let mut items = Vec::with_capacity(py_tuple.len());
-                for (index, element) in py_tuple.iter().enumerate() {
-                    let op_next = self
-                        .filter
-                        .index_filter(index, include, exclude, Some(py_tuple.len()))?;
-                    if let Some((next_include, next_exclude)) = op_next {
-                        items.push(item_serializer.to_python(element, next_include, next_exclude, extra)?);
-                    }
-                }
-                match extra.mode {
-                    SerMode::Json => Ok(PyList::new(py, items).into_py(py)),
-                    _ => Ok(PyTuple::new(py, items).into_py(py)),
-                }
-            }
-            Err(_) => {
-                extra.warnings.on_fallback_py(&self.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.downcast::<PyTuple>() {
-            Ok(py_tuple) => {
-                let item_serializer = self.item_serializer.as_ref();
-
-                let mut key_builder = KeyBuilder::new();
-                for element in py_tuple {
-                    key_builder.push(&item_serializer.json_key(element, extra)?);
-                }
-                Ok(Cow::Owned(key_builder.finish()))
-            }
-            Err(_) => {
-                extra.warnings.on_fallback_py(&self.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::<PyTuple>() {
-            Ok(py_tuple) => {
-                let py_tuple: &PyTuple = py_tuple.downcast().map_err(py_err_se_err)?;
-                let item_serializer = self.item_serializer.as_ref();
-
-                let mut seq = serializer.serialize_seq(Some(py_tuple.len()))?;
-                for (index, element) in py_tuple.iter().enumerate() {
-                    let op_next = self
-                        .filter
-                        .index_filter(index, include, exclude, Some(py_tuple.len()))
-                        .map_err(py_err_se_err)?;
-                    if let Some((next_include, next_exclude)) = op_next {
-                        let item_serialize =
-                            PydanticSerializer::new(element, item_serializer, next_include, next_exclude, extra);
-                        seq.serialize_element(&item_serialize)?;
-                    }
-                }
-                seq.end()
-            }
-            Err(_) => {
-                extra.warnings.on_fallback_ser::<S>(&self.name, value, extra)?;
-                infer_serialize(value, serializer, include, exclude, extra)
-            }
-        }
-    }
-
-    fn get_name(&self) -> &str {
-        &self.name
-    }
-}
-
-#[derive(Debug, Clone)]
-pub struct TuplePositionalSerializer {
-    items_serializers: Vec<CombinedSerializer>,
-    extra_serializer: Box<CombinedSerializer>,
-    filter: SchemaFilter<usize>,
-    name: String,
-}
-
-impl BuildSerializer for TuplePositionalSerializer {
-    const EXPECTED_TYPE: &'static str = "tuple-positional";
+impl BuildSerializer for TupleSerializer {
+    const EXPECTED_TYPE: &'static str = "tuple";
 
     fn build(
         schema: &PyDict,
@@ -158,37 +33,31 @@ impl BuildSerializer for TuplePositionalSerializer {
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
         let items: &PyList = schema.get_as_req(intern!(py, "items_schema"))?;
-
-        let extra_serializer = match schema.get_as::<&PyDict>(intern!(py, "extras_schema"))? {
-            Some(extras_schema) => CombinedSerializer::build(extras_schema, config, definitions)?,
-            None => AnySerializer::build(schema, config, definitions)?,
-        };
-        let items_serializers: Vec<CombinedSerializer> = items
+        let serializers: Vec<CombinedSerializer> = items
             .iter()
             .map(|item| CombinedSerializer::build(item.downcast()?, config, definitions))
             .collect::<PyResult<_>>()?;
 
-        let descr = items_serializers
-            .iter()
-            .map(TypeSerializer::get_name)
-            .collect::<Vec<_>>()
-            .join(", ");
+        let mut serializer_names = serializers.iter().map(TypeSerializer::get_name).collect::<Vec<_>>();
+        let variadic_item_index: Option<usize> = schema.get_as(intern!(py, "variadic_item_index"))?;
+        if let Some(variadic_item_index) = variadic_item_index {
+            serializer_names.insert(variadic_item_index + 1, "...");
+        }
+        let name = format!("tuple[{}]", serializer_names.join(", "));
+
         Ok(Self {
-            items_serializers,
-            extra_serializer: Box::new(extra_serializer),
+            serializers,
+            variadic_item_index,
             filter: SchemaFilter::from_schema(schema)?,
-            name: format!("tuple[{descr}]"),
+            name,
         }
         .into())
     }
 }
 
-impl_py_gc_traverse!(TuplePositionalSerializer {
-    items_serializers,
-    extra_serializer
-});
+impl_py_gc_traverse!(TupleSerializer { serializers });
 
-impl TypeSerializer for TuplePositionalSerializer {
+impl TypeSerializer for TupleSerializer {
     fn to_python(
         &self,
         value: &PyAny,
@@ -200,31 +69,53 @@ impl TypeSerializer for TuplePositionalSerializer {
             Ok(py_tuple) => {
                 let py = value.py();
 
+                let n_items = py_tuple.len();
                 let mut py_tuple_iter = py_tuple.iter();
-                let mut items = Vec::with_capacity(py_tuple.len());
-                for (index, serializer) in self.items_serializers.iter().enumerate() {
-                    let element = match py_tuple_iter.next() {
-                        Some(value) => value,
-                        None => break,
+                let mut items = Vec::with_capacity(n_items);
+
+                macro_rules! use_serializers {
+                    ($serializers_iter:expr) => {
+                        for (index, serializer) in $serializers_iter.enumerate() {
+                            let element = match py_tuple_iter.next() {
+                                Some(value) => value,
+                                None => break,
+                            };
+                            let op_next = self
+                                .filter
+                                .index_filter(index, include, exclude, Some(n_items))?;
+                            if let Some((next_include, next_exclude)) = op_next {
+                                items.push(serializer.to_python(element, next_include, next_exclude, extra)?);
+                            }
+                        }
                     };
-                    let op_next = self
-                        .filter
-                        .index_filter(index, include, exclude, Some(py_tuple.len()))?;
-                    if let Some((next_include, next_exclude)) = op_next {
-                        items.push(serializer.to_python(element, next_include, next_exclude, extra)?);
-                    }
                 }
-                let expected_length = self.items_serializers.len();
-                let extra_serializer = self.extra_serializer.as_ref();
-                for (index2, element) in py_tuple_iter.enumerate() {
-                    let index = index2 + expected_length;
-                    let op_next = self
-                        .filter
-                        .index_filter(index, include, exclude, Some(py_tuple.len()))?;
-                    if let Some((next_include, next_exclude)) = op_next {
-                        items.push(extra_serializer.to_python(element, next_include, next_exclude, extra)?);
+
+                if let Some(variadic_item_index) = self.variadic_item_index {
+                    // Need `saturating_sub` to handle items with too few elements without panicking
+                    let n_variadic_items = (n_items + 1).saturating_sub(self.serializers.len());
+                    let serializers_iter = self.serializers[..variadic_item_index]
+                        .iter()
+                        .chain(iter::repeat(&self.serializers[variadic_item_index]).take(n_variadic_items))
+                        .chain(self.serializers[variadic_item_index + 1..].iter());
+                    use_serializers!(serializers_iter);
+                } else {
+                    use_serializers!(self.serializers.iter());
+                    let mut warned = false;
+                    for (i, element) in py_tuple_iter.enumerate() {
+                        if !warned {
+                            extra
+                                .warnings
+                                .custom_warning("Unexpected extra items present in tuple".to_string());
+                            warned = true;
+                        }
+                        let op_next =
+                            self.filter
+                                .index_filter(i + self.serializers.len(), include, exclude, Some(n_items))?;
+                        if let Some((next_include, next_exclude)) = op_next {
+                            items.push(AnySerializer.to_python(element, next_include, next_exclude, extra)?);
+                        }
                     }
-                }
+                };
 
                 match extra.mode {
                     SerMode::Json => Ok(PyList::new(py, items).into_py(py)),
@@ -244,17 +135,33 @@ impl TypeSerializer for TuplePositionalSerializer {
                 let mut py_tuple_iter = py_tuple.iter();
 
                 let mut key_builder = KeyBuilder::new();
-                for serializer in &self.items_serializers {
-                    let element = match py_tuple_iter.next() {
-                        Some(value) => value,
-                        None => break,
+
+                let n_items = py_tuple.len();
+
+                macro_rules! use_serializers {
+                    ($serializers_iter:expr) => {
+                        for serializer in $serializers_iter {
+                            let element = match py_tuple_iter.next() {
+                                Some(value) => value,
+                                None => break,
+                            };
+                            key_builder.push(&serializer.json_key(element, extra)?);
+                        }
                     };
-                    key_builder.push(&serializer.json_key(element, extra)?);
-                }
-                let extra_serializer = self.extra_serializer.as_ref();
-                for element in py_tuple_iter {
-                    key_builder.push(&extra_serializer.json_key(element, extra)?);
                 }
+
+                if let Some(variadic_item_index) = self.variadic_item_index {
+                    // Need `saturating_sub` to handle items with too few elements without panicking
+                    let n_variadic_items = (n_items + 1).saturating_sub(self.serializers.len());
+                    let serializers_iter = self.serializers[..variadic_item_index]
+                        .iter()
+                        .chain(iter::repeat(&self.serializers[variadic_item_index]).take(n_variadic_items))
+                        .chain(self.serializers[variadic_item_index + 1..].iter());
+                    use_serializers!(serializers_iter);
+                } else {
+                    use_serializers!(self.serializers.iter());
+                };
+
                 Ok(Cow::Owned(key_builder.finish()))
             }
             Err(_) => {
@@ -276,38 +183,64 @@ impl TypeSerializer for TuplePositionalSerializer {
             Ok(py_tuple) => {
                 let py_tuple: &PyTuple = py_tuple.downcast().map_err(py_err_se_err)?;
 
+                let n_items = py_tuple.len();
                 let mut py_tuple_iter = py_tuple.iter();
-                let mut seq = serializer.serialize_seq(Some(py_tuple.len()))?;
-                for (index, serializer) in self.items_serializers.iter().enumerate() {
-                    let element = match py_tuple_iter.next() {
-                        Some(value) => value,
-                        None => break,
+                let mut seq = serializer.serialize_seq(Some(n_items))?;
+
+                macro_rules! use_serializers {
+                    ($serializers_iter:expr) => {
+                        for (index, serializer) in $serializers_iter.enumerate() {
+                            let element = match py_tuple_iter.next() {
+                                Some(value) => value,
+                                None => break,
+                            };
+                            let op_next = self
+                                .filter
+                                .index_filter(index, include, exclude, Some(n_items))
+                                .map_err(py_err_se_err)?;
+                            if let Some((next_include, next_exclude)) = op_next {
+                                let item_serialize =
+                                    PydanticSerializer::new(element, serializer, next_include, next_exclude, extra);
+                                seq.serialize_element(&item_serialize)?;
+                            }
+                        }
                     };
-                    let op_next = self
-                        .filter
-                        .index_filter(index, include, exclude, Some(py_tuple.len()))
-                        .map_err(py_err_se_err)?;
-                    if let Some((next_include, next_exclude)) = op_next {
-                        let item_serialize =
-                            PydanticSerializer::new(element, serializer, next_include, next_exclude, extra);
-                        seq.serialize_element(&item_serialize)?;
-                    }
                 }
 
-                let expected_length = self.items_serializers.len();
-                let extra_serializer = self.extra_serializer.as_ref();
-                for (index2, element) in py_tuple_iter.enumerate() {
-                    let index = index2 + expected_length;
-                    let op_next = self
-                        .filter
-                        .index_filter(index, include, exclude, Some(py_tuple.len()))
-                        .map_err(py_err_se_err)?;
-                    if let Some((next_include, next_exclude)) = op_next {
-                        let item_serialize =
-                            PydanticSerializer::new(element, extra_serializer, next_include, next_exclude, extra);
-                        seq.serialize_element(&item_serialize)?;
+                if let Some(variadic_item_index) = self.variadic_item_index {
+                    // Need `saturating_sub` to handle items with too few elements without panicking
+                    let n_variadic_items = (n_items + 1).saturating_sub(self.serializers.len());
+                    let serializers_iter = self.serializers[..variadic_item_index]
+                        .iter()
+                        .chain(iter::repeat(&self.serializers[variadic_item_index]).take(n_variadic_items))
+                        .chain(self.serializers[variadic_item_index + 1..].iter());
+                    use_serializers!(serializers_iter);
+                } else {
+                    use_serializers!(self.serializers.iter());
+                    let mut warned = false;
+                    for (i, element) in py_tuple_iter.enumerate() {
+                        if !warned {
+                            extra
+                                .warnings
+                                .custom_warning("Unexpected extra items present in tuple".to_string());
+                            warned = true;
+                        }
+                        let op_next = self
+                            .filter
+                            .index_filter(i + self.serializers.len(), include, exclude, Some(n_items))
+                            .map_err(py_err_se_err)?;
+                        if let Some((next_include, next_exclude)) = op_next {
+                            let item_serialize = PydanticSerializer::new(
+                                element,
+                                &CombinedSerializer::Any(AnySerializer),
+                                next_include,
+                                next_exclude,
+                                extra,
+                            );
+                            seq.serialize_element(&item_serialize)?;
+                        }
                     }
-                }
+                };
 
                 seq.end()
             }
diff --git a/src/validators/mod.rs b/src/validators/mod.rs
index 7809b1ee3..fc1584080 100644
--- a/src/validators/mod.rs
+++ b/src/validators/mod.rs
@@ -491,8 +491,7 @@ pub fn build_validator<'a>(
         // decimals
         decimal::DecimalValidator,
         // tuples
-        tuple::TuplePositionalValidator,
-        tuple::TupleVariableValidator,
+        tuple::TupleValidator,
         // list/arrays
         list::ListValidator,
         // sets - unique lists
@@ -639,8 +638,7 @@ pub enum CombinedValidator {
     // sets - unique lists
     Set(set::SetValidator),
     // tuples
-    TuplePositional(tuple::TuplePositionalValidator),
-    TupleVariable(tuple::TupleVariableValidator),
+    Tuple(tuple::TupleValidator),
     // dicts/objects (recursive)
     Dict(dict::DictValidator),
     // None/null
diff --git a/src/validators/tuple.rs b/src/validators/tuple.rs
index af134c8ee..db9c57953 100644
--- a/src/validators/tuple.rs
+++ b/src/validators/tuple.rs
@@ -1,39 +1,52 @@
 use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList, PyTuple};
+use std::collections::VecDeque;
 
 use crate::build_tools::is_strict;
-use crate::errors::{ErrorType, ErrorTypeDefaults, ValError, ValLineError, ValResult};
+use crate::errors::{py_err_string, ErrorType, ErrorTypeDefaults, ValError, ValLineError, ValResult};
 use crate::input::{GenericIterable, Input};
 use crate::tools::SchemaDict;
 use crate::validators::Exactness;
 
-use super::list::{get_items_schema, min_length_check};
 use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
 
 #[derive(Debug)]
-pub struct TupleVariableValidator {
+pub struct TupleValidator {
     strict: bool,
-    item_validator: Option<Box<CombinedValidator>>,
+    validators: Vec<CombinedValidator>,
+    variadic_item_index: Option<usize>,
     min_length: Option<usize>,
     max_length: Option<usize>,
     name: String,
 }
 
-impl BuildValidator for TupleVariableValidator {
-    const EXPECTED_TYPE: &'static str = "tuple-variable";
+impl BuildValidator for TupleValidator {
+    const EXPECTED_TYPE: &'static str = "tuple";
     fn build(
         schema: &PyDict,
         config: Option<&PyDict>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
-        let item_validator = get_items_schema(schema, config, definitions)?.map(Box::new);
-        let inner_name = item_validator.as_ref().map_or("any", |v| v.get_name());
-        let name = format!("tuple[{inner_name}, ...]");
+        let items: &PyList = schema.get_as_req(intern!(py, "items_schema"))?;
+        let validators: Vec<CombinedValidator> = items
+            .iter()
+            .map(|item| build_validator(item, config, definitions))
+            .collect::<PyResult<_>>()?;
+
+        let mut validator_names = validators.iter().map(Validator::get_name).collect::<Vec<_>>();
+        let variadic_item_index: Option<usize> = schema.get_as(intern!(py, "variadic_item_index"))?;
+        // FIXME add friendly schema error if item out of bounds
+        if let Some(variadic_item_index) = variadic_item_index {
+            validator_names.insert(variadic_item_index + 1, "...");
+        }
+        let name = format!("tuple[{}]", validator_names.join(", "));
+
         Ok(Self {
             strict: is_strict(schema, config)?,
-            item_validator,
+            validators,
+            variadic_item_index,
             min_length: schema.get_as(intern!(py, "min_length"))?,
             max_length: schema.get_as(intern!(py, "max_length"))?,
             name,
@@ -42,191 +55,276 @@ impl BuildValidator for TupleVariableValidator {
     }
 }
 
-impl_py_gc_traverse!(TupleVariableValidator { item_validator });
+impl_py_gc_traverse!(TupleValidator { validators });
 
-impl Validator for TupleVariableValidator {
-    fn validate<'data>(
+impl TupleValidator {
+    #[allow(clippy::too_many_arguments)]
+    fn validate_tuple_items<'s, 'data, I: Input<'data> + 'data>(
         &self,
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
-    ) -> ValResult<PyObject> {
-        let seq = input.validate_tuple(state.strict_or(self.strict))?;
-        let exactness = match &seq {
-            GenericIterable::Tuple(_) | GenericIterable::JsonArray(_) => Exactness::Exact,
-            GenericIterable::List(_) => Exactness::Strict,
-            _ => Exactness::Lax,
-        };
-        state.floor_exactness(exactness);
+        output: &mut Vec<PyObject>,
+        errors: &mut Vec<ValLineError>,
+        item_validators: &[CombinedValidator],
+        collection_iter: &mut NextCountingIterator<impl Iterator<Item = &'data I>>,
+        actual_length: Option<usize>,
+    ) -> ValResult<()> {
+        // Validate the head:
+        for validator in item_validators {
+            match collection_iter.next() {
+                Some((index, input_item)) => match validator.validate(py, input_item, state) {
+                    Ok(item) => self.push_output_item(input, output, item, actual_length)?,
+                    Err(ValError::LineErrors(line_errors)) => {
+                        errors.extend(line_errors.into_iter().map(|err| err.with_outer_location(index.into())));
+                    }
+                    Err(ValError::Omit) => (),
+                    Err(err) => return Err(err),
+                },
+                None => {
+                    let index = collection_iter.next_calls() - 1;
+                    if let Some(value) = validator.default_value(py, Some(index), state)? {
+                        output.push(value);
+                    } else {
+                        errors.push(ValLineError::new_with_loc(ErrorTypeDefaults::Missing, input, index));
+                    }
+                }
+            }
+        }
 
-        let output = match self.item_validator {
-            Some(ref v) => seq.validate_to_vec(py, input, self.max_length, "Tuple", v, state)?,
-            None => seq.to_vec(py, input, "Tuple", self.max_length)?,
-        };
-        min_length_check!(input, "Tuple", self.min_length, output);
-        Ok(PyTuple::new(py, &output).into_py(py))
+        Ok(())
     }
 
-    fn get_name(&self) -> &str {
-        &self.name
-    }
-}
+    #[allow(clippy::too_many_arguments)]
+    fn validate_tuple_variable<'data, I: Input<'data> + 'data, InputT: Input<'data> + 'data>(
+        &self,
+        py: Python<'data>,
+        input: &'data InputT,
+        state: &mut ValidationState,
+        errors: &mut Vec<ValLineError>,
+        collection_iter: &mut NextCountingIterator<impl Iterator<Item = &'data I>>,
+        actual_length: Option<usize>,
+    ) -> ValResult<Vec<PyObject>> {
+        let expected_length = if self.variadic_item_index.is_some() {
+            actual_length.unwrap_or(self.validators.len())
+        } else {
+            self.validators.len()
+        };
+        let mut output = Vec::with_capacity(expected_length);
+        if let Some(variable_validator_index) = self.variadic_item_index {
+            let (head_validators, [variable_validator, tail_validators @ ..]) =
+                self.validators.split_at(variable_validator_index)
+            else {
+                unreachable!("validators will always contain variable validator")
+            };
 
-#[derive(Debug)]
-pub struct TuplePositionalValidator {
-    strict: bool,
-    items_validators: Vec<CombinedValidator>,
-    extras_validator: Option<Box<CombinedValidator>>,
-    name: String,
-}
+            // Validate the "head" items
+            self.validate_tuple_items(
+                py,
+                input,
+                state,
+                &mut output,
+                errors,
+                head_validators,
+                collection_iter,
+                actual_length,
+            )?;
 
-impl BuildValidator for TuplePositionalValidator {
-    const EXPECTED_TYPE: &'static str = "tuple-positional";
-    fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
-        definitions: &mut DefinitionsBuilder<CombinedValidator>,
-    ) -> PyResult<CombinedValidator> {
-        let py = schema.py();
-        let items: &PyList = schema.get_as_req(intern!(py, "items_schema"))?;
-        let validators: Vec<CombinedValidator> = items
-            .iter()
-            .map(|item| build_validator(item, config, definitions))
-            .collect::<PyResult<_>>()?;
+            let n_tail_validators = tail_validators.len();
+            if n_tail_validators == 0 {
+                for (index, input_item) in collection_iter {
+                    match variable_validator.validate(py, input_item, state) {
+                        Ok(item) => self.push_output_item(input, &mut output, item, actual_length)?,
+                        Err(ValError::LineErrors(line_errors)) => {
+                            errors.extend(line_errors.into_iter().map(|err| err.with_outer_location(index.into())));
+                        }
+                        Err(ValError::Omit) => (),
+                        Err(err) => return Err(err),
+                    }
+                }
+            } else {
+                // Populate a buffer with the first n_tail_validators items
+                // NB: We take from collection_iter.inner to avoid increasing the next calls count
+                // while populating the buffer. This means the index in the following loop is the
+                // right one for user errors.
+                let mut tail_buffer: VecDeque<&'data I> =
+                    collection_iter.inner.by_ref().take(n_tail_validators).collect();
 
-        let descr = validators
-            .iter()
-            .map(Validator::get_name)
-            .collect::<Vec<_>>()
-            .join(", ");
-        Ok(Self {
-            strict: is_strict(schema, config)?,
-            items_validators: validators,
-            extras_validator: match schema.get_item(intern!(py, "extras_schema"))? {
-                Some(v) => Some(Box::new(build_validator(v, config, definitions)?)),
-                None => None,
-            },
-            name: format!("tuple[{descr}]"),
-        }
-        .into())
-    }
-}
+                // Save the current index for the tail validation below when we recreate a new NextCountingIterator
+                let mut index = collection_iter.next_calls();
 
-#[allow(clippy::too_many_arguments)]
-fn validate_tuple_positional<'s, 'data, T: Iterator<Item = PyResult<&'data I>>, I: Input<'data> + 'data>(
-    py: Python<'data>,
-    input: &'data impl Input<'data>,
-    state: &mut ValidationState,
-    output: &mut Vec<PyObject>,
-    errors: &mut Vec<ValLineError>,
-    extras_validator: &Option<Box<CombinedValidator>>,
-    items_validators: &[CombinedValidator],
-    collection_iter: &mut T,
-    actual_length: Option<usize>,
-) -> ValResult<()> {
-    for (index, validator) in items_validators.iter().enumerate() {
-        match collection_iter.next() {
-            Some(result) => match validator.validate(py, result?, state) {
-                Ok(item) => output.push(item),
-                Err(ValError::LineErrors(line_errors)) => {
-                    errors.extend(line_errors.into_iter().map(|err| err.with_outer_location(index.into())));
-                }
-                Err(err) => return Err(err),
-            },
-            None => {
-                if let Some(value) = validator.default_value(py, Some(index), state)? {
-                    output.push(value);
-                } else {
-                    errors.push(ValLineError::new_with_loc(ErrorTypeDefaults::Missing, input, index));
+                // Iterate over all remaining collection items, validating as items "leave" the buffer
+                for (buffer_item_index, input_item) in collection_iter {
+                    index = buffer_item_index;
+                    // This `unwrap` is safe because you can only get here
+                    // if there were at least `n_tail_validators` (> 0) items in the iterator
+                    let buffered_item = tail_buffer.pop_front().unwrap();
+                    tail_buffer.push_back(input_item);
+
+                    match variable_validator.validate(py, buffered_item, state) {
+                        Ok(item) => self.push_output_item(input, &mut output, item, actual_length)?,
+                        Err(ValError::LineErrors(line_errors)) => {
+                            errors.extend(
+                                line_errors
+                                    .into_iter()
+                                    .map(|err| err.with_outer_location(buffer_item_index.into())),
+                            );
+                        }
+                        Err(ValError::Omit) => (),
+                        Err(err) => return Err(err),
+                    }
                 }
+
+                // Validate the buffered items using the tail validators
+                self.validate_tuple_items(
+                    py,
+                    input,
+                    state,
+                    &mut output,
+                    errors,
+                    tail_validators,
+                    &mut NextCountingIterator::new(tail_buffer.into_iter(), index),
+                    actual_length,
+                )?;
+            }
+        } else {
+            // Validate all items as positional
+            self.validate_tuple_items(
+                py,
+                input,
+                state,
+                &mut output,
+                errors,
+                &self.validators,
+                collection_iter,
+                actual_length,
+            )?;
+
+            // Generate an error if there are any extra items:
+            if collection_iter.next().is_some() {
+                return Err(ValError::new(
+                    ErrorType::TooLong {
+                        field_type: "Tuple".to_string(),
+                        max_length: self.validators.len(),
+                        actual_length,
+                        context: None,
+                    },
+                    input,
+                ));
             }
         }
+        Ok(output)
     }
-    for (index, result) in collection_iter.enumerate() {
-        let item = result?;
-        match extras_validator {
-            Some(ref extras_validator) => match extras_validator.validate(py, item, state) {
-                Ok(item) => output.push(item),
-                Err(ValError::LineErrors(line_errors)) => {
-                    errors.extend(
-                        line_errors
-                            .into_iter()
-                            .map(|err| err.with_outer_location((index + items_validators.len()).into())),
-                    );
-                }
-                Err(ValError::Omit) => (),
-                Err(err) => return Err(err),
-            },
-            None => {
-                errors.push(ValLineError::new(
+
+    fn push_output_item<'data>(
+        &self,
+        input: &'data impl Input<'data>,
+        output: &mut Vec<PyObject>,
+        item: PyObject,
+        actual_length: Option<usize>,
+    ) -> ValResult<()> {
+        output.push(item);
+        if let Some(max_length) = self.max_length {
+            if output.len() > max_length {
+                return Err(ValError::new(
                     ErrorType::TooLong {
                         field_type: "Tuple".to_string(),
-                        max_length: items_validators.len(),
+                        max_length,
                         actual_length,
                         context: None,
                     },
                     input,
                 ));
-                // no need to continue through further items
-                break;
             }
         }
+        Ok(())
     }
-    Ok(())
 }
 
-impl_py_gc_traverse!(TuplePositionalValidator {
-    items_validators,
-    extras_validator
-});
-
-impl Validator for TuplePositionalValidator {
+impl Validator for TupleValidator {
     fn validate<'data>(
         &self,
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
-        let collection = input.validate_tuple(state.strict_or(self.strict))?;
-        let exactness: crate::validators::Exactness = match &collection {
+        let collection: GenericIterable<'_> = input.validate_tuple(state.strict_or(self.strict))?;
+        let exactness = match &collection {
             GenericIterable::Tuple(_) | GenericIterable::JsonArray(_) => Exactness::Exact,
             GenericIterable::List(_) => Exactness::Strict,
             _ => Exactness::Lax,
         };
         state.floor_exactness(exactness);
-
         let actual_length = collection.generic_len();
-        let expected_length = if self.extras_validator.is_some() {
-            actual_length.unwrap_or(self.items_validators.len())
-        } else {
-            self.items_validators.len()
-        };
 
-        let mut output: Vec<PyObject> = Vec::with_capacity(expected_length);
         let mut errors: Vec<ValLineError> = Vec::new();
 
+        let mut iteration_error = None;
+
         macro_rules! iter {
-            ($collection_iter:expr) => {{
-                validate_tuple_positional(
+            ($collection_iter:expr) => {
+                self.validate_tuple_variable(
                     py,
                     input,
                     state,
-                    &mut output,
                     &mut errors,
-                    &self.extras_validator,
-                    &self.items_validators,
-                    &mut $collection_iter,
+                    &mut NextCountingIterator::new($collection_iter, 0),
                     actual_length,
-                )?
-            }};
+                )
+            };
         }
 
-        match collection {
-            GenericIterable::List(collection_iter) => iter!(collection_iter.iter().map(Ok)),
-            GenericIterable::Tuple(collection_iter) => iter!(collection_iter.iter().map(Ok)),
-            GenericIterable::JsonArray(collection_iter) => iter!(collection_iter.iter().map(Ok)),
-            other => iter!(other.as_sequence_iterator(py)?),
+        let output = match collection {
+            GenericIterable::List(collection_iter) => iter!(collection_iter.iter())?,
+            GenericIterable::Tuple(collection_iter) => iter!(collection_iter.iter())?,
+            GenericIterable::JsonArray(collection_iter) => iter!(collection_iter.iter())?,
+            other => iter!({
+                let mut sequence_iterator = other.as_sequence_iterator(py)?;
+                let iteration_error = &mut iteration_error;
+                let mut index: usize = 0;
+                std::iter::from_fn(move || {
+                    if iteration_error.is_some() {
+                        return None;
+                    }
+                    index += 1;
+                    match sequence_iterator.next() {
+                        Some(Ok(item)) => Some(item),
+                        Some(Err(e)) => {
+                            *iteration_error = Some(ValError::new_with_loc(
+                                ErrorType::IterationError {
+                                    error: py_err_string(py, e),
+                                    context: None,
+                                },
+                                input,
+                                index,
+                            ));
+                            None
+                        }
+                        None => None,
+                    }
+                })
+            })?,
+        };
+
+        if let Some(err) = iteration_error {
+            return Err(err);
+        }
+
+        if let Some(min_length) = self.min_length {
+            let actual_length = output.len();
+            if actual_length < min_length {
+                errors.push(ValLineError::new(
+                    ErrorType::TooShort {
+                        field_type: "Tuple".to_string(),
+                        min_length,
+                        actual_length,
+                        context: None,
+                    },
+                    input,
+                ));
+            }
         }
+
         if errors.is_empty() {
             Ok(PyTuple::new(py, &output).into_py(py))
         } else {
@@ -238,3 +336,28 @@ impl Validator for TuplePositionalValidator {
         &self.name
     }
 }
+
+struct NextCountingIterator<I: Iterator> {
+    inner: I,
+    count: usize,
+}
+
+impl<I: Iterator> NextCountingIterator<I> {
+    fn new(inner: I, count: usize) -> Self {
+        Self { inner, count }
+    }
+
+    fn next_calls(&self) -> usize {
+        self.count
+    }
+}
+
+impl<I: Iterator> Iterator for NextCountingIterator<I> {
+    type Item = (usize, I::Item);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let count = self.count;
+        self.count += 1;
+        self.inner.next().map(|item| (count, item))
+    }
+}
diff --git a/src/validators/union.rs b/src/validators/union.rs
index 0148e1287..e010348af 100644
--- a/src/validators/union.rs
+++ b/src/validators/union.rs
@@ -457,7 +457,7 @@ impl TaggedUnionValidator {
         let tag_cow = either_tag.as_cow()?;
         let tag = tag_cow.as_ref();
         // custom logic to distinguish between different function and tuple schemas
-        if tag == "function" || tag == "tuple" {
+        if tag == "function" {
             let mode = match dict {
                 GenericMapping::PyDict(dict) => match dict.get_item(intern!(py, "mode"))? {
                     Some(m) => Some(m.validate_str(true, false)?.into_inner()),
@@ -465,21 +465,11 @@ impl TaggedUnionValidator {
                 },
                 _ => unreachable!(),
             };
-            if tag == "function" {
-                let mode = mode.ok_or_else(|| self.tag_not_found(input))?;
-                match mode.as_cow()?.as_ref() {
-                    "plain" => Ok(intern!(py, "function-plain")),
-                    "wrap" => Ok(intern!(py, "function-wrap")),
-                    _ => Ok(intern!(py, "function")),
-                }
-            } else {
-                // tag == "tuple"
-                if let Some(mode) = mode {
-                    if mode.as_cow()?.as_ref() == "positional" {
-                        return Ok(intern!(py, "tuple-positional"));
-                    }
-                }
-                Ok(intern!(py, "tuple-variable"))
+            let mode = mode.ok_or_else(|| self.tag_not_found(input))?;
+            match mode.as_cow()?.as_ref() {
+                "plain" => Ok(intern!(py, "function-plain")),
+                "wrap" => Ok(intern!(py, "function-wrap")),
+                _ => Ok(intern!(py, "function")),
             }
         } else {
             Ok(PyString::new(py, tag))
diff --git a/tests/benchmarks/complete_schema.py b/tests/benchmarks/complete_schema.py
index 8c24b9b7e..cfc522d29 100644
--- a/tests/benchmarks/complete_schema.py
+++ b/tests/benchmarks/complete_schema.py
@@ -83,16 +83,20 @@ def wrap_function(input_value, validator, info):
                         'max_length': 42,
                     },
                 },
-                'field_tuple_var_len_any': {'type': 'model-field', 'schema': {'type': 'tuple-variable'}},
+                'field_tuple_var_len_any': {
+                    'type': 'model-field',
+                    'schema': {'type': 'tuple', 'items_schema': [{'type': 'any'}], 'variadic_item_index': 0},
+                },
                 'field_tuple_var_len_float': {
                     'type': 'model-field',
-                    'schema': {'type': 'tuple-variable', 'items_schema': {'type': 'float'}},
+                    'schema': {'type': 'tuple', 'items_schema': [{'type': 'float'}], 'variadic_item_index': 0},
                 },
                 'field_tuple_var_len_float_con': {
                     'type': 'model-field',
                     'schema': {
-                        'type': 'tuple-variable',
-                        'items_schema': {'type': 'float'},
+                        'type': 'tuple',
+                        'items_schema': [{'type': 'float'}],
+                        'variadic_item_index': 0,
                         'min_length': 3,
                         'max_length': 42,
                     },
@@ -100,7 +104,7 @@ def wrap_function(input_value, validator, info):
                 'field_tuple_fix_len': {
                     'type': 'model-field',
                     'schema': {
-                        'type': 'tuple-positional',
+                        'type': 'tuple',
                         'items_schema': [{'type': 'str'}, {'type': 'int'}, {'type': 'float'}, {'type': 'bool'}],
                     },
                 },
diff --git a/tests/benchmarks/test_micro_benchmarks.py b/tests/benchmarks/test_micro_benchmarks.py
index cb08436c6..f1ec32eef 100644
--- a/tests/benchmarks/test_micro_benchmarks.py
+++ b/tests/benchmarks/test_micro_benchmarks.py
@@ -848,7 +848,7 @@ def t():
 def test_positional_tuple(benchmark):
     v = SchemaValidator(
         {
-            'type': 'tuple-positional',
+            'type': 'tuple',
             'items_schema': [{'type': 'int'}, {'type': 'int'}, {'type': 'int'}, {'type': 'int'}, {'type': 'int'}],
         }
     )
@@ -859,7 +859,7 @@ def test_positional_tuple(benchmark):
 
 @pytest.mark.benchmark(group='tuple')
 def test_variable_tuple(benchmark):
-    v = SchemaValidator({'type': 'tuple-variable', 'items_schema': {'type': 'int'}})
+    v = SchemaValidator({'type': 'tuple', 'items_schema': [{'type': 'int'}], 'variadic_item_index': 0})
     assert v.validate_python((1, 2, 3, '4', 5)) == (1, 2, 3, 4, 5)
 
     benchmark(v.validate_python, (1, 2, 3, '4', 5))
@@ -867,7 +867,7 @@ def test_variable_tuple(benchmark):
 
 @pytest.mark.benchmark(group='tuple-many')
 def test_tuple_many_variable(benchmark):
-    v = SchemaValidator({'type': 'tuple-variable', 'items_schema': {'type': 'int'}})
+    v = SchemaValidator({'type': 'tuple', 'items_schema': [{'type': 'int'}], 'variadic_item_index': 0})
     assert v.validate_python(list(range(10))) == tuple(range(10))
 
     benchmark(v.validate_python, list(range(10)))
@@ -875,7 +875,7 @@ def test_tuple_many_variable(benchmark):
 
 @pytest.mark.benchmark(group='tuple-many')
 def test_tuple_many_positional(benchmark):
-    v = SchemaValidator({'type': 'tuple-positional', 'items_schema': [], 'extras_schema': {'type': 'int'}})
+    v = SchemaValidator({'type': 'tuple', 'items_schema': [{'type': 'int'}], 'variadic_item_index': 0})
     assert v.validate_python(list(range(10))) == tuple(range(10))
 
     benchmark(v.validate_python, list(range(10)))
diff --git a/tests/serializers/test_list_tuple.py b/tests/serializers/test_list_tuple.py
index c695bbcc4..df6aabd8a 100644
--- a/tests/serializers/test_list_tuple.py
+++ b/tests/serializers/test_list_tuple.py
@@ -329,19 +329,20 @@ def test_filter_list_of_dicts():
 
 
 def test_positional_tuple():
-    s = SchemaSerializer(
-        {'type': 'tuple-positional', 'items_schema': [{'type': 'int'}, {'type': 'bytes'}, {'type': 'float'}]}
-    )
+    s = SchemaSerializer({'type': 'tuple', 'items_schema': [{'type': 'int'}, {'type': 'bytes'}, {'type': 'float'}]})
     assert s.to_python((1, b'2', 3.0)) == (1, b'2', 3.0)
-    assert s.to_python((1, b'2', 3.0, 123)) == (1, b'2', 3.0, 123)
+    with pytest.warns(UserWarning, match='Unexpected extra items present in tuple'):
+        assert s.to_python((1, b'2', 3.0, 123)) == (1, b'2', 3.0, 123)
     assert s.to_python((1, b'2')) == (1, b'2')
 
     assert s.to_python((1, b'2', 3.0), mode='json') == [1, '2', 3.0]
-    assert s.to_python((1, b'2', 3.0, 123), mode='json') == [1, '2', 3.0, 123]
+    with pytest.warns(UserWarning, match='Unexpected extra items present in tuple'):
+        assert s.to_python((1, b'2', 3.0, 123), mode='json') == [1, '2', 3.0, 123]
     assert s.to_python((1, b'2'), mode='json') == [1, '2']
 
     assert s.to_json((1, b'2', 3.0)) == b'[1,"2",3.0]'
-    assert s.to_json((1, b'2', 3.0, 123)) == b'[1,"2",3.0,123]'
+    with pytest.warns(UserWarning, match='Unexpected extra items present in tuple'):
+        assert s.to_json((1, b'2', 3.0, 123)) == b'[1,"2",3.0,123]'
     assert s.to_json((1, b'2')) == b'[1,"2"]'
 
 
@@ -351,7 +352,7 @@ def f(prefix, value, _info):
 
     s = SchemaSerializer(
         {
-            'type': 'tuple-positional',
+            'type': 'tuple',
             'items_schema': [
                 core_schema.any_schema(
                     serialization=core_schema.plain_serializer_function_ser_schema(partial(f, 'a'), info_arg=True)
@@ -359,10 +360,11 @@ def f(prefix, value, _info):
                 core_schema.any_schema(
                     serialization=core_schema.plain_serializer_function_ser_schema(partial(f, 'b'), info_arg=True)
                 ),
+                core_schema.any_schema(
+                    serialization=core_schema.plain_serializer_function_ser_schema(partial(f, 'extra'), info_arg=True)
+                ),
             ],
-            'extras_schema': core_schema.any_schema(
-                serialization=core_schema.plain_serializer_function_ser_schema(partial(f, 'extra'), info_arg=True)
-            ),
+            'variadic_item_index': 2,
         }
     )
     assert s.to_python((1,)) == ('a1',)
diff --git a/tests/serializers/test_none.py b/tests/serializers/test_none.py
index 6bbd49c46..e5e1a9093 100644
--- a/tests/serializers/test_none.py
+++ b/tests/serializers/test_none.py
@@ -16,7 +16,7 @@
     'url',
     'multi-host-url',
 )
-all_types = all_scalars + ('list', 'tuple-variable', 'dict', 'set', 'frozenset')
+all_types = all_scalars + ('list', 'dict', 'set', 'frozenset')
 
 
 @pytest.mark.parametrize('schema_type', all_types)
diff --git a/tests/test_schema_functions.py b/tests/test_schema_functions.py
index d4b53cbe4..2a6032174 100644
--- a/tests/test_schema_functions.py
+++ b/tests/test_schema_functions.py
@@ -79,17 +79,7 @@ def args(*args, **kwargs):
     (core_schema.callable_schema, args(), {'type': 'callable'}),
     (core_schema.list_schema, args(), {'type': 'list'}),
     (core_schema.list_schema, args({'type': 'int'}), {'type': 'list', 'items_schema': {'type': 'int'}}),
-    (
-        core_schema.tuple_positional_schema,
-        args([{'type': 'int'}]),
-        {'type': 'tuple-positional', 'items_schema': [{'type': 'int'}]},
-    ),
-    (core_schema.tuple_positional_schema, args([]), {'type': 'tuple-positional', 'items_schema': []}),
-    (
-        core_schema.tuple_variable_schema,
-        args({'type': 'int'}),
-        {'type': 'tuple-variable', 'items_schema': {'type': 'int'}},
-    ),
+    (core_schema.tuple_schema, args([]), {'type': 'tuple', 'items_schema': []}),
     (
         core_schema.set_schema,
         args({'type': 'int'}, min_length=4),
diff --git a/tests/test_typing.py b/tests/test_typing.py
index dcd2f267a..fb9f3e949 100644
--- a/tests/test_typing.py
+++ b/tests/test_typing.py
@@ -77,9 +77,9 @@ def test_schema_typing() -> None:
     SchemaValidator(schema)
     schema: CoreSchema = {'type': 'set', 'items_schema': {'type': 'str'}, 'max_length': 3}
     SchemaValidator(schema)
-    schema: CoreSchema = {'type': 'tuple-variable', 'items_schema': {'type': 'str'}, 'max_length': 3}
+    schema: CoreSchema = {'type': 'tuple', 'items_schema': [{'type': 'str'}], 'variadic_item_index': 0, 'max_length': 3}
     SchemaValidator(schema)
-    schema: CoreSchema = {'type': 'tuple-positional', 'items_schema': [{'type': 'str'}, {'type': 'int'}]}
+    schema: CoreSchema = {'type': 'tuple', 'items_schema': [{'type': 'str'}, {'type': 'int'}]}
     SchemaValidator(schema)
     schema: CoreSchema = {'type': 'frozenset', 'items_schema': {'type': 'str'}, 'max_length': 3}
     SchemaValidator(schema)
diff --git a/tests/validators/test_definitions_recursive.py b/tests/validators/test_definitions_recursive.py
index 9f7a93d57..1d7994054 100644
--- a/tests/validators/test_definitions_recursive.py
+++ b/tests/validators/test_definitions_recursive.py
@@ -279,7 +279,7 @@ def test_outside_parent():
                 }
             ),
             [
-                core_schema.tuple_positional_schema(
+                core_schema.tuple_schema(
                     [core_schema.int_schema(), core_schema.int_schema(), core_schema.str_schema()], ref='tuple-iis'
                 )
             ],
@@ -426,7 +426,7 @@ def multiple_tuple_schema() -> SchemaValidator:
                 }
             ),
             [
-                core_schema.tuple_positional_schema(
+                core_schema.tuple_schema(
                     [
                         core_schema.int_schema(),
                         core_schema.nullable_schema(core_schema.definition_reference_schema('t')),
@@ -522,7 +522,7 @@ def wrap_func(input_value, validator, info):
             [
                 core_schema.with_info_wrap_validator_function(
                     wrap_func,
-                    core_schema.tuple_positional_schema(
+                    core_schema.tuple_schema(
                         [
                             core_schema.int_schema(),
                             core_schema.nullable_schema(core_schema.definition_reference_schema('wrapper')),
diff --git a/tests/validators/test_frozenset.py b/tests/validators/test_frozenset.py
index 9ec2f10d5..6ee297b22 100644
--- a/tests/validators/test_frozenset.py
+++ b/tests/validators/test_frozenset.py
@@ -276,13 +276,13 @@ def gen(error: bool):
     [
         pytest.param(
             {1: 10, 2: 20, '3': '30'}.items(),
-            {'type': 'tuple-variable', 'items_schema': {'type': 'any'}},
+            {'type': 'tuple', 'items_schema': [{'type': 'any'}], 'variadic_item_index': 0},
             frozenset(((1, 10), (2, 20), ('3', '30'))),
             id='Tuple[Any, Any]',
         ),
         pytest.param(
             {1: 10, 2: 20, '3': '30'}.items(),
-            {'type': 'tuple-variable', 'items_schema': {'type': 'int'}},
+            {'type': 'tuple', 'items_schema': [{'type': 'int'}], 'variadic_item_index': 0},
             frozenset(((1, 10), (2, 20), (3, 30))),
             id='Tuple[int, int]',
         ),
diff --git a/tests/validators/test_list.py b/tests/validators/test_list.py
index 6f5ca8a34..187c0b851 100644
--- a/tests/validators/test_list.py
+++ b/tests/validators/test_list.py
@@ -305,13 +305,13 @@ def gen(error: bool):
     [
         pytest.param(
             {1: 10, 2: 20, '3': '30'}.items(),
-            {'type': 'tuple-variable', 'items_schema': {'type': 'any'}},
+            {'type': 'tuple', 'items_schema': [{'type': 'any'}], 'variadic_item_index': 0},
             [(1, 10), (2, 20), ('3', '30')],
             id='Tuple[Any, Any]',
         ),
         pytest.param(
             {1: 10, 2: 20, '3': '30'}.items(),
-            {'type': 'tuple-variable', 'items_schema': {'type': 'int'}},
+            {'type': 'tuple', 'items_schema': [{'type': 'int'}], 'variadic_item_index': 0},
             [(1, 10), (2, 20), (3, 30)],
             id='Tuple[int, int]',
         ),
diff --git a/tests/validators/test_set.py b/tests/validators/test_set.py
index a6babb80d..e58cedff8 100644
--- a/tests/validators/test_set.py
+++ b/tests/validators/test_set.py
@@ -242,13 +242,13 @@ def gen(error: bool):
     [
         pytest.param(
             {1: 10, 2: 20, '3': '30'}.items(),
-            {'type': 'tuple-variable', 'items_schema': {'type': 'any'}},
+            {'type': 'tuple', 'items_schema': [{'type': 'any'}], 'variadic_item_index': 0},
             {(1, 10), (2, 20), ('3', '30')},
             id='Tuple[Any, Any]',
         ),
         pytest.param(
             {1: 10, 2: 20, '3': '30'}.items(),
-            {'type': 'tuple-variable', 'items_schema': {'type': 'int'}},
+            {'type': 'tuple', 'items_schema': [{'type': 'int'}], 'variadic_item_index': 0},
             {(1, 10), (2, 20), (3, 30)},
             id='Tuple[int, int]',
         ),
diff --git a/tests/validators/test_tuple.py b/tests/validators/test_tuple.py
index 023a2b48e..e62f49f1d 100644
--- a/tests/validators/test_tuple.py
+++ b/tests/validators/test_tuple.py
@@ -5,19 +5,19 @@
 import pytest
 from dirty_equals import IsNonNegative, IsTuple
 
-from pydantic_core import SchemaValidator, ValidationError
+from pydantic_core import SchemaValidator, ValidationError, core_schema
 
 from ..conftest import Err, PyAndJson, infinite_generator
 
 
 @pytest.mark.parametrize(
-    'mode,items,input_value,expected',
+    'variadic_item_index,items,input_value,expected',
     [
-        ('variable', {'type': 'int'}, [1, 2, 3], (1, 2, 3)),
-        ('variable', {'type': 'int'}, 1, Err('[type=tuple_type, input_value=1, input_type=int]')),
-        ('positional', [{'type': 'int'}, {'type': 'int'}, {'type': 'int'}], [1, 2, '3'], (1, 2, 3)),
+        (0, [{'type': 'int'}], [1, 2, 3], (1, 2, 3)),
+        (0, [{'type': 'int'}], 1, Err('[type=tuple_type, input_value=1, input_type=int]')),
+        (None, [{'type': 'int'}, {'type': 'int'}, {'type': 'int'}], [1, 2, '3'], (1, 2, 3)),
         (
-            'positional',
+            None,
             [{'type': 'int'}, {'type': 'int'}, {'type': 'int'}],
             5,
             Err('[type=tuple_type, input_value=5, input_type=int]'),
@@ -25,8 +25,8 @@
     ],
     ids=repr,
 )
-def test_tuple_json(py_and_json: PyAndJson, mode, items, input_value, expected):
-    v = py_and_json({'type': f'tuple-{mode}', 'items_schema': items})
+def test_tuple_json(py_and_json: PyAndJson, variadic_item_index, items, input_value, expected):
+    v = py_and_json(core_schema.tuple_schema(items_schema=items, variadic_item_index=variadic_item_index))
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_test(input_value)
@@ -35,7 +35,7 @@ def test_tuple_json(py_and_json: PyAndJson, mode, items, input_value, expected):
 
 
 def test_any_no_copy():
-    v = SchemaValidator({'type': 'tuple-variable'})
+    v = SchemaValidator({'type': 'tuple', 'items_schema': [{'type': 'any'}], 'variadic_item_index': 0})
     input_value = (1, '2', b'3')
     output = v.validate_python(input_value)
     assert output == input_value
@@ -44,20 +44,22 @@ def test_any_no_copy():
 
 
 @pytest.mark.parametrize(
-    'mode,items,input_value,expected',
+    'variadic_item_index,items,input_value,expected',
     [
-        ('variable', {'type': 'int'}, (1, 2, '33'), (1, 2, 33)),
-        ('variable', {'type': 'str'}, (b'1', b'2', '33'), ('1', '2', '33')),
-        ('positional', [{'type': 'int'}, {'type': 'str'}, {'type': 'float'}], (1, b'a', 33), (1, 'a', 33.0)),
+        (0, [{'type': 'int'}], (1, 2, '33'), (1, 2, 33)),
+        (0, [{'type': 'str'}], (b'1', b'2', '33'), ('1', '2', '33')),
+        (None, [{'type': 'int'}, {'type': 'str'}, {'type': 'float'}], (1, b'a', 33), (1, 'a', 33.0)),
     ],
 )
-def test_tuple_strict_passes_with_tuple(mode, items, input_value, expected):
-    v = SchemaValidator({'type': f'tuple-{mode}', 'items_schema': items, 'strict': True})
+def test_tuple_strict_passes_with_tuple(variadic_item_index, items, input_value, expected):
+    v = SchemaValidator(
+        core_schema.tuple_schema(items_schema=items, variadic_item_index=variadic_item_index, strict=True)
+    )
     assert v.validate_python(input_value) == expected
 
 
 def test_empty_positional_tuple():
-    v = SchemaValidator({'type': 'tuple-positional', 'items_schema': []})
+    v = SchemaValidator({'type': 'tuple', 'items_schema': []})
     assert v.validate_python(()) == ()
     assert v.validate_python([]) == ()
     with pytest.raises(ValidationError) as exc_info:
@@ -76,11 +78,13 @@ def test_empty_positional_tuple():
 
 
 @pytest.mark.parametrize(
-    'mode,items', [('variable', {'type': 'int'}), ('positional', [{'type': 'int'}, {'type': 'int'}, {'type': 'int'}])]
+    'variadic_item_index,items', [(0, [{'type': 'int'}]), (None, [{'type': 'int'}, {'type': 'int'}, {'type': 'int'}])]
 )
 @pytest.mark.parametrize('wrong_coll_type', [list, set, frozenset])
-def test_tuple_strict_fails_without_tuple(wrong_coll_type: Type[Any], mode, items):
-    v = SchemaValidator({'type': f'tuple-{mode}', 'items_schema': items, 'strict': True})
+def test_tuple_strict_fails_without_tuple(wrong_coll_type: Type[Any], variadic_item_index, items):
+    v = SchemaValidator(
+        core_schema.tuple_schema(variadic_item_index=variadic_item_index, items_schema=items, strict=True)
+    )
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python(wrong_coll_type([1, 2, '33']))
     assert exc_info.value.errors(include_url=False) == [
@@ -119,7 +123,7 @@ def test_tuple_strict_fails_without_tuple(wrong_coll_type: Type[Any], mode, item
     ids=repr,
 )
 def test_tuple_var_len_kwargs(kwargs: Dict[str, Any], input_value, expected):
-    v = SchemaValidator({'type': 'tuple-variable', **kwargs})
+    v = SchemaValidator({'type': 'tuple', 'items_schema': [{'type': 'any'}], 'variadic_item_index': 0, **kwargs})
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value)
@@ -128,7 +132,7 @@ def test_tuple_var_len_kwargs(kwargs: Dict[str, Any], input_value, expected):
 
 
 @pytest.mark.parametrize(
-    'mode,items', [('variable', {'type': 'int'}), ('positional', [{'type': 'int'}, {'type': 'int'}, {'type': 'int'}])]
+    'variadic_item_index,items', [(0, [{'type': 'int'}]), (None, [{'type': 'int'}, {'type': 'int'}, {'type': 'int'}])]
 )
 @pytest.mark.parametrize(
     'input_value,expected',
@@ -144,8 +148,8 @@ def test_tuple_var_len_kwargs(kwargs: Dict[str, Any], input_value, expected):
     ],
     ids=repr,
 )
-def test_tuple_validate(input_value, expected, mode, items):
-    v = SchemaValidator({'type': f'tuple-{mode}', 'items_schema': items})
+def test_tuple_validate(input_value, expected, variadic_item_index, items):
+    v = SchemaValidator(core_schema.tuple_schema(items_schema=items, variadic_item_index=variadic_item_index))
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value)
@@ -157,10 +161,10 @@ def test_tuple_validate(input_value, expected, mode, items):
 # on the first test run. This is a workaround to make sure the generator is
 # always recreated.
 @pytest.mark.parametrize(
-    'mode,items', [('variable', {'type': 'int'}), ('positional', [{'type': 'int'}, {'type': 'int'}, {'type': 'int'}])]
+    'variadic_item_index,items', [(0, [{'type': 'int'}]), (None, [{'type': 'int'}, {'type': 'int'}, {'type': 'int'}])]
 )
-def test_tuple_validate_iterator(mode, items):
-    v = SchemaValidator({'type': f'tuple-{mode}', 'items_schema': items})
+def test_tuple_validate_iterator(variadic_item_index, items):
+    v = SchemaValidator(core_schema.tuple_schema(items_schema=items, variadic_item_index=variadic_item_index))
     assert v.validate_python((x for x in [1, 2, '3'])) == (1, 2, 3)
 
 
@@ -175,7 +179,7 @@ def test_tuple_validate_iterator(mode, items):
     ],
 )
 def test_tuple_var_len_errors(input_value, index):
-    v = SchemaValidator({'type': 'tuple-variable', 'items_schema': {'type': 'int'}})
+    v = SchemaValidator({'type': 'tuple', 'items_schema': [{'type': 'int'}], 'variadic_item_index': 0})
     with pytest.raises(ValidationError) as exc_info:
         assert v.validate_python(input_value)
     assert exc_info.value.errors(include_url=False) == [
@@ -203,7 +207,7 @@ def test_tuple_var_len_errors(input_value, index):
     ],
 )
 def test_tuple_fix_len_errors(input_value, items, index):
-    v = SchemaValidator({'type': 'tuple-positional', 'items_schema': items})
+    v = SchemaValidator({'type': 'tuple', 'items_schema': items})
     with pytest.raises(ValidationError) as exc_info:
         assert v.validate_python(input_value)
     assert exc_info.value.errors(include_url=False) == [
@@ -218,10 +222,7 @@ def test_tuple_fix_len_errors(input_value, items, index):
 
 def test_multiple_missing(py_and_json: PyAndJson):
     v = py_and_json(
-        {
-            'type': 'tuple-positional',
-            'items_schema': [{'type': 'int'}, {'type': 'int'}, {'type': 'int'}, {'type': 'int'}],
-        }
+        {'type': 'tuple', 'items_schema': [{'type': 'int'}, {'type': 'int'}, {'type': 'int'}, {'type': 'int'}]}
     )
     assert v.validate_test([1, 2, 3, 4]) == (1, 2, 3, 4)
     with pytest.raises(ValidationError) as exc_info:
@@ -239,7 +240,7 @@ def test_multiple_missing(py_and_json: PyAndJson):
 
 
 def test_extra_arguments(py_and_json: PyAndJson):
-    v = py_and_json({'type': 'tuple-positional', 'items_schema': [{'type': 'int'}, {'type': 'int'}]})
+    v = py_and_json({'type': 'tuple', 'items_schema': [{'type': 'int'}, {'type': 'int'}]})
     assert v.validate_test([1, 2]) == (1, 2)
     with pytest.raises(ValidationError) as exc_info:
         v.validate_test([1, 2, 3, 4])
@@ -256,7 +257,7 @@ def test_extra_arguments(py_and_json: PyAndJson):
 
 
 def test_positional_empty(py_and_json: PyAndJson):
-    v = py_and_json({'type': 'tuple-positional', 'items_schema': []})
+    v = py_and_json({'type': 'tuple', 'items_schema': []})
     assert v.validate_test([]) == ()
     assert v.validate_python(()) == ()
     with pytest.raises(ValidationError, match='type=too_long,'):
@@ -264,7 +265,7 @@ def test_positional_empty(py_and_json: PyAndJson):
 
 
 def test_positional_empty_extra(py_and_json: PyAndJson):
-    v = py_and_json({'type': 'tuple-positional', 'items_schema': [], 'extras_schema': {'type': 'int'}})
+    v = py_and_json({'type': 'tuple', 'items_schema': [{'type': 'int'}], 'variadic_item_index': 0})
     assert v.validate_test([]) == ()
     assert v.validate_python(()) == ()
     assert v.validate_test([1]) == (1,)
@@ -273,7 +274,15 @@ def test_positional_empty_extra(py_and_json: PyAndJson):
 
 @pytest.mark.parametrize('input_value,expected', [((1, 2, 3), (1, 2, 3)), ([1, 2, 3], [1, 2, 3])])
 def test_union_tuple_list(input_value, expected):
-    v = SchemaValidator({'type': 'union', 'choices': [{'type': 'tuple-variable'}, {'type': 'list'}]})
+    v = SchemaValidator(
+        {
+            'type': 'union',
+            'choices': [
+                {'type': 'tuple', 'items_schema': [{'type': 'any'}], 'variadic_item_index': 0},
+                {'type': 'list'},
+            ],
+        }
+    )
     assert v.validate_python(input_value) == expected
 
 
@@ -313,8 +322,8 @@ def test_union_tuple_var_len(input_value, expected):
         {
             'type': 'union',
             'choices': [
-                {'type': 'tuple-variable', 'items_schema': {'type': 'int'}, 'strict': True},
-                {'type': 'tuple-variable', 'items_schema': {'type': 'str'}, 'strict': True},
+                {'type': 'tuple', 'items_schema': [{'type': 'int'}], 'variadic_item_index': 0, 'strict': True},
+                {'type': 'tuple', 'items_schema': [{'type': 'str'}], 'variadic_item_index': 0, 'strict': True},
             ],
         }
     )
@@ -360,16 +369,8 @@ def test_union_tuple_fix_len(input_value, expected):
         {
             'type': 'union',
             'choices': [
-                {
-                    'type': 'tuple-positional',
-                    'items_schema': [{'type': 'int'}, {'type': 'int'}, {'type': 'int'}],
-                    'strict': True,
-                },
-                {
-                    'type': 'tuple-positional',
-                    'items_schema': [{'type': 'str'}, {'type': 'str'}, {'type': 'str'}],
-                    'strict': True,
-                },
+                {'type': 'tuple', 'items_schema': [{'type': 'int'}, {'type': 'int'}, {'type': 'int'}], 'strict': True},
+                {'type': 'tuple', 'items_schema': [{'type': 'str'}, {'type': 'str'}, {'type': 'str'}], 'strict': True},
             ],
         }
     )
@@ -383,7 +384,7 @@ def test_union_tuple_fix_len(input_value, expected):
 
 
 def test_tuple_fix_error():
-    v = SchemaValidator({'type': 'tuple-positional', 'items_schema': [{'type': 'int'}, {'type': 'str'}]})
+    v = SchemaValidator({'type': 'tuple', 'items_schema': [{'type': 'int'}, {'type': 'str'}]})
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python([1])
 
@@ -403,13 +404,9 @@ def test_tuple_fix_error():
         ([1], Err('type=missing', errors=[{'type': 'missing', 'loc': (1,), 'msg': 'Field required', 'input': [1]}])),
     ],
 )
-def test_tuple_fix_extra(input_value, expected, cache):
+def test_tuple_fix_extra(input_value, expected):
     v = SchemaValidator(
-        {
-            'type': 'tuple-positional',
-            'items_schema': [{'type': 'int'}, {'type': 'str'}],
-            'extras_schema': {'type': 'str'},
-        }
+        {'type': 'tuple', 'items_schema': [{'type': 'int'}, {'type': 'str'}, {'type': 'str'}], 'variadic_item_index': 2}
     )
 
     if isinstance(expected, Err):
@@ -421,9 +418,7 @@ def test_tuple_fix_extra(input_value, expected, cache):
 
 
 def test_tuple_fix_extra_any():
-    v = SchemaValidator(
-        {'type': 'tuple-positional', 'items_schema': [{'type': 'str'}], 'extras_schema': {'type': 'any'}}
-    )
+    v = SchemaValidator({'type': 'tuple', 'items_schema': [{'type': 'str'}, {'type': 'any'}], 'variadic_item_index': 1})
     assert v.validate_python([b'1']) == ('1',)
     assert v.validate_python([b'1', 2]) == ('1', 2)
     assert v.validate_python((b'1', 2)) == ('1', 2)
@@ -443,7 +438,7 @@ def gen(error: bool):
             raise RuntimeError('error')
         yield 3
 
-    v = SchemaValidator({'type': 'tuple-variable', 'items_schema': {'type': 'int'}})
+    v = SchemaValidator({'type': 'tuple', 'items_schema': [{'type': 'int'}], 'variadic_item_index': 0})
     assert v.validate_python(gen(False)) == (1, 2, 3)
 
     msg = r'Error iterating over object, error: RuntimeError: error \[type=iteration_error,'
@@ -456,13 +451,13 @@ def gen(error: bool):
     [
         pytest.param(
             {1: 10, 2: 20, '3': '30'}.items(),
-            {'type': 'tuple-variable', 'items_schema': {'type': 'any'}},
+            {'type': 'tuple', 'items_schema': [{'type': 'any'}], 'variadic_item_index': 0},
             ((1, 10), (2, 20), ('3', '30')),
             id='Tuple[Any, Any]',
         ),
         pytest.param(
             {1: 10, 2: 20, '3': '30'}.items(),
-            {'type': 'tuple-variable', 'items_schema': {'type': 'int'}},
+            {'type': 'tuple', 'items_schema': [{'type': 'int'}], 'variadic_item_index': 0},
             ((1, 10), (2, 20), (3, 30)),
             id='Tuple[int, int]',
         ),
@@ -470,7 +465,7 @@ def gen(error: bool):
     ],
 )
 def test_frozenset_from_dict_items(input_value, items_schema, expected):
-    v = SchemaValidator({'type': 'tuple-variable', 'items_schema': items_schema})
+    v = SchemaValidator({'type': 'tuple', 'items_schema': [items_schema], 'variadic_item_index': 0})
     output = v.validate_python(input_value)
     assert isinstance(output, tuple)
     assert output == expected
@@ -487,8 +482,9 @@ def test_frozenset_from_dict_items(input_value, items_schema, expected):
 def test_length_constraints_omit(input_value, expected):
     v = SchemaValidator(
         {
-            'type': 'tuple-variable',
-            'items_schema': {'type': 'default', 'schema': {'type': 'int'}, 'on_error': 'omit'},
+            'type': 'tuple',
+            'items_schema': [{'type': 'default', 'schema': {'type': 'int'}, 'on_error': 'omit'}],
+            'variadic_item_index': 0,
             'max_length': 4,
         }
     )
diff --git a/tests/validators/test_with_default.py b/tests/validators/test_with_default.py
index 7ca0d9f54..189a555bb 100644
--- a/tests/validators/test_with_default.py
+++ b/tests/validators/test_with_default.py
@@ -164,7 +164,11 @@ def test_dict_keys():
 
 def test_tuple_variable(py_and_json: PyAndJson):
     v = py_and_json(
-        {'type': 'tuple-variable', 'items_schema': {'type': 'default', 'schema': {'type': 'int'}, 'on_error': 'omit'}}
+        {
+            'type': 'tuple',
+            'items_schema': [{'type': 'default', 'schema': {'type': 'int'}, 'on_error': 'omit'}],
+            'variadic_item_index': 0,
+        }
     )
     assert v.validate_python((1, 2, 3)) == (1, 2, 3)
     assert v.validate_python([1, '2', 3]) == (1, 2, 3)
@@ -174,7 +178,7 @@ def test_tuple_variable(py_and_json: PyAndJson):
 def test_tuple_positional():
     v = SchemaValidator(
         {
-            'type': 'tuple-positional',
+            'type': 'tuple',
             'items_schema': [{'type': 'int'}, {'type': 'default', 'schema': {'type': 'int'}, 'default': 42}],
         }
     )
@@ -187,9 +191,13 @@ def test_tuple_positional():
 def test_tuple_positional_omit():
     v = SchemaValidator(
         {
-            'type': 'tuple-positional',
-            'items_schema': [{'type': 'int'}, {'type': 'int'}],
-            'extras_schema': {'type': 'default', 'schema': {'type': 'int'}, 'on_error': 'omit'},
+            'type': 'tuple',
+            'items_schema': [
+                {'type': 'int'},
+                {'type': 'int'},
+                {'type': 'default', 'schema': {'type': 'int'}, 'on_error': 'omit'},
+            ],
+            'variadic_item_index': 2,
         }
     )
     assert v.validate_python((1, '2')) == (1, 2)

From 8dde89e06523f89a803d7753d24096839f6039bc Mon Sep 17 00:00:00 2001
From: Sukhorosov Aleksey <39103632+alexdrydew@users.noreply.github.com>
Date: Wed, 10 Jan 2024 12:15:44 +0100
Subject: [PATCH 173/550] Use stricter serializer for unions of simple types
 (#1132)

---
 src/serializers/type_serializers/simple.rs |  28 +++--
 tests/serializers/test_union.py            | 116 +++++++++++++++++++++
 2 files changed, 134 insertions(+), 10 deletions(-)

diff --git a/src/serializers/type_serializers/simple.rs b/src/serializers/type_serializers/simple.rs
index dafb2b786..65fbee146 100644
--- a/src/serializers/type_serializers/simple.rs
+++ b/src/serializers/type_serializers/simple.rs
@@ -5,11 +5,12 @@ use std::borrow::Cow;
 
 use serde::Serialize;
 
+use crate::PydanticSerializationUnexpectedValue;
 use crate::{definitions::DefinitionsBuilder, input::Int};
 
 use super::{
     infer_json_key, infer_serialize, infer_to_python, BuildSerializer, CombinedSerializer, Extra, IsType, ObType,
-    SerMode, TypeSerializer,
+    SerCheck, SerMode, TypeSerializer,
 };
 
 #[derive(Debug, Clone)]
@@ -85,7 +86,7 @@ impl TypeSerializer for NoneSerializer {
 }
 
 macro_rules! build_simple_serializer {
-    ($struct_name:ident, $expected_type:literal, $rust_type:ty, $ob_type:expr, $key_method:ident) => {
+    ($struct_name:ident, $expected_type:literal, $rust_type:ty, $ob_type:expr, $key_method:ident, $subtypes_allowed:expr) => {
         #[derive(Debug, Clone)]
         pub struct $struct_name;
 
@@ -114,12 +115,15 @@ macro_rules! build_simple_serializer {
                 let py = value.py();
                 match extra.ob_type_lookup.is_type(value, $ob_type) {
                     IsType::Exact => Ok(value.into_py(py)),
-                    IsType::Subclass => match extra.mode {
-                        SerMode::Json => {
-                            let rust_value = value.extract::<$rust_type>()?;
-                            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::<$rust_type>()?;
+                                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)?;
@@ -160,6 +164,10 @@ macro_rules! build_simple_serializer {
             fn get_name(&self) -> &str {
                 Self::EXPECTED_TYPE
             }
+
+            fn retry_with_lax_check(&self) -> bool {
+                $subtypes_allowed
+            }
         }
     };
 }
@@ -168,7 +176,7 @@ pub(crate) fn to_str_json_key(key: &PyAny) -> PyResult<Cow<str>> {
     Ok(key.str()?.to_string_lossy())
 }
 
-build_simple_serializer!(IntSerializer, "int", Int, ObType::Int, to_str_json_key);
+build_simple_serializer!(IntSerializer, "int", Int, ObType::Int, to_str_json_key, true);
 
 pub(crate) fn bool_json_key(key: &PyAny) -> PyResult<Cow<str>> {
     let v = if key.is_true().unwrap_or(false) {
@@ -179,4 +187,4 @@ pub(crate) fn bool_json_key(key: &PyAny) -> PyResult<Cow<str>> {
     Ok(Cow::Borrowed(v))
 }
 
-build_simple_serializer!(BoolSerializer, "bool", bool, ObType::Bool, bool_json_key);
+build_simple_serializer!(BoolSerializer, "bool", bool, ObType::Bool, bool_json_key, false);
diff --git a/tests/serializers/test_union.py b/tests/serializers/test_union.py
index 9b021e66e..ee5ed3fc4 100644
--- a/tests/serializers/test_union.py
+++ b/tests/serializers/test_union.py
@@ -1,6 +1,8 @@
 import dataclasses
 import json
 import re
+import uuid
+from decimal import Decimal
 from typing import Any, ClassVar, Union
 
 import pytest
@@ -510,3 +512,117 @@ class Item(BaseModel):
     )
 
     assert s.to_python([DBUser(name='John', password='secret')]) == [{'name': 'John'}]
+
+
+EXAMPLE_UUID = uuid.uuid4()
+
+
+class IntSubclass(int):
+    pass
+
+
+@pytest.mark.parametrize('reverse', [False, True])
+@pytest.mark.parametrize(
+    'core_schema_left,core_schema_right,input_value,expected_value',
+    [
+        (core_schema.int_schema(), core_schema.bool_schema(), True, True),
+        (core_schema.int_schema(), core_schema.bool_schema(), 1, 1),
+        (core_schema.str_schema(), core_schema.int_schema(), 1, 1),
+        (core_schema.str_schema(), core_schema.int_schema(), '1', '1'),
+        (core_schema.int_schema(), core_schema.bool_schema(), IntSubclass(1), 1),
+        (
+            core_schema.decimal_schema(),
+            core_schema.int_schema(),
+            Decimal('1'),
+            Decimal('1'),
+        ),
+        (core_schema.decimal_schema(), core_schema.int_schema(), 1, 1),
+        (
+            core_schema.decimal_schema(),
+            core_schema.float_schema(),
+            Decimal('1.'),
+            Decimal('1.'),
+        ),
+        (
+            core_schema.decimal_schema(),
+            core_schema.str_schema(),
+            Decimal('_1'),
+            Decimal('_1'),
+        ),
+        (
+            core_schema.decimal_schema(),
+            core_schema.str_schema(),
+            '_1',
+            '_1',
+        ),
+        (
+            core_schema.uuid_schema(),
+            core_schema.str_schema(),
+            EXAMPLE_UUID,
+            EXAMPLE_UUID,
+        ),
+        (
+            core_schema.uuid_schema(),
+            core_schema.str_schema(),
+            str(EXAMPLE_UUID),
+            str(EXAMPLE_UUID),
+        ),
+    ],
+)
+def test_union_serializer_picks_exact_type_over_subclass(
+    core_schema_left, core_schema_right, input_value, expected_value, reverse
+):
+    s = SchemaSerializer(
+        core_schema.union_schema(
+            [core_schema_right, core_schema_left] if reverse else [core_schema_left, core_schema_right]
+        )
+    )
+    assert s.to_python(input_value) == expected_value
+
+
+@pytest.mark.parametrize('reverse', [False, True])
+@pytest.mark.parametrize(
+    'core_schema_left,core_schema_right,input_value,expected_value',
+    [
+        (core_schema.int_schema(), core_schema.bool_schema(), True, True),
+        (core_schema.int_schema(), core_schema.bool_schema(), 1, 1),
+        (core_schema.str_schema(), core_schema.int_schema(), 1, 1),
+        (core_schema.str_schema(), core_schema.int_schema(), '1', '1'),
+        (core_schema.int_schema(), core_schema.bool_schema(), IntSubclass(1), 1),
+        (
+            core_schema.decimal_schema(),
+            core_schema.int_schema(),
+            Decimal('1'),
+            '1',
+        ),
+        (core_schema.decimal_schema(), core_schema.int_schema(), 1, 1),
+        (
+            core_schema.decimal_schema(),
+            core_schema.float_schema(),
+            Decimal('1.'),
+            '1',
+        ),
+        (
+            core_schema.decimal_schema(),
+            core_schema.str_schema(),
+            Decimal('_1'),
+            '1',
+        ),
+        (
+            core_schema.decimal_schema(),
+            core_schema.str_schema(),
+            '_1',
+            '_1',
+        ),
+    ],
+)
+def test_union_serializer_picks_exact_type_over_subclass_json(
+    core_schema_left, core_schema_right, input_value, expected_value, reverse
+):
+    s = SchemaSerializer(
+        core_schema.union_schema(
+            [core_schema_right, core_schema_left] if reverse else [core_schema_left, core_schema_right]
+        )
+    )
+    assert s.to_python(input_value, mode='json') == expected_value
+    assert s.to_json(input_value) == json.dumps(expected_value).encode()

From 82c4ca35f6281bd49117e86e4371ee78dcc8c65c Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Wed, 10 Jan 2024 13:46:15 +0000
Subject: [PATCH 174/550] adjust build for upload-artifact-4 (#1146)

---
 .github/workflows/ci.yml | 52 ++++++++++------------------------------
 1 file changed, 13 insertions(+), 39 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 1bf0698a1..826635499 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -358,7 +358,7 @@ jobs:
           rust-toolchain: stable
       - uses: actions/upload-artifact@v4
         with:
-          name: pypi_files
+          name: pypi_files_sdist
           path: dist
 
   build:
@@ -447,7 +447,7 @@ jobs:
         uses: PyO3/maturin-action@v1
         with:
           target: ${{ matrix.target }}
-          manylinux: ${{ matrix.manylinux == 'manylinux' && 'auto' || matrix.manylinux }}
+          manylinux: ${{ matrix.manylinux }}
           args: --release --out dist --interpreter ${{ matrix.interpreter || '3.8 3.9 3.10 3.11 3.12 pypy3.9 pypy3.10' }}
           rust-toolchain: stable
           docker-options: -e CI
@@ -458,7 +458,7 @@ jobs:
 
       - uses: actions/upload-artifact@v4
         with:
-          name: pypi_files
+          name: pypi_files_${{ matrix.os }}_${{ matrix.target }}_${{ matrix.interpreter || 'all' }}_${{ matrix.manylinux }}
           path: dist
 
   build-pgo:
@@ -553,7 +553,7 @@ jobs:
 
       - uses: actions/upload-artifact@v4
         with:
-          name: pypi_files_pgo
+          name: pypi_files_${{ matrix.os }}_${{ matrix.interpreter }}
           path: dist
 
   inspect-pypi-assets:
@@ -566,22 +566,11 @@ jobs:
       - name: get dist artifacts
         uses: actions/download-artifact@v4
         with:
-          name: pypi_files
+          pattern: pypi_files_*
+          merge-multiple: true
           path: dist
 
-      - name: list dist files before PGO builds
-        run: |
-         ls -lh dist/
-         ls -l dist/
-         echo "`ls dist | wc -l` files"
-
-      - name: get PGO dist artifacts (comes after "get dist artifacts" to so these files override the non-PGO builds)
-        uses: actions/download-artifact@v4
-        with:
-          name: pypi_files_pgo
-          path: dist
-
-      - name: list dist files with PGO builds
+      - name: list dist files
         run: |
          ls -lh dist/
          ls -l dist/
@@ -618,13 +607,8 @@ jobs:
       - name: get dist artifacts
         uses: actions/download-artifact@v4
         with:
-          name: pypi_files
-          path: dist
-
-      - name: get PGO dist artifacts (comes after "get dist artifacts" to so these files override the non-PGO builds)
-        uses: actions/download-artifact@v4
-        with:
-          name: pypi_files_pgo
+          pattern: pypi_files_linux_*
+          merge-multiple: true
           path: dist
 
       - uses: uraimo/run-on-arch-action@v2.6.0
@@ -676,13 +660,8 @@ jobs:
       - name: get dist artifacts
         uses: actions/download-artifact@v4
         with:
-          name: pypi_files
-          path: dist
-
-      - name: get PGO dist artifacts (comes after "get dist artifacts" to so these files override the non-PGO builds)
-        uses: actions/download-artifact@v4
-        with:
-          name: pypi_files_pgo
+          pattern: pypi_files_*
+          merge-multiple: true
           path: dist
 
       - run: pip install typing-extensions
@@ -711,13 +690,8 @@ jobs:
       - name: get dist artifacts
         uses: actions/download-artifact@v4
         with:
-          name: pypi_files
-          path: dist
-
-      - name: get PGO dist artifacts (comes after "get dist artifacts" to so these files override the non-PGO builds)
-        uses: actions/download-artifact@v4
-        with:
-          name: pypi_files_pgo
+          pattern: pypi_files_*
+          merge-multiple: true
           path: dist
 
       - run: twine check --strict dist/*

From 700e17d8ce69caed42776365874006a9dfb90cf3 Mon Sep 17 00:00:00 2001
From: Marcelo Trylesinski <marcelotryle@gmail.com>
Date: Fri, 12 Jan 2024 22:23:29 +0100
Subject: [PATCH 175/550] Group dependencies on dependabot updates (#1149)

---
 .github/dependabot.yml | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/.github/dependabot.yml b/.github/dependabot.yml
index b93ab648d..67fb85756 100644
--- a/.github/dependabot.yml
+++ b/.github/dependabot.yml
@@ -9,6 +9,10 @@ updates:
     directory: "/"
     schedule:
       interval: "monthly"
+    groups:
+      python-packages:
+        patterns:
+          - "*"
 
   - package-ecosystem: "github-actions"
     directory: "/"

From 8030c5ae1cfb0517d333d5647ee66af8ab820440 Mon Sep 17 00:00:00 2001
From: Samuel Colvin <s@muelcolvin.com>
Date: Sun, 14 Jan 2024 21:38:48 +0000
Subject: [PATCH 176/550] add to_json ser benchmark

---
 tests/benchmarks/test_serialization_micro.py | 17 ++++++++++++++++-
 1 file changed, 16 insertions(+), 1 deletion(-)

diff --git a/tests/benchmarks/test_serialization_micro.py b/tests/benchmarks/test_serialization_micro.py
index 6a78de87a..9200fc24b 100644
--- a/tests/benchmarks/test_serialization_micro.py
+++ b/tests/benchmarks/test_serialization_micro.py
@@ -4,7 +4,7 @@
 
 import pytest
 
-from pydantic_core import SchemaSerializer, SchemaValidator, core_schema
+from pydantic_core import SchemaSerializer, SchemaValidator, core_schema, to_json
 
 
 class TestBenchmarkSimpleModel:
@@ -394,3 +394,18 @@ def test_filter(benchmark):
     @benchmark
     def t():
         v.to_python(['a', 'b', 'c', 'd', 'e'], include={-1, -2})
+
+
+@pytest.mark.benchmark(group='list-of-lists')
+def test_to_json_list_of_lists(benchmark):
+    data = [[i + j for j in range(10)] for i in range(1000)]
+
+    benchmark(to_json, data)
+
+
+@pytest.mark.benchmark(group='list-of-lists')
+def test_ser_list_of_lists(benchmark):
+    s = SchemaSerializer(core_schema.list_schema(core_schema.list_schema(core_schema.int_schema())))
+    data = [[i + j for j in range(10)] for i in range(1000)]
+
+    benchmark(s.to_json, data)

From fa65fcdbbe70cd2eff9f94e156735e4a67545c6e Mon Sep 17 00:00:00 2001
From: Samuel Colvin <s@muelcolvin.com>
Date: Mon, 15 Jan 2024 09:52:03 +0000
Subject: [PATCH 177/550] simplify instantiation of undefined type (#1157)

---
 src/argument_markers.rs        | 6 ------
 src/validators/model.rs        | 6 ++++--
 src/validators/with_default.rs | 4 +++-
 3 files changed, 7 insertions(+), 9 deletions(-)

diff --git a/src/argument_markers.rs b/src/argument_markers.rs
index a4472351d..3e73fb629 100644
--- a/src/argument_markers.rs
+++ b/src/argument_markers.rs
@@ -102,9 +102,3 @@ impl PydanticUndefinedType {
         "PydanticUndefined"
     }
 }
-
-impl PydanticUndefinedType {
-    pub fn py_undefined() -> Py<Self> {
-        Python::with_gil(PydanticUndefinedType::new)
-    }
-}
diff --git a/src/validators/model.rs b/src/validators/model.rs
index 1831d2fde..0cc39b6a3 100644
--- a/src/validators/model.rs
+++ b/src/validators/model.rs
@@ -60,6 +60,7 @@ pub struct ModelValidator {
     frozen: bool,
     custom_init: bool,
     root_model: bool,
+    undefined: PyObject,
     name: String,
 }
 
@@ -93,6 +94,7 @@ impl BuildValidator for ModelValidator {
             frozen: schema.get_as(intern!(py, "frozen"))?.unwrap_or(false),
             custom_init: schema.get_as(intern!(py, "custom_init"))?.unwrap_or(false),
             root_model: schema.get_as(intern!(py, "root_model"))?.unwrap_or(false),
+            undefined: PydanticUndefinedType::new(py).to_object(py),
             // Get the class's `__name__`, not using `class.name()` since it uses `__qualname__`
             // which is not what we want here
             name: class.getattr(intern!(py, "__name__"))?.extract()?,
@@ -229,7 +231,7 @@ impl ModelValidator {
         let output = self.validator.validate(py, input, state)?;
 
         if self.root_model {
-            let fields_set = if input.to_object(py).is(&PydanticUndefinedType::py_undefined()) {
+            let fields_set = if input.to_object(py).is(&self.undefined) {
                 PySet::empty(py)?
             } else {
                 PySet::new(py, [&String::from(ROOT_FIELD)])?
@@ -270,7 +272,7 @@ impl ModelValidator {
         let instance_ref = instance.as_ref(py);
 
         if self.root_model {
-            let fields_set = if input.to_object(py).is(&PydanticUndefinedType::py_undefined()) {
+            let fields_set = if input.to_object(py).is(&self.undefined) {
                 PySet::empty(py)?
             } else {
                 PySet::new(py, [&String::from(ROOT_FIELD)])?
diff --git a/src/validators/with_default.rs b/src/validators/with_default.rs
index 443c0e271..a17c2cefc 100644
--- a/src/validators/with_default.rs
+++ b/src/validators/with_default.rs
@@ -74,6 +74,7 @@ pub struct WithDefaultValidator {
     validate_default: bool,
     copy_default: bool,
     name: String,
+    undefined: PyObject,
 }
 
 impl BuildValidator for WithDefaultValidator {
@@ -118,6 +119,7 @@ impl BuildValidator for WithDefaultValidator {
             validate_default: schema_or_config_same(schema, config, intern!(py, "validate_default"))?.unwrap_or(false),
             copy_default,
             name,
+            undefined: PydanticUndefinedType::new(py).to_object(py),
         }
         .into())
     }
@@ -132,7 +134,7 @@ impl Validator for WithDefaultValidator {
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
-        if input.to_object(py).is(&PydanticUndefinedType::py_undefined()) {
+        if input.to_object(py).is(&self.undefined) {
             Ok(self.default_value(py, None::<usize>, state)?.unwrap())
         } else {
             match self.validator.validate(py, input, state) {

From b9b28ad69fa2ffb02f5e294c5f4297291ec0bff2 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Mon, 15 Jan 2024 10:24:29 +0000
Subject: [PATCH 178/550] unify 'profile.profiling' configuration (#1158)

---
 .github/workflows/codspeed.yml | 6 ++----
 Cargo.toml                     | 4 +++-
 Makefile                       | 4 ++--
 3 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/.github/workflows/codspeed.yml b/.github/workflows/codspeed.yml
index 5d69d4d5f..fc6591314 100644
--- a/.github/workflows/codspeed.yml
+++ b/.github/workflows/codspeed.yml
@@ -52,8 +52,7 @@ jobs:
           key: v1
 
       - name: Compile pydantic-core for profiling
-        run: |
-          pip install -e . --config-settings=build-args='--verbose --profile codspeed' -v
+        run: make build-profiling
         env:
           CONST_RANDOM_SEED: 0 # Fix the compile time RNG seed
           RUSTFLAGS: "-Cprofile-generate=${{ github.workspace }}/profdata"
@@ -65,8 +64,7 @@ jobs:
         run: rustup run stable bash -c '$RUSTUP_HOME/toolchains/$RUSTUP_TOOLCHAIN/lib/rustlib/x86_64-unknown-linux-gnu/bin/llvm-profdata merge -o ${{ github.workspace }}/merged.profdata ${{ github.workspace }}/profdata'
 
       - name: Compile pydantic-core for benchmarking
-        run: |
-          pip install -e . --config-settings=build-args='--verbose --profile codspeed' -v
+        run: make build-profiling
         env:
           CONST_RANDOM_SEED: 0 # Fix the compile time RNG seed
           RUSTFLAGS: "-Cprofile-use=${{ github.workspace }}/merged.profdata"
diff --git a/Cargo.toml b/Cargo.toml
index 66a8667e0..9bad92573 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -62,7 +62,9 @@ strip = true
 debug = true
 strip = false
 
-[profile.codspeed]
+# This is separate to benchmarks because `bench` ends up building testing
+# harnesses into code, as it's a special cargo profile.
+[profile.profiling]
 inherits = "release"
 debug = true
 strip = false
diff --git a/Makefile b/Makefile
index e1f0bc607..ba8adca62 100644
--- a/Makefile
+++ b/Makefile
@@ -48,9 +48,9 @@ endif
 build-profiling:
 	@rm -f python/pydantic_core/*.so
 ifneq ($(USE_MATURIN),)
-	CARGO_PROFILE_RELEASE_STRIP=false CARGO_PROFILE_RELEASE_DEBUG=true maturin develop --release
+	maturin develop '--profile profiling'
 else
-	CARGO_PROFILE_RELEASE_STRIP=false CARGO_PROFILE_RELEASE_DEBUG=true pip install -v -e .
+	pip install -v -e . --config-settings=build-args='--profile profiling'
 endif
 
 .PHONY: build-coverage

From 3f7b0b428d692cfedf67c10ef2fa9571a98f6050 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 15 Jan 2024 10:28:42 +0000
Subject: [PATCH 179/550] Bump the python-packages group with 4 updates (#1154)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 6 +++---
 tests/requirements.txt         | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index e1e5e4268..043482646 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,4 +1,4 @@
-griffe==0.38.0
-pyright==1.1.339
-ruff==0.1.7
+griffe==0.38.1
+pyright==1.1.345
+ruff==0.1.13
 mypy==1.8.0
diff --git a/tests/requirements.txt b/tests/requirements.txt
index 4297177d8..29bf5bcad 100644
--- a/tests/requirements.txt
+++ b/tests/requirements.txt
@@ -1,6 +1,6 @@
 coverage==7.4.0
 dirty-equals==0.7.1.post0
-hypothesis==6.92.5
+hypothesis==6.92.9
 # TODO: remove manual override for dateutil once a version newer than 2.8.2 is
 # released which removes use of deprecated utcfromtimestamp
 git+https://github.com/dateutil/dateutil.git@f2293200747fb03d56c6c5997bfebeabe703576f

From a1f6023d0acca9748c4f6120a336cde916d199a6 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 15 Jan 2024 10:28:55 +0000
Subject: [PATCH 180/550] Bump base64 from 0.21.5 to 0.21.7 (#1153)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 2f17cec97..ab1212242 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -32,9 +32,9 @@ checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
 
 [[package]]
 name = "base64"
-version = "0.21.5"
+version = "0.21.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "35636a1494ede3b646cc98f74f8e62c773a38a659ebc777a2cf26b9b74171df9"
+checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
 
 [[package]]
 name = "bitflags"
diff --git a/Cargo.toml b/Cargo.toml
index 9bad92573..905122b1d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -39,7 +39,7 @@ ahash = "0.8.7"
 url = "2.5.0"
 # idna is already required by url, added here to be explicit
 idna = "0.5.0"
-base64 = "0.21.5"
+base64 = "0.21.7"
 num-bigint = "0.4.4"
 python3-dll-a = "0.2.7"
 uuid = "1.6.1"

From 1ff756f03a6e91c6996c98baa3a55111ec536401 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 15 Jan 2024 10:29:08 +0000
Subject: [PATCH 181/550] Bump pyo3 from 0.20.1 to 0.20.2 (#1152)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 20 ++++++++++----------
 Cargo.toml |  4 ++--
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index ab1212242..c80c15e4e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -346,9 +346,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.20.1"
+version = "0.20.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e82ad98ce1991c9c70c3464ba4187337b9c45fcbbb060d46dca15f0c075e14e2"
+checksum = "9a89dc7a5850d0e983be1ec2a463a171d20990487c3cfcd68b5363f1ee3d6fe0"
 dependencies = [
  "cfg-if",
  "indoc",
@@ -364,9 +364,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.20.1"
+version = "0.20.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5503d0b3aee2c7a8dbb389cd87cd9649f675d4c7f60ca33699a3e3859d81a891"
+checksum = "07426f0d8fe5a601f26293f300afd1a7b1ed5e78b2a705870c5f30893c5163be"
 dependencies = [
  "once_cell",
  "python3-dll-a",
@@ -375,9 +375,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.20.1"
+version = "0.20.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "18a79e8d80486a00d11c0dcb27cd2aa17c022cc95c677b461f01797226ba8f41"
+checksum = "dbb7dec17e17766b46bca4f1a4215a85006b4c2ecde122076c562dd058da6cf1"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -385,9 +385,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.20.1"
+version = "0.20.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f4b0dc7eaa578604fab11c8c7ff8934c71249c61d4def8e272c76ed879f03d4"
+checksum = "05f738b4e40d50b5711957f142878cfa0f28e054aa0ebdfc3fd137a843f74ed3"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -397,9 +397,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.20.1"
+version = "0.20.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "816a4f709e29ddab2e3cdfe94600d554c5556cad0ddfeea95c47b580c3247fa4"
+checksum = "0fc910d4851847827daf9d6cdd4a823fbdaab5b8818325c5e97a86da79e8881f"
 dependencies = [
  "heck",
  "proc-macro2",
diff --git a/Cargo.toml b/Cargo.toml
index 905122b1d..0caafc668 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -26,7 +26,7 @@ include = [
 ]
 
 [dependencies]
-pyo3 = { version = "0.20.1", features = ["generate-import-lib", "num-bigint"] }
+pyo3 = { version = "0.20.2", features = ["generate-import-lib", "num-bigint"] }
 regex = "1.10.2"
 strum = { version = "0.25.0", features = ["derive"] }
 strum_macros = "0.25.3"
@@ -70,7 +70,7 @@ debug = true
 strip = false
 
 [dev-dependencies]
-pyo3 = { version = "0.20.1", features = ["auto-initialize"] }
+pyo3 = { version = "0.20.2", features = ["auto-initialize"] }
 
 [build-dependencies]
 version_check = "0.9.4"

From 545f8c3f8c476673e0068c48006509a36539fcb2 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 15 Jan 2024 10:29:23 +0000
Subject: [PATCH 182/550] Bump pyo3-build-config from 0.20.1 to 0.20.2 (#1151)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index 0caafc668..8f31c28b3 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -75,7 +75,7 @@ pyo3 = { version = "0.20.2", features = ["auto-initialize"] }
 [build-dependencies]
 version_check = "0.9.4"
 # used where logic has to be version/distribution specific, e.g. pypy
-pyo3-build-config = { version = "0.20.1" }
+pyo3-build-config = { version = "0.20.2" }
 
 [lints.clippy]
 dbg_macro = "warn"

From 579166767174e267d7b68f3ba01d5d6de0158b10 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 15 Jan 2024 10:29:32 +0000
Subject: [PATCH 183/550] Bump serde from 1.0.193 to 1.0.195 (#1150)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 20 ++++++++++----------
 Cargo.toml |  2 +-
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index c80c15e4e..34b46ee65 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -312,9 +312,9 @@ checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.69"
+version = "1.0.76"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "134c189feb4956b20f6f547d2cf727d4c0fe06722b20a0eec87ed445a97f92da"
+checksum = "95fc56cda0b5c3325f5fbbd7ff9fda9e02bb00bb3dac51252d2f1bfa1cb8cc8c"
 dependencies = [
  "unicode-ident",
 ]
@@ -418,9 +418,9 @@ dependencies = [
 
 [[package]]
 name = "quote"
-version = "1.0.29"
+version = "1.0.35"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "573015e8ab27661678357f27dc26460738fd2b6c86e46f386fde94cb5d913105"
+checksum = "291ec9ab5efd934aaf503a6466c5d5251535d108ee747472c3977cc5acc868ef"
 dependencies = [
  "proc-macro2",
 ]
@@ -483,18 +483,18 @@ checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
 
 [[package]]
 name = "serde"
-version = "1.0.193"
+version = "1.0.195"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "25dd9975e68d0cb5aa1120c288333fc98731bd1dd12f561e468ea4728c042b89"
+checksum = "63261df402c67811e9ac6def069e4786148c4563f4b50fd4bf30aa370d626b02"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.193"
+version = "1.0.195"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43576ca501357b9b071ac53cdc7da8ef0cbd9493d8df094cd821777ea6e894d3"
+checksum = "46fe8f8603d81ba86327b23a2e9cdf49e1255fb94a4c5f297f6ee0547178ea2c"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -559,9 +559,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.38"
+version = "2.0.48"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e96b79aaa137db8f61e26363a0c9b47d8b4ec75da28b7d1d614c2303e232408b"
+checksum = "0f3531638e407dfc0814761abb7c00a5b54992b849452a0646b7f65c9f770f3f"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/Cargo.toml b/Cargo.toml
index 8f31c28b3..283e364f9 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -32,7 +32,7 @@ strum = { version = "0.25.0", features = ["derive"] }
 strum_macros = "0.25.3"
 serde_json = {version = "1.0.109", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.8"
-serde = { version = "1.0.193", features = ["derive"] }
+serde = { version = "1.0.195", features = ["derive"] }
 speedate = "0.13.0"
 smallvec = "1.11.2"
 ahash = "0.8.7"

From 5d3aa43f4b5421648d657cd316b6c237cc435ea1 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Mon, 15 Jan 2024 10:55:33 +0000
Subject: [PATCH 184/550] correct build-profiling make command (#1160)

---
 Makefile | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Makefile b/Makefile
index ba8adca62..8fbe91389 100644
--- a/Makefile
+++ b/Makefile
@@ -48,7 +48,7 @@ endif
 build-profiling:
 	@rm -f python/pydantic_core/*.so
 ifneq ($(USE_MATURIN),)
-	maturin develop '--profile profiling'
+	maturin develop --profile profiling
 else
 	pip install -v -e . --config-settings=build-args='--profile profiling'
 endif

From d7cf72d8d591632889967b37eb4367f9f9f889e7 Mon Sep 17 00:00:00 2001
From: Samuel Colvin <s@muelcolvin.com>
Date: Mon, 15 Jan 2024 12:23:05 +0000
Subject: [PATCH 185/550] Int extraction (#1155)

---
 .gitignore                                  |  3 +++
 src/errors/types.rs                         |  2 +-
 src/errors/value_exception.rs               |  2 +-
 src/input/input_python.rs                   | 10 ++++----
 src/input/return_enums.rs                   |  6 ++---
 src/lookup_key.rs                           |  2 +-
 src/serializers/infer.rs                    |  5 +++-
 src/serializers/type_serializers/literal.rs |  4 +--
 src/tools.rs                                | 28 +++++++++++++++------
 tests/benchmarks/test_micro_benchmarks.py   | 12 +++++++++
 tests/validators/test_int.py                | 15 ++++++++---
 11 files changed, 64 insertions(+), 25 deletions(-)

diff --git a/.gitignore b/.gitignore
index 6c9ace5f4..efffcbf69 100644
--- a/.gitignore
+++ b/.gitignore
@@ -36,3 +36,6 @@ node_modules/
 /foobar.py
 /python/pydantic_core/*.so
 /src/self_schema.py
+
+# samply
+/profile.json
diff --git a/src/errors/types.rs b/src/errors/types.rs
index cfa96221e..eddd7dbaa 100644
--- a/src/errors/types.rs
+++ b/src/errors/types.rs
@@ -786,7 +786,7 @@ impl From<Int> for Number {
 
 impl FromPyObject<'_> for Number {
     fn extract(obj: &PyAny) -> PyResult<Self> {
-        if let Ok(int) = extract_i64(obj) {
+        if let Some(int) = extract_i64(obj) {
             Ok(Number::Int(int))
         } else if let Ok(float) = obj.extract::<f64>() {
             Ok(Number::Float(float))
diff --git a/src/errors/value_exception.rs b/src/errors/value_exception.rs
index a88610eef..68f93d463 100644
--- a/src/errors/value_exception.rs
+++ b/src/errors/value_exception.rs
@@ -122,7 +122,7 @@ impl PydanticCustomError {
                 let key: &PyString = key.downcast()?;
                 if let Ok(py_str) = value.downcast::<PyString>() {
                     message = message.replace(&format!("{{{}}}", key.to_str()?), py_str.to_str()?);
-                } else if let Ok(value_int) = extract_i64(value) {
+                } else if let Some(value_int) = extract_i64(value) {
                     message = message.replace(&format!("{{{}}}", key.to_str()?), &value_int.to_string());
                 } else {
                     // fallback for anything else just in case
diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index 5d4d4826c..2eaaebe10 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -96,7 +96,7 @@ impl AsLocItem for PyAny {
     fn as_loc_item(&self) -> LocItem {
         if let Ok(py_str) = self.downcast::<PyString>() {
             py_str.to_string_lossy().as_ref().into()
-        } else if let Ok(key_int) = extract_i64(self) {
+        } else if let Some(key_int) = extract_i64(self) {
             key_int.into()
         } else {
             safe_repr(self).to_string().into()
@@ -292,7 +292,7 @@ impl<'a> Input<'a> for PyAny {
         if !strict {
             if let Some(cow_str) = maybe_as_string(self, ErrorTypeDefaults::BoolParsing)? {
                 return str_as_bool(self, &cow_str).map(ValidationMatch::lax);
-            } else if let Ok(int) = extract_i64(self) {
+            } else if let Some(int) = extract_i64(self) {
                 return int_as_bool(self, int).map(ValidationMatch::lax);
             } else if let Ok(float) = self.extract::<f64>() {
                 if let Ok(int) = float_as_int(self, float) {
@@ -635,7 +635,7 @@ impl<'a> Input<'a> for PyAny {
                     bytes_as_time(self, py_bytes.as_bytes(), microseconds_overflow_behavior)
                 } else if PyBool::is_exact_type_of(self) {
                     Err(ValError::new(ErrorTypeDefaults::TimeType, self))
-                } else if let Ok(int) = extract_i64(self) {
+                } else if let Some(int) = extract_i64(self) {
                     int_as_time(self, int, 0)
                 } else if let Ok(float) = self.extract::<f64>() {
                     float_as_time(self, float)
@@ -669,7 +669,7 @@ impl<'a> Input<'a> for PyAny {
                     bytes_as_datetime(self, py_bytes.as_bytes(), microseconds_overflow_behavior)
                 } else if PyBool::is_exact_type_of(self) {
                     Err(ValError::new(ErrorTypeDefaults::DatetimeType, self))
-                } else if let Ok(int) = extract_i64(self) {
+                } else if let Some(int) = extract_i64(self) {
                     int_as_datetime(self, int, 0)
                 } else if let Ok(float) = self.extract::<f64>() {
                     float_as_datetime(self, float)
@@ -706,7 +706,7 @@ impl<'a> Input<'a> for PyAny {
                     bytes_as_timedelta(self, str.as_bytes(), microseconds_overflow_behavior)
                 } else if let Ok(py_bytes) = self.downcast::<PyBytes>() {
                     bytes_as_timedelta(self, py_bytes.as_bytes(), microseconds_overflow_behavior)
-                } else if let Ok(int) = extract_i64(self) {
+                } else if let Some(int) = extract_i64(self) {
                     Ok(int_as_duration(self, int)?.into())
                 } else if let Ok(float) = self.extract::<f64>() {
                     Ok(float_as_duration(self, float)?.into())
diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index fa70880ca..905b895f9 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -23,7 +23,7 @@ use pyo3::PyTypeInfo;
 use serde::{ser::Error, Serialize, Serializer};
 
 use crate::errors::{py_err_string, ErrorType, ErrorTypeDefaults, InputValue, ValError, ValLineError, ValResult};
-use crate::tools::py_err;
+use crate::tools::{extract_i64, py_err};
 use crate::validators::{CombinedValidator, Exactness, ValidationState, Validator};
 
 use super::input_string::StringMapping;
@@ -863,7 +863,7 @@ pub enum EitherInt<'a> {
 impl<'a> EitherInt<'a> {
     pub fn upcast(py_any: &'a PyAny) -> ValResult<Self> {
         // Safety: we know that py_any is a python int
-        if let Ok(int_64) = py_any.extract::<i64>() {
+        if let Some(int_64) = extract_i64(py_any) {
             Ok(Self::I64(int_64))
         } else {
             let big_int: BigInt = py_any.extract()?;
@@ -1021,7 +1021,7 @@ impl<'a> Rem for &'a Int {
 
 impl<'a> FromPyObject<'a> for Int {
     fn extract(obj: &'a PyAny) -> PyResult<Self> {
-        if let Ok(i) = obj.extract::<i64>() {
+        if let Some(i) = extract_i64(obj) {
             Ok(Int::I64(i))
         } else if let Ok(b) = obj.extract::<BigInt>() {
             Ok(Int::Big(b))
diff --git a/src/lookup_key.rs b/src/lookup_key.rs
index e145c1f41..e4d2dcce7 100644
--- a/src/lookup_key.rs
+++ b/src/lookup_key.rs
@@ -429,7 +429,7 @@ impl PathItem {
             } else {
                 Ok(Self::Pos(usize_key))
             }
-        } else if let Ok(int_key) = extract_i64(obj) {
+        } else if let Some(int_key) = extract_i64(obj) {
             if index == 0 {
                 py_err!(PyTypeError; "The first item in an alias path should be a string")
             } else {
diff --git a/src/serializers/infer.rs b/src/serializers/infer.rs
index 13c20062b..e39ca38f8 100644
--- a/src/serializers/infer.rs
+++ b/src/serializers/infer.rs
@@ -123,7 +123,10 @@ pub(crate) fn infer_to_python_known(
             // `bool` and `None` can't be subclasses, `ObType::Int`, `ObType::Float`, `ObType::Str` refer to exact types
             ObType::None | ObType::Bool | ObType::Int | ObType::Str => value.into_py(py),
             // have to do this to make sure subclasses of for example str are upcast to `str`
-            ObType::IntSubclass => extract_i64(value)?.into_py(py),
+            ObType::IntSubclass => match extract_i64(value) {
+                Some(v) => v.into_py(py),
+                None => return py_err!(PyTypeError; "expected int, got {}", safe_repr(value)),
+            },
             ObType::Float | ObType::FloatSubclass => {
                 let v = value.extract::<f64>()?;
                 if (v.is_nan() || v.is_infinite()) && extra.config.inf_nan_mode == InfNanMode::Null {
diff --git a/src/serializers/type_serializers/literal.rs b/src/serializers/type_serializers/literal.rs
index 846b8843f..d6b08afa5 100644
--- a/src/serializers/type_serializers/literal.rs
+++ b/src/serializers/type_serializers/literal.rs
@@ -46,7 +46,7 @@ impl BuildSerializer for LiteralSerializer {
             repr_args.push(item.repr()?.extract()?);
             if let Ok(bool) = item.downcast::<PyBool>() {
                 expected_py.append(bool)?;
-            } else if let Ok(int) = extract_i64(item) {
+            } else if let Some(int) = extract_i64(item) {
                 expected_int.insert(int);
             } else if let Ok(py_str) = item.downcast::<PyString>() {
                 expected_str.insert(py_str.to_str()?.to_string());
@@ -79,7 +79,7 @@ impl LiteralSerializer {
     fn check<'a>(&self, value: &'a PyAny, extra: &Extra) -> PyResult<OutputValue<'a>> {
         if extra.check.enabled() {
             if !self.expected_int.is_empty() && !PyBool::is_type_of(value) {
-                if let Ok(int) = extract_i64(value) {
+                if let Some(int) = extract_i64(value) {
                     if self.expected_int.contains(&int) {
                         return Ok(OutputValue::OkInt(int));
                     }
diff --git a/src/tools.rs b/src/tools.rs
index af58131f5..bdc41583c 100644
--- a/src/tools.rs
+++ b/src/tools.rs
@@ -1,9 +1,9 @@
 use std::borrow::Cow;
 
-use pyo3::exceptions::{PyKeyError, PyTypeError};
+use pyo3::exceptions::PyKeyError;
 use pyo3::prelude::*;
-use pyo3::types::{PyDict, PyInt, PyString};
-use pyo3::{intern, FromPyObject, PyTypeInfo};
+use pyo3::types::{PyDict, PyString};
+use pyo3::{ffi, intern, FromPyObject};
 
 pub trait SchemaDict<'py> {
     fn get_as<T>(&'py self, key: &PyString) -> PyResult<Option<T>>
@@ -99,10 +99,24 @@ pub fn safe_repr(v: &PyAny) -> Cow<str> {
     }
 }
 
-pub fn extract_i64(v: &PyAny) -> PyResult<i64> {
-    if PyInt::is_type_of(v) {
-        v.extract()
+/// Extract an i64 from a python object more quickly, see
+/// https://github.com/PyO3/pyo3/pull/3742#discussion_r1451763928
+#[cfg(not(any(target_pointer_width = "32", windows, PyPy)))]
+pub fn extract_i64(obj: &PyAny) -> Option<i64> {
+    let val = unsafe { ffi::PyLong_AsLong(obj.as_ptr()) };
+    if val == -1 && PyErr::occurred(obj.py()) {
+        unsafe { ffi::PyErr_Clear() };
+        None
     } else {
-        py_err!(PyTypeError; "expected int, got {}", safe_repr(v))
+        Some(val)
+    }
+}
+
+#[cfg(any(target_pointer_width = "32", windows, PyPy))]
+pub fn extract_i64(v: &PyAny) -> Option<i64> {
+    if v.is_instance_of::<pyo3::types::PyInt>() {
+        v.extract().ok()
+    } else {
+        None
     }
 }
diff --git a/tests/benchmarks/test_micro_benchmarks.py b/tests/benchmarks/test_micro_benchmarks.py
index f1ec32eef..c2320427c 100644
--- a/tests/benchmarks/test_micro_benchmarks.py
+++ b/tests/benchmarks/test_micro_benchmarks.py
@@ -1232,6 +1232,18 @@ def test_strict_int(benchmark):
     benchmark(v.validate_python, 42)
 
 
+@pytest.mark.benchmark(group='strict_int')
+def test_strict_int_fails(benchmark):
+    v = SchemaValidator(core_schema.int_schema(strict=True))
+
+    @benchmark
+    def t():
+        try:
+            v.validate_python(())
+        except ValidationError:
+            pass
+
+
 @pytest.mark.benchmark(group='int_range')
 def test_int_range(benchmark):
     v = SchemaValidator(core_schema.int_schema(gt=0, lt=100))
diff --git a/tests/validators/test_int.py b/tests/validators/test_int.py
index 80dd1cf73..35a13f6a7 100644
--- a/tests/validators/test_int.py
+++ b/tests/validators/test_int.py
@@ -29,6 +29,8 @@
         ('123456789123456.00001', Err('Input should be a valid integer, unable to parse string as an integer')),
         (int(1e10), int(1e10)),
         (i64_max, i64_max),
+        (i64_max + 1, i64_max + 1),
+        (i64_max * 2, i64_max * 2),
         pytest.param(
             12.5,
             Err('Input should be a valid integer, got a number with a fractional part [type=int_from_float'),
@@ -106,10 +108,15 @@ def test_int(input_value, expected):
 @pytest.mark.parametrize(
     'input_value,expected',
     [
-        (Decimal('1'), 1),
-        (Decimal('1.0'), 1),
-        (i64_max, i64_max),
-        (i64_max + 1, i64_max + 1),
+        pytest.param(Decimal('1'), 1),
+        pytest.param(Decimal('1.0'), 1),
+        pytest.param(i64_max, i64_max, id='i64_max'),
+        pytest.param(i64_max + 1, i64_max + 1, id='i64_max+1'),
+        pytest.param(
+            -1,
+            Err('Input should be greater than 0 [type=greater_than, input_value=-1, input_type=int]'),
+            id='-1',
+        ),
         (
             -i64_max + 1,
             Err('Input should be greater than 0 [type=greater_than, input_value=-9223372036854775806, input_type=int]'),

From e1cb0ebe5633fee835cd149768ebf43adfde4f6b Mon Sep 17 00:00:00 2001
From: Samuel Colvin <s@muelcolvin.com>
Date: Mon, 15 Jan 2024 16:26:37 +0000
Subject: [PATCH 186/550] improve performance of recursion guard (#1156)

Co-authored-by: David Hewitt <mail@davidhewitt.dev>
Co-authored-by: David Hewitt <david.hewitt@pydantic.dev>
---
 src/recursion_guard.rs        | 144 ++++++++++++++++++++++++++++------
 src/serializers/extra.rs      |  14 ++--
 src/validators/definitions.rs |  16 ++--
 tests/serializers/test_any.py |   2 +-
 4 files changed, 134 insertions(+), 42 deletions(-)

diff --git a/src/recursion_guard.rs b/src/recursion_guard.rs
index 453f01a1d..fe5b1bcdd 100644
--- a/src/recursion_guard.rs
+++ b/src/recursion_guard.rs
@@ -1,4 +1,5 @@
 use ahash::AHashSet;
+use std::mem::MaybeUninit;
 
 type RecursionKey = (
     // Identifier for the input object, e.g. the id() of a Python dict
@@ -13,56 +14,147 @@ type RecursionKey = (
 /// It's used in `validators/definition` to detect when a reference is reused within itself.
 #[derive(Debug, Clone, Default)]
 pub struct RecursionGuard {
-    ids: Option<AHashSet<RecursionKey>>,
+    ids: RecursionStack,
     // depth could be a hashmap {validator_id => depth} but for simplicity and performance it's easier to just
     // use one number for all validators
-    depth: u16,
+    depth: u8,
 }
 
 // A hard limit to avoid stack overflows when rampant recursion occurs
-pub const RECURSION_GUARD_LIMIT: u16 = if cfg!(any(target_family = "wasm", all(windows, PyPy))) {
+pub const RECURSION_GUARD_LIMIT: u8 = if cfg!(any(target_family = "wasm", all(windows, PyPy))) {
     // wasm and windows PyPy have very limited stack sizes
-    50
+    49
 } else if cfg!(any(PyPy, windows)) {
     // PyPy and Windows in general have more restricted stack space
-    100
+    99
 } else {
     255
 };
 
 impl RecursionGuard {
-    // insert a new id into the set, return whether the set already had the id in it
-    pub fn contains_or_insert(&mut self, obj_id: usize, node_id: usize) -> bool {
-        match self.ids {
-            // https://doc.rust-lang.org/std/collections/struct.HashSet.html#method.insert
-            // "If the set did not have this value present, `true` is returned."
-            Some(ref mut set) => !set.insert((obj_id, node_id)),
-            None => {
-                let mut set: AHashSet<RecursionKey> = AHashSet::with_capacity(10);
-                set.insert((obj_id, node_id));
-                self.ids = Some(set);
-                false
-            }
-        }
+    // insert a new value
+    // * return `false` if the stack already had it in it
+    // * return `true` if the stack didn't have it in it and it was inserted
+    pub fn insert(&mut self, obj_id: usize, node_id: usize) -> bool {
+        self.ids.insert((obj_id, node_id))
     }
 
     // see #143 this is used as a backup in case the identity check recursion guard fails
     #[must_use]
+    #[cfg(any(target_family = "wasm", windows, PyPy))]
     pub fn incr_depth(&mut self) -> bool {
-        self.depth += 1;
-        self.depth >= RECURSION_GUARD_LIMIT
+        // use saturating_add as it's faster (since there's no error path)
+        // and the RECURSION_GUARD_LIMIT check will be hit before it overflows
+        debug_assert!(RECURSION_GUARD_LIMIT < 255);
+        self.depth = self.depth.saturating_add(1);
+        self.depth > RECURSION_GUARD_LIMIT
+    }
+
+    #[must_use]
+    #[cfg(not(any(target_family = "wasm", windows, PyPy)))]
+    pub fn incr_depth(&mut self) -> bool {
+        debug_assert_eq!(RECURSION_GUARD_LIMIT, 255);
+        // use checked_add to check if we've hit the limit
+        if let Some(depth) = self.depth.checked_add(1) {
+            self.depth = depth;
+            false
+        } else {
+            true
+        }
     }
 
     pub fn decr_depth(&mut self) {
-        self.depth -= 1;
+        // for the same reason as incr_depth, use saturating_sub
+        self.depth = self.depth.saturating_sub(1);
     }
 
     pub fn remove(&mut self, obj_id: usize, node_id: usize) {
-        match self.ids {
-            Some(ref mut set) => {
-                set.remove(&(obj_id, node_id));
+        self.ids.remove(&(obj_id, node_id));
+    }
+}
+
+// trial and error suggests this is a good value, going higher causes array lookups to get significantly slower
+const ARRAY_SIZE: usize = 16;
+
+#[derive(Debug, Clone)]
+enum RecursionStack {
+    Array {
+        data: [MaybeUninit<RecursionKey>; ARRAY_SIZE],
+        len: usize,
+    },
+    Set(AHashSet<RecursionKey>),
+}
+
+impl Default for RecursionStack {
+    fn default() -> Self {
+        Self::Array {
+            data: std::array::from_fn(|_| MaybeUninit::uninit()),
+            len: 0,
+        }
+    }
+}
+
+impl RecursionStack {
+    // insert a new value
+    // * return `false` if the stack already had it in it
+    // * return `true` if the stack didn't have it in it and it was inserted
+    pub fn insert(&mut self, v: RecursionKey) -> bool {
+        match self {
+            Self::Array { data, len } => {
+                if *len < ARRAY_SIZE {
+                    for value in data.iter().take(*len) {
+                        // Safety: reading values within bounds
+                        if unsafe { value.assume_init() } == v {
+                            return false;
+                        }
+                    }
+
+                    data[*len].write(v);
+                    *len += 1;
+                    true
+                } else {
+                    let mut set = AHashSet::with_capacity(ARRAY_SIZE + 1);
+                    for existing in data.iter() {
+                        // Safety: the array is fully initialized
+                        set.insert(unsafe { existing.assume_init() });
+                    }
+                    let inserted = set.insert(v);
+                    *self = Self::Set(set);
+                    inserted
+                }
+            }
+            // https://doc.rust-lang.org/std/collections/struct.HashSet.html#method.insert
+            // "If the set did not have this value present, `true` is returned."
+            Self::Set(set) => set.insert(v),
+        }
+    }
+
+    pub fn remove(&mut self, v: &RecursionKey) {
+        match self {
+            Self::Array { data, len } => {
+                *len = len.checked_sub(1).expect("remove from empty recursion guard");
+                // Safety: this is reading what was the back of the initialized array
+                let removed = unsafe { data.get_unchecked_mut(*len) };
+                assert!(unsafe { removed.assume_init_ref() } == v, "remove did not match insert");
+                // this should compile away to a noop
+                unsafe { std::ptr::drop_in_place(removed.as_mut_ptr()) }
+            }
+            Self::Set(set) => {
+                set.remove(v);
+            }
+        }
+    }
+}
+
+impl Drop for RecursionStack {
+    fn drop(&mut self) {
+        // This should compile away to a noop as Recursion>Key doesn't implement Drop, but it seemed
+        // desirable to leave this in for safety in case that should change in the future
+        if let Self::Array { data, len } = self {
+            for value in data.iter_mut().take(*len) {
+                // Safety: reading values within bounds
+                unsafe { std::ptr::drop_in_place(value.as_mut_ptr()) };
             }
-            None => unreachable!(),
-        };
+        }
     }
 }
diff --git a/src/serializers/extra.rs b/src/serializers/extra.rs
index 37307055e..b3978613a 100644
--- a/src/serializers/extra.rs
+++ b/src/serializers/extra.rs
@@ -346,17 +346,17 @@ pub struct SerRecursionGuard {
 
 impl SerRecursionGuard {
     pub fn add(&self, value: &PyAny, def_ref_id: usize) -> PyResult<usize> {
-        // https://doc.rust-lang.org/std/collections/struct.HashSet.html#method.insert
-        // "If the set did not have this value present, `true` is returned."
         let id = value.as_ptr() as usize;
         let mut guard = self.guard.borrow_mut();
 
-        if guard.contains_or_insert(id, def_ref_id) {
-            Err(PyValueError::new_err("Circular reference detected (id repeated)"))
-        } else if guard.incr_depth() {
-            Err(PyValueError::new_err("Circular reference detected (depth exceeded)"))
+        if guard.insert(id, def_ref_id) {
+            if guard.incr_depth() {
+                Err(PyValueError::new_err("Circular reference detected (depth exceeded)"))
+            } else {
+                Ok(id)
+            }
         } else {
-            Ok(id)
+            Err(PyValueError::new_err("Circular reference detected (id repeated)"))
         }
     }
 
diff --git a/src/validators/definitions.rs b/src/validators/definitions.rs
index 0b5f78c10..e8c67a690 100644
--- a/src/validators/definitions.rs
+++ b/src/validators/definitions.rs
@@ -76,10 +76,7 @@ impl Validator for DefinitionRefValidator {
         self.definition.read(|validator| {
             let validator = validator.unwrap();
             if let Some(id) = input.identity() {
-                if state.recursion_guard.contains_or_insert(id, self.definition.id()) {
-                    // we don't remove id here, we leave that to the validator which originally added id to `recursion_guard`
-                    Err(ValError::new(ErrorTypeDefaults::RecursionLoop, input))
-                } else {
+                if state.recursion_guard.insert(id, self.definition.id()) {
                     if state.recursion_guard.incr_depth() {
                         return Err(ValError::new(ErrorTypeDefaults::RecursionLoop, input));
                     }
@@ -87,6 +84,9 @@ impl Validator for DefinitionRefValidator {
                     state.recursion_guard.remove(id, self.definition.id());
                     state.recursion_guard.decr_depth();
                     output
+                } else {
+                    // we don't remove id here, we leave that to the validator which originally added id to `recursion_guard`
+                    Err(ValError::new(ErrorTypeDefaults::RecursionLoop, input))
                 }
             } else {
                 validator.validate(py, input, state)
@@ -105,10 +105,7 @@ impl Validator for DefinitionRefValidator {
         self.definition.read(|validator| {
             let validator = validator.unwrap();
             if let Some(id) = obj.identity() {
-                if state.recursion_guard.contains_or_insert(id, self.definition.id()) {
-                    // we don't remove id here, we leave that to the validator which originally added id to `recursion_guard`
-                    Err(ValError::new(ErrorTypeDefaults::RecursionLoop, obj))
-                } else {
+                if state.recursion_guard.insert(id, self.definition.id()) {
                     if state.recursion_guard.incr_depth() {
                         return Err(ValError::new(ErrorTypeDefaults::RecursionLoop, obj));
                     }
@@ -116,6 +113,9 @@ impl Validator for DefinitionRefValidator {
                     state.recursion_guard.remove(id, self.definition.id());
                     state.recursion_guard.decr_depth();
                     output
+                } else {
+                    // we don't remove id here, we leave that to the validator which originally added id to `recursion_guard`
+                    Err(ValError::new(ErrorTypeDefaults::RecursionLoop, obj))
                 }
             } else {
                 validator.validate_assignment(py, obj, field_name, field_value, state)
diff --git a/tests/serializers/test_any.py b/tests/serializers/test_any.py
index 98ec22c1f..fa6e702fe 100644
--- a/tests/serializers/test_any.py
+++ b/tests/serializers/test_any.py
@@ -371,7 +371,7 @@ def fallback_func(obj):
     f = FoobarCount(0)
     v = 0
     # when recursion is detected and we're in mode python, we just return the value
-    expected_visits = pydantic_core._pydantic_core._recursion_limit - 1
+    expected_visits = pydantic_core._pydantic_core._recursion_limit
     assert any_serializer.to_python(f, fallback=fallback_func) == HasRepr(f'<FoobarCount {expected_visits} repr>')
 
     with pytest.raises(ValueError, match=r'Circular reference detected \(depth exceeded\)'):

From 5a1385b86e28f6c3e30cf4a22a2b173a2ecb4742 Mon Sep 17 00:00:00 2001
From: Samuel Colvin <s@muelcolvin.com>
Date: Tue, 16 Jan 2024 19:13:46 +0000
Subject: [PATCH 187/550] dataclass serialization speedups (#1162)

---
 src/serializers/fields.rs                     | 257 +++++++++++-------
 src/serializers/infer.rs                      | 130 +++++----
 src/serializers/shared.rs                     |  42 +--
 src/serializers/type_serializers/dataclass.rs |  74 +++--
 tests/benchmarks/test_serialization_micro.py  |  46 ++++
 5 files changed, 362 insertions(+), 187 deletions(-)

diff --git a/src/serializers/fields.rs b/src/serializers/fields.rs
index f48f8e0b9..cefdec1d7 100644
--- a/src/serializers/fields.rs
+++ b/src/serializers/fields.rs
@@ -100,6 +100,15 @@ pub struct GeneralFieldsSerializer {
     required_fields: usize,
 }
 
+macro_rules! option_length {
+    ($op_has_len:expr) => {
+        match $op_has_len {
+            Some(ref has_len) => has_len.len(),
+            None => 0,
+        }
+    };
+}
+
 impl GeneralFieldsSerializer {
     pub(super) fn new(
         fields: AHashMap<String, SerField>,
@@ -136,50 +145,21 @@ impl GeneralFieldsSerializer {
             }
         }
     }
-}
-
-macro_rules! option_length {
-    ($op_has_len:expr) => {
-        match $op_has_len {
-            Some(ref has_len) => has_len.len(),
-            None => 0,
-        }
-    };
-}
 
-impl_py_gc_traverse!(GeneralFieldsSerializer {
-    fields,
-    computed_fields
-});
-
-impl TypeSerializer for GeneralFieldsSerializer {
-    fn to_python(
+    pub fn main_to_python<'py>(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
-        extra: &Extra,
-    ) -> PyResult<PyObject> {
-        let py = value.py();
-        // If there is already a model registered (from a dataclass, BaseModel)
-        // then do not touch it
-        // If there is no model, we (a TypedDict) are the model
-        let td_extra = Extra {
-            model: extra.model.map_or_else(|| Some(value), Some),
-            ..*extra
-        };
-        let (main_dict, extra_dict) = if let Some(main_extra_dict) = self.extract_dicts(value) {
-            main_extra_dict
-        } else {
-            td_extra.warnings.on_fallback_py(self.get_name(), value, &td_extra)?;
-            return infer_to_python(value, include, exclude, &td_extra);
-        };
-
+        py: Python<'py>,
+        main_iter: impl Iterator<Item = PyResult<(&'py PyAny, &'py PyAny)>>,
+        include: Option<&'py PyAny>,
+        exclude: Option<&'py PyAny>,
+        extra: Extra,
+    ) -> PyResult<&'py PyDict> {
         let output_dict = PyDict::new(py);
         let mut used_req_fields: usize = 0;
 
         // NOTE! we maintain the order of the input dict assuming that's right
-        for (key, value) in main_dict {
+        for result in main_iter {
+            let (key, value) = result?;
             let key_str = key_str(key)?;
             let op_field = self.fields.get(key_str);
             if extra.exclude_none && value.is_none() {
@@ -190,16 +170,16 @@ impl TypeSerializer for GeneralFieldsSerializer {
                 }
                 continue;
             }
-            let extra = Extra {
+            let field_extra = Extra {
                 field_name: Some(key_str),
-                ..td_extra
+                ..extra
             };
             if let Some((next_include, next_exclude)) = self.filter.key_filter(key, include, exclude)? {
                 if let Some(field) = op_field {
                     if let Some(ref serializer) = field.serializer {
-                        if !exclude_default(value, &extra, serializer)? {
-                            let value = serializer.to_python(value, next_include, next_exclude, &extra)?;
-                            let output_key = field.get_key_py(output_dict.py(), &extra);
+                        if !exclude_default(value, &field_extra, serializer)? {
+                            let value = serializer.to_python(value, next_include, next_exclude, &field_extra)?;
+                            let output_key = field.get_key_py(output_dict.py(), &field_extra);
                             output_dict.set_item(output_key, value)?;
                         }
                     }
@@ -209,23 +189,140 @@ impl TypeSerializer for GeneralFieldsSerializer {
                     }
                 } else if self.mode == FieldsMode::TypedDictAllow {
                     let value = match &self.extra_serializer {
-                        Some(serializer) => serializer.to_python(value, next_include, next_exclude, &extra)?,
-                        None => infer_to_python(value, next_include, next_exclude, &extra)?,
+                        Some(serializer) => serializer.to_python(value, next_include, next_exclude, &field_extra)?,
+                        None => infer_to_python(value, next_include, next_exclude, &field_extra)?,
                     };
                     output_dict.set_item(key, value)?;
-                } else if extra.check == SerCheck::Strict {
+                } else if field_extra.check == SerCheck::Strict {
                     return Err(PydanticSerializationUnexpectedValue::new_err(None));
                 }
             }
         }
-        if td_extra.check.enabled()
+
+        if extra.check.enabled()
             // If any of these are true we can't count fields
             && !(extra.exclude_defaults || extra.exclude_unset || extra.exclude_none)
             // Check for missing fields, we can't have extra fields here
             && self.required_fields > used_req_fields
         {
-            return Err(PydanticSerializationUnexpectedValue::new_err(None));
+            Err(PydanticSerializationUnexpectedValue::new_err(None))
+        } else {
+            Ok(output_dict)
+        }
+    }
+
+    pub fn main_serde_serialize<'py, S: serde::ser::Serializer>(
+        &self,
+        main_iter: impl Iterator<Item = PyResult<(&'py PyAny, &'py PyAny)>>,
+        expected_len: usize,
+        serializer: S,
+        include: Option<&'py PyAny>,
+        exclude: Option<&'py PyAny>,
+        extra: Extra,
+    ) -> Result<S::SerializeMap, S::Error> {
+        // NOTE! As above, we maintain the order of the input dict assuming that's right
+        // we don't both with `used_fields` here because on unions, `to_python(..., mode='json')` is used
+        let mut map = serializer.serialize_map(Some(expected_len))?;
+
+        for result in main_iter {
+            let (key, value) = result.map_err(py_err_se_err)?;
+            if extra.exclude_none && value.is_none() {
+                continue;
+            }
+            let key_str = key_str(key).map_err(py_err_se_err)?;
+            let field_extra = Extra {
+                field_name: Some(key_str),
+                ..extra
+            };
+
+            let filter = self.filter.key_filter(key, include, exclude).map_err(py_err_se_err)?;
+            if let Some((next_include, next_exclude)) = filter {
+                if let Some(field) = self.fields.get(key_str) {
+                    if let Some(ref serializer) = field.serializer {
+                        if !exclude_default(value, &field_extra, serializer).map_err(py_err_se_err)? {
+                            let s =
+                                PydanticSerializer::new(value, serializer, next_include, next_exclude, &field_extra);
+                            let output_key = field.get_key_json(key_str, &field_extra);
+                            map.serialize_entry(&output_key, &s)?;
+                        }
+                    }
+                } else if self.mode == FieldsMode::TypedDictAllow {
+                    let output_key = infer_json_key(key, &field_extra).map_err(py_err_se_err)?;
+                    let s = SerializeInfer::new(value, next_include, next_exclude, &field_extra);
+                    map.serialize_entry(&output_key, &s)?;
+                }
+                // no error case here since unions (which need the error case) use `to_python(..., mode='json')`
+            }
         }
+        Ok(map)
+    }
+
+    pub fn add_computed_fields_python(
+        &self,
+        model: Option<&PyAny>,
+        output_dict: &PyDict,
+        include: Option<&PyAny>,
+        exclude: Option<&PyAny>,
+        extra: &Extra,
+    ) -> PyResult<()> {
+        if let Some(ref computed_fields) = self.computed_fields {
+            if let Some(model_value) = model {
+                let cf_extra = Extra { model, ..*extra };
+                computed_fields.to_python(model_value, output_dict, &self.filter, include, exclude, &cf_extra)?;
+            }
+        }
+        Ok(())
+    }
+
+    pub fn add_computed_fields_json<S: serde::ser::Serializer>(
+        &self,
+        model: Option<&PyAny>,
+        map: &mut S::SerializeMap,
+        include: Option<&PyAny>,
+        exclude: Option<&PyAny>,
+        extra: &Extra,
+    ) -> Result<(), S::Error> {
+        if let Some(ref computed_fields) = self.computed_fields {
+            if let Some(model) = model {
+                computed_fields.serde_serialize::<S>(model, map, &self.filter, include, exclude, extra)?;
+            }
+        }
+        Ok(())
+    }
+
+    pub fn computed_field_count(&self) -> usize {
+        option_length!(self.computed_fields)
+    }
+}
+
+impl_py_gc_traverse!(GeneralFieldsSerializer {
+    fields,
+    computed_fields
+});
+
+impl TypeSerializer for GeneralFieldsSerializer {
+    fn to_python(
+        &self,
+        value: &PyAny,
+        include: Option<&PyAny>,
+        exclude: Option<&PyAny>,
+        extra: &Extra,
+    ) -> PyResult<PyObject> {
+        let py = value.py();
+        // If there is already a model registered (from a dataclass, BaseModel)
+        // then do not touch it
+        // If there is no model, we (a TypedDict) are the model
+        let model = extra.model.map_or_else(|| Some(value), Some);
+        let td_extra = Extra { model, ..*extra };
+        let (main_dict, extra_dict) = if let Some(main_extra_dict) = self.extract_dicts(value) {
+            main_extra_dict
+        } else {
+            td_extra.warnings.on_fallback_py(self.get_name(), value, &td_extra)?;
+            return infer_to_python(value, include, exclude, &td_extra);
+        };
+
+        let output_dict = self.main_to_python(py, main_dict.iter().map(Ok), include, exclude, td_extra)?;
+
         // this is used to include `__pydantic_extra__` in serialization on models
         if let Some(extra_dict) = extra_dict {
             for (key, value) in extra_dict {
@@ -241,11 +338,7 @@ impl TypeSerializer for GeneralFieldsSerializer {
                 }
             }
         }
-        if let Some(ref computed_fields) = self.computed_fields {
-            if let Some(model) = td_extra.model {
-                computed_fields.to_python(model, output_dict, &self.filter, include, exclude, &td_extra)?;
-            }
-        }
+        self.add_computed_fields_python(model, output_dict, include, exclude, extra)?;
         Ok(output_dict.into_py(py))
     }
 
@@ -271,46 +364,23 @@ impl TypeSerializer for GeneralFieldsSerializer {
         // If there is already a model registered (from a dataclass, BaseModel)
         // then do not touch it
         // If there is no model, we (a TypedDict) are the model
-        let td_extra = Extra {
-            model: extra.model.map_or_else(|| Some(value), Some),
-            ..*extra
-        };
+        let model = extra.model.map_or_else(|| Some(value), Some);
+        let td_extra = Extra { model, ..*extra };
         let expected_len = match self.mode {
-            FieldsMode::TypedDictAllow => main_dict.len() + option_length!(self.computed_fields),
-            _ => self.fields.len() + option_length!(extra_dict) + option_length!(self.computed_fields),
+            FieldsMode::TypedDictAllow => main_dict.len() + self.computed_field_count(),
+            _ => self.fields.len() + option_length!(extra_dict) + self.computed_field_count(),
         };
         // NOTE! As above, we maintain the order of the input dict assuming that's right
         // we don't both with `used_fields` here because on unions, `to_python(..., mode='json')` is used
-        let mut map = serializer.serialize_map(Some(expected_len))?;
-
-        for (key, value) in main_dict {
-            if extra.exclude_none && value.is_none() {
-                continue;
-            }
-            let key_str = key_str(key).map_err(py_err_se_err)?;
-            let extra = Extra {
-                field_name: Some(key_str),
-                ..td_extra
-            };
+        let mut map = self.main_serde_serialize(
+            main_dict.iter().map(Ok),
+            expected_len,
+            serializer,
+            include,
+            exclude,
+            td_extra,
+        )?;
 
-            let filter = self.filter.key_filter(key, include, exclude).map_err(py_err_se_err)?;
-            if let Some((next_include, next_exclude)) = filter {
-                if let Some(field) = self.fields.get(key_str) {
-                    if let Some(ref serializer) = field.serializer {
-                        if !exclude_default(value, &extra, serializer).map_err(py_err_se_err)? {
-                            let s = PydanticSerializer::new(value, serializer, next_include, next_exclude, &extra);
-                            let output_key = field.get_key_json(key_str, &extra);
-                            map.serialize_entry(&output_key, &s)?;
-                        }
-                    }
-                } else if self.mode == FieldsMode::TypedDictAllow {
-                    let output_key = infer_json_key(key, &extra).map_err(py_err_se_err)?;
-                    let s = SerializeInfer::new(value, next_include, next_exclude, &extra);
-                    map.serialize_entry(&output_key, &s)?;
-                }
-                // no error case here since unions (which need the error case) use `to_python(..., mode='json')`
-            }
-        }
         // this is used to include `__pydantic_extra__` in serialization on models
         if let Some(extra_dict) = extra_dict {
             for (key, value) in extra_dict {
@@ -319,17 +389,14 @@ impl TypeSerializer for GeneralFieldsSerializer {
                 }
                 let filter = self.filter.key_filter(key, include, exclude).map_err(py_err_se_err)?;
                 if let Some((next_include, next_exclude)) = filter {
-                    let output_key = infer_json_key(key, &td_extra).map_err(py_err_se_err)?;
-                    let s = SerializeInfer::new(value, next_include, next_exclude, &td_extra);
+                    let output_key = infer_json_key(key, extra).map_err(py_err_se_err)?;
+                    let s = SerializeInfer::new(value, next_include, next_exclude, extra);
                     map.serialize_entry(&output_key, &s)?;
                 }
             }
         }
-        if let Some(ref computed_fields) = self.computed_fields {
-            if let Some(model) = td_extra.model {
-                computed_fields.serde_serialize::<S>(model, &mut map, &self.filter, include, exclude, &td_extra)?;
-            }
-        }
+
+        self.add_computed_fields_json::<S>(model, &mut map, include, exclude, extra)?;
         map.end()
     }
 
diff --git a/src/serializers/infer.rs b/src/serializers/infer.rs
index e39ca38f8..5ddf77597 100644
--- a/src/serializers/infer.rs
+++ b/src/serializers/infer.rs
@@ -10,19 +10,17 @@ use pyo3::types::{
 use serde::ser::{Error, Serialize, SerializeMap, SerializeSeq, Serializer};
 
 use crate::input::{EitherTimedelta, Int};
-use crate::serializers::config::InfNanMode;
-use crate::serializers::errors::SERIALIZATION_ERR_MARKER;
-use crate::serializers::filter::SchemaFilter;
-use crate::serializers::shared::{PydanticSerializer, TypeSerializer};
-use crate::serializers::SchemaSerializer;
 use crate::tools::{extract_i64, py_err, safe_repr};
 use crate::url::{PyMultiHostUrl, PyUrl};
 
+use super::config::InfNanMode;
+use super::errors::SERIALIZATION_ERR_MARKER;
 use super::errors::{py_err_se_err, PydanticSerializationError};
 use super::extra::{Extra, SerMode};
-use super::filter::AnyFilter;
+use super::filter::{AnyFilter, SchemaFilter};
 use super::ob_type::ObType;
-use super::shared::dataclass_to_dict;
+use super::shared::{any_dataclass_iter, PydanticSerializer, TypeSerializer};
+use super::SchemaSerializer;
 
 pub(crate) fn infer_to_python(
     value: &PyAny,
@@ -83,22 +81,6 @@ pub(crate) fn infer_to_python_known(
         }};
     }
 
-    let serialize_dict = |dict: &PyDict| {
-        let new_dict = PyDict::new(py);
-        let filter = AnyFilter::new();
-
-        for (k, v) in dict {
-            let op_next = filter.key_filter(k, include, exclude)?;
-            if let Some((next_include, next_exclude)) = op_next {
-                let k_str = infer_json_key(k, extra)?;
-                let k = PyString::new(py, &k_str);
-                let v = infer_to_python(v, next_include, next_exclude, extra)?;
-                new_dict.set_item(k, v)?;
-            }
-        }
-        Ok::<PyObject, PyErr>(new_dict.into_py(py))
-    };
-
     let serialize_with_serializer = || {
         let py_serializer = value.getattr(intern!(py, "__pydantic_serializer__"))?;
         let serializer: PyRef<SchemaSerializer> = py_serializer.extract()?;
@@ -168,7 +150,12 @@ pub(crate) fn infer_to_python_known(
                 let elements = serialize_seq!(PyFrozenSet);
                 PyList::new(py, elements).into_py(py)
             }
-            ObType::Dict => serialize_dict(value.downcast()?)?,
+            ObType::Dict => {
+                let dict: &PyDict = value.downcast()?;
+                serialize_pairs_python(py, dict.iter().map(Ok), include, exclude, extra, |k| {
+                    Ok(PyString::new(py, &infer_json_key(k, extra)?))
+                })?
+            }
             ObType::Datetime => {
                 let py_dt: &PyDateTime = value.downcast()?;
                 let iso_dt = super::type_serializers::datetime_etc::datetime_to_string(py_dt)?;
@@ -205,7 +192,11 @@ pub(crate) fn infer_to_python_known(
                 uuid.into_py(py)
             }
             ObType::PydanticSerializable => serialize_with_serializer()?,
-            ObType::Dataclass => serialize_dict(dataclass_to_dict(value)?)?,
+            ObType::Dataclass => {
+                serialize_pairs_python(py, any_dataclass_iter(value)?.0, include, exclude, extra, |k| {
+                    Ok(PyString::new(py, &infer_json_key(k, extra)?))
+                })?
+            }
             ObType::Enum => {
                 let v = value.getattr(intern!(py, "value"))?;
                 infer_to_python(v, include, exclude, extra)?.into_py(py)
@@ -256,22 +247,11 @@ pub(crate) fn infer_to_python_known(
                 PyFrozenSet::new(py, &elements)?.into_py(py)
             }
             ObType::Dict => {
-                // different logic for keys from above
                 let dict: &PyDict = value.downcast()?;
-                let new_dict = PyDict::new(py);
-                let filter = AnyFilter::new();
-
-                for (k, v) in dict {
-                    let op_next = filter.key_filter(k, include, exclude)?;
-                    if let Some((next_include, next_exclude)) = op_next {
-                        let v = infer_to_python(v, next_include, next_exclude, extra)?;
-                        new_dict.set_item(k, v)?;
-                    }
-                }
-                new_dict.into_py(py)
+                serialize_pairs_python(py, dict.iter().map(Ok), include, exclude, extra, Ok)?
             }
             ObType::PydanticSerializable => serialize_with_serializer()?,
-            ObType::Dataclass => serialize_dict(dataclass_to_dict(value)?)?,
+            ObType::Dataclass => serialize_pairs_python(py, any_dataclass_iter(value)?.0, include, exclude, extra, Ok)?,
             ObType::Generator => {
                 let iter = super::type_serializers::generator::SerializationIterator::new(
                     value.downcast()?,
@@ -405,23 +385,6 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
         }};
     }
 
-    macro_rules! serialize_dict {
-        ($py_dict:expr) => {{
-            let mut map = serializer.serialize_map(Some($py_dict.len()))?;
-            let filter = AnyFilter::new();
-
-            for (key, value) in $py_dict {
-                let op_next = filter.key_filter(key, include, exclude).map_err(py_err_se_err)?;
-                if let Some((next_include, next_exclude)) = op_next {
-                    let key = infer_json_key(key, extra).map_err(py_err_se_err)?;
-                    let value_serializer = SerializeInfer::new(value, next_include, next_exclude, extra);
-                    map.serialize_entry(&key, &value_serializer)?;
-                }
-            }
-            map.end()
-        }};
-    }
-
     let ser_result = match ob_type {
         ObType::None => serializer.serialize_none(),
         ObType::Int | ObType::IntSubclass => serialize!(Int),
@@ -445,7 +408,10 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
                 .bytes_mode
                 .serialize_bytes(unsafe { py_byte_array.as_bytes() }, serializer)
         }
-        ObType::Dict => serialize_dict!(value.downcast::<PyDict>().map_err(py_err_se_err)?),
+        ObType::Dict => {
+            let dict = value.downcast::<PyDict>().map_err(py_err_se_err)?;
+            serialize_pairs_json(dict.iter().map(Ok), dict.len(), serializer, include, exclude, extra)
+        }
         ObType::List => serialize_seq_filter!(PyList),
         ObType::Tuple => serialize_seq_filter!(PyTuple),
         ObType::Set => serialize_seq!(PySet),
@@ -503,7 +469,10 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
                 PydanticSerializer::new(value, &extracted_serializer.serializer, include, exclude, &extra);
             pydantic_serializer.serialize(serializer)
         }
-        ObType::Dataclass => serialize_dict!(dataclass_to_dict(value).map_err(py_err_se_err)?),
+        ObType::Dataclass => {
+            let (pairs_iter, fields_dict) = any_dataclass_iter(value).map_err(py_err_se_err)?;
+            serialize_pairs_json(pairs_iter, fields_dict.len(), serializer, include, exclude, extra)
+        }
         ObType::Uuid => {
             let py_uuid: &PyAny = value.downcast().map_err(py_err_se_err)?;
             let uuid = super::type_serializers::uuid::uuid_to_string(py_uuid).map_err(py_err_se_err)?;
@@ -672,3 +641,50 @@ pub(crate) fn infer_json_key_known<'py>(ob_type: ObType, key: &'py PyAny, extra:
         }
     }
 }
+
+fn serialize_pairs_python<'py>(
+    py: Python,
+    pairs_iter: impl Iterator<Item = PyResult<(&'py PyAny, &'py PyAny)>>,
+    include: Option<&PyAny>,
+    exclude: Option<&PyAny>,
+    extra: &Extra,
+    key_transform: impl Fn(&'py PyAny) -> PyResult<&'py PyAny>,
+) -> PyResult<PyObject> {
+    let new_dict = PyDict::new(py);
+    let filter = AnyFilter::new();
+
+    for result in pairs_iter {
+        let (k, v) = result?;
+        let op_next = filter.key_filter(k, include, exclude)?;
+        if let Some((next_include, next_exclude)) = op_next {
+            let k = key_transform(k)?;
+            let v = infer_to_python(v, next_include, next_exclude, extra)?;
+            new_dict.set_item(k, v)?;
+        }
+    }
+    Ok(new_dict.into_py(py))
+}
+
+fn serialize_pairs_json<'py, S: Serializer>(
+    pairs_iter: impl Iterator<Item = PyResult<(&'py PyAny, &'py PyAny)>>,
+    iter_size: usize,
+    serializer: S,
+    include: Option<&PyAny>,
+    exclude: Option<&PyAny>,
+    extra: &Extra,
+) -> Result<S::Ok, S::Error> {
+    let mut map = serializer.serialize_map(Some(iter_size))?;
+    let filter = AnyFilter::new();
+
+    for result in pairs_iter {
+        let (key, value) = result.map_err(py_err_se_err)?;
+
+        let op_next = filter.key_filter(key, include, exclude).map_err(py_err_se_err)?;
+        if let Some((next_include, next_exclude)) = op_next {
+            let key = infer_json_key(key, extra).map_err(py_err_se_err)?;
+            let value_serializer = SerializeInfer::new(value, next_include, next_exclude, extra);
+            map.serialize_entry(&key, &value_serializer)?;
+        }
+    }
+    map.end()
+}
diff --git a/src/serializers/shared.rs b/src/serializers/shared.rs
index 11aac037d..7cfe6ce6e 100644
--- a/src/serializers/shared.rs
+++ b/src/serializers/shared.rs
@@ -364,29 +364,33 @@ pub(crate) fn to_json_bytes(
     Ok(bytes)
 }
 
+pub(super) fn any_dataclass_iter<'py>(
+    dataclass: &'py PyAny,
+) -> PyResult<(impl Iterator<Item = PyResult<(&'py PyAny, &'py PyAny)>> + 'py, &PyDict)> {
+    let py = dataclass.py();
+    let fields: &PyDict = dataclass.getattr(intern!(py, "__dataclass_fields__"))?.downcast()?;
+    let field_type_marker = get_field_marker(py)?;
+
+    let next = move |(field_name, field): (&'py PyAny, &'py PyAny)| -> PyResult<Option<(&'py PyAny, &'py PyAny)>> {
+        let field_type = field.getattr(intern!(py, "_field_type"))?;
+        if field_type.is(field_type_marker) {
+            let field_name: &PyString = field_name.downcast()?;
+            let value = dataclass.getattr(field_name)?;
+            Ok(Some((field_name, value)))
+        } else {
+            Ok(None)
+        }
+    };
+
+    Ok((fields.iter().filter_map(move |field| next(field).transpose()), fields))
+}
+
 static DC_FIELD_MARKER: GILOnceCell<PyObject> = GILOnceCell::new();
 
 /// needed to match the logic from dataclasses.fields `tuple(f for f in fields.values() if f._field_type is _FIELD)`
-pub(super) fn get_field_marker(py: Python<'_>) -> PyResult<&PyAny> {
+fn get_field_marker(py: Python<'_>) -> PyResult<&PyAny> {
     let field_type_marker_obj = DC_FIELD_MARKER.get_or_try_init(py, || {
-        let field_ = py.import("dataclasses")?.getattr("_FIELD")?;
-        Ok::<PyObject, PyErr>(field_.into_py(py))
+        py.import("dataclasses")?.getattr("_FIELD").map(|f| f.into_py(py))
     })?;
     Ok(field_type_marker_obj.as_ref(py))
 }
-
-pub(super) fn dataclass_to_dict(dc: &PyAny) -> PyResult<&PyDict> {
-    let py = dc.py();
-    let dc_fields: &PyDict = dc.getattr(intern!(py, "__dataclass_fields__"))?.downcast()?;
-    let dict = PyDict::new(py);
-
-    let field_type_marker = get_field_marker(py)?;
-    for (field_name, field) in dc_fields {
-        let field_type = field.getattr(intern!(py, "_field_type"))?;
-        if field_type.is(field_type_marker) {
-            let field_name: &PyString = field_name.downcast()?;
-            dict.set_item(field_name, dc.getattr(field_name)?)?;
-        }
-    }
-    Ok(dict)
-}
diff --git a/src/serializers/type_serializers/dataclass.rs b/src/serializers/type_serializers/dataclass.rs
index a82643186..93548bcba 100644
--- a/src/serializers/type_serializers/dataclass.rs
+++ b/src/serializers/type_serializers/dataclass.rs
@@ -4,6 +4,7 @@ use pyo3::types::{PyDict, PyList, PyString, PyType};
 use std::borrow::Cow;
 
 use ahash::AHashMap;
+use serde::ser::SerializeMap;
 
 use crate::build_tools::{py_schema_error_type, ExtraBehavior};
 use crate::definitions::DefinitionsBuilder;
@@ -131,16 +132,30 @@ impl TypeSerializer for DataclassSerializer {
         exclude: Option<&PyAny>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
-        let extra = Extra {
+        let dc_extra = Extra {
             model: Some(value),
             ..*extra
         };
-        if self.allow_value(value, &extra)? {
-            let inner_value = self.get_inner_value(value)?;
-            self.serializer.to_python(inner_value, include, exclude, &extra)
+        if self.allow_value(value, extra)? {
+            let py = value.py();
+            if let CombinedSerializer::Fields(ref fields_serializer) = *self.serializer {
+                let output_dict = fields_serializer.main_to_python(
+                    py,
+                    known_dataclass_iter(&self.fields, value),
+                    include,
+                    exclude,
+                    dc_extra,
+                )?;
+
+                fields_serializer.add_computed_fields_python(Some(value), output_dict, include, exclude, extra)?;
+                Ok(output_dict.into_py(py))
+            } else {
+                let inner_value = self.get_inner_value(value)?;
+                self.serializer.to_python(inner_value, include, exclude, &dc_extra)
+            }
         } else {
-            extra.warnings.on_fallback_py(self.get_name(), value, &extra)?;
-            infer_to_python(value, include, exclude, &extra)
+            extra.warnings.on_fallback_py(self.get_name(), value, &dc_extra)?;
+            infer_to_python(value, include, exclude, &dc_extra)
         }
     }
 
@@ -161,17 +176,29 @@ impl TypeSerializer for DataclassSerializer {
         exclude: Option<&PyAny>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
-        let extra = Extra {
-            model: Some(value),
-            ..*extra
-        };
-        if self.allow_value(value, &extra).map_err(py_err_se_err)? {
-            let inner_value = self.get_inner_value(value).map_err(py_err_se_err)?;
-            self.serializer
-                .serde_serialize(inner_value, serializer, include, exclude, &extra)
+        let model = Some(value);
+        let dc_extra = Extra { model, ..*extra };
+        if self.allow_value(value, extra).map_err(py_err_se_err)? {
+            if let CombinedSerializer::Fields(ref fields_serializer) = *self.serializer {
+                let expected_len = self.fields.len() + fields_serializer.computed_field_count();
+                let mut map = fields_serializer.main_serde_serialize(
+                    known_dataclass_iter(&self.fields, value),
+                    expected_len,
+                    serializer,
+                    include,
+                    exclude,
+                    dc_extra,
+                )?;
+                fields_serializer.add_computed_fields_json::<S>(model, &mut map, include, exclude, extra)?;
+                map.end()
+            } else {
+                let inner_value = self.get_inner_value(value).map_err(py_err_se_err)?;
+                self.serializer
+                    .serde_serialize(inner_value, serializer, include, exclude, extra)
+            }
         } else {
-            extra.warnings.on_fallback_ser::<S>(self.get_name(), value, &extra)?;
-            infer_serialize(value, serializer, include, exclude, &extra)
+            extra.warnings.on_fallback_ser::<S>(self.get_name(), value, extra)?;
+            infer_serialize(value, serializer, include, exclude, extra)
         }
     }
 
@@ -183,3 +210,18 @@ impl TypeSerializer for DataclassSerializer {
         true
     }
 }
+
+fn known_dataclass_iter<'a, 'py>(
+    fields: &'a [Py<PyString>],
+    dataclass: &'py PyAny,
+) -> impl Iterator<Item = PyResult<(&'py PyAny, &'py PyAny)>> + 'a
+where
+    'py: 'a,
+{
+    let py = dataclass.py();
+    fields.iter().map(move |field| {
+        let field_ref = field.clone_ref(py).into_ref(py);
+        let value = dataclass.getattr(field_ref)?;
+        Ok((field_ref as &PyAny, value))
+    })
+}
diff --git a/tests/benchmarks/test_serialization_micro.py b/tests/benchmarks/test_serialization_micro.py
index 9200fc24b..96170b5eb 100644
--- a/tests/benchmarks/test_serialization_micro.py
+++ b/tests/benchmarks/test_serialization_micro.py
@@ -1,4 +1,5 @@
 import json
+from dataclasses import dataclass
 from datetime import date, datetime
 from uuid import UUID
 
@@ -409,3 +410,48 @@ def test_ser_list_of_lists(benchmark):
     data = [[i + j for j in range(10)] for i in range(1000)]
 
     benchmark(s.to_json, data)
+
+
+@dataclass
+class Foo:
+    a: str
+    b: bytes
+    c: int
+    d: float
+
+
+dataclass_schema = core_schema.dataclass_schema(
+    Foo,
+    core_schema.dataclass_args_schema(
+        'Foo',
+        [
+            core_schema.dataclass_field(name='a', schema=core_schema.str_schema()),
+            core_schema.dataclass_field(name='b', schema=core_schema.bytes_schema()),
+            core_schema.dataclass_field(name='c', schema=core_schema.int_schema()),
+            core_schema.dataclass_field(name='d', schema=core_schema.float_schema()),
+        ],
+    ),
+    ['a', 'b', 'c', 'd'],
+)
+
+
+@pytest.mark.benchmark(group='dataclass-ser')
+def test_dataclass_serialization_python(benchmark):
+    s = SchemaSerializer(dataclass_schema)
+    dc = Foo(a='hello', b=b'more', c=123, d=1.23)
+    assert s.to_python(dc) == {'a': 'hello', 'b': b'more', 'c': 123, 'd': 1.23}
+    benchmark(s.to_python, dc)
+
+
+@pytest.mark.benchmark(group='dataclass-ser')
+def test_dataclass_serialization_json(benchmark):
+    s = SchemaSerializer(dataclass_schema)
+    dc = Foo(a='hello', b=b'more', c=123, d=1.23)
+    assert s.to_python(dc) == {'a': 'hello', 'b': b'more', 'c': 123, 'd': 1.23}
+    benchmark(s.to_json, dc)
+
+
+@pytest.mark.benchmark(group='dataclass-ser')
+def test_dataclass_to_json(benchmark):
+    dc = Foo(a='hello', b=b'more', c=123, d=1.23)
+    benchmark(to_json, dc)

From 29c541917ad31595a938bf4e96654e29b4f50f7f Mon Sep 17 00:00:00 2001
From: David Montague <35119617+dmontagu@users.noreply.github.com>
Date: Wed, 17 Jan 2024 07:27:14 -0700
Subject: [PATCH 188/550] Add support for dataclass fields init (#1163)

Co-authored-by: sydney-runkle <sydneymarierunkle@gmail.com>
Co-authored-by: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Co-authored-by: David Hewitt <david.hewitt@pydantic.dev>
---
 python/pydantic_core/core_schema.py  |   4 +
 src/validators/dataclass.rs          |  19 +++++
 tests/validators/test_dataclasses.py | 121 +++++++++++++++++++++++++++
 3 files changed, 144 insertions(+)

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index 44f58c48a..31bf48782 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -2985,6 +2985,7 @@ class DataclassField(TypedDict, total=False):
     name: Required[str]
     schema: Required[CoreSchema]
     kw_only: bool  # default: True
+    init: bool  # default: True
     init_only: bool  # default: False
     frozen: bool  # default: False
     validation_alias: Union[str, List[Union[str, int]], List[List[Union[str, int]]]]
@@ -2998,6 +2999,7 @@ def dataclass_field(
     schema: CoreSchema,
     *,
     kw_only: bool | None = None,
+    init: bool | None = None,
     init_only: bool | None = None,
     validation_alias: str | list[str | int] | list[list[str | int]] | None = None,
     serialization_alias: str | None = None,
@@ -3023,6 +3025,7 @@ def dataclass_field(
         name: The name to use for the argument parameter
         schema: The schema to use for the argument parameter
         kw_only: Whether the field can be set with a positional argument as well as a keyword argument
+        init: Whether the field should be validated during initialization
         init_only: Whether the field should be omitted  from `__dict__` and passed to `__post_init__`
         validation_alias: The alias(es) to use to find the field in the validation data
         serialization_alias: The alias to use as a key when serializing
@@ -3035,6 +3038,7 @@ def dataclass_field(
         name=name,
         schema=schema,
         kw_only=kw_only,
+        init=init,
         init_only=init_only,
         validation_alias=validation_alias,
         serialization_alias=serialization_alias,
diff --git a/src/validators/dataclass.rs b/src/validators/dataclass.rs
index 986556b66..3161541f0 100644
--- a/src/validators/dataclass.rs
+++ b/src/validators/dataclass.rs
@@ -26,6 +26,7 @@ struct Field {
     kw_only: bool,
     name: String,
     py_name: Py<PyString>,
+    init: bool,
     init_only: bool,
     lookup_key: LookupKey,
     validator: CombinedValidator,
@@ -107,6 +108,7 @@ impl BuildValidator for DataclassArgsValidator {
                 py_name: py_name.into(),
                 lookup_key,
                 validator,
+                init: field.get_as(intern!(py, "init"))?.unwrap_or(true),
                 init_only: field.get_as(intern!(py, "init_only"))?.unwrap_or(false),
                 frozen: field.get_as::<bool>(intern!(py, "frozen"))?.unwrap_or(false),
             });
@@ -176,6 +178,23 @@ impl Validator for DataclassArgsValidator {
                     ($args:ident, $get_method:ident, $get_macro:ident, $slice_macro:ident) => {{
                         // go through fields getting the value from args or kwargs and validating it
                         for (index, field) in self.fields.iter().enumerate() {
+                            if (!field.init) {
+                                match field.validator.default_value(py, Some(field.name.as_str()), state) {
+                                    Ok(Some(value)) => {
+                                        // Default value exists, and passed validation if required
+                                        set_item!(field, value);
+                                    },
+                                    Ok(None) | Err(ValError::Omit) => continue,
+                                    // Note: this will always use the field name even if there is an alias
+                                    // However, we don't mind so much because this error can only happen if the
+                                    // default value fails validation, which is arguably a developer error.
+                                    // We could try to "fix" this in the future if desired.
+                                    Err(ValError::LineErrors(line_errors)) => errors.extend(line_errors),
+                                    Err(err) => return Err(err),
+                                };
+                                continue;
+                            };
+
                             let mut pos_value = None;
                             if let Some(args) = $args.args {
                                 if !field.kw_only {
diff --git a/tests/validators/test_dataclasses.py b/tests/validators/test_dataclasses.py
index 94bf7fd65..a9b367008 100644
--- a/tests/validators/test_dataclasses.py
+++ b/tests/validators/test_dataclasses.py
@@ -1592,3 +1592,124 @@ def _wrap_validator(cls, v, validator, info):
     gc.collect()
 
     assert ref() is None
+
+
+init_test_cases = [
+    ({'a': 'hello', 'b': 'bye'}, 'ignore', {'a': 'hello', 'b': 'HELLO'}),
+    ({'a': 'hello'}, 'ignore', {'a': 'hello', 'b': 'HELLO'}),
+    # note, for the case below, we don't actually support this case in Pydantic
+    # it's disallowed in Pydantic to have a model with extra='allow' and a field
+    # with init=False, so this case isn't really possible at the momment
+    # however, no conflict arises here because we don't pass in the value for b
+    # to __init__
+    ({'a': 'hello'}, 'allow', {'a': 'hello', 'b': 'HELLO'}),
+    (
+        {'a': 'hello', 'b': 'bye'},
+        'forbid',
+        Err(
+            'Unexpected keyword argument',
+            errors=[
+                {
+                    'type': 'unexpected_keyword_argument',
+                    'loc': ('b',),
+                    'msg': 'Unexpected keyword argument',
+                    'input': 'bye',
+                }
+            ],
+        ),
+    ),
+    ({'a': 'hello'}, 'forbid', {'a': 'hello', 'b': 'HELLO'}),
+]
+
+
+@pytest.mark.parametrize(
+    'input_value,extra_behavior,expected',
+    [
+        *init_test_cases,
+        # special case - when init=False, extra='allow', and the value is provided
+        # currently, it's disallowed in Pydantic to have a model with extra='allow'
+        # and a field with init=False, so this case isn't really possible at the momment
+        # TODO: open to changing this behavior, and changes won't be significantly breaking
+        # because we currently don't support this case
+        ({'a': 'hello', 'b': 'bye'}, 'allow', {'a': 'hello', 'b': 'HELLO'}),
+    ],
+)
+def test_dataclass_args_init(input_value, extra_behavior, expected):
+    @dataclasses.dataclass
+    class Foo:
+        a: str
+        b: str
+
+        def __post_init__(self):
+            self.b = self.a.upper()
+
+    schema = core_schema.dataclass_schema(
+        Foo,
+        core_schema.dataclass_args_schema(
+            'Foo',
+            [
+                core_schema.dataclass_field(name='a', schema=core_schema.str_schema()),
+                core_schema.dataclass_field(name='b', schema=core_schema.str_schema(), init=False),
+            ],
+            extra_behavior=extra_behavior,
+        ),
+        ['a', 'b'],
+        post_init=True,
+    )
+
+    v = SchemaValidator(schema)
+
+    if isinstance(expected, Err):
+        with pytest.raises(ValidationError, match=re.escape(expected.message)) as exc_info:
+            v.validate_python(input_value)
+
+        if expected.errors is not None:
+            assert exc_info.value.errors(include_url=False) == expected.errors
+    else:
+        assert dataclasses.asdict(v.validate_python(input_value)) == expected
+
+
+@pytest.mark.parametrize(
+    'input_value,extra_behavior,expected',
+    [
+        *init_test_cases,
+        # special case - allow override of default, even when init=False, if extra='allow'
+        # TODO: we haven't really decided if this should be allowed or not
+        # currently, it's disallowed in Pydantic to have a model with extra='allow'
+        # and a field with init=False, so this case isn't really possible at the momment
+        ({'a': 'hello', 'b': 'bye'}, 'allow', {'a': 'hello', 'b': 'bye'}),
+    ],
+)
+def test_dataclass_args_init_with_default(input_value, extra_behavior, expected):
+    @dataclasses.dataclass
+    class Foo:
+        a: str
+        b: str
+
+    schema = core_schema.dataclass_schema(
+        Foo,
+        core_schema.dataclass_args_schema(
+            'Foo',
+            [
+                core_schema.dataclass_field(name='a', schema=core_schema.str_schema()),
+                core_schema.dataclass_field(
+                    name='b',
+                    schema=core_schema.with_default_schema(schema=core_schema.str_schema(), default='HELLO'),
+                    init=False,
+                ),
+            ],
+            extra_behavior=extra_behavior,
+        ),
+        ['a', 'b'],
+    )
+
+    v = SchemaValidator(schema)
+
+    if isinstance(expected, Err):
+        with pytest.raises(ValidationError, match=re.escape(expected.message)) as exc_info:
+            v.validate_python(input_value)
+
+        if expected.errors is not None:
+            assert exc_info.value.errors(include_url=False) == expected.errors
+    else:
+        assert dataclasses.asdict(v.validate_python(input_value)) == expected

From 4da7192ffc104cd6c424d102bc1c9c5bfdad543e Mon Sep 17 00:00:00 2001
From: Samuel Colvin <s@muelcolvin.com>
Date: Wed, 17 Jan 2024 20:02:10 +0000
Subject: [PATCH 189/550] uprev to jiter v0.0.6, uprev pydantic-core (#1165)

---
 Cargo.lock | 21 ++++++++++++++++-----
 Cargo.toml |  4 ++--
 2 files changed, 18 insertions(+), 7 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 34b46ee65..a2993621f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -24,6 +24,12 @@ dependencies = [
  "memchr",
 ]
 
+[[package]]
+name = "allocator-api2"
+version = "0.2.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0942ffc6dcaadf03badf6e6a2d0228460359d5e34b57ccdc720b7382dfbd5ec5"
+
 [[package]]
 name = "autocfg"
 version = "1.1.0"
@@ -94,9 +100,13 @@ dependencies = [
 
 [[package]]
 name = "hashbrown"
-version = "0.14.0"
+version = "0.14.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c6201b9ff9fd90a5a3bac2e56a830d0caa509576f0e503818ee82c181b3437a"
+checksum = "290f1a1d9242c78d09ce40a5e87e7554ee637af1351968159f4952f028f75604"
+dependencies = [
+ "ahash",
+ "allocator-api2",
+]
 
 [[package]]
 name = "heck"
@@ -138,11 +148,12 @@ checksum = "62b02a5381cc465bd3041d84623d0fa3b66738b52b8e2fc3bab8ad63ab032f4a"
 
 [[package]]
 name = "jiter"
-version = "0.0.5"
+version = "0.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e184598fea113663dd78e33a24ad3a1e7ba8ceedf71effb7406b3f2eccb63ed1"
+checksum = "87db066a99f69382be06d02313f8ce989996b53a04a8a70cfd1a6483a56227f7"
 dependencies = [
  "ahash",
+ "hashbrown",
  "lexical-core",
  "num-bigint",
  "num-traits",
@@ -321,7 +332,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.15.0"
+version = "2.16.0"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index 283e364f9..a878fcfd4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.15.0"
+version = "2.16.0"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"
@@ -43,7 +43,7 @@ base64 = "0.21.7"
 num-bigint = "0.4.4"
 python3-dll-a = "0.2.7"
 uuid = "1.6.1"
-jiter = {version = "0.0.5", features = ["python"]}
+jiter = {version = "0.0.6", features = ["python"]}
 
 [lib]
 name = "_pydantic_core"

From 7a5f8e6b9a9951dd674a9841e1b463aec7a7a281 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Fri, 19 Jan 2024 12:10:36 +0000
Subject: [PATCH 190/550] Ensure recursion guard is always used as a stack
 (#1166)

---
 src/recursion_guard.rs                        | 63 +++++++++++++++++--
 src/serializers/extra.rs                      | 56 +++++++++--------
 src/serializers/infer.rs                      | 29 ++++-----
 src/serializers/mod.rs                        |  8 +--
 .../type_serializers/definitions.rs           | 19 +++---
 src/validators/definitions.rs                 | 33 +++-------
 src/validators/generator.rs                   |  4 +-
 src/validators/mod.rs                         | 10 +--
 src/validators/validation_state.rs            | 12 +++-
 9 files changed, 137 insertions(+), 97 deletions(-)

diff --git a/src/recursion_guard.rs b/src/recursion_guard.rs
index fe5b1bcdd..d3302c0e9 100644
--- a/src/recursion_guard.rs
+++ b/src/recursion_guard.rs
@@ -12,8 +12,59 @@ type RecursionKey = (
 
 /// This is used to avoid cyclic references in input data causing recursive validation and a nasty segmentation fault.
 /// It's used in `validators/definition` to detect when a reference is reused within itself.
+pub(crate) struct RecursionGuard<'a, S: ContainsRecursionState> {
+    state: &'a mut S,
+    obj_id: usize,
+    node_id: usize,
+}
+
+pub(crate) enum RecursionError {
+    /// Cyclic reference detected
+    Cyclic,
+    /// Recursion limit exceeded
+    Depth,
+}
+
+impl<S: ContainsRecursionState> RecursionGuard<'_, S> {
+    /// Creates a recursion guard for the given object and node id.
+    ///
+    /// When dropped, this will release the recursion for the given object and node id.
+    pub fn new(state: &'_ mut S, obj_id: usize, node_id: usize) -> Result<RecursionGuard<'_, S>, RecursionError> {
+        state.access_recursion_state(|state| {
+            if !state.insert(obj_id, node_id) {
+                return Err(RecursionError::Cyclic);
+            }
+            if state.incr_depth() {
+                return Err(RecursionError::Depth);
+            }
+            Ok(())
+        })?;
+        Ok(RecursionGuard { state, obj_id, node_id })
+    }
+
+    /// Retrieves the underlying state for further use.
+    pub fn state(&mut self) -> &mut S {
+        self.state
+    }
+}
+
+impl<S: ContainsRecursionState> Drop for RecursionGuard<'_, S> {
+    fn drop(&mut self) {
+        self.state.access_recursion_state(|state| {
+            state.decr_depth();
+            state.remove(self.obj_id, self.node_id);
+        });
+    }
+}
+
+/// This trait is used to retrieve the recursion state from some other type
+pub(crate) trait ContainsRecursionState {
+    fn access_recursion_state<R>(&mut self, f: impl FnOnce(&mut RecursionState) -> R) -> R;
+}
+
+/// State for the RecursionGuard. Can also be used directly to increase / decrease depth.
 #[derive(Debug, Clone, Default)]
-pub struct RecursionGuard {
+pub struct RecursionState {
     ids: RecursionStack,
     // depth could be a hashmap {validator_id => depth} but for simplicity and performance it's easier to just
     // use one number for all validators
@@ -31,11 +82,11 @@ pub const RECURSION_GUARD_LIMIT: u8 = if cfg!(any(target_family = "wasm", all(wi
     255
 };
 
-impl RecursionGuard {
+impl RecursionState {
     // insert a new value
     // * return `false` if the stack already had it in it
     // * return `true` if the stack didn't have it in it and it was inserted
-    pub fn insert(&mut self, obj_id: usize, node_id: usize) -> bool {
+    fn insert(&mut self, obj_id: usize, node_id: usize) -> bool {
         self.ids.insert((obj_id, node_id))
     }
 
@@ -68,7 +119,7 @@ impl RecursionGuard {
         self.depth = self.depth.saturating_sub(1);
     }
 
-    pub fn remove(&mut self, obj_id: usize, node_id: usize) {
+    fn remove(&mut self, obj_id: usize, node_id: usize) {
         self.ids.remove(&(obj_id, node_id));
     }
 }
@@ -98,7 +149,7 @@ impl RecursionStack {
     // insert a new value
     // * return `false` if the stack already had it in it
     // * return `true` if the stack didn't have it in it and it was inserted
-    pub fn insert(&mut self, v: RecursionKey) -> bool {
+    fn insert(&mut self, v: RecursionKey) -> bool {
         match self {
             Self::Array { data, len } => {
                 if *len < ARRAY_SIZE {
@@ -129,7 +180,7 @@ impl RecursionStack {
         }
     }
 
-    pub fn remove(&mut self, v: &RecursionKey) {
+    fn remove(&mut self, v: &RecursionKey) {
         match self {
             Self::Array { data, len } => {
                 *len = len.checked_sub(1).expect("remove from empty recursion guard");
diff --git a/src/serializers/extra.rs b/src/serializers/extra.rs
index b3978613a..8d598d46b 100644
--- a/src/serializers/extra.rs
+++ b/src/serializers/extra.rs
@@ -10,20 +10,23 @@ use serde::ser::Error;
 use super::config::SerializationConfig;
 use super::errors::{PydanticSerializationUnexpectedValue, UNEXPECTED_TYPE_SER_MARKER};
 use super::ob_type::ObTypeLookup;
+use crate::recursion_guard::ContainsRecursionState;
+use crate::recursion_guard::RecursionError;
 use crate::recursion_guard::RecursionGuard;
+use crate::recursion_guard::RecursionState;
 
 /// this is ugly, would be much better if extra could be stored in `SerializationState`
 /// then `SerializationState` got a `serialize_infer` method, but I couldn't get it to work
 pub(crate) struct SerializationState {
     warnings: CollectWarnings,
-    rec_guard: SerRecursionGuard,
+    rec_guard: SerRecursionState,
     config: SerializationConfig,
 }
 
 impl SerializationState {
     pub fn new(timedelta_mode: &str, bytes_mode: &str, inf_nan_mode: &str) -> PyResult<Self> {
         let warnings = CollectWarnings::new(false);
-        let rec_guard = SerRecursionGuard::default();
+        let rec_guard = SerRecursionState::default();
         let config = SerializationConfig::from_args(timedelta_mode, bytes_mode, inf_nan_mode)?;
         Ok(Self {
             warnings,
@@ -77,7 +80,7 @@ pub(crate) struct Extra<'a> {
     pub exclude_none: bool,
     pub round_trip: bool,
     pub config: &'a SerializationConfig,
-    pub rec_guard: &'a SerRecursionGuard,
+    pub rec_guard: &'a SerRecursionState,
     // the next two are used for union logic
     pub check: SerCheck,
     // data representing the current model field
@@ -101,7 +104,7 @@ impl<'a> Extra<'a> {
         exclude_none: bool,
         round_trip: bool,
         config: &'a SerializationConfig,
-        rec_guard: &'a SerRecursionGuard,
+        rec_guard: &'a SerRecursionState,
         serialize_unknown: bool,
         fallback: Option<&'a PyAny>,
     ) -> Self {
@@ -124,6 +127,22 @@ impl<'a> Extra<'a> {
         }
     }
 
+    pub fn recursion_guard<'x, 'y>(
+        // TODO: this double reference is a bit if a hack, but it's necessary because the recursion
+        // guard is not passed around with &mut reference
+        //
+        // See how validation has &mut ValidationState passed around; we should aim to refactor
+        // to match that.
+        self: &'x mut &'y Self,
+        value: &PyAny,
+        def_ref_id: usize,
+    ) -> PyResult<RecursionGuard<'x, &'y Self>> {
+        RecursionGuard::new(self, value.as_ptr() as usize, def_ref_id).map_err(|e| match e {
+            RecursionError::Depth => PyValueError::new_err("Circular reference detected (depth exceeded)"),
+            RecursionError::Cyclic => PyValueError::new_err("Circular reference detected (id repeated)"),
+        })
+    }
+
     pub fn serialize_infer<'py>(&'py self, value: &'py PyAny) -> super::infer::SerializeInfer<'py> {
         super::infer::SerializeInfer::new(value, None, None, self)
     }
@@ -157,7 +176,7 @@ pub(crate) struct ExtraOwned {
     exclude_none: bool,
     round_trip: bool,
     config: SerializationConfig,
-    rec_guard: SerRecursionGuard,
+    rec_guard: SerRecursionState,
     check: SerCheck,
     model: Option<PyObject>,
     field_name: Option<String>,
@@ -340,29 +359,12 @@ impl CollectWarnings {
 
 #[derive(Default, Clone)]
 #[cfg_attr(debug_assertions, derive(Debug))]
-pub struct SerRecursionGuard {
-    guard: RefCell<RecursionGuard>,
+pub struct SerRecursionState {
+    guard: RefCell<RecursionState>,
 }
 
-impl SerRecursionGuard {
-    pub fn add(&self, value: &PyAny, def_ref_id: usize) -> PyResult<usize> {
-        let id = value.as_ptr() as usize;
-        let mut guard = self.guard.borrow_mut();
-
-        if guard.insert(id, def_ref_id) {
-            if guard.incr_depth() {
-                Err(PyValueError::new_err("Circular reference detected (depth exceeded)"))
-            } else {
-                Ok(id)
-            }
-        } else {
-            Err(PyValueError::new_err("Circular reference detected (id repeated)"))
-        }
-    }
-
-    pub fn pop(&self, id: usize, def_ref_id: usize) {
-        let mut guard = self.guard.borrow_mut();
-        guard.decr_depth();
-        guard.remove(id, def_ref_id);
+impl ContainsRecursionState for &'_ Extra<'_> {
+    fn access_recursion_state<R>(&mut self, f: impl FnOnce(&mut RecursionState) -> R) -> R {
+        f(&mut self.rec_guard.guard.borrow_mut())
     }
 }
diff --git a/src/serializers/infer.rs b/src/serializers/infer.rs
index 5ddf77597..487d0d091 100644
--- a/src/serializers/infer.rs
+++ b/src/serializers/infer.rs
@@ -40,19 +40,22 @@ pub(crate) fn infer_to_python_known(
     value: &PyAny,
     include: Option<&PyAny>,
     exclude: Option<&PyAny>,
-    extra: &Extra,
+    mut extra: &Extra,
 ) -> PyResult<PyObject> {
     let py = value.py();
-    let value_id = match extra.rec_guard.add(value, INFER_DEF_REF_ID) {
-        Ok(id) => id,
+
+    let mode = extra.mode;
+    let mut guard = match extra.recursion_guard(value, INFER_DEF_REF_ID) {
+        Ok(v) => v,
         Err(e) => {
-            return match extra.mode {
+            return match mode {
                 SerMode::Json => Err(e),
                 // if recursion is detected by we're serializing to python, we just return the value
                 _ => Ok(value.into_py(py)),
             };
         }
     };
+    let extra = guard.state();
 
     macro_rules! serialize_seq {
         ($t:ty) => {
@@ -220,7 +223,6 @@ pub(crate) fn infer_to_python_known(
                 if let Some(fallback) = extra.fallback {
                     let next_value = fallback.call1((value,))?;
                     let next_result = infer_to_python(next_value, include, exclude, extra);
-                    extra.rec_guard.pop(value_id, INFER_DEF_REF_ID);
                     return next_result;
                 } else if extra.serialize_unknown {
                     serialize_unknown(value).into_py(py)
@@ -267,7 +269,6 @@ pub(crate) fn infer_to_python_known(
                 if let Some(fallback) = extra.fallback {
                     let next_value = fallback.call1((value,))?;
                     let next_result = infer_to_python(next_value, include, exclude, extra);
-                    extra.rec_guard.pop(value_id, INFER_DEF_REF_ID);
                     return next_result;
                 }
                 value.into_py(py)
@@ -275,7 +276,6 @@ pub(crate) fn infer_to_python_known(
             _ => value.into_py(py),
         },
     };
-    extra.rec_guard.pop(value_id, INFER_DEF_REF_ID);
     Ok(value)
 }
 
@@ -332,18 +332,21 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
     serializer: S,
     include: Option<&PyAny>,
     exclude: Option<&PyAny>,
-    extra: &Extra,
+    mut extra: &Extra,
 ) -> Result<S::Ok, S::Error> {
-    let value_id = match extra.rec_guard.add(value, INFER_DEF_REF_ID).map_err(py_err_se_err) {
+    let extra_serialize_unknown = extra.serialize_unknown;
+    let mut guard = match extra.recursion_guard(value, INFER_DEF_REF_ID) {
         Ok(v) => v,
         Err(e) => {
-            return if extra.serialize_unknown {
+            return if extra_serialize_unknown {
                 serializer.serialize_str("...")
             } else {
-                Err(e)
-            }
+                Err(py_err_se_err(e))
+            };
         }
     };
+    let extra = guard.state();
+
     macro_rules! serialize {
         ($t:ty) => {
             match value.extract::<$t>() {
@@ -506,7 +509,6 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
             if let Some(fallback) = extra.fallback {
                 let next_value = fallback.call1((value,)).map_err(py_err_se_err)?;
                 let next_result = infer_serialize(next_value, serializer, include, exclude, extra);
-                extra.rec_guard.pop(value_id, INFER_DEF_REF_ID);
                 return next_result;
             } else if extra.serialize_unknown {
                 serializer.serialize_str(&serialize_unknown(value))
@@ -520,7 +522,6 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
             }
         }
     };
-    extra.rec_guard.pop(value_id, INFER_DEF_REF_ID);
     ser_result
 }
 
diff --git a/src/serializers/mod.rs b/src/serializers/mod.rs
index 8159691cb..7d9c5347c 100644
--- a/src/serializers/mod.rs
+++ b/src/serializers/mod.rs
@@ -10,7 +10,7 @@ use crate::py_gc::PyGcTraverse;
 
 use config::SerializationConfig;
 pub use errors::{PydanticSerializationError, PydanticSerializationUnexpectedValue};
-use extra::{CollectWarnings, SerRecursionGuard};
+use extra::{CollectWarnings, SerRecursionState};
 pub(crate) use extra::{Extra, SerMode, SerializationState};
 pub use shared::CombinedSerializer;
 use shared::{to_json_bytes, BuildSerializer, TypeSerializer};
@@ -52,7 +52,7 @@ impl SchemaSerializer {
         exclude_defaults: bool,
         exclude_none: bool,
         round_trip: bool,
-        rec_guard: &'a SerRecursionGuard,
+        rec_guard: &'a SerRecursionState,
         serialize_unknown: bool,
         fallback: Option<&'a PyAny>,
     ) -> Extra<'b> {
@@ -113,7 +113,7 @@ impl SchemaSerializer {
     ) -> PyResult<PyObject> {
         let mode: SerMode = mode.into();
         let warnings = CollectWarnings::new(warnings);
-        let rec_guard = SerRecursionGuard::default();
+        let rec_guard = SerRecursionState::default();
         let extra = self.build_extra(
             py,
             &mode,
@@ -152,7 +152,7 @@ impl SchemaSerializer {
         fallback: Option<&PyAny>,
     ) -> PyResult<PyObject> {
         let warnings = CollectWarnings::new(warnings);
-        let rec_guard = SerRecursionGuard::default();
+        let rec_guard = SerRecursionState::default();
         let extra = self.build_extra(
             py,
             &SerMode::Json,
diff --git a/src/serializers/type_serializers/definitions.rs b/src/serializers/type_serializers/definitions.rs
index 99dae5bcd..2f98a94e0 100644
--- a/src/serializers/type_serializers/definitions.rs
+++ b/src/serializers/type_serializers/definitions.rs
@@ -66,14 +66,12 @@ impl TypeSerializer for DefinitionRefSerializer {
         value: &PyAny,
         include: Option<&PyAny>,
         exclude: Option<&PyAny>,
-        extra: &Extra,
+        mut extra: &Extra,
     ) -> PyResult<PyObject> {
         self.definition.read(|comb_serializer| {
             let comb_serializer = comb_serializer.unwrap();
-            let value_id = extra.rec_guard.add(value, self.definition.id())?;
-            let r = comb_serializer.to_python(value, include, exclude, extra);
-            extra.rec_guard.pop(value_id, self.definition.id());
-            r
+            let mut guard = extra.recursion_guard(value, self.definition.id())?;
+            comb_serializer.to_python(value, include, exclude, guard.state())
         })
     }
 
@@ -87,17 +85,14 @@ impl TypeSerializer for DefinitionRefSerializer {
         serializer: S,
         include: Option<&PyAny>,
         exclude: Option<&PyAny>,
-        extra: &Extra,
+        mut extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         self.definition.read(|comb_serializer| {
             let comb_serializer = comb_serializer.unwrap();
-            let value_id = extra
-                .rec_guard
-                .add(value, self.definition.id())
+            let mut guard = extra
+                .recursion_guard(value, self.definition.id())
                 .map_err(py_err_se_err)?;
-            let r = comb_serializer.serde_serialize(value, serializer, include, exclude, extra);
-            extra.rec_guard.pop(value_id, self.definition.id());
-            r
+            comb_serializer.serde_serialize(value, serializer, include, exclude, guard.state())
         })
     }
 
diff --git a/src/validators/definitions.rs b/src/validators/definitions.rs
index e8c67a690..e4bc270c2 100644
--- a/src/validators/definitions.rs
+++ b/src/validators/definitions.rs
@@ -6,6 +6,7 @@ use crate::definitions::DefinitionRef;
 use crate::errors::{ErrorTypeDefaults, ValError, ValResult};
 use crate::input::Input;
 
+use crate::recursion_guard::RecursionGuard;
 use crate::tools::SchemaDict;
 
 use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
@@ -76,18 +77,10 @@ impl Validator for DefinitionRefValidator {
         self.definition.read(|validator| {
             let validator = validator.unwrap();
             if let Some(id) = input.identity() {
-                if state.recursion_guard.insert(id, self.definition.id()) {
-                    if state.recursion_guard.incr_depth() {
-                        return Err(ValError::new(ErrorTypeDefaults::RecursionLoop, input));
-                    }
-                    let output = validator.validate(py, input, state);
-                    state.recursion_guard.remove(id, self.definition.id());
-                    state.recursion_guard.decr_depth();
-                    output
-                } else {
-                    // we don't remove id here, we leave that to the validator which originally added id to `recursion_guard`
-                    Err(ValError::new(ErrorTypeDefaults::RecursionLoop, input))
-                }
+                let Ok(mut guard) = RecursionGuard::new(state, id, self.definition.id()) else {
+                    return Err(ValError::new(ErrorTypeDefaults::RecursionLoop, input));
+                };
+                validator.validate(py, input, guard.state())
             } else {
                 validator.validate(py, input, state)
             }
@@ -105,18 +98,10 @@ impl Validator for DefinitionRefValidator {
         self.definition.read(|validator| {
             let validator = validator.unwrap();
             if let Some(id) = obj.identity() {
-                if state.recursion_guard.insert(id, self.definition.id()) {
-                    if state.recursion_guard.incr_depth() {
-                        return Err(ValError::new(ErrorTypeDefaults::RecursionLoop, obj));
-                    }
-                    let output = validator.validate_assignment(py, obj, field_name, field_value, state);
-                    state.recursion_guard.remove(id, self.definition.id());
-                    state.recursion_guard.decr_depth();
-                    output
-                } else {
-                    // we don't remove id here, we leave that to the validator which originally added id to `recursion_guard`
-                    Err(ValError::new(ErrorTypeDefaults::RecursionLoop, obj))
-                }
+                let Ok(mut guard) = RecursionGuard::new(state, id, self.definition.id()) else {
+                    return Err(ValError::new(ErrorTypeDefaults::RecursionLoop, obj));
+                };
+                validator.validate_assignment(py, obj, field_name, field_value, guard.state())
             } else {
                 validator.validate_assignment(py, obj, field_name, field_value, state)
             }
diff --git a/src/validators/generator.rs b/src/validators/generator.rs
index 3b5fedd97..a366da431 100644
--- a/src/validators/generator.rs
+++ b/src/validators/generator.rs
@@ -6,7 +6,7 @@ use pyo3::types::PyDict;
 
 use crate::errors::{ErrorType, LocItem, ValError, ValResult};
 use crate::input::{GenericIterator, Input};
-use crate::recursion_guard::RecursionGuard;
+use crate::recursion_guard::RecursionState;
 use crate::tools::SchemaDict;
 use crate::ValidationError;
 
@@ -212,7 +212,7 @@ pub struct InternalValidator {
     from_attributes: Option<bool>,
     context: Option<PyObject>,
     self_instance: Option<PyObject>,
-    recursion_guard: RecursionGuard,
+    recursion_guard: RecursionState,
     pub(crate) exactness: Option<Exactness>,
     validation_mode: InputType,
     hide_input_in_errors: bool,
diff --git a/src/validators/mod.rs b/src/validators/mod.rs
index fc1584080..496da5c73 100644
--- a/src/validators/mod.rs
+++ b/src/validators/mod.rs
@@ -13,7 +13,7 @@ use crate::definitions::{Definitions, DefinitionsBuilder};
 use crate::errors::{LocItem, ValError, ValResult, ValidationError};
 use crate::input::{Input, InputType, StringMapping};
 use crate::py_gc::PyGcTraverse;
-use crate::recursion_guard::RecursionGuard;
+use crate::recursion_guard::RecursionState;
 use crate::tools::SchemaDict;
 
 mod any;
@@ -263,7 +263,7 @@ impl SchemaValidator {
             self_instance: None,
         };
 
-        let guard = &mut RecursionGuard::default();
+        let guard = &mut RecursionState::default();
         let mut state = ValidationState::new(extra, guard);
         self.validator
             .validate_assignment(py, obj, field_name, field_value, &mut state)
@@ -280,7 +280,7 @@ impl SchemaValidator {
             context,
             self_instance: None,
         };
-        let recursion_guard = &mut RecursionGuard::default();
+        let recursion_guard = &mut RecursionState::default();
         let mut state = ValidationState::new(extra, recursion_guard);
         let r = self.validator.default_value(py, None::<i64>, &mut state);
         match r {
@@ -326,7 +326,7 @@ impl SchemaValidator {
     where
         's: 'data,
     {
-        let mut recursion_guard = RecursionGuard::default();
+        let mut recursion_guard = RecursionState::default();
         let mut state = ValidationState::new(
             Extra::new(strict, from_attributes, context, self_instance, input_type),
             &mut recursion_guard,
@@ -378,7 +378,7 @@ impl<'py> SelfValidator<'py> {
     }
 
     pub fn validate_schema(&self, py: Python<'py>, schema: &'py PyAny, strict: Option<bool>) -> PyResult<&'py PyAny> {
-        let mut recursion_guard = RecursionGuard::default();
+        let mut recursion_guard = RecursionState::default();
         let mut state = ValidationState::new(
             Extra::new(strict, None, None, None, InputType::Python),
             &mut recursion_guard,
diff --git a/src/validators/validation_state.rs b/src/validators/validation_state.rs
index aacd7d2af..4f241d768 100644
--- a/src/validators/validation_state.rs
+++ b/src/validators/validation_state.rs
@@ -1,4 +1,4 @@
-use crate::recursion_guard::RecursionGuard;
+use crate::recursion_guard::{ContainsRecursionState, RecursionState};
 
 use super::Extra;
 
@@ -10,14 +10,14 @@ pub enum Exactness {
 }
 
 pub struct ValidationState<'a> {
-    pub recursion_guard: &'a mut RecursionGuard,
+    pub recursion_guard: &'a mut RecursionState,
     pub exactness: Option<Exactness>,
     // deliberately make Extra readonly
     extra: Extra<'a>,
 }
 
 impl<'a> ValidationState<'a> {
-    pub fn new(extra: Extra<'a>, recursion_guard: &'a mut RecursionGuard) -> Self {
+    pub fn new(extra: Extra<'a>, recursion_guard: &'a mut RecursionState) -> Self {
         Self {
             recursion_guard, // Don't care about exactness unless doing union validation
             exactness: None,
@@ -84,6 +84,12 @@ impl<'a> ValidationState<'a> {
     }
 }
 
+impl ContainsRecursionState for ValidationState<'_> {
+    fn access_recursion_state<R>(&mut self, f: impl FnOnce(&mut RecursionState) -> R) -> R {
+        f(self.recursion_guard)
+    }
+}
+
 pub struct ValidationStateWithReboundExtra<'state, 'a> {
     state: &'state mut ValidationState<'a>,
     old_extra: Extra<'a>,

From 4538190f0e7a47a99ca44351f744007b016511d4 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Fri, 19 Jan 2024 06:46:11 -0600
Subject: [PATCH 191/550] Uprev core to 2.16.1 (#1167)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index a2993621f..5d113589f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -332,7 +332,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.16.0"
+version = "2.16.1"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index a878fcfd4..c26c91419 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.16.0"
+version = "2.16.1"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From c670b2bd729d2b91eca5b24b2fe3d2785e3e8cd2 Mon Sep 17 00:00:00 2001
From: Samuel Colvin <s@muelcolvin.com>
Date: Mon, 22 Jan 2024 11:46:34 +0000
Subject: [PATCH 192/550] remove `AsLocItem` trait (#1169)

---
 src/errors/line_error.rs       |  7 +++--
 src/errors/location.rs         | 16 +++++------
 src/errors/mod.rs              |  2 +-
 src/input/input_abstract.rs    |  4 +--
 src/input/input_json.rs        | 40 ++++++++++-----------------
 src/input/input_python.rs      | 50 +++++++++++++++++-----------------
 src/input/input_string.rs      | 14 +++++-----
 src/input/return_enums.rs      |  4 +--
 src/lookup_key.rs              |  4 +--
 src/validators/arguments.rs    | 12 ++++----
 src/validators/call.rs         |  2 +-
 src/validators/dataclass.rs    | 14 ++++------
 src/validators/dict.rs         | 16 ++++++-----
 src/validators/function.rs     |  6 ++--
 src/validators/model_fields.rs | 12 ++++----
 src/validators/tuple.rs        |  6 ++--
 src/validators/typed_dict.rs   | 12 ++++----
 src/validators/union.rs        |  6 ++--
 src/validators/with_default.rs |  2 +-
 19 files changed, 108 insertions(+), 121 deletions(-)

diff --git a/src/errors/line_error.rs b/src/errors/line_error.rs
index f5fa11b70..2a48bfaf4 100644
--- a/src/errors/line_error.rs
+++ b/src/errors/line_error.rs
@@ -61,7 +61,8 @@ impl ValError {
     }
 
     /// helper function to call with_outer on line items if applicable
-    pub fn with_outer_location(self, loc_item: LocItem) -> Self {
+    pub fn with_outer_location(self, into_loc_item: impl Into<LocItem>) -> Self {
+        let loc_item = into_loc_item.into();
         match self {
             Self::LineErrors(mut line_errors) => {
                 for line_error in &mut line_errors {
@@ -120,8 +121,8 @@ impl ValLineError {
 
     /// location is stored reversed so it's quicker to add "outer" items as that's what we always do
     /// hence `push` here instead of `insert`
-    pub fn with_outer_location(mut self, loc_item: LocItem) -> Self {
-        self.location.with_outer(loc_item);
+    pub fn with_outer_location(mut self, into_loc_item: impl Into<LocItem>) -> Self {
+        self.location.with_outer(into_loc_item.into());
         self
     }
 
diff --git a/src/errors/location.rs b/src/errors/location.rs
index 8acc2a039..55bab0017 100644
--- a/src/errors/location.rs
+++ b/src/errors/location.rs
@@ -34,18 +34,18 @@ impl fmt::Display for LocItem {
     }
 }
 
-// TODO rename to ToLocItem
-pub trait AsLocItem {
-    // TODO rename to to_loc_item
-    fn as_loc_item(&self) -> LocItem;
-}
-
 impl From<String> for LocItem {
     fn from(s: String) -> Self {
         Self::S(s)
     }
 }
 
+impl From<&String> for LocItem {
+    fn from(s: &String) -> Self {
+        s.to_string().into()
+    }
+}
+
 impl From<&str> for LocItem {
     fn from(s: &str) -> Self {
         Self::S(s.to_string())
@@ -201,9 +201,9 @@ impl TryFrom<Option<&PyAny>> for Location {
     fn try_from(location: Option<&PyAny>) -> PyResult<Self> {
         if let Some(location) = location {
             let mut loc_vec: Vec<LocItem> = if let Ok(tuple) = location.downcast::<PyTuple>() {
-                tuple.iter().map(AsLocItem::as_loc_item).collect()
+                tuple.iter().map(Into::into).collect()
             } else if let Ok(list) = location.downcast::<PyList>() {
-                list.iter().map(AsLocItem::as_loc_item).collect()
+                list.iter().map(Into::into).collect()
             } else {
                 return Err(PyTypeError::new_err(
                     "Location must be a list or tuple of strings and ints",
diff --git a/src/errors/mod.rs b/src/errors/mod.rs
index 131e54177..de6650527 100644
--- a/src/errors/mod.rs
+++ b/src/errors/mod.rs
@@ -7,7 +7,7 @@ mod validation_exception;
 mod value_exception;
 
 pub use self::line_error::{AsErrorValue, InputValue, ValError, ValLineError, ValResult};
-pub use self::location::{AsLocItem, LocItem};
+pub use self::location::LocItem;
 pub use self::types::{list_all_errors, ErrorType, ErrorTypeDefaults, Number};
 pub use self::validation_exception::ValidationError;
 pub use self::value_exception::{PydanticCustomError, PydanticKnownError, PydanticOmit, PydanticUseDefault};
diff --git a/src/input/input_abstract.rs b/src/input/input_abstract.rs
index 8229677b6..6ce1479f6 100644
--- a/src/input/input_abstract.rs
+++ b/src/input/input_abstract.rs
@@ -4,7 +4,7 @@ use pyo3::exceptions::PyValueError;
 use pyo3::types::{PyDict, PyType};
 use pyo3::{intern, prelude::*};
 
-use crate::errors::{AsLocItem, ErrorTypeDefaults, InputValue, ValError, ValResult};
+use crate::errors::{ErrorTypeDefaults, InputValue, LocItem, ValError, ValResult};
 use crate::tools::py_err;
 use crate::{PyMultiHostUrl, PyUrl};
 
@@ -46,7 +46,7 @@ impl TryFrom<&str> for InputType {
 /// the convention is to either implement:
 /// * `strict_*` & `lax_*` if they have different behavior
 /// * or, `validate_*` and `strict_*` to just call `validate_*` if the behavior for strict and lax is the same
-pub trait Input<'a>: fmt::Debug + ToPyObject + AsLocItem + Sized {
+pub trait Input<'a>: fmt::Debug + ToPyObject + Into<LocItem> + Sized {
     fn as_error_value(&self) -> InputValue;
 
     fn identity(&self) -> Option<usize> {
diff --git a/src/input/input_json.rs b/src/input/input_json.rs
index 195f9caba..cd4ac919c 100644
--- a/src/input/input_json.rs
+++ b/src/input/input_json.rs
@@ -6,7 +6,7 @@ use pyo3::types::{PyDict, PyString};
 use speedate::MicrosecondsPrecisionOverflowBehavior;
 use strum::EnumMessage;
 
-use crate::errors::{AsLocItem, ErrorType, ErrorTypeDefaults, InputValue, LocItem, ValError, ValResult};
+use crate::errors::{ErrorType, ErrorTypeDefaults, InputValue, LocItem, ValError, ValResult};
 use crate::validators::decimal::create_decimal;
 
 use super::datetime::{
@@ -21,9 +21,9 @@ use super::{
 };
 
 /// This is required but since JSON object keys are always strings, I don't think it can be called
-impl AsLocItem for JsonValue {
-    fn as_loc_item(&self) -> LocItem {
-        match self {
+impl From<&JsonValue> for LocItem {
+    fn from(json_value: &JsonValue) -> Self {
+        match json_value {
             JsonValue::Int(i) => (*i).into(),
             JsonValue::Str(s) => s.as_str().into(),
             v => format!("{v:?}").into(),
@@ -31,9 +31,9 @@ impl AsLocItem for JsonValue {
     }
 }
 
-impl AsLocItem for &JsonValue {
-    fn as_loc_item(&self) -> LocItem {
-        AsLocItem::as_loc_item(*self)
+impl From<JsonValue> for LocItem {
+    fn from(json_value: JsonValue) -> Self {
+        (&json_value).into()
     }
 }
 
@@ -84,13 +84,6 @@ impl<'a> Input<'a> for JsonValue {
         }
     }
 
-    fn exact_str(&'a self) -> ValResult<EitherString<'a>> {
-        match self {
-            JsonValue::Str(s) => Ok(s.as_str().into()),
-            _ => Err(ValError::new(ErrorTypeDefaults::StringType, self)),
-        }
-    }
-
     fn validate_str(
         &'a self,
         strict: bool,
@@ -144,6 +137,13 @@ impl<'a> Input<'a> for JsonValue {
         }
     }
 
+    fn exact_str(&'a self) -> ValResult<EitherString<'a>> {
+        match self {
+            JsonValue::Str(s) => Ok(s.as_str().into()),
+            _ => Err(ValError::new(ErrorTypeDefaults::StringType, self)),
+        }
+    }
+
     fn validate_float(&'a self, strict: bool) -> ValResult<ValidationMatch<EitherFloat<'a>>> {
         match self {
             JsonValue::Float(f) => Ok(ValidationMatch::exact(EitherFloat::F64(*f))),
@@ -319,18 +319,6 @@ impl BorrowInput for &'_ JsonValue {
     }
 }
 
-impl AsLocItem for String {
-    fn as_loc_item(&self) -> LocItem {
-        self.to_string().into()
-    }
-}
-
-impl AsLocItem for &String {
-    fn as_loc_item(&self) -> LocItem {
-        AsLocItem::as_loc_item(*self)
-    }
-}
-
 /// Required for JSON Object keys so the string can behave like an Input
 impl<'a> Input<'a> for String {
     fn as_error_value(&self) -> InputValue {
diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index 2eaaebe10..fd93820ef 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -12,7 +12,7 @@ use pyo3::{intern, PyTypeInfo};
 
 use speedate::MicrosecondsPrecisionOverflowBehavior;
 
-use crate::errors::{AsLocItem, ErrorType, ErrorTypeDefaults, InputValue, LocItem, ValError, ValResult};
+use crate::errors::{ErrorType, ErrorTypeDefaults, InputValue, LocItem, ValError, ValResult};
 use crate::tools::{extract_i64, safe_repr};
 use crate::validators::decimal::{create_decimal, get_decimal_type};
 use crate::validators::Exactness;
@@ -92,21 +92,21 @@ macro_rules! extract_dict_items {
     };
 }
 
-impl AsLocItem for PyAny {
-    fn as_loc_item(&self) -> LocItem {
-        if let Ok(py_str) = self.downcast::<PyString>() {
+impl From<&PyAny> for LocItem {
+    fn from(py_any: &PyAny) -> Self {
+        if let Ok(py_str) = py_any.downcast::<PyString>() {
             py_str.to_string_lossy().as_ref().into()
-        } else if let Some(key_int) = extract_i64(self) {
+        } else if let Some(key_int) = extract_i64(py_any) {
             key_int.into()
         } else {
-            safe_repr(self).to_string().into()
+            safe_repr(py_any).to_string().into()
         }
     }
 }
 
-impl AsLocItem for &'_ PyAny {
-    fn as_loc_item(&self) -> LocItem {
-        AsLocItem::as_loc_item(*self)
+impl From<PyAny> for LocItem {
+    fn from(py_any: PyAny) -> Self {
+        (&py_any).into()
     }
 }
 
@@ -244,22 +244,6 @@ impl<'a> Input<'a> for PyAny {
         Err(ValError::new(ErrorTypeDefaults::StringType, self))
     }
 
-    fn exact_str(&'a self) -> ValResult<EitherString<'a>> {
-        if let Ok(py_str) = <PyString as PyTryFrom>::try_from_exact(self) {
-            Ok(EitherString::Py(py_str))
-        } else {
-            Err(ValError::new(ErrorTypeDefaults::IntType, self))
-        }
-    }
-
-    fn exact_int(&'a self) -> ValResult<EitherInt<'a>> {
-        if PyInt::is_exact_type_of(self) {
-            Ok(EitherInt::Py(self))
-        } else {
-            Err(ValError::new(ErrorTypeDefaults::IntType, self))
-        }
-    }
-
     fn validate_bytes(&'a self, strict: bool) -> ValResult<ValidationMatch<EitherBytes<'a>>> {
         if let Ok(py_bytes) = self.downcast_exact::<PyBytes>() {
             return Ok(ValidationMatch::exact(py_bytes.into()));
@@ -347,6 +331,22 @@ impl<'a> Input<'a> for PyAny {
         Err(ValError::new(ErrorTypeDefaults::IntType, self))
     }
 
+    fn exact_int(&'a self) -> ValResult<EitherInt<'a>> {
+        if PyInt::is_exact_type_of(self) {
+            Ok(EitherInt::Py(self))
+        } else {
+            Err(ValError::new(ErrorTypeDefaults::IntType, self))
+        }
+    }
+
+    fn exact_str(&'a self) -> ValResult<EitherString<'a>> {
+        if let Ok(py_str) = <PyString as PyTryFrom>::try_from_exact(self) {
+            Ok(EitherString::Py(py_str))
+        } else {
+            Err(ValError::new(ErrorTypeDefaults::IntType, self))
+        }
+    }
+
     fn validate_float(&'a self, strict: bool) -> ValResult<ValidationMatch<EitherFloat<'a>>> {
         if let Ok(float) = self.downcast_exact::<PyFloat>() {
             return Ok(ValidationMatch::exact(EitherFloat::Py(float)));
diff --git a/src/input/input_string.rs b/src/input/input_string.rs
index 0c2c9a8ca..cd5931b24 100644
--- a/src/input/input_string.rs
+++ b/src/input/input_string.rs
@@ -3,7 +3,7 @@ use pyo3::types::{PyDict, PyString};
 
 use speedate::MicrosecondsPrecisionOverflowBehavior;
 
-use crate::errors::{AsLocItem, ErrorTypeDefaults, InputValue, LocItem, ValError, ValResult};
+use crate::errors::{ErrorTypeDefaults, InputValue, LocItem, ValError, ValResult};
 use crate::input::py_string_str;
 use crate::tools::safe_repr;
 use crate::validators::decimal::create_decimal;
@@ -17,7 +17,7 @@ use super::{
     GenericIterator, GenericMapping, Input, ValidationMatch,
 };
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub enum StringMapping<'py> {
     String(&'py PyString),
     Mapping(&'py PyDict),
@@ -52,11 +52,11 @@ impl<'py> StringMapping<'py> {
     }
 }
 
-impl AsLocItem for StringMapping<'_> {
-    fn as_loc_item(&self) -> LocItem {
-        match self {
-            Self::String(s) => s.to_string_lossy().as_ref().into(),
-            Self::Mapping(d) => safe_repr(d).to_string().into(),
+impl From<StringMapping<'_>> for LocItem {
+    fn from(string_mapping: StringMapping<'_>) -> Self {
+        match string_mapping {
+            StringMapping::String(s) => s.to_string_lossy().as_ref().into(),
+            StringMapping::Mapping(d) => safe_repr(d).to_string().into(),
         }
     }
 }
diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index 905b895f9..b323383b7 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -205,7 +205,7 @@ fn validate_iter_to_vec<'a, 's>(
             }
             Err(ValError::LineErrors(line_errors)) => {
                 max_length_check.incr()?;
-                errors.extend(line_errors.into_iter().map(|err| err.with_outer_location(index.into())));
+                errors.extend(line_errors.into_iter().map(|err| err.with_outer_location(index)));
             }
             Err(ValError::Omit) => (),
             Err(err) => return Err(err),
@@ -284,7 +284,7 @@ fn validate_iter_to_set<'a, 's>(
                 }
             }
             Err(ValError::LineErrors(line_errors)) => {
-                errors.extend(line_errors.into_iter().map(|err| err.with_outer_location(index.into())));
+                errors.extend(line_errors.into_iter().map(|err| err.with_outer_location(index)));
             }
             Err(ValError::Omit) => (),
             Err(err) => return Err(err),
diff --git a/src/lookup_key.rs b/src/lookup_key.rs
index e4d2dcce7..d4fba403f 100644
--- a/src/lookup_key.rs
+++ b/src/lookup_key.rs
@@ -366,11 +366,11 @@ impl LookupPath {
     pub fn apply_error_loc(&self, mut line_error: ValLineError, loc_by_alias: bool, field_name: &str) -> ValLineError {
         if loc_by_alias {
             for path_item in self.iter().rev() {
-                line_error = line_error.with_outer_location(path_item.clone().into());
+                line_error = line_error.with_outer_location(path_item.clone());
             }
             line_error
         } else {
-            line_error.with_outer_location(field_name.to_string().into())
+            line_error.with_outer_location(field_name)
         }
     }
 
diff --git a/src/validators/arguments.rs b/src/validators/arguments.rs
index a605ff999..661aaf1e4 100644
--- a/src/validators/arguments.rs
+++ b/src/validators/arguments.rs
@@ -6,7 +6,7 @@ use ahash::AHashSet;
 
 use crate::build_tools::py_schema_err;
 use crate::build_tools::{schema_or_config_same, ExtraBehavior};
-use crate::errors::{AsLocItem, ErrorTypeDefaults, ValError, ValLineError, ValResult};
+use crate::errors::{ErrorTypeDefaults, ValError, ValLineError, ValResult};
 use crate::input::{GenericArguments, Input, ValidationMatch};
 use crate::lookup_key::LookupKey;
 
@@ -209,7 +209,7 @@ impl Validator for ArgumentsValidator {
                             {
                                 Ok(value) => output_args.push(value),
                                 Err(ValError::LineErrors(line_errors)) => {
-                                    errors.extend(line_errors.into_iter().map(|err| err.with_outer_location(index.into())));
+                                    errors.extend(line_errors.into_iter().map(|err| err.with_outer_location(index)));
                                 }
                                 Err(err) => return Err(err),
                             }
@@ -263,7 +263,7 @@ impl Validator for ArgumentsValidator {
                                         errors.extend(
                                             line_errors
                                                 .into_iter()
-                                                .map(|err| err.with_outer_location((index + self.positional_params_count).into())),
+                                                .map(|err| err.with_outer_location(index + self.positional_params_count)),
                                         );
                                     }
                                     Err(err) => return Err(err),
@@ -289,7 +289,7 @@ impl Validator for ArgumentsValidator {
                                 Err(ValError::LineErrors(line_errors)) => {
                                     for err in line_errors {
                                         errors.push(
-                                            err.with_outer_location(raw_key.as_loc_item())
+                                            err.with_outer_location(raw_key)
                                                 .with_type(ErrorTypeDefaults::InvalidKey),
                                         );
                                     }
@@ -303,7 +303,7 @@ impl Validator for ArgumentsValidator {
                                         Ok(value) => output_kwargs.set_item(either_str.as_py_string(py), value)?,
                                         Err(ValError::LineErrors(line_errors)) => {
                                             for err in line_errors {
-                                                errors.push(err.with_outer_location(raw_key.as_loc_item()));
+                                                errors.push(err.with_outer_location(raw_key));
                                             }
                                         }
                                         Err(err) => return Err(err),
@@ -313,7 +313,7 @@ impl Validator for ArgumentsValidator {
                                             errors.push(ValLineError::new_with_loc(
                                                 ErrorTypeDefaults::UnexpectedKeywordArgument,
                                                 value,
-                                                raw_key.as_loc_item(),
+                                                raw_key,
                                             ));
                                         }
                                     }
diff --git a/src/validators/call.rs b/src/validators/call.rs
index bf80415af..32b76f582 100644
--- a/src/validators/call.rs
+++ b/src/validators/call.rs
@@ -93,7 +93,7 @@ impl Validator for CallValidator {
         if let Some(return_validator) = &self.return_validator {
             return_validator
                 .validate(py, return_value.into_ref(py), state)
-                .map_err(|e| e.with_outer_location("return".into()))
+                .map_err(|e| e.with_outer_location("return"))
         } else {
             Ok(return_value.to_object(py))
         }
diff --git a/src/validators/dataclass.rs b/src/validators/dataclass.rs
index 3161541f0..bfeac2115 100644
--- a/src/validators/dataclass.rs
+++ b/src/validators/dataclass.rs
@@ -7,7 +7,7 @@ use ahash::AHashSet;
 
 use crate::build_tools::py_schema_err;
 use crate::build_tools::{is_strict, schema_or_config_same, ExtraBehavior};
-use crate::errors::{AsLocItem, ErrorType, ErrorTypeDefaults, ValError, ValLineError, ValResult};
+use crate::errors::{ErrorType, ErrorTypeDefaults, ValError, ValLineError, ValResult};
 use crate::input::InputType;
 use crate::input::{BorrowInput, GenericArguments, Input, ValidationMatch};
 use crate::lookup_key::LookupKey;
@@ -231,7 +231,7 @@ impl Validator for DataclassArgsValidator {
                                         errors.extend(
                                             line_errors
                                                 .into_iter()
-                                                .map(|err| err.with_outer_location(index.into())),
+                                                .map(|err| err.with_outer_location(index)),
                                         );
                                     }
                                     Err(err) => return Err(err),
@@ -310,7 +310,7 @@ impl Validator for DataclassArgsValidator {
                                                             ValLineError::new_with_loc(
                                                                 ErrorTypeDefaults::UnexpectedKeywordArgument,
                                                                 value,
-                                                                raw_key.as_loc_item(),
+                                                                raw_key,
                                                             ),
                                                         );
                                                     }
@@ -322,9 +322,7 @@ impl Validator for DataclassArgsValidator {
                                                                     .set_item(either_str.as_py_string(py), value)?,
                                                                 Err(ValError::LineErrors(line_errors)) => {
                                                                     for err in line_errors {
-                                                                        errors.push(err.with_outer_location(
-                                                                            raw_key.as_loc_item(),
-                                                                        ));
+                                                                        errors.push(err.with_outer_location(raw_key));
                                                                     }
                                                                 }
                                                                 Err(err) => return Err(err),
@@ -339,7 +337,7 @@ impl Validator for DataclassArgsValidator {
                                         Err(ValError::LineErrors(line_errors)) => {
                                             for err in line_errors {
                                                 errors.push(
-                                                    err.with_outer_location(raw_key.as_loc_item())
+                                                    err.with_outer_location(raw_key)
                                                         .with_type(ErrorTypeDefaults::InvalidKey),
                                                 );
                                             }
@@ -430,7 +428,7 @@ impl Validator for DataclassArgsValidator {
                 Err(ValError::LineErrors(line_errors)) => {
                     let errors = line_errors
                         .into_iter()
-                        .map(|e| e.with_outer_location(field_name.into()))
+                        .map(|e| e.with_outer_location(field_name))
                         .collect();
                     Err(ValError::LineErrors(errors))
                 }
diff --git a/src/validators/dict.rs b/src/validators/dict.rs
index d6507e8e9..3f8ff820b 100644
--- a/src/validators/dict.rs
+++ b/src/validators/dict.rs
@@ -3,7 +3,7 @@ use pyo3::prelude::*;
 use pyo3::types::PyDict;
 
 use crate::build_tools::is_strict;
-use crate::errors::{AsLocItem, ValError, ValLineError, ValResult};
+use crate::errors::{LocItem, ValError, ValLineError, ValResult};
 use crate::input::BorrowInput;
 use crate::input::{
     DictGenericIterator, GenericMapping, Input, JsonObjectGenericIterator, MappingGenericIterator,
@@ -103,7 +103,12 @@ impl DictValidator {
         &'s self,
         py: Python<'data>,
         input: &'data impl Input<'data>,
-        mapping_iter: impl Iterator<Item = ValResult<(impl BorrowInput + AsLocItem + 'data, impl BorrowInput + 'data)>>,
+        mapping_iter: impl Iterator<
+            Item = ValResult<(
+                impl BorrowInput + Clone + Into<LocItem> + 'data,
+                impl BorrowInput + 'data,
+            )>,
+        >,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         let output = PyDict::new(py);
@@ -118,10 +123,7 @@ impl DictValidator {
                 Err(ValError::LineErrors(line_errors)) => {
                     for err in line_errors {
                         // these are added in reverse order so [key] is shunted along by the second call
-                        errors.push(
-                            err.with_outer_location("[key]".into())
-                                .with_outer_location(key.as_loc_item()),
-                        );
+                        errors.push(err.with_outer_location("[key]").with_outer_location(key.clone()));
                     }
                     None
                 }
@@ -132,7 +134,7 @@ impl DictValidator {
                 Ok(value) => Some(value),
                 Err(ValError::LineErrors(line_errors)) => {
                     for err in line_errors {
-                        errors.push(err.with_outer_location(key.as_loc_item()));
+                        errors.push(err.with_outer_location(key.clone()));
                     }
                     None
                 }
diff --git a/src/validators/function.rs b/src/validators/function.rs
index e7134ab29..34e0b6327 100644
--- a/src/validators/function.rs
+++ b/src/validators/function.rs
@@ -6,7 +6,7 @@ use pyo3::types::{PyAny, PyDict, PyString};
 use pyo3::{intern, PyTraverseError, PyVisit};
 
 use crate::errors::{
-    AsLocItem, ErrorType, PydanticCustomError, PydanticKnownError, PydanticOmit, ValError, ValResult, ValidationError,
+    ErrorType, PydanticCustomError, PydanticKnownError, PydanticOmit, ValError, ValResult, ValidationError,
 };
 use crate::input::Input;
 use crate::py_gc::PyGcTraverse;
@@ -371,7 +371,7 @@ struct ValidatorCallable {
 #[pymethods]
 impl ValidatorCallable {
     fn __call__(&mut self, py: Python, input_value: &PyAny, outer_location: Option<&PyAny>) -> PyResult<PyObject> {
-        let outer_location = outer_location.map(AsLocItem::as_loc_item);
+        let outer_location = outer_location.map(Into::into);
         self.validator.validate(py, input_value, outer_location)
     }
 
@@ -399,7 +399,7 @@ struct AssignmentValidatorCallable {
 #[pymethods]
 impl AssignmentValidatorCallable {
     fn __call__(&mut self, py: Python, input_value: &PyAny, outer_location: Option<&PyAny>) -> PyResult<PyObject> {
-        let outer_location = outer_location.map(AsLocItem::as_loc_item);
+        let outer_location = outer_location.map(Into::into);
         self.validator.validate_assignment(
             py,
             input_value,
diff --git a/src/validators/model_fields.rs b/src/validators/model_fields.rs
index c73a2821d..192d1ba8f 100644
--- a/src/validators/model_fields.rs
+++ b/src/validators/model_fields.rs
@@ -7,7 +7,7 @@ use ahash::AHashSet;
 
 use crate::build_tools::py_schema_err;
 use crate::build_tools::{is_strict, schema_or_config_same, ExtraBehavior};
-use crate::errors::{AsLocItem, ErrorType, ErrorTypeDefaults, ValError, ValLineError, ValResult};
+use crate::errors::{ErrorType, ErrorTypeDefaults, ValError, ValLineError, ValResult};
 use crate::input::{
     AttributesGenericIterator, BorrowInput, DictGenericIterator, GenericMapping, Input, JsonObjectGenericIterator,
     MappingGenericIterator, StringMappingGenericIterator, ValidationMatch,
@@ -183,7 +183,7 @@ impl Validator for ModelFieldsValidator {
                             Ok(v) => v,
                             Err(ValError::LineErrors(line_errors)) => {
                                 for err in line_errors {
-                                    errors.push(err.with_outer_location(field.name.as_loc_item()));
+                                    errors.push(err.with_outer_location(&field.name));
                                 }
                                 continue;
                             }
@@ -256,7 +256,7 @@ impl Validator for ModelFieldsValidator {
                             Err(ValError::LineErrors(line_errors)) => {
                                 for err in line_errors {
                                     errors.push(
-                                        err.with_outer_location(raw_key.as_loc_item())
+                                        err.with_outer_location(raw_key.clone())
                                             .with_type(ErrorTypeDefaults::InvalidKey)
 
                                     );
@@ -278,7 +278,7 @@ impl Validator for ModelFieldsValidator {
                                     ValLineError::new_with_loc(
                                         ErrorTypeDefaults::ExtraForbidden,
                                         value,
-                                        raw_key.as_loc_item(),
+                                        raw_key,
                                     )
 
                                 );
@@ -294,7 +294,7 @@ impl Validator for ModelFieldsValidator {
                                         }
                                         Err(ValError::LineErrors(line_errors)) => {
                                             for err in line_errors {
-                                                errors.push(err.with_outer_location(raw_key.as_loc_item()));
+                                                errors.push(err.with_outer_location(raw_key.clone()));
                                             }
                                         }
                                         Err(err) => return Err(err),
@@ -355,7 +355,7 @@ impl Validator for ModelFieldsValidator {
             Err(ValError::LineErrors(line_errors)) => {
                 let errors = line_errors
                     .into_iter()
-                    .map(|e| e.with_outer_location(field_name.to_string().into()))
+                    .map(|e| e.with_outer_location(field_name))
                     .collect();
                 Err(ValError::LineErrors(errors))
             }
diff --git a/src/validators/tuple.rs b/src/validators/tuple.rs
index db9c57953..6cad26073 100644
--- a/src/validators/tuple.rs
+++ b/src/validators/tuple.rs
@@ -76,7 +76,7 @@ impl TupleValidator {
                 Some((index, input_item)) => match validator.validate(py, input_item, state) {
                     Ok(item) => self.push_output_item(input, output, item, actual_length)?,
                     Err(ValError::LineErrors(line_errors)) => {
-                        errors.extend(line_errors.into_iter().map(|err| err.with_outer_location(index.into())));
+                        errors.extend(line_errors.into_iter().map(|err| err.with_outer_location(index)));
                     }
                     Err(ValError::Omit) => (),
                     Err(err) => return Err(err),
@@ -136,7 +136,7 @@ impl TupleValidator {
                     match variable_validator.validate(py, input_item, state) {
                         Ok(item) => self.push_output_item(input, &mut output, item, actual_length)?,
                         Err(ValError::LineErrors(line_errors)) => {
-                            errors.extend(line_errors.into_iter().map(|err| err.with_outer_location(index.into())));
+                            errors.extend(line_errors.into_iter().map(|err| err.with_outer_location(index)));
                         }
                         Err(ValError::Omit) => (),
                         Err(err) => return Err(err),
@@ -167,7 +167,7 @@ impl TupleValidator {
                             errors.extend(
                                 line_errors
                                     .into_iter()
-                                    .map(|err| err.with_outer_location(buffer_item_index.into())),
+                                    .map(|err| err.with_outer_location(buffer_item_index)),
                             );
                         }
                         Err(ValError::Omit) => (),
diff --git a/src/validators/typed_dict.rs b/src/validators/typed_dict.rs
index d2fc00ec7..ec0cc07cf 100644
--- a/src/validators/typed_dict.rs
+++ b/src/validators/typed_dict.rs
@@ -8,7 +8,7 @@ use ahash::AHashSet;
 
 use crate::build_tools::py_schema_err;
 use crate::build_tools::{is_strict, schema_or_config, schema_or_config_same, ExtraBehavior};
-use crate::errors::{AsLocItem, ErrorTypeDefaults, ValError, ValLineError, ValResult};
+use crate::errors::{ErrorTypeDefaults, ValError, ValLineError, ValResult};
 use crate::input::{
     AttributesGenericIterator, BorrowInput, DictGenericIterator, GenericMapping, Input, JsonObjectGenericIterator,
     MappingGenericIterator, StringMappingGenericIterator, ValidationMatch,
@@ -183,7 +183,7 @@ impl Validator for TypedDictValidator {
                             Ok(v) => v,
                             Err(ValError::LineErrors(line_errors)) => {
                                 for err in line_errors {
-                                    errors.push(err.with_outer_location(field.name.as_loc_item()));
+                                    errors.push(err.with_outer_location(&field.name));
                                 }
                                 continue;
                             }
@@ -256,7 +256,7 @@ impl Validator for TypedDictValidator {
                             Err(ValError::LineErrors(line_errors)) => {
                                 for err in line_errors {
                                     errors.push(
-                                        err.with_outer_location(raw_key.as_loc_item())
+                                        err.with_outer_location(raw_key.clone())
                                             .with_type(ErrorTypeDefaults::InvalidKey)
 
                                     );
@@ -278,7 +278,7 @@ impl Validator for TypedDictValidator {
                                     ValLineError::new_with_loc(
                                         ErrorTypeDefaults::ExtraForbidden,
                                         value,
-                                        raw_key.as_loc_item(),
+                                        raw_key,
                                     )
 
                                 );
@@ -294,9 +294,7 @@ impl Validator for TypedDictValidator {
                                         Err(ValError::LineErrors(line_errors)) => {
                                             for err in line_errors {
                                                 errors.push(
-                                                    err
-                                                    .with_outer_location(raw_key.as_loc_item())
-
+                                                    err.with_outer_location(raw_key.clone())
                                                 );
                                             }
                                         }
diff --git a/src/validators/union.rs b/src/validators/union.rs
index e010348af..0a5bd0c65 100644
--- a/src/validators/union.rs
+++ b/src/validators/union.rs
@@ -8,7 +8,7 @@ use smallvec::SmallVec;
 
 use crate::build_tools::py_schema_err;
 use crate::build_tools::{is_strict, schema_or_config};
-use crate::errors::{AsLocItem, ErrorType, ValError, ValLineError, ValResult};
+use crate::errors::{ErrorType, ValError, ValLineError, ValResult};
 use crate::input::{GenericMapping, Input};
 use crate::lookup_key::LookupKey;
 use crate::py_gc::PyGcTraverse;
@@ -263,7 +263,7 @@ impl<'a> MaybeErrors<'a> {
                          }| {
                             line_errors.into_iter().map(move |err| {
                                 let case_label = label.unwrap_or(choice.get_name());
-                                err.with_outer_location(case_label.into())
+                                err.with_outer_location(case_label)
                             })
                         },
                     )
@@ -486,7 +486,7 @@ impl TaggedUnionValidator {
         if let Ok(Some((tag, validator))) = self.lookup.validate(py, tag) {
             return match validator.validate(py, input, state) {
                 Ok(res) => Ok(res),
-                Err(err) => Err(err.with_outer_location(tag.as_loc_item())),
+                Err(err) => Err(err.with_outer_location(tag)),
             };
         }
         match self.custom_error {
diff --git a/src/validators/with_default.rs b/src/validators/with_default.rs
index a17c2cefc..f520eaf38 100644
--- a/src/validators/with_default.rs
+++ b/src/validators/with_default.rs
@@ -170,7 +170,7 @@ impl Validator for WithDefaultValidator {
                         Ok(v) => Ok(Some(v)),
                         Err(e) => {
                             if let Some(outer_loc) = outer_loc {
-                                Err(e.with_outer_location(outer_loc.into()))
+                                Err(e.with_outer_location(outer_loc))
                             } else {
                                 Err(e)
                             }

From 8be45e67aa0de48727331057366e2abc21cfc2c5 Mon Sep 17 00:00:00 2001
From: Smixi <sismixx@hotmail.fr>
Date: Mon, 22 Jan 2024 14:09:25 +0100
Subject: [PATCH 193/550] fix: 8405 pattern serialization (#1168)

---
 src/serializers/infer.rs      | 12 ++++++++++++
 src/serializers/ob_type.rs    | 10 ++++++++++
 tests/serializers/test_any.py |  3 ++-
 3 files changed, 24 insertions(+), 1 deletion(-)

diff --git a/src/serializers/infer.rs b/src/serializers/infer.rs
index 487d0d091..edbe614e4 100644
--- a/src/serializers/infer.rs
+++ b/src/serializers/infer.rs
@@ -219,6 +219,7 @@ pub(crate) fn infer_to_python_known(
                 PyList::new(py, items).into_py(py)
             }
             ObType::Path => value.str()?.into_py(py),
+            ObType::Pattern => value.getattr(intern!(py, "pattern"))?.into_py(py),
             ObType::Unknown => {
                 if let Some(fallback) = extra.fallback {
                     let next_value = fallback.call1((value,))?;
@@ -505,6 +506,16 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
             let s = value.str().map_err(py_err_se_err)?.to_str().map_err(py_err_se_err)?;
             serializer.serialize_str(s)
         }
+        ObType::Pattern => {
+            let s = value
+                .getattr(intern!(value.py(), "pattern"))
+                .map_err(py_err_se_err)?
+                .str()
+                .map_err(py_err_se_err)?
+                .to_str()
+                .map_err(py_err_se_err)?;
+            serializer.serialize_str(s)
+        }
         ObType::Unknown => {
             if let Some(fallback) = extra.fallback {
                 let next_value = fallback.call1((value,)).map_err(py_err_se_err)?;
@@ -628,6 +639,7 @@ pub(crate) fn infer_json_key_known<'py>(ob_type: ObType, key: &'py PyAny, extra:
             infer_json_key(k, extra)
         }
         ObType::Path => Ok(key.str()?.to_string_lossy()),
+        ObType::Pattern => Ok(key.getattr(intern!(key.py(), "pattern"))?.str()?.to_string_lossy()),
         ObType::Unknown => {
             if let Some(fallback) = extra.fallback {
                 let next_key = fallback.call1((key,))?;
diff --git a/src/serializers/ob_type.rs b/src/serializers/ob_type.rs
index 7493d5abd..924de001b 100644
--- a/src/serializers/ob_type.rs
+++ b/src/serializers/ob_type.rs
@@ -44,6 +44,8 @@ pub struct ObTypeLookup {
     generator_object: PyObject,
     // path
     path_object: PyObject,
+    // pattern
+    pattern_object: PyObject,
     // uuid type
     uuid_object: PyObject,
 }
@@ -87,6 +89,7 @@ impl ObTypeLookup {
                 .unwrap()
                 .to_object(py),
             path_object: py.import("pathlib").unwrap().getattr("Path").unwrap().to_object(py),
+            pattern_object: py.import("re").unwrap().getattr("Pattern").unwrap().to_object(py),
             uuid_object: py.import("uuid").unwrap().getattr("UUID").unwrap().to_object(py),
         }
     }
@@ -150,6 +153,7 @@ impl ObTypeLookup {
             ObType::Enum => self.enum_object.as_ptr() as usize == ob_type,
             ObType::Generator => self.generator_object.as_ptr() as usize == ob_type,
             ObType::Path => self.path_object.as_ptr() as usize == ob_type,
+            ObType::Pattern => self.path_object.as_ptr() as usize == ob_type,
             ObType::Uuid => self.uuid_object.as_ptr() as usize == ob_type,
             ObType::Unknown => false,
         };
@@ -242,6 +246,8 @@ impl ObTypeLookup {
             ObType::Generator
         } else if ob_type == self.path_object.as_ptr() as usize {
             ObType::Path
+        } else if ob_type == self.pattern_object.as_ptr() as usize {
+            ObType::Pattern
         } 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
@@ -319,6 +325,8 @@ impl ObTypeLookup {
             ObType::Generator
         } else if value.is_instance(self.path_object.as_ref(py)).unwrap_or(false) {
             ObType::Path
+        } else if value.is_instance(self.pattern_object.as_ref(py)).unwrap_or(false) {
+            ObType::Pattern
         } else {
             ObType::Unknown
         }
@@ -396,6 +404,8 @@ pub enum ObType {
     Generator,
     // Path
     Path,
+    //Pattern,
+    Pattern,
     // Uuid
     Uuid,
     // unknown type
diff --git a/tests/serializers/test_any.py b/tests/serializers/test_any.py
index fa6e702fe..875a3fcf1 100644
--- a/tests/serializers/test_any.py
+++ b/tests/serializers/test_any.py
@@ -1,6 +1,7 @@
 import dataclasses
 import json
 import platform
+import re
 import sys
 from collections import namedtuple
 from datetime import date, datetime, time, timedelta, timezone
@@ -437,7 +438,7 @@ def test_base64():
         (lambda: MyEnum.a, {}, b'1'),
         (lambda: MyEnum.b, {}, b'"b"'),
         (lambda: [MyDataclass(1, 'a', 2), MyModel(a=2, b='b')], {}, b'[{"a":1,"b":"a"},{"a":2,"b":"b"}]'),
-        # # (lambda: re.compile('^regex$'), b'"^regex$"'),
+        (lambda: re.compile('^regex$'), {}, b'"^regex$"'),
     ],
 )
 def test_encoding(any_serializer, gen_input, kwargs, expected_json):

From 758bc51d4bb7e94aae0c8e6f4ce515b2d55cc3a6 Mon Sep 17 00:00:00 2001
From: Jean Arhancet <jean.arhancetebehere@gmail.com>
Date: Thu, 25 Jan 2024 16:29:12 +0100
Subject: [PATCH 194/550] fix(uuid): validation from string (#1172)

---
 src/validators/uuid.rs        | 15 +++++++++++++++
 tests/validators/test_uuid.py |  5 +++++
 2 files changed, 20 insertions(+)

diff --git a/src/validators/uuid.rs b/src/validators/uuid.rs
index 4cfd7a272..c0854c10f 100644
--- a/src/validators/uuid.rs
+++ b/src/validators/uuid.rs
@@ -5,6 +5,7 @@ use pyo3::prelude::*;
 use pyo3::sync::GILOnceCell;
 use pyo3::types::{PyDict, PyType};
 use uuid::Uuid;
+use uuid::Variant;
 
 use crate::build_tools::is_strict;
 use crate::errors::{ErrorType, ErrorTypeDefaults, ValError, ValResult};
@@ -125,6 +126,20 @@ impl Validator for UuidValidator {
                 state.floor_exactness(Exactness::Lax);
             }
             let uuid = self.get_uuid(input)?;
+            // This block checks if the UUID version matches the expected version and
+            // if the UUID variant conforms to RFC 4122. When dealing with Python inputs,
+            // UUIDs must adhere to RFC 4122 standards.
+            if let Some(expected_version) = self.version {
+                if uuid.get_version_num() != expected_version || uuid.get_variant() != Variant::RFC4122 {
+                    return Err(ValError::new(
+                        ErrorType::UuidVersion {
+                            expected_version,
+                            context: None,
+                        },
+                        input,
+                    ));
+                }
+            }
             self.create_py_uuid(py, class, &uuid)
         }
     }
diff --git a/tests/validators/test_uuid.py b/tests/validators/test_uuid.py
index 9b4ef60cf..eae950a63 100644
--- a/tests/validators/test_uuid.py
+++ b/tests/validators/test_uuid.py
@@ -24,6 +24,7 @@
         ('886313e1-3b8a-5372-9b90-0c9aee199e5d', UUID('886313e1-3b8a-5372-9b90-0c9aee199e5d')),
         ('c0a8f9a8-aa5e-482b-a067-9cb3a51f5c11', UUID('c0a8f9a8-aa5e-482b-a067-9cb3a51f5c11')),
         ('00000000-8000-4000-8000-000000000000', UUID('00000000-8000-4000-8000-000000000000')),
+        ('00000000-0000-4000-0000-000000000000', UUID('00000000-0000-4000-0000-000000000000')),
         (b'\x12\x34\x56\x78' * 4, UUID('12345678-1234-5678-1234-567812345678')),
         (b'\x00\x00\x00\x00' * 4, UUID('00000000-0000-0000-0000-000000000000')),
         (b'ebcdab58-6eb8-46fb-a190-d07a33e9eac8', UUID('ebcdab58-6eb8-46fb-a190-d07a33e9eac8')),
@@ -123,6 +124,8 @@ def test_uuid_strict(input_value, expected):
         # `UUID.version` makes sense for RFC 4122 UUIDs only. For non RFC 4122 UUIDs Python uses `UUID.version=None`
         ('00000000-8000-4000-8000-000000000000', 4, UUID('00000000-8000-4000-8000-000000000000')),
         (UUID('00000000-8000-4000-8000-000000000000'), 4, UUID('00000000-8000-4000-8000-000000000000')),
+        ('00000000-0000-4000-0000-000000000000', None, UUID('00000000-0000-4000-0000-000000000000')),
+        (UUID('00000000-0000-4000-0000-000000000000'), None, UUID('00000000-0000-4000-0000-000000000000')),
         ('00000000-7fff-4000-7fff-000000000000', None, UUID('00000000-7fff-4000-7fff-000000000000')),
         (UUID('00000000-7fff-4000-7fff-000000000000'), None, UUID('00000000-7fff-4000-7fff-000000000000')),
         (UUID('00000000-7fff-4000-7fff-000000000000'), 4, Err('UUID version 4 expected')),
@@ -138,6 +141,8 @@ def test_uuid_strict(input_value, expected):
         (UUID('0e7ac198-9acd-4c0c-b4b4-761974bf71d7'), 3, Err('UUID version 3 expected')),
         ('08ed0736-fb95-5cc5-85ed-37e4f3df9b29', 1, Err('UUID version 1 expected')),
         (UUID('08ed0736-fb95-5cc5-85ed-37e4f3df9b29'), 1, Err('UUID version 1 expected')),
+        ('00000000-0000-4000-0000-000000000000', 4, Err('UUID version 4 expected')),
+        (UUID('00000000-0000-4000-0000-000000000000'), 4, Err('UUID version 4 expected')),
     ],
 )
 def test_uuid_version(input_value, version, expected):

From dcaf63ece0836d8f09707d66f9d66721bfa50dd9 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Thu, 1 Feb 2024 14:04:09 +0000
Subject: [PATCH 195/550] Fix warning for tuple of wrong size in union (#1174)

---
 src/serializers/type_serializers/tuple.rs | 244 +++++++++++-----------
 tests/serializers/test_list_tuple.py      |  26 +++
 2 files changed, 144 insertions(+), 126 deletions(-)

diff --git a/src/serializers/type_serializers/tuple.rs b/src/serializers/type_serializers/tuple.rs
index e5f225c92..5890288d6 100644
--- a/src/serializers/type_serializers/tuple.rs
+++ b/src/serializers/type_serializers/tuple.rs
@@ -7,8 +7,10 @@ use std::iter;
 use serde::ser::SerializeSeq;
 
 use crate::definitions::DefinitionsBuilder;
+use crate::serializers::extra::SerCheck;
 use crate::serializers::type_serializers::any::AnySerializer;
 use crate::tools::SchemaDict;
+use crate::PydanticSerializationUnexpectedValue;
 
 use super::{
     infer_json_key, infer_serialize, infer_to_python, py_err_se_err, BuildSerializer, CombinedSerializer, Extra,
@@ -70,52 +72,14 @@ impl TypeSerializer for TupleSerializer {
                 let py = value.py();
 
                 let n_items = py_tuple.len();
-                let mut py_tuple_iter = py_tuple.iter();
                 let mut items = Vec::with_capacity(n_items);
 
-                macro_rules! use_serializers {
-                    ($serializers_iter:expr) => {
-                        for (index, serializer) in $serializers_iter.enumerate() {
-                            let element = match py_tuple_iter.next() {
-                                Some(value) => value,
-                                None => break,
-                            };
-                            let op_next = self
-                                .filter
-                                .index_filter(index, include, exclude, Some(n_items))?;
-                            if let Some((next_include, next_exclude)) = op_next {
-                                items.push(serializer.to_python(element, next_include, next_exclude, extra)?);
-                            }
-                        }
-                    };
-                }
-
-                if let Some(variadic_item_index) = self.variadic_item_index {
-                    // Need `saturating_sub` to handle items with too few elements without panicking
-                    let n_variadic_items = (n_items + 1).saturating_sub(self.serializers.len());
-                    let serializers_iter = self.serializers[..variadic_item_index]
-                        .iter()
-                        .chain(iter::repeat(&self.serializers[variadic_item_index]).take(n_variadic_items))
-                        .chain(self.serializers[variadic_item_index + 1..].iter());
-                    use_serializers!(serializers_iter);
-                } else {
-                    use_serializers!(self.serializers.iter());
-                    let mut warned = false;
-                    for (i, element) in py_tuple_iter.enumerate() {
-                        if !warned {
-                            extra
-                                .warnings
-                                .custom_warning("Unexpected extra items present in tuple".to_string());
-                            warned = true;
-                        }
-                        let op_next =
-                            self.filter
-                                .index_filter(i + self.serializers.len(), include, exclude, Some(n_items))?;
-                        if let Some((next_include, next_exclude)) = op_next {
-                            items.push(AnySerializer.to_python(element, next_include, next_exclude, extra)?);
-                        }
-                    }
-                };
+                self.for_each_tuple_item_and_serializer(py_tuple, include, exclude, extra, |entry| {
+                    entry
+                        .serializer
+                        .to_python(entry.item, entry.include, entry.exclude, extra)
+                        .map(|item| items.push(item))
+                })??;
 
                 match extra.mode {
                     SerMode::Json => Ok(PyList::new(py, items).into_py(py)),
@@ -132,35 +96,14 @@ impl TypeSerializer for TupleSerializer {
     fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
         match key.downcast::<PyTuple>() {
             Ok(py_tuple) => {
-                let mut py_tuple_iter = py_tuple.iter();
-
                 let mut key_builder = KeyBuilder::new();
 
-                let n_items = py_tuple.len();
-
-                macro_rules! use_serializers {
-                    ($serializers_iter:expr) => {
-                        for serializer in $serializers_iter {
-                            let element = match py_tuple_iter.next() {
-                                Some(value) => value,
-                                None => break,
-                            };
-                            key_builder.push(&serializer.json_key(element, extra)?);
-                        }
-                    };
-                }
-
-                if let Some(variadic_item_index) = self.variadic_item_index {
-                    // Need `saturating_sub` to handle items with too few elements without panicking
-                    let n_variadic_items = (n_items + 1).saturating_sub(self.serializers.len());
-                    let serializers_iter = self.serializers[..variadic_item_index]
-                        .iter()
-                        .chain(iter::repeat(&self.serializers[variadic_item_index]).take(n_variadic_items))
-                        .chain(self.serializers[variadic_item_index + 1..].iter());
-                    use_serializers!(serializers_iter);
-                } else {
-                    use_serializers!(self.serializers.iter());
-                };
+                self.for_each_tuple_item_and_serializer(py_tuple, None, None, extra, |entry| {
+                    entry
+                        .serializer
+                        .json_key(entry.item, extra)
+                        .map(|key| key_builder.push(&key))
+                })??;
 
                 Ok(Cow::Owned(key_builder.finish()))
             }
@@ -184,63 +127,18 @@ impl TypeSerializer for TupleSerializer {
                 let py_tuple: &PyTuple = py_tuple.downcast().map_err(py_err_se_err)?;
 
                 let n_items = py_tuple.len();
-                let mut py_tuple_iter = py_tuple.iter();
                 let mut seq = serializer.serialize_seq(Some(n_items))?;
 
-                macro_rules! use_serializers {
-                    ($serializers_iter:expr) => {
-                        for (index, serializer) in $serializers_iter.enumerate() {
-                            let element = match py_tuple_iter.next() {
-                                Some(value) => value,
-                                None => break,
-                            };
-                            let op_next = self
-                                .filter
-                                .index_filter(index, include, exclude, Some(n_items))
-                                .map_err(py_err_se_err)?;
-                            if let Some((next_include, next_exclude)) = op_next {
-                                let item_serialize =
-                                    PydanticSerializer::new(element, serializer, next_include, next_exclude, extra);
-                                seq.serialize_element(&item_serialize)?;
-                            }
-                        }
-                    };
-                }
-
-                if let Some(variadic_item_index) = self.variadic_item_index {
-                    // Need `saturating_sub` to handle items with too few elements without panicking
-                    let n_variadic_items = (n_items + 1).saturating_sub(self.serializers.len());
-                    let serializers_iter = self.serializers[..variadic_item_index]
-                        .iter()
-                        .chain(iter::repeat(&self.serializers[variadic_item_index]).take(n_variadic_items))
-                        .chain(self.serializers[variadic_item_index + 1..].iter());
-                    use_serializers!(serializers_iter);
-                } else {
-                    use_serializers!(self.serializers.iter());
-                    let mut warned = false;
-                    for (i, element) in py_tuple_iter.enumerate() {
-                        if !warned {
-                            extra
-                                .warnings
-                                .custom_warning("Unexpected extra items present in tuple".to_string());
-                            warned = true;
-                        }
-                        let op_next = self
-                            .filter
-                            .index_filter(i + self.serializers.len(), include, exclude, Some(n_items))
-                            .map_err(py_err_se_err)?;
-                        if let Some((next_include, next_exclude)) = op_next {
-                            let item_serialize = PydanticSerializer::new(
-                                element,
-                                &CombinedSerializer::Any(AnySerializer),
-                                next_include,
-                                next_exclude,
-                                extra,
-                            );
-                            seq.serialize_element(&item_serialize)?;
-                        }
-                    }
-                };
+                self.for_each_tuple_item_and_serializer(py_tuple, include, exclude, extra, |entry| {
+                    seq.serialize_element(&PydanticSerializer::new(
+                        entry.item,
+                        entry.serializer,
+                        entry.include,
+                        entry.exclude,
+                        extra,
+                    ))
+                })
+                .map_err(py_err_se_err)??;
 
                 seq.end()
             }
@@ -254,6 +152,100 @@ impl TypeSerializer for TupleSerializer {
     fn get_name(&self) -> &str {
         &self.name
     }
+
+    fn retry_with_lax_check(&self) -> bool {
+        true
+    }
+}
+
+struct TupleSerializerEntry<'a, 'py> {
+    item: &'py PyAny,
+    include: Option<&'py PyAny>,
+    exclude: Option<&'py PyAny>,
+    serializer: &'a CombinedSerializer,
+}
+
+impl TupleSerializer {
+    /// Try to serialize each item in the tuple with the corresponding serializer.
+    ///
+    /// If the tuple doesn't match the length of the serializer, in strict mode, an error is returned.
+    ///
+    /// The error type E is the type of the error returned by the closure, which is why there are two
+    /// levels of `Result`.
+    fn for_each_tuple_item_and_serializer<E>(
+        &self,
+        tuple: &PyTuple,
+        include: Option<&PyAny>,
+        exclude: Option<&PyAny>,
+        extra: &Extra,
+        mut f: impl for<'a, 'py> FnMut(TupleSerializerEntry<'a, 'py>) -> Result<(), E>,
+    ) -> PyResult<Result<(), E>> {
+        let n_items = tuple.len();
+        let mut py_tuple_iter = tuple.iter();
+
+        macro_rules! use_serializers {
+            ($serializers_iter:expr) => {
+                for (index, serializer) in $serializers_iter.enumerate() {
+                    let element = match py_tuple_iter.next() {
+                        Some(value) => value,
+                        None => break,
+                    };
+                    let op_next = self.filter.index_filter(index, include, exclude, Some(n_items))?;
+                    if let Some((next_include, next_exclude)) = op_next {
+                        if let Err(e) = f(TupleSerializerEntry {
+                            item: element,
+                            include: next_include,
+                            exclude: next_exclude,
+                            serializer,
+                        }) {
+                            return Ok(Err(e));
+                        };
+                    }
+                }
+            };
+        }
+
+        if let Some(variadic_item_index) = self.variadic_item_index {
+            // Need `saturating_sub` to handle items with too few elements without panicking
+            let n_variadic_items = (n_items + 1).saturating_sub(self.serializers.len());
+            let serializers_iter = self.serializers[..variadic_item_index]
+                .iter()
+                .chain(iter::repeat(&self.serializers[variadic_item_index]).take(n_variadic_items))
+                .chain(self.serializers[variadic_item_index + 1..].iter());
+            use_serializers!(serializers_iter);
+        } else if extra.check == SerCheck::Strict && n_items != self.serializers.len() {
+            return Err(PydanticSerializationUnexpectedValue::new_err(Some(format!(
+                "Expected {} items, but got {}",
+                self.serializers.len(),
+                n_items
+            ))));
+        } else {
+            use_serializers!(self.serializers.iter());
+            let mut warned = false;
+            for (i, element) in py_tuple_iter.enumerate() {
+                if !warned {
+                    extra
+                        .warnings
+                        .custom_warning("Unexpected extra items present in tuple".to_string());
+                    warned = true;
+                }
+                let op_next = self
+                    .filter
+                    .index_filter(i + self.serializers.len(), include, exclude, Some(n_items))?;
+                if let Some((next_include, next_exclude)) = op_next {
+                    if let Err(e) = f(TupleSerializerEntry {
+                        item: element,
+                        include: next_include,
+                        exclude: next_exclude,
+                        serializer: &CombinedSerializer::Any(AnySerializer),
+                    }) {
+                        return Ok(Err(e));
+                    };
+                }
+            }
+        };
+        Ok(Ok(()))
+    }
 }
 
 pub(crate) struct KeyBuilder {
diff --git a/tests/serializers/test_list_tuple.py b/tests/serializers/test_list_tuple.py
index df6aabd8a..256a342fe 100644
--- a/tests/serializers/test_list_tuple.py
+++ b/tests/serializers/test_list_tuple.py
@@ -411,3 +411,29 @@ def test_tuple_pos_dict_key():
     assert s.to_python({(1, 'a', 2): 1}, mode='json') == {'1,a,2': 1}
     assert s.to_json({(1, 'a'): 1}) == b'{"1,a":1}'
     assert s.to_json({(1, 'a', 2): 1}) == b'{"1,a,2":1}'
+
+
+def test_tuple_wrong_size_union():
+    # See https://github.com/pydantic/pydantic/issues/8677
+
+    f = core_schema.float_schema()
+    s = SchemaSerializer(
+        core_schema.union_schema([core_schema.tuple_schema([f, f]), core_schema.tuple_schema([f, f, f])])
+    )
+    assert s.to_python((1.0, 2.0)) == (1.0, 2.0)
+    assert s.to_python((1.0, 2.0, 3.0)) == (1.0, 2.0, 3.0)
+
+    with pytest.warns(UserWarning, match='Unexpected extra items present in tuple'):
+        s.to_python((1.0, 2.0, 3.0, 4.0))
+
+    assert s.to_python((1.0, 2.0), mode='json') == [1.0, 2.0]
+    assert s.to_python((1.0, 2.0, 3.0), mode='json') == [1.0, 2.0, 3.0]
+
+    with pytest.warns(UserWarning, match='Unexpected extra items present in tuple'):
+        s.to_python((1.0, 2.0, 3.0, 4.0), mode='json')
+
+    assert s.to_json((1.0, 2.0)) == b'[1.0,2.0]'
+    assert s.to_json((1.0, 2.0, 3.0)) == b'[1.0,2.0,3.0]'
+
+    with pytest.warns(UserWarning, match='Unexpected extra items present in tuple'):
+        s.to_json((1.0, 2.0, 3.0, 4.0))

From 42394acb0fdd9b7cb64ec56174be4ac3b9eca5c9 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Thu, 1 Feb 2024 12:57:54 -0600
Subject: [PATCH 196/550] Fix model computed field serializer (json) (#1187)

---
 src/serializers/computed_fields.rs |  2 +-
 tests/serializers/test_model.py    | 45 ++++++++++++++++++++++++++++++
 2 files changed, 46 insertions(+), 1 deletion(-)

diff --git a/src/serializers/computed_fields.rs b/src/serializers/computed_fields.rs
index 6f4553069..43e284fdd 100644
--- a/src/serializers/computed_fields.rs
+++ b/src/serializers/computed_fields.rs
@@ -75,7 +75,7 @@ impl ComputedFields {
             let property_name_py = computed_field.property_name_py.as_ref(model.py());
             let value = model.getattr(property_name_py).map_err(py_err_se_err)?;
             if extra.exclude_none && value.is_none() {
-                return Ok(());
+                continue;
             }
             if let Some((next_include, next_exclude)) = filter
                 .key_filter(property_name_py, include, exclude)
diff --git a/tests/serializers/test_model.py b/tests/serializers/test_model.py
index 4249c3015..0be83e538 100644
--- a/tests/serializers/test_model.py
+++ b/tests/serializers/test_model.py
@@ -650,6 +650,51 @@ def volume(self) -> None:
     assert s.to_json(Model(3, 4), exclude_none=True) == b'{"width":3,"height":4,"Area":12}'
 
 
+def test_computed_field_exclude_none_different_order():
+    # verify that order of computed fields doesn't matter
+    # issue originally reported via: https://github.com/pydantic/pydantic/issues/8691
+
+    @dataclasses.dataclass
+    class Model:
+        width: int
+        height: int
+
+        @property
+        def volume(self) -> None:
+            return None
+
+        @property
+        def area(self) -> int:
+            return self.width * self.height
+
+    s = SchemaSerializer(
+        core_schema.model_schema(
+            Model,
+            core_schema.model_fields_schema(
+                {
+                    'width': core_schema.model_field(core_schema.int_schema()),
+                    'height': core_schema.model_field(core_schema.int_schema()),
+                },
+                computed_fields=[
+                    core_schema.computed_field('volume', core_schema.int_schema()),
+                    core_schema.computed_field('area', core_schema.int_schema(), alias='Area'),
+                ],
+            ),
+        )
+    )
+    assert s.to_python(Model(3, 4), exclude_none=False) == {'width': 3, 'height': 4, 'Area': 12, 'volume': None}
+    assert s.to_python(Model(3, 4), exclude_none=True) == {'width': 3, 'height': 4, 'Area': 12}
+    assert s.to_python(Model(3, 4), mode='json', exclude_none=False) == {
+        'width': 3,
+        'height': 4,
+        'Area': 12,
+        'volume': None,
+    }
+    assert s.to_python(Model(3, 4), mode='json', exclude_none=True) == {'width': 3, 'height': 4, 'Area': 12}
+    assert s.to_json(Model(3, 4), exclude_none=False) == b'{"width":3,"height":4,"volume":null,"Area":12}'
+    assert s.to_json(Model(3, 4), exclude_none=True) == b'{"width":3,"height":4,"Area":12}'
+
+
 @pytest.mark.skipif(cached_property is None, reason='cached_property is not available')
 def test_cached_property_alias():
     @dataclasses.dataclass

From 305a837e9f76872a5e91db396c8de22cc81aaffc Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Fri, 2 Feb 2024 11:59:10 -0600
Subject: [PATCH 197/550] Version bump, 2.16.2 (#1188)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 5d113589f..40419c743 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -332,7 +332,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.16.1"
+version = "2.16.2"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index c26c91419..a10c8e0f4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.16.1"
+version = "2.16.2"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From 858d85df0fac21f4230e110b0020fea8825309c7 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 5 Feb 2024 10:07:37 +0000
Subject: [PATCH 198/550] Bump the python-packages group with 7 updates (#1182)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 6 +++---
 tests/requirements.txt         | 8 ++++----
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index 043482646..1692fa86d 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,4 +1,4 @@
-griffe==0.38.1
-pyright==1.1.345
-ruff==0.1.13
+griffe==0.40.0
+pyright==1.1.349
+ruff==0.1.15
 mypy==1.8.0
diff --git a/tests/requirements.txt b/tests/requirements.txt
index 29bf5bcad..756792f2a 100644
--- a/tests/requirements.txt
+++ b/tests/requirements.txt
@@ -1,12 +1,12 @@
-coverage==7.4.0
+coverage==7.4.1
 dirty-equals==0.7.1.post0
-hypothesis==6.92.9
+hypothesis==6.97.4
 # TODO: remove manual override for dateutil once a version newer than 2.8.2 is
 # released which removes use of deprecated utcfromtimestamp
 git+https://github.com/dateutil/dateutil.git@f2293200747fb03d56c6c5997bfebeabe703576f
 # pandas doesn't offer prebuilt wheels for all versions and platforms we test in CI e.g. aarch64 musllinux
 pandas==2.1.3; python_version >= "3.9" and python_version < "3.13" and implementation_name == "cpython" and platform_machine == 'x86_64'
-pytest==7.4.4
+pytest==8.0.0
 # we run codspeed benchmarks on x86_64 CPython (i.e. native github actions architecture)
 pytest-codspeed~=2.2.0; implementation_name == "cpython" and platform_machine == 'x86_64'
 # pytest-examples currently depends on aiohttp via black; we don't want to build
@@ -16,7 +16,7 @@ pytest-speed==0.3.5
 pytest-mock==3.11.1
 pytest-pretty==1.2.0
 pytest-timeout==2.2.0
-pytz==2023.3.post1
+pytz==2023.4
 # numpy doesn't offer prebuilt wheels for all versions and platforms we test in CI e.g. aarch64 musllinux
 numpy==1.26.2; python_version >= "3.9" and python_version < "3.13" and implementation_name == "cpython" and platform_machine == 'x86_64'
 exceptiongroup==1.1; python_version < "3.11"

From b393063f98c995726f775023927f6a68a5e1a2e2 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 5 Feb 2024 10:08:12 +0000
Subject: [PATCH 199/550] Bump actions/cache from 3 to 4 (#1186)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/ci.yml       | 2 +-
 .github/workflows/codspeed.yml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 826635499..42a210688 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -239,7 +239,7 @@ jobs:
         with:
           node-version: '18'
 
-      - uses: actions/cache@v3
+      - uses: actions/cache@v4
         id: cache-py
         name: cache python
         with:
diff --git a/.github/workflows/codspeed.yml b/.github/workflows/codspeed.yml
index fc6591314..33497021f 100644
--- a/.github/workflows/codspeed.yml
+++ b/.github/workflows/codspeed.yml
@@ -20,7 +20,7 @@ jobs:
         with:
           python-version: '3.12'
 
-      - uses: actions/cache@v3
+      - uses: actions/cache@v4
         id: cache-py
         name: cache python
         with:

From 1fb3343cbfe4cb75de0f542dd002daa3a3f497af Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 5 Feb 2024 10:08:20 +0000
Subject: [PATCH 200/550] Bump mymindstorm/setup-emsdk from 13 to 14 (#1185)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 42a210688..884cd663c 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -304,7 +304,7 @@ jobs:
       - name: cache rust
         uses: Swatinem/rust-cache@v2
 
-      - uses: mymindstorm/setup-emsdk@v13
+      - uses: mymindstorm/setup-emsdk@v14
         with:
           # NOTE!: as per https://github.com/pydantic/pydantic-core/pull/149 this version needs to match the version
           # in node_modules/pyodide/repodata.json, to get the version, run:

From ff073f0c9a70c2b4fe1bfcb1a98cf7a395a962c1 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 5 Feb 2024 10:08:45 +0000
Subject: [PATCH 201/550] Bump codecov/codecov-action from 3 to 4 (#1184)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 884cd663c..57dba20a2 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -55,7 +55,7 @@ jobs:
 
       - run: coverage-prepare lcov python/pydantic_core/*.so
 
-      - uses: codecov/codecov-action@v3
+      - uses: codecov/codecov-action@v4
 
   # See https://github.com/PyO3/pyo3/discussions/2781
   # tests intermittently segfault with pypy and cpython 3.7 when using `coverage run ...`, hence separate job

From 5ba2d52fbcf839f6655b3845bfcaef9a6a798474 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 5 Feb 2024 10:09:18 +0000
Subject: [PATCH 202/550] Bump uraimo/run-on-arch-action from 2.6.0 to 2.7.1
 (#1183)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 57dba20a2..6a4d32a4d 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -611,7 +611,7 @@ jobs:
           merge-multiple: true
           path: dist
 
-      - uses: uraimo/run-on-arch-action@v2.6.0
+      - uses: uraimo/run-on-arch-action@v2.7.1
         name: install & test
         with:
           arch: ${{ matrix.target }}

From d0a438a3847f8e194e81b33ce965b9969ce9b386 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 5 Feb 2024 10:09:35 +0000
Subject: [PATCH 203/550] Bump smallvec from 1.11.2 to 1.13.1 (#1181)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 40419c743..28ceaf2ff 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -526,9 +526,9 @@ dependencies = [
 
 [[package]]
 name = "smallvec"
-version = "1.11.2"
+version = "1.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4dccd0940a2dcdf68d092b8cbab7dc0ad8fa938bf95787e1b916b0e3d0e8e970"
+checksum = "e6ecd384b10a64542d77071bd64bd7b231f4ed5940fba55e98c3de13824cf3d7"
 
 [[package]]
 name = "speedate"
diff --git a/Cargo.toml b/Cargo.toml
index a10c8e0f4..ce5d70a60 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -34,7 +34,7 @@ serde_json = {version = "1.0.109", features = ["arbitrary_precision", "preserve_
 enum_dispatch = "0.3.8"
 serde = { version = "1.0.195", features = ["derive"] }
 speedate = "0.13.0"
-smallvec = "1.11.2"
+smallvec = "1.13.1"
 ahash = "0.8.7"
 url = "2.5.0"
 # idna is already required by url, added here to be explicit

From a2bf4d8e3905a8a9d9c61958a55e265d8be160ca Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 5 Feb 2024 10:09:46 +0000
Subject: [PATCH 204/550] Bump regex from 1.10.2 to 1.10.3 (#1180)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 8 ++++----
 Cargo.toml | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 28ceaf2ff..29c8f9dec 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -447,9 +447,9 @@ dependencies = [
 
 [[package]]
 name = "regex"
-version = "1.10.2"
+version = "1.10.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "380b951a9c5e80ddfd6136919eef32310721aa4aacd4889a8d39124b026ab343"
+checksum = "b62dbe01f0b06f9d8dc7d49e05a0785f153b00b2c227856282f671e0318c9b15"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -459,9 +459,9 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.4.3"
+version = "0.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5f804c7828047e88b2d32e2d7fe5a105da8ee3264f01902f796c8e067dc2483f"
+checksum = "5bb987efffd3c6d0d8f5f89510bb458559eab11e4f869acb20bf845e016259cd"
 dependencies = [
  "aho-corasick",
  "memchr",
diff --git a/Cargo.toml b/Cargo.toml
index ce5d70a60..68983ae1d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -27,7 +27,7 @@ include = [
 
 [dependencies]
 pyo3 = { version = "0.20.2", features = ["generate-import-lib", "num-bigint"] }
-regex = "1.10.2"
+regex = "1.10.3"
 strum = { version = "0.25.0", features = ["derive"] }
 strum_macros = "0.25.3"
 serde_json = {version = "1.0.109", features = ["arbitrary_precision", "preserve_order"]}

From 0c804383967c6453a81b3c8e2ef0cf7004c5083f Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 5 Feb 2024 10:10:02 +0000
Subject: [PATCH 205/550] Bump uuid from 1.6.1 to 1.7.0 (#1179)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 29c8f9dec..63637bd1e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -640,9 +640,9 @@ dependencies = [
 
 [[package]]
 name = "uuid"
-version = "1.6.1"
+version = "1.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e395fcf16a7a3d8127ec99782007af141946b4795001f876d54fb0d55978560"
+checksum = "f00cc9702ca12d3c81455259621e676d0f7251cec66a21e98fe2e9a37db93b2a"
 
 [[package]]
 name = "version_check"
diff --git a/Cargo.toml b/Cargo.toml
index 68983ae1d..f74a9cafb 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -42,7 +42,7 @@ idna = "0.5.0"
 base64 = "0.21.7"
 num-bigint = "0.4.4"
 python3-dll-a = "0.2.7"
-uuid = "1.6.1"
+uuid = "1.7.0"
 jiter = {version = "0.0.6", features = ["python"]}
 
 [lib]

From 80660d582a173773f20a7342d735e920a6aff503 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 5 Feb 2024 10:10:21 +0000
Subject: [PATCH 206/550] Bump serde_json from 1.0.109 to 1.0.113 (#1178)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 8 ++++----
 Cargo.toml | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 63637bd1e..d099e33ef 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -126,9 +126,9 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.0.0"
+version = "2.2.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5477fe2230a79769d8dc68e0eabf5437907c0457a5614a9e8dddb67f65eb65d"
+checksum = "824b2ae422412366ba479e8111fd301f7b5faece8149317bb81925979a53f520"
 dependencies = [
  "equivalent",
  "hashbrown",
@@ -514,9 +514,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.109"
+version = "1.0.113"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "cb0652c533506ad7a2e353cce269330d6afd8bdfb6d75e0ace5b35aacbd7b9e9"
+checksum = "69801b70b1c3dac963ecb03a364ba0ceda9cf60c71cfe475e99864759c8b8a79"
 dependencies = [
  "indexmap",
  "itoa",
diff --git a/Cargo.toml b/Cargo.toml
index f74a9cafb..d8b2ba182 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -30,7 +30,7 @@ pyo3 = { version = "0.20.2", features = ["generate-import-lib", "num-bigint"] }
 regex = "1.10.3"
 strum = { version = "0.25.0", features = ["derive"] }
 strum_macros = "0.25.3"
-serde_json = {version = "1.0.109", features = ["arbitrary_precision", "preserve_order"]}
+serde_json = {version = "1.0.113", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.8"
 serde = { version = "1.0.195", features = ["derive"] }
 speedate = "0.13.0"

From 44621f1dee5160c737a0749d21e0b2118fa99705 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 5 Feb 2024 10:19:19 +0000
Subject: [PATCH 207/550] Bump serde from 1.0.195 to 1.0.196 (#1177)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 8 ++++----
 Cargo.toml | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index d099e33ef..c00c1131e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -494,18 +494,18 @@ checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
 
 [[package]]
 name = "serde"
-version = "1.0.195"
+version = "1.0.196"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "63261df402c67811e9ac6def069e4786148c4563f4b50fd4bf30aa370d626b02"
+checksum = "870026e60fa08c69f064aa766c10f10b1d62db9ccd4d0abb206472bee0ce3b32"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.195"
+version = "1.0.196"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46fe8f8603d81ba86327b23a2e9cdf49e1255fb94a4c5f297f6ee0547178ea2c"
+checksum = "33c85360c95e7d137454dc81d9a4ed2b8efd8fbe19cee57357b32b9771fccb67"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/Cargo.toml b/Cargo.toml
index d8b2ba182..47b9d784c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -32,7 +32,7 @@ strum = { version = "0.25.0", features = ["derive"] }
 strum_macros = "0.25.3"
 serde_json = {version = "1.0.113", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.8"
-serde = { version = "1.0.195", features = ["derive"] }
+serde = { version = "1.0.196", features = ["derive"] }
 speedate = "0.13.0"
 smallvec = "1.13.1"
 ahash = "0.8.7"

From fadeecc0b25c9f9533fcd2e615f63a0e7e8be7a7 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Thu, 15 Feb 2024 13:33:34 +0000
Subject: [PATCH 208/550] ci: updates for Rust 1.76 (#1191)

---
 src/errors/value_exception.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/errors/value_exception.rs b/src/errors/value_exception.rs
index 68f93d463..3152044d1 100644
--- a/src/errors/value_exception.rs
+++ b/src/errors/value_exception.rs
@@ -98,7 +98,7 @@ impl PydanticCustomError {
 
     fn __repr__(&self, py: Python) -> PyResult<String> {
         let msg = self.message(py)?;
-        match { self.context.as_ref() } {
+        match self.context.as_ref() {
             Some(ctx) => Ok(format!("{msg} [type={}, context={}]", self.error_type, ctx.as_ref(py))),
             None => Ok(format!("{msg} [type={}, context=None]", self.error_type)),
         }
@@ -173,7 +173,7 @@ impl PydanticKnownError {
 
     fn __repr__(&self, py: Python) -> PyResult<String> {
         let msg = self.message(py)?;
-        match { self.context(py)?.as_ref() } {
+        match self.context(py)?.as_ref() {
             Some(ctx) => Ok(format!(
                 "{msg} [type={}, context={}]",
                 self.error_type(),

From 61a656239d0e4748cd5c59a134372eab907b5cf6 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Thu, 15 Feb 2024 07:53:32 -0600
Subject: [PATCH 209/550] `date` string coerced to `datetime` shouldn't infer
 timezone (#1193)

---
 src/validators/datetime.rs        | 3 +--
 tests/validators/test_datetime.py | 2 +-
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/validators/datetime.rs b/src/validators/datetime.rs
index 8779ea76c..94dc7ba05 100644
--- a/src/validators/datetime.rs
+++ b/src/validators/datetime.rs
@@ -140,7 +140,6 @@ impl Validator for DateTimeValidator {
 }
 
 /// In lax mode, if the input is not a datetime, we try parsing the input as a date and add the "00:00:00" time.
-///
 /// Ok(None) means that this is not relevant to datetimes (the input was not a date nor a string)
 fn datetime_from_date<'data>(input: &'data impl Input<'data>) -> Result<Option<EitherDateTime<'data>>, ValError> {
     let either_date = match input.validate_date(false) {
@@ -171,7 +170,7 @@ fn datetime_from_date<'data>(input: &'data impl Input<'data>) -> Result<Option<E
         minute: 0,
         second: 0,
         microsecond: 0,
-        tz_offset: Some(0),
+        tz_offset: None,
     };
 
     let datetime = DateTime {
diff --git a/tests/validators/test_datetime.py b/tests/validators/test_datetime.py
index 1d4a216f9..33ebb1250 100644
--- a/tests/validators/test_datetime.py
+++ b/tests/validators/test_datetime.py
@@ -19,7 +19,7 @@
     [
         (datetime(2022, 6, 8, 12, 13, 14), datetime(2022, 6, 8, 12, 13, 14)),
         (date(2022, 6, 8), datetime(2022, 6, 8)),
-        ('2022-01-01', datetime(2022, 1, 1, 0, 0, 0, tzinfo=timezone.utc)),
+        ('2022-01-01', datetime(2022, 1, 1, 0, 0, 0)),
         ('2022-06-08T12:13:14', datetime(2022, 6, 8, 12, 13, 14)),
         ('1000000000000', datetime(2001, 9, 9, 1, 46, 40, tzinfo=timezone.utc)),
         (b'2022-06-08T12:13:14', datetime(2022, 6, 8, 12, 13, 14)),

From cf4251138ec80cb17da7d0c89437a2100c56db74 Mon Sep 17 00:00:00 2001
From: Alex Hall <alex.mojaki@gmail.com>
Date: Sat, 17 Feb 2024 14:22:42 +0200
Subject: [PATCH 210/550] Add benchmarks for serializing model with complete
 schema (#1189)

---
 tests/benchmarks/test_complete_benchmark.py | 21 ++++++++++++++++++++-
 1 file changed, 20 insertions(+), 1 deletion(-)

diff --git a/tests/benchmarks/test_complete_benchmark.py b/tests/benchmarks/test_complete_benchmark.py
index 57fb7645c..b13fddda7 100644
--- a/tests/benchmarks/test_complete_benchmark.py
+++ b/tests/benchmarks/test_complete_benchmark.py
@@ -8,7 +8,7 @@
 
 import pytest
 
-from pydantic_core import SchemaValidator, ValidationError, validate_core_schema
+from pydantic_core import SchemaSerializer, SchemaValidator, ValidationError, validate_core_schema
 
 from .complete_schema import input_data_lax, input_data_strict, input_data_wrong, schema
 
@@ -98,6 +98,25 @@ def test_complete_core_strict(benchmark):
     benchmark(v.validate_python, input_data_strict())
 
 
+@pytest.mark.benchmark(group='complete-to-python')
+def test_complete_core_serializer_to_python(benchmark):
+    core_schema = validate_core_schema(schema())
+    v = SchemaValidator(core_schema)
+    model = v.validate_python(input_data_lax())
+    serializer = SchemaSerializer(core_schema)
+    assert serializer.to_python(model) == model.__dict__
+    benchmark(serializer.to_python, model)
+
+
+@pytest.mark.benchmark(group='complete-to-json')
+def test_complete_core_serializer_to_json(benchmark):
+    core_schema = validate_core_schema(schema())
+    v = SchemaValidator(core_schema)
+    model = v.validate_python(input_data_lax())
+    serializer = SchemaSerializer(core_schema)
+    benchmark(serializer.to_json, model)
+
+
 @pytest.mark.benchmark(group='complete-wrong')
 def test_complete_core_error(benchmark):
     v = SchemaValidator(validate_core_schema(schema()))

From ea443ba0b08bde949c9460aa2d43ad0058fd407c Mon Sep 17 00:00:00 2001
From: Alex Hall <alex.mojaki@gmail.com>
Date: Mon, 19 Feb 2024 13:36:48 +0200
Subject: [PATCH 211/550] Prevent panicking when `__dict__` changes during
 iteration (#1196)

---
 src/serializers/fields.rs       | 12 ++++++--
 tests/serializers/test_model.py | 52 +++++++++++++++++++++++++++++++++
 2 files changed, 62 insertions(+), 2 deletions(-)

diff --git a/src/serializers/fields.rs b/src/serializers/fields.rs
index cefdec1d7..c57729c46 100644
--- a/src/serializers/fields.rs
+++ b/src/serializers/fields.rs
@@ -5,6 +5,7 @@ use pyo3::types::{PyDict, PyString};
 
 use ahash::AHashMap;
 use serde::ser::SerializeMap;
+use smallvec::SmallVec;
 
 use crate::serializers::extra::SerCheck;
 use crate::PydanticSerializationUnexpectedValue;
@@ -321,7 +322,7 @@ impl TypeSerializer for GeneralFieldsSerializer {
             return infer_to_python(value, include, exclude, &td_extra);
         };
 
-        let output_dict = self.main_to_python(py, main_dict.iter().map(Ok), include, exclude, td_extra)?;
+        let output_dict = self.main_to_python(py, dict_items(main_dict), include, exclude, td_extra)?;
 
         // this is used to include `__pydantic_extra__` in serialization on models
         if let Some(extra_dict) = extra_dict {
@@ -373,7 +374,7 @@ impl TypeSerializer for GeneralFieldsSerializer {
         // NOTE! As above, we maintain the order of the input dict assuming that's right
         // we don't both with `used_fields` here because on unions, `to_python(..., mode='json')` is used
         let mut map = self.main_serde_serialize(
-            main_dict.iter().map(Ok),
+            dict_items(main_dict),
             expected_len,
             serializer,
             include,
@@ -408,3 +409,10 @@ impl TypeSerializer for GeneralFieldsSerializer {
 fn key_str(key: &PyAny) -> PyResult<&str> {
     key.downcast::<PyString>()?.to_str()
 }
+
+fn dict_items(main_dict: &PyDict) -> impl Iterator<Item = PyResult<(&PyAny, &PyAny)>> {
+    // Collect items before iterating to prevent panic on dict mutation.
+    // Use a SmallVec to avoid heap allocation for models with a reasonable number of fields.
+    let main_items: SmallVec<[_; 16]> = main_dict.iter().collect();
+    main_items.into_iter().map(Ok)
+}
diff --git a/tests/serializers/test_model.py b/tests/serializers/test_model.py
index 0be83e538..c93825839 100644
--- a/tests/serializers/test_model.py
+++ b/tests/serializers/test_model.py
@@ -456,6 +456,58 @@ def ser_x(self, v: Any, _) -> str:
     assert s.to_python(Model(x=1000)) == {'x': '1_000'}
 
 
+@pytest.mark.skipif(cached_property is None, reason='cached_property is not available')
+def test_field_serializer_cached_property():
+    @dataclasses.dataclass
+    class Model:
+        x: int
+        y: int
+
+        @cached_property
+        def x_formatted(self) -> str:
+            return f'{self.x:_}'
+
+        # This is a @computed_field
+        @cached_property
+        def y_formatted(self) -> str:
+            return f'{self.y:_}'
+
+        def ser_x(self, v: Any, _) -> str:
+            assert self.x == 1_000 == v
+            return self.x_formatted
+
+        def ser_y(self, v: Any, _) -> str:
+            assert self.y == 2_000 == v
+            return self.y_formatted
+
+    s = SchemaSerializer(
+        core_schema.model_schema(
+            Model,
+            core_schema.model_fields_schema(
+                {
+                    'x': core_schema.model_field(
+                        core_schema.int_schema(
+                            serialization=core_schema.plain_serializer_function_ser_schema(
+                                Model.ser_x, is_field_serializer=True, info_arg=True
+                            )
+                        )
+                    ),
+                    'y': core_schema.model_field(
+                        core_schema.int_schema(
+                            serialization=core_schema.plain_serializer_function_ser_schema(
+                                Model.ser_y, is_field_serializer=True, info_arg=True
+                            )
+                        )
+                    ),
+                },
+                computed_fields=[core_schema.computed_field('y_formatted', core_schema.str_schema())],
+            ),
+        )
+    )
+    assert s.to_python(Model(x=1000, y=2000)) == {'x': '1_000', 'y': '2_000', 'y_formatted': '2_000'}
+    assert s.to_json(Model(x=1000, y=2000)) == b'{"x":"1_000","y":"2_000","y_formatted":"2_000"}'
+
+
 def test_function_wrap_field_serializer_to_python():
     @dataclasses.dataclass
     class Model:

From 8c6e2bdd8b9ed9354d92587e69cf7ee2eff7ce7e Mon Sep 17 00:00:00 2001
From: Sam Dobson <1309834+samdobson@users.noreply.github.com>
Date: Tue, 20 Feb 2024 09:57:02 +0000
Subject: [PATCH 212/550] Update pyodide to 0.25.0 (#1199)

---
 .github/workflows/ci.yml  | 2 +-
 package.json              | 2 +-
 wasm-preview/run_tests.py | 2 +-
 wasm-preview/worker.js    | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 6a4d32a4d..5c1675b62 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -309,7 +309,7 @@ jobs:
           # NOTE!: as per https://github.com/pydantic/pydantic-core/pull/149 this version needs to match the version
           # in node_modules/pyodide/repodata.json, to get the version, run:
           # `cat node_modules/pyodide/repodata.json | python -m json.tool | rg platform`
-          version: '3.1.32'
+          version: '3.1.46'
           actions-cache-folder: emsdk-cache
 
       - run: pip install 'maturin>=1,<2' 'ruff==0.1.3' typing_extensions
diff --git a/package.json b/package.json
index 4683dc942..8bb850741 100644
--- a/package.json
+++ b/package.json
@@ -8,7 +8,7 @@
   "main": "tests/emscripten_runner.js",
   "dependencies": {
     "prettier": "^2.7.1",
-    "pyodide": "^0.23.0"
+    "pyodide": "^0.25.0"
   },
   "scripts": {
     "test": "node tests/emscripten_runner.js",
diff --git a/wasm-preview/run_tests.py b/wasm-preview/run_tests.py
index f17b314a6..538c10e49 100644
--- a/wasm-preview/run_tests.py
+++ b/wasm-preview/run_tests.py
@@ -21,7 +21,7 @@ async def main(tests_zip: str, tag_name: str):
     # File saved on the GH release
     pydantic_core_wheel = (
         'https://githubproxy.samuelcolvin.workers.dev/pydantic/pydantic-core/releases/'
-        f'download/{tag_name}/pydantic_core-{tag_name.lstrip("v")}-cp311-cp311-emscripten_3_1_32_wasm32.whl'
+        f'download/{tag_name}/pydantic_core-{tag_name.lstrip("v")}-cp311-cp311-emscripten_3_1_46_wasm32.whl'
     )
     zip_file = ZipFile(BytesIO(base64.b64decode(tests_zip)))
     count = 0
diff --git a/wasm-preview/worker.js b/wasm-preview/worker.js
index 7ef438974..b769281ef 100644
--- a/wasm-preview/worker.js
+++ b/wasm-preview/worker.js
@@ -89,7 +89,7 @@ async function main() {
       get(`./run_tests.py?v=${Date.now()}`, 'text'),
       // e4cf2e2 commit matches the pydantic-core wheel being used, so tests should pass
       get(zip_url, 'blob'),
-      importScripts('https://cdn.jsdelivr.net/pyodide/v0.23.0/full/pyodide.js'),
+      importScripts('https://cdn.jsdelivr.net/pyodide/v0.25.0/full/pyodide.js'),
     ]);
 
     const pyodide = await loadPyodide();

From c2c90fd001d8df98fc0e864674d49f0a144fc85e Mon Sep 17 00:00:00 2001
From: Sarbjot Singh <s2benipal@gmail.com>
Date: Tue, 20 Feb 2024 05:44:45 -0500
Subject: [PATCH 213/550] Fix TzInfo equality check based on offset (#1197)

Co-authored-by: David Hewitt <mail@davidhewitt.dev>
---
 src/input/datetime.rs | 15 +++++++++++++--
 tests/test_tzinfo.py  | 16 ++++++++++++++++
 2 files changed, 29 insertions(+), 2 deletions(-)

diff --git a/src/input/datetime.rs b/src/input/datetime.rs
index 0a3cdf929..ebb5675f2 100644
--- a/src/input/datetime.rs
+++ b/src/input/datetime.rs
@@ -563,8 +563,19 @@ impl TzInfo {
         hasher.finish()
     }
 
-    fn __richcmp__(&self, other: &Self, op: CompareOp) -> bool {
-        op.matches(self.seconds.cmp(&other.seconds))
+    fn __richcmp__(&self, other: &PyAny, op: CompareOp) -> PyResult<Py<PyAny>> {
+        let py = other.py();
+        if other.is_instance_of::<PyTzInfo>() {
+            let offset_delta = other.call_method1(intern!(py, "utcoffset"), (py.None(),))?;
+            if offset_delta.is_none() {
+                return Ok(py.NotImplemented());
+            }
+            let offset_seconds: f64 = offset_delta.call_method0(intern!(py, "total_seconds"))?.extract()?;
+            let offset = offset_seconds.round() as i32;
+            Ok(op.matches(self.seconds.cmp(&offset)).into_py(py))
+        } else {
+            Ok(py.NotImplemented())
+        }
     }
 
     fn __deepcopy__(&self, py: Python, _memo: &PyDict) -> PyResult<Py<Self>> {
diff --git a/tests/test_tzinfo.py b/tests/test_tzinfo.py
index cb67b737e..949c9175d 100644
--- a/tests/test_tzinfo.py
+++ b/tests/test_tzinfo.py
@@ -1,11 +1,15 @@
 import copy
 import functools
 import pickle
+import sys
 import unittest
 from datetime import datetime, timedelta, timezone, tzinfo
 
 from pydantic_core import SchemaValidator, TzInfo, core_schema
 
+if sys.version_info >= (3, 9):
+    from zoneinfo import ZoneInfo
+
 
 class _ALWAYS_EQ:
     """
@@ -80,6 +84,7 @@ class TestTzInfo(unittest.TestCase):
     def setUp(self):
         self.ACDT = TzInfo(timedelta(hours=9.5).total_seconds())
         self.EST = TzInfo(-timedelta(hours=5).total_seconds())
+        self.UTC = TzInfo(timedelta(0).total_seconds())
         self.DT = datetime(2010, 1, 1)
 
     def test_str(self):
@@ -163,6 +168,17 @@ def test_comparison(self):
         self.assertFalse(tz <= SMALLEST)
         self.assertTrue(tz >= SMALLEST)
 
+        # offset based comparion tests for tzinfo derived classes like datetime.timezone.
+        utcdatetime = self.DT.replace(tzinfo=timezone.utc)
+        self.assertTrue(tz == utcdatetime.tzinfo)
+        estdatetime = self.DT.replace(tzinfo=timezone(-timedelta(hours=5)))
+        self.assertTrue(self.EST == estdatetime.tzinfo)
+        self.assertTrue(tz > estdatetime.tzinfo)
+        if sys.version_info >= (3, 9) and sys.platform == 'linux':
+            self.assertFalse(tz == ZoneInfo('Europe/London'))
+            with self.assertRaises(TypeError):
+                tz > ZoneInfo('Europe/London')
+
     def test_copy(self):
         for tz in self.ACDT, self.EST:
             tz_copy = copy.copy(tz)

From 47aff70a7fb57c7fee3e63714fe7343d9cfbe4a5 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Tue, 20 Feb 2024 14:17:06 +0000
Subject: [PATCH 214/550] ci: if tzdata not available, skip comparing to
 `ZoneInfo` (#1200)

---
 tests/test_tzinfo.py | 15 +++++++++++----
 1 file changed, 11 insertions(+), 4 deletions(-)

diff --git a/tests/test_tzinfo.py b/tests/test_tzinfo.py
index 949c9175d..e67bf9098 100644
--- a/tests/test_tzinfo.py
+++ b/tests/test_tzinfo.py
@@ -8,7 +8,7 @@
 from pydantic_core import SchemaValidator, TzInfo, core_schema
 
 if sys.version_info >= (3, 9):
-    from zoneinfo import ZoneInfo
+    from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
 
 
 class _ALWAYS_EQ:
@@ -174,10 +174,17 @@ def test_comparison(self):
         estdatetime = self.DT.replace(tzinfo=timezone(-timedelta(hours=5)))
         self.assertTrue(self.EST == estdatetime.tzinfo)
         self.assertTrue(tz > estdatetime.tzinfo)
+
         if sys.version_info >= (3, 9) and sys.platform == 'linux':
-            self.assertFalse(tz == ZoneInfo('Europe/London'))
-            with self.assertRaises(TypeError):
-                tz > ZoneInfo('Europe/London')
+            try:
+                europe_london = ZoneInfo('Europe/London')
+            except ZoneInfoNotFoundError:
+                # tz data not available
+                pass
+            else:
+                self.assertFalse(tz == europe_london)
+                with self.assertRaises(TypeError):
+                    tz > europe_london
 
     def test_copy(self):
         for tz in self.ACDT, self.EST:

From 1a9046801ffdafe4bf29a2e2c15996b6efec852c Mon Sep 17 00:00:00 2001
From: Hungtsetse <33526088+hungtsetse@users.noreply.github.com>
Date: Mon, 26 Feb 2024 19:39:30 +0800
Subject: [PATCH 215/550] Trimming str before parsing to int and float (#1203)

Co-authored-by: Hung Tse Lee <hungtsetse@tse-mac.local>
---
 src/input/shared.rs            | 3 ++-
 tests/validators/test_float.py | 1 +
 tests/validators/test_int.py   | 1 +
 3 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/input/shared.rs b/src/input/shared.rs
index 591c5abfc..c81dff1e8 100644
--- a/src/input/shared.rs
+++ b/src/input/shared.rs
@@ -72,6 +72,7 @@ fn strip_underscores(s: &str) -> Option<String> {
 /// https://docs.python.org/3/whatsnew/3.11.html#other-cpython-implementation-changes and
 /// https://github.com/python/cpython/issues/95778 for more info in that length bound
 pub fn str_as_int<'s, 'l>(input: &'s impl Input<'s>, str: &'l str) -> ValResult<EitherInt<'s>> {
+    let str = str.trim();
     let len = str.len();
     if len > 4300 {
         Err(ValError::new(ErrorTypeDefaults::IntParsingSize, input))
@@ -96,7 +97,7 @@ pub fn str_as_int<'s, 'l>(input: &'s impl Input<'s>, str: &'l str) -> ValResult<
 
 /// parse a float as a float
 pub fn str_as_float<'s, 'l>(input: &'s impl Input<'s>, str: &'l str) -> ValResult<EitherFloat<'s>> {
-    match str.parse() {
+    match str.trim().parse() {
         Ok(float) => Ok(EitherFloat::F64(float)),
         Err(_) => match strip_underscores(str).and_then(|stripped| stripped.parse().ok()) {
             Some(float) => Ok(EitherFloat::F64(float)),
diff --git a/tests/validators/test_float.py b/tests/validators/test_float.py
index 56c03d40e..5af0d4adb 100644
--- a/tests/validators/test_float.py
+++ b/tests/validators/test_float.py
@@ -20,6 +20,7 @@
         (1, 1),
         (42, 42),
         ('42', 42),
+        ('  42.1  ', 42.1),
         ('42.123', 42.123),
         (42.0, 42),
         (42.5, 42.5),
diff --git a/tests/validators/test_int.py b/tests/validators/test_int.py
index 35a13f6a7..24928718d 100644
--- a/tests/validators/test_int.py
+++ b/tests/validators/test_int.py
@@ -21,6 +21,7 @@
         (0, 0),
         ('0', 0),
         (1, 1),
+        ('  1  ', 1),
         (42, 42),
         ('42', 42),
         (42.0, 42),

From 7779206d1dd3a8a2bb0203c727cf7a865a3fd672 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Mon, 26 Feb 2024 14:29:38 +0000
Subject: [PATCH 216/550] support Rust 1.70 as MSRV (#1206)

---
 .github/workflows/ci.yml       | 43 ++++++++++++++++++++++++++++------
 .github/workflows/codspeed.yml |  2 --
 Cargo.toml                     |  1 +
 src/serializers/fields.rs      | 10 ++++----
 4 files changed, 42 insertions(+), 14 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 5c1675b62..e0a7cb9b3 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -24,8 +24,6 @@ jobs:
       - id: cache-rust
         name: cache rust
         uses: Swatinem/rust-cache@v2
-        with:
-          key: coverage-v2
 
       - run: cargo install rustfilt coverage-prepare
         if: steps.cache-rust.outputs.cache-hit != 'true'
@@ -120,14 +118,49 @@ jobs:
 
       - name: cache rust
         uses: Swatinem/rust-cache@v2
+
+      - name: set up python
+        uses: actions/setup-python@v5
         with:
-          key: ${{ matrix.os }}-v1
+          python-version: '3.11'
+
+      - run: pip install -r tests/requirements.txt
+
+      - run: pip install -e .
+        env:
+          RUST_BACKTRACE: 1
+
+      - run: pip freeze
+
+      - run: pytest
+
+      - run: cargo test
+
+  test-msrv:
+    name: test MSRV
+
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
 
       - name: set up python
         uses: actions/setup-python@v5
         with:
           python-version: '3.11'
 
+      - name: resolve MSRV
+        id: resolve-msrv
+        run:
+          echo MSRV=`python -c 'import tomllib; print(tomllib.load(open("Cargo.toml", "rb"))["package"]["rust-version"])'` >> $GITHUB_OUTPUT
+
+      - name: install rust MSRV
+        uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: ${{ steps.resolve-msrv.outputs.MSRV }}
+
+      - name: cache rust
+        uses: Swatinem/rust-cache@v2
+
       - run: pip install -r tests/requirements.txt
 
       - run: pip install -e .
@@ -164,8 +197,6 @@ jobs:
 
       - name: cache rust
         uses: Swatinem/rust-cache@v2
-        with:
-          key: test-debug
 
       - run: pip install -r tests/requirements.txt
       - run: make build-dev
@@ -197,8 +228,6 @@ jobs:
 
       - name: cache rust
         uses: Swatinem/rust-cache@v2
-        with:
-          key: test-pydantic-integration
 
       - name: install deps
         run: |
diff --git a/.github/workflows/codspeed.yml b/.github/workflows/codspeed.yml
index 33497021f..332c6ae58 100644
--- a/.github/workflows/codspeed.yml
+++ b/.github/workflows/codspeed.yml
@@ -48,8 +48,6 @@ jobs:
 
       - name: cache rust
         uses: Swatinem/rust-cache@v2
-        with:
-          key: v1
 
       - name: Compile pydantic-core for profiling
         run: make build-profiling
diff --git a/Cargo.toml b/Cargo.toml
index 47b9d784c..7ba4759da 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -24,6 +24,7 @@ include = [
     "!tests/.pytest_cache",
     "!*.so",
 ]
+rust-version = "1.70"
 
 [dependencies]
 pyo3 = { version = "0.20.2", features = ["generate-import-lib", "num-bigint"] }
diff --git a/src/serializers/fields.rs b/src/serializers/fields.rs
index c57729c46..4d192d344 100644
--- a/src/serializers/fields.rs
+++ b/src/serializers/fields.rs
@@ -147,7 +147,7 @@ impl GeneralFieldsSerializer {
         }
     }
 
-    pub fn main_to_python<'py>(
+    pub(crate) fn main_to_python<'py>(
         &self,
         py: Python<'py>,
         main_iter: impl Iterator<Item = PyResult<(&'py PyAny, &'py PyAny)>>,
@@ -212,7 +212,7 @@ impl GeneralFieldsSerializer {
         }
     }
 
-    pub fn main_serde_serialize<'py, S: serde::ser::Serializer>(
+    pub(crate) fn main_serde_serialize<'py, S: serde::ser::Serializer>(
         &self,
         main_iter: impl Iterator<Item = PyResult<(&'py PyAny, &'py PyAny)>>,
         expected_len: usize,
@@ -258,7 +258,7 @@ impl GeneralFieldsSerializer {
         Ok(map)
     }
 
-    pub fn add_computed_fields_python(
+    pub(crate) fn add_computed_fields_python(
         &self,
         model: Option<&PyAny>,
         output_dict: &PyDict,
@@ -275,7 +275,7 @@ impl GeneralFieldsSerializer {
         Ok(())
     }
 
-    pub fn add_computed_fields_json<S: serde::ser::Serializer>(
+    pub(crate) fn add_computed_fields_json<S: serde::ser::Serializer>(
         &self,
         model: Option<&PyAny>,
         map: &mut S::SerializeMap,
@@ -291,7 +291,7 @@ impl GeneralFieldsSerializer {
         Ok(())
     }
 
-    pub fn computed_field_count(&self) -> usize {
+    pub(crate) fn computed_field_count(&self) -> usize {
         option_length!(self.computed_fields)
     }
 }

From 7fe78edc8582c3863b217ed864c5a35b4e08f1ae Mon Sep 17 00:00:00 2001
From: David Montague <35119617+dmontagu@users.noreply.github.com>
Date: Mon, 26 Feb 2024 09:56:23 -0700
Subject: [PATCH 217/550] Fix stack overflow due to recursion in some recursive
 serializer schemas. (#1198)

Co-authored-by: David Hewitt <mail@davidhewitt.dev>
---
 src/definitions.rs                            | 67 +++++++++----
 .../type_serializers/definitions.rs           | 33 ++++++-
 tests/test.rs                                 | 98 +++++++++++++++++++
 3 files changed, 174 insertions(+), 24 deletions(-)

diff --git a/src/definitions.rs b/src/definitions.rs
index 46a77196d..6fefb8c4a 100644
--- a/src/definitions.rs
+++ b/src/definitions.rs
@@ -4,6 +4,7 @@
 /// We use DefinitionsBuilder to collect the references / definitions into a single vector
 /// and then get a definition from a reference using an integer id (just for performance of not using a HashMap)
 use std::{
+    borrow::Borrow,
     collections::hash_map::Entry,
     fmt::Debug,
     sync::{
@@ -194,23 +195,39 @@ impl<T: std::fmt::Debug> DefinitionsBuilder<T> {
     }
 }
 
-struct LazyName {
-    initialized: OnceLock<String>,
+/// Because definitions can create recursive structures, we often need to be able to populate
+/// values lazily from these structures in a way that avoids infinite recursion. This structure
+/// avoids infinite recursion by returning a default value when a recursion loop is detected.
+pub(crate) struct RecursionSafeCache<T> {
+    cache: OnceLock<T>,
     in_recursion: AtomicBool,
 }
 
-impl LazyName {
-    fn new() -> Self {
+impl<T: Clone> Clone for RecursionSafeCache<T> {
+    fn clone(&self) -> Self {
         Self {
-            initialized: OnceLock::new(),
+            cache: self.cache.clone(),
             in_recursion: AtomicBool::new(false),
         }
     }
+}
 
-    /// Gets the validator name, returning the default in the case of recursion loops
-    fn get_or_init(&self, init: impl FnOnce() -> String) -> &str {
-        if let Some(s) = self.initialized.get() {
-            return s.as_str();
+impl<T> RecursionSafeCache<T> {
+    /// Creates a new RecursionSafeCache
+    pub(crate) fn new() -> Self {
+        Self {
+            cache: OnceLock::new(),
+            in_recursion: AtomicBool::new(false),
+        }
+    }
+
+    /// Gets or initialized the cached value, returning the default in the case of recursion loops
+    pub(crate) fn get_or_init<D: ?Sized>(&self, init: impl FnOnce() -> T, recursive_default: &'static D) -> &D
+    where
+        T: Borrow<D>,
+    {
+        if let Some(cached) = self.cache.get() {
+            return cached.borrow();
         }
 
         if self
@@ -218,25 +235,35 @@ impl LazyName {
             .compare_exchange(false, true, Ordering::SeqCst, Ordering::SeqCst)
             .is_err()
         {
-            return "...";
+            return recursive_default;
         }
-        let result = self.initialized.get_or_init(init).as_str();
+        let result = self.cache.get_or_init(init).borrow();
         self.in_recursion.store(false, Ordering::SeqCst);
         result
     }
+
+    /// Gets the value, if it is set
+    fn get(&self) -> Option<&T> {
+        self.cache.get()
+    }
 }
 
-impl Debug for LazyName {
-    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
-        self.initialized.get().map_or("...", String::as_str).fmt(f)
+#[derive(Clone)]
+struct LazyName(RecursionSafeCache<String>);
+
+impl LazyName {
+    fn new() -> Self {
+        Self(RecursionSafeCache::new())
+    }
+
+    /// Gets the validator name, returning the default in the case of recursion loops
+    fn get_or_init(&self, init: impl FnOnce() -> String) -> &str {
+        self.0.get_or_init(init, "...")
     }
 }
 
-impl Clone for LazyName {
-    fn clone(&self) -> Self {
-        Self {
-            initialized: OnceLock::new(),
-            in_recursion: AtomicBool::new(false),
-        }
+impl Debug for LazyName {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        self.0.get().map_or("...", String::as_str).fmt(f)
     }
 }
diff --git a/src/serializers/type_serializers/definitions.rs b/src/serializers/type_serializers/definitions.rs
index 2f98a94e0..3e2d48b19 100644
--- a/src/serializers/type_serializers/definitions.rs
+++ b/src/serializers/type_serializers/definitions.rs
@@ -4,8 +4,8 @@ use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList};
 
-use crate::definitions::DefinitionRef;
 use crate::definitions::DefinitionsBuilder;
+use crate::definitions::{DefinitionRef, RecursionSafeCache};
 
 use crate::tools::SchemaDict;
 
@@ -39,9 +39,28 @@ impl BuildSerializer for DefinitionsSerializerBuilder {
     }
 }
 
-#[derive(Debug, Clone)]
 pub struct DefinitionRefSerializer {
     definition: DefinitionRef<CombinedSerializer>,
+    retry_with_lax_check: RecursionSafeCache<bool>,
+}
+
+// TODO(DH): Remove the need to clone serializers
+impl Clone for DefinitionRefSerializer {
+    fn clone(&self) -> Self {
+        Self {
+            definition: self.definition.clone(),
+            retry_with_lax_check: RecursionSafeCache::new(),
+        }
+    }
+}
+
+impl std::fmt::Debug for DefinitionRefSerializer {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("DefinitionRefSerializer")
+            .field("definition", &self.definition)
+            .field("retry_with_lax_check", &self.retry_with_lax_check())
+            .finish()
+    }
 }
 
 impl BuildSerializer for DefinitionRefSerializer {
@@ -54,7 +73,11 @@ impl BuildSerializer for DefinitionRefSerializer {
     ) -> PyResult<CombinedSerializer> {
         let schema_ref = schema.get_as_req(intern!(schema.py(), "schema_ref"))?;
         let definition = definitions.get_definition(schema_ref);
-        Ok(Self { definition }.into())
+        Ok(Self {
+            definition,
+            retry_with_lax_check: RecursionSafeCache::new(),
+        }
+        .into())
     }
 }
 
@@ -101,6 +124,8 @@ impl TypeSerializer for DefinitionRefSerializer {
     }
 
     fn retry_with_lax_check(&self) -> bool {
-        self.definition.read(|s| s.unwrap().retry_with_lax_check())
+        *self
+            .retry_with_lax_check
+            .get_or_init(|| self.definition.read(|s| s.unwrap().retry_with_lax_check()), &false)
     }
 }
diff --git a/tests/test.rs b/tests/test.rs
index e0b76a4d8..4a5776e7d 100644
--- a/tests/test.rs
+++ b/tests/test.rs
@@ -117,4 +117,102 @@ json_input = '{"a": "something"}'
             assert_eq!(repr, "{'a': 'something'}");
         });
     }
+
+    #[test]
+    fn test_segfault_for_recursive_schemas() {
+        Python::with_gil(|py| {
+            let code = r"
+schema = {
+    'type': 'definitions',
+    'schema': {
+        'type': 'definition-ref',
+        'schema_ref': '__main__.JSONData:4303261344'
+    },
+    'definitions': [
+        {
+            'type': 'union',
+            'choices': [
+                {
+                    'type': 'dict',
+                    'keys_schema': {'type': 'str'},
+                    'values_schema': {
+                        'type': 'definition-ref',
+                        'schema_ref': '__main__.JSONData:4303261344'
+                    },
+                    'strict': False
+                },
+                {
+                    'type': 'list',
+                    'items_schema': {
+                        'type': 'definition-ref',
+                        'schema_ref': '__main__.JSONData:4303261344'
+                    },
+                    'strict': False
+                }
+            ],
+            'ref': '__main__.JSONData:4303261344'
+        }
+    ]
+}
+dump_json_input_1 = 1
+dump_json_input_2 = {'a': 'something'}
+            ";
+            let locals = PyDict::new(py);
+            py.run(code, None, Some(locals)).unwrap();
+            let schema: &PyDict = locals.get_item("schema").unwrap().unwrap().extract().unwrap();
+            let dump_json_input_1: &PyAny = locals
+                .get_item("dump_json_input_1")
+                .unwrap()
+                .unwrap()
+                .extract()
+                .unwrap();
+            let dump_json_input_2: &PyAny = locals
+                .get_item("dump_json_input_2")
+                .unwrap()
+                .unwrap()
+                .extract()
+                .unwrap();
+            let binding = SchemaSerializer::py_new(py, schema, None)
+                .unwrap()
+                .to_json(
+                    py,
+                    dump_json_input_1,
+                    None,
+                    None,
+                    None,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    None,
+                )
+                .unwrap();
+            let serialization_result: &PyAny = binding.extract(py).unwrap();
+            let repr = format!("{}", serialization_result.repr().unwrap());
+            assert_eq!(repr, "b'1'");
+
+            let binding = SchemaSerializer::py_new(py, schema, None)
+                .unwrap()
+                .to_json(
+                    py,
+                    dump_json_input_2,
+                    None,
+                    None,
+                    None,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    false,
+                    None,
+                )
+                .unwrap();
+            let serialization_result: &PyAny = binding.extract(py).unwrap();
+            let repr = format!("{}", serialization_result.repr().unwrap());
+            assert_eq!(repr, "b'{\"a\":\"something\"}'");
+        });
+    }
 }

From ad5007dc86e9d18192377f5fb41659699097c50b Mon Sep 17 00:00:00 2001
From: stonebig <stonebig34@gmail.com>
Date: Mon, 4 Mar 2024 14:55:38 +0100
Subject: [PATCH 218/550] Update pyproject.toml to get a 'Summary' metadata
 (#1214)

Co-authored-by: David Hewitt <mail@davidhewitt.dev>
---
 pyproject.toml | 1 +
 1 file changed, 1 insertion(+)

diff --git a/pyproject.toml b/pyproject.toml
index 5cdbca806..9683cf642 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -7,6 +7,7 @@ build-backend = 'maturin'
 
 [project]
 name = 'pydantic_core'
+description = "Core functionality for Pydantic validation and serialization"
 requires-python = '>=3.8'
 authors = [
     {name = 'Samuel Colvin', email = 's@muelcolvin.com'}

From 68a7e968722bda860f78e4fbcf212690e003bb86 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 4 Mar 2024 14:18:33 +0000
Subject: [PATCH 219/550] Bump serde_json from 1.0.113 to 1.0.114 (#1211)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index c00c1131e..c78b54265 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -514,9 +514,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.113"
+version = "1.0.114"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "69801b70b1c3dac963ecb03a364ba0ceda9cf60c71cfe475e99864759c8b8a79"
+checksum = "c5f09b1bd632ef549eaa9f60a1f8de742bdbc698e6cee2095fc84dde5f549ae0"
 dependencies = [
  "indexmap",
  "itoa",
diff --git a/Cargo.toml b/Cargo.toml
index 7ba4759da..9abfac444 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -31,7 +31,7 @@ pyo3 = { version = "0.20.2", features = ["generate-import-lib", "num-bigint"] }
 regex = "1.10.3"
 strum = { version = "0.25.0", features = ["derive"] }
 strum_macros = "0.25.3"
-serde_json = {version = "1.0.113", features = ["arbitrary_precision", "preserve_order"]}
+serde_json = {version = "1.0.114", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.8"
 serde = { version = "1.0.196", features = ["derive"] }
 speedate = "0.13.0"

From 1f905160ecc5aeb3e56423beffec067d5bd8340d Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 4 Mar 2024 14:19:16 +0000
Subject: [PATCH 220/550] Bump ahash from 0.8.7 to 0.8.10 (#1210)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index c78b54265..cc8525f03 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4,9 +4,9 @@ version = 3
 
 [[package]]
 name = "ahash"
-version = "0.8.7"
+version = "0.8.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77c3a9648d43b9cd48db467b3f87fdd6e146bcc88ab0180006cef2179fe11d01"
+checksum = "8b79b82693f705137f8fb9b37871d99e4f9a7df12b917eed79c3d3954830a60b"
 dependencies = [
  "cfg-if",
  "getrandom",
diff --git a/Cargo.toml b/Cargo.toml
index 9abfac444..90b1cb4d9 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -36,7 +36,7 @@ enum_dispatch = "0.3.8"
 serde = { version = "1.0.196", features = ["derive"] }
 speedate = "0.13.0"
 smallvec = "1.13.1"
-ahash = "0.8.7"
+ahash = "0.8.10"
 url = "2.5.0"
 # idna is already required by url, added here to be explicit
 idna = "0.5.0"

From 19769b8d62c6aafb6b46e4980d7bae21c4c6597c Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 4 Mar 2024 14:24:40 +0000
Subject: [PATCH 221/550] Bump pyo3 from 0.20.2 to 0.20.3 (#1212)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 28 ++++++++++++++++++----------
 Cargo.toml |  4 ++--
 2 files changed, 20 insertions(+), 12 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index cc8525f03..ef9843b7e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -321,6 +321,12 @@ version = "2.3.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e3148f5046208a5d56bcfc03053e3ca6334e51da8dfb19b6cdc8b306fae3283e"
 
+[[package]]
+name = "portable-atomic"
+version = "1.6.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7170ef9988bc169ba16dd36a7fa041e5c4cbeb6a35b76d4c03daded371eae7c0"
+
 [[package]]
 name = "proc-macro2"
 version = "1.0.76"
@@ -357,9 +363,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.20.2"
+version = "0.20.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9a89dc7a5850d0e983be1ec2a463a171d20990487c3cfcd68b5363f1ee3d6fe0"
+checksum = "53bdbb96d49157e65d45cc287af5f32ffadd5f4761438b527b055fb0d4bb8233"
 dependencies = [
  "cfg-if",
  "indoc",
@@ -367,6 +373,7 @@ dependencies = [
  "memoffset",
  "num-bigint",
  "parking_lot",
+ "portable-atomic",
  "pyo3-build-config",
  "pyo3-ffi",
  "pyo3-macros",
@@ -375,9 +382,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.20.2"
+version = "0.20.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07426f0d8fe5a601f26293f300afd1a7b1ed5e78b2a705870c5f30893c5163be"
+checksum = "deaa5745de3f5231ce10517a1f5dd97d53e5a2fd77aa6b5842292085831d48d7"
 dependencies = [
  "once_cell",
  "python3-dll-a",
@@ -386,9 +393,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.20.2"
+version = "0.20.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dbb7dec17e17766b46bca4f1a4215a85006b4c2ecde122076c562dd058da6cf1"
+checksum = "62b42531d03e08d4ef1f6e85a2ed422eb678b8cd62b762e53891c05faf0d4afa"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -396,9 +403,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.20.2"
+version = "0.20.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05f738b4e40d50b5711957f142878cfa0f28e054aa0ebdfc3fd137a843f74ed3"
+checksum = "7305c720fa01b8055ec95e484a6eca7a83c841267f0dd5280f0c8b8551d2c158"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -408,12 +415,13 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.20.2"
+version = "0.20.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fc910d4851847827daf9d6cdd4a823fbdaab5b8818325c5e97a86da79e8881f"
+checksum = "7c7e9b68bb9c3149c5b0cade5d07f953d6d125eb4337723c4ccdb665f1f96185"
 dependencies = [
  "heck",
  "proc-macro2",
+ "pyo3-build-config",
  "quote",
  "syn",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index 90b1cb4d9..c437e4d6a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -27,7 +27,7 @@ include = [
 rust-version = "1.70"
 
 [dependencies]
-pyo3 = { version = "0.20.2", features = ["generate-import-lib", "num-bigint"] }
+pyo3 = { version = "0.20.3", features = ["generate-import-lib", "num-bigint"] }
 regex = "1.10.3"
 strum = { version = "0.25.0", features = ["derive"] }
 strum_macros = "0.25.3"
@@ -71,7 +71,7 @@ debug = true
 strip = false
 
 [dev-dependencies]
-pyo3 = { version = "0.20.2", features = ["auto-initialize"] }
+pyo3 = { version = "0.20.3", features = ["auto-initialize"] }
 
 [build-dependencies]
 version_check = "0.9.4"

From 6d23acdb1ba547983d7736212f34cc9578dbe831 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 4 Mar 2024 14:30:20 +0000
Subject: [PATCH 222/550] Bump strum_macros from 0.25.3 to 0.26.1 (#1208)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 19 ++++++++++++++++---
 Cargo.toml |  2 +-
 2 files changed, 17 insertions(+), 4 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index ef9843b7e..b74074c8d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -355,7 +355,7 @@ dependencies = [
  "smallvec",
  "speedate",
  "strum",
- "strum_macros",
+ "strum_macros 0.26.1",
  "url",
  "uuid",
  "version_check",
@@ -545,7 +545,7 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "242f76c50fd18cbf098607090ade73a08d39cfd84ea835f3796a2c855223b19b"
 dependencies = [
  "strum",
- "strum_macros",
+ "strum_macros 0.25.3",
 ]
 
 [[package]]
@@ -560,7 +560,7 @@ version = "0.25.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "290d54ea6f91c969195bdbcd7442c8c2a2ba87da8bf60a7ee86a235d4bc1e125"
 dependencies = [
- "strum_macros",
+ "strum_macros 0.25.3",
 ]
 
 [[package]]
@@ -576,6 +576,19 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "strum_macros"
+version = "0.26.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a3417fc93d76740d974a01654a09777cb500428cc874ca9f45edfe0c4d4cd18"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "rustversion",
+ "syn",
+]
+
 [[package]]
 name = "syn"
 version = "2.0.48"
diff --git a/Cargo.toml b/Cargo.toml
index c437e4d6a..ea3e3d73c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -30,7 +30,7 @@ rust-version = "1.70"
 pyo3 = { version = "0.20.3", features = ["generate-import-lib", "num-bigint"] }
 regex = "1.10.3"
 strum = { version = "0.25.0", features = ["derive"] }
-strum_macros = "0.25.3"
+strum_macros = "0.26.1"
 serde_json = {version = "1.0.114", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.8"
 serde = { version = "1.0.196", features = ["derive"] }

From a98b8b040a92e49561305e200f1202616cd8c3ac Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 4 Mar 2024 14:53:23 +0000
Subject: [PATCH 223/550] Bump the python-packages group with 7 updates (#1213)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: David Hewitt <mail@davidhewitt.dev>
---
 Makefile                                    |  4 +--
 generate_self_schema.py                     |  1 +
 pyproject.toml                              |  2 ++
 python/pydantic_core/core_schema.py         | 39 +++++++--------------
 tests/benchmarks/test_complete_benchmark.py |  1 +
 tests/benchmarks/test_micro_benchmarks.py   |  1 +
 tests/requirements-linting.txt              |  6 ++--
 tests/requirements.txt                      |  8 ++---
 tests/test_typing.py                        | 12 +++----
 9 files changed, 31 insertions(+), 43 deletions(-)

diff --git a/Makefile b/Makefile
index 8fbe91389..0b361de63 100644
--- a/Makefile
+++ b/Makefile
@@ -90,13 +90,13 @@ build-wasm:
 
 .PHONY: format
 format:
-	ruff --fix $(sources)
+	ruff check --fix $(sources)
 	ruff format $(sources)
 	cargo fmt
 
 .PHONY: lint-python
 lint-python:
-	ruff $(sources)
+	ruff check $(sources)
 	ruff format --check $(sources)
 	$(mypy-stubtest)
 	griffe dump -f -d google -LWARNING -o/dev/null python/pydantic_core
diff --git a/generate_self_schema.py b/generate_self_schema.py
index 8d27247d6..3aef99b18 100644
--- a/generate_self_schema.py
+++ b/generate_self_schema.py
@@ -4,6 +4,7 @@
 
 The schema is generated from `python/pydantic_core/core_schema.py`.
 """
+
 from __future__ import annotations as _annotations
 
 import decimal
diff --git a/pyproject.toml b/pyproject.toml
index 9683cf642..d56dc1255 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -55,6 +55,8 @@ features = ["pyo3/extension-module"]
 
 [tool.ruff]
 line-length = 120
+
+[tool.ruff.lint]
 extend-select = ['Q', 'RUF100', 'C90', 'I']
 extend-ignore = [
     'E721',  # using type() instead of isinstance() - we use this in tests
diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index 31bf48782..bef04bc3a 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -117,51 +117,39 @@ class CoreConfig(TypedDict, total=False):
 
 class SerializationInfo(Protocol):
     @property
-    def include(self) -> IncExCall:
-        ...
+    def include(self) -> IncExCall: ...
 
     @property
-    def exclude(self) -> IncExCall:
-        ...
+    def exclude(self) -> IncExCall: ...
 
     @property
-    def mode(self) -> str:
-        ...
+    def mode(self) -> str: ...
 
     @property
-    def by_alias(self) -> bool:
-        ...
+    def by_alias(self) -> bool: ...
 
     @property
-    def exclude_unset(self) -> bool:
-        ...
+    def exclude_unset(self) -> bool: ...
 
     @property
-    def exclude_defaults(self) -> bool:
-        ...
+    def exclude_defaults(self) -> bool: ...
 
     @property
-    def exclude_none(self) -> bool:
-        ...
+    def exclude_none(self) -> bool: ...
 
     @property
-    def round_trip(self) -> bool:
-        ...
+    def round_trip(self) -> bool: ...
 
-    def mode_is_json(self) -> bool:
-        ...
+    def mode_is_json(self) -> bool: ...
 
-    def __str__(self) -> str:
-        ...
+    def __str__(self) -> str: ...
 
-    def __repr__(self) -> str:
-        ...
+    def __repr__(self) -> str: ...
 
 
 class FieldSerializationInfo(SerializationInfo, Protocol):
     @property
-    def field_name(self) -> str:
-        ...
+    def field_name(self) -> str: ...
 
 
 class ValidationInfo(Protocol):
@@ -305,8 +293,7 @@ def plain_serializer_function_ser_schema(
 
 
 class SerializerFunctionWrapHandler(Protocol):  # pragma: no cover
-    def __call__(self, __input_value: Any, __index_key: int | str | None = None) -> Any:
-        ...
+    def __call__(self, __input_value: Any, __index_key: int | str | None = None) -> Any: ...
 
 
 # (__input_value: Any, __serializer: SerializerFunctionWrapHandler) -> Any
diff --git a/tests/benchmarks/test_complete_benchmark.py b/tests/benchmarks/test_complete_benchmark.py
index b13fddda7..3217efe13 100644
--- a/tests/benchmarks/test_complete_benchmark.py
+++ b/tests/benchmarks/test_complete_benchmark.py
@@ -1,6 +1,7 @@
 """
 General benchmarks that attempt to cover all field types, through by no means all uses of all field types.
 """
+
 import json
 from datetime import date, datetime, time
 from decimal import Decimal
diff --git a/tests/benchmarks/test_micro_benchmarks.py b/tests/benchmarks/test_micro_benchmarks.py
index c2320427c..6086c5bd7 100644
--- a/tests/benchmarks/test_micro_benchmarks.py
+++ b/tests/benchmarks/test_micro_benchmarks.py
@@ -1,6 +1,7 @@
 """
 Numerous benchmarks of specific functionality.
 """
+
 import decimal
 import json
 import platform
diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index 1692fa86d..8e3ea74da 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,4 +1,4 @@
-griffe==0.40.0
-pyright==1.1.349
-ruff==0.1.15
+griffe==0.41.0
+pyright==1.1.352
+ruff==0.3.0
 mypy==1.8.0
diff --git a/tests/requirements.txt b/tests/requirements.txt
index 756792f2a..b2c8dba6b 100644
--- a/tests/requirements.txt
+++ b/tests/requirements.txt
@@ -1,12 +1,12 @@
-coverage==7.4.1
+coverage==7.4.3
 dirty-equals==0.7.1.post0
-hypothesis==6.97.4
+hypothesis==6.98.15
 # TODO: remove manual override for dateutil once a version newer than 2.8.2 is
 # released which removes use of deprecated utcfromtimestamp
 git+https://github.com/dateutil/dateutil.git@f2293200747fb03d56c6c5997bfebeabe703576f
 # pandas doesn't offer prebuilt wheels for all versions and platforms we test in CI e.g. aarch64 musllinux
 pandas==2.1.3; python_version >= "3.9" and python_version < "3.13" and implementation_name == "cpython" and platform_machine == 'x86_64'
-pytest==8.0.0
+pytest==8.0.2
 # we run codspeed benchmarks on x86_64 CPython (i.e. native github actions architecture)
 pytest-codspeed~=2.2.0; implementation_name == "cpython" and platform_machine == 'x86_64'
 # pytest-examples currently depends on aiohttp via black; we don't want to build
@@ -16,7 +16,7 @@ pytest-speed==0.3.5
 pytest-mock==3.11.1
 pytest-pretty==1.2.0
 pytest-timeout==2.2.0
-pytz==2023.4
+pytz==2024.1
 # numpy doesn't offer prebuilt wheels for all versions and platforms we test in CI e.g. aarch64 musllinux
 numpy==1.26.2; python_version >= "3.9" and python_version < "3.13" and implementation_name == "cpython" and platform_machine == 'x86_64'
 exceptiongroup==1.1; python_version < "3.11"
diff --git a/tests/test_typing.py b/tests/test_typing.py
index fb9f3e949..00f58e31f 100644
--- a/tests/test_typing.py
+++ b/tests/test_typing.py
@@ -19,20 +19,16 @@ class Foo:
     bar: str
 
 
-def foo(bar: str) -> None:
-    ...
+def foo(bar: str) -> None: ...
 
 
-def validator_deprecated(value: Any, info: core_schema.FieldValidationInfo) -> None:
-    ...
+def validator_deprecated(value: Any, info: core_schema.FieldValidationInfo) -> None: ...
 
 
-def validator(value: Any, info: core_schema.ValidationInfo) -> None:
-    ...
+def validator(value: Any, info: core_schema.ValidationInfo) -> None: ...
 
 
-def wrap_validator(value: Any, call_next: Callable[[Any], Any], info: core_schema.ValidationInfo) -> None:
-    ...
+def wrap_validator(value: Any, call_next: Callable[[Any], Any], info: core_schema.ValidationInfo) -> None: ...
 
 
 def test_schema_typing() -> None:

From f669db9c054cceb4248784e4253edc8f72fa81ad Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Tue, 5 Mar 2024 18:26:46 +0100
Subject: [PATCH 224/550] Use PEP570 syntax (#1216)

---
 python/pydantic_core/_pydantic_core.pyi |  2 +-
 python/pydantic_core/core_schema.py     | 30 ++++++++++++-------------
 tests/test_typing.py                    |  8 +++----
 tests/validators/test_model_fields.py   | 10 ++++-----
 tests/validators/test_typed_dict.py     |  4 ++--
 5 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index a7b727f86..a6001f63c 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -73,7 +73,7 @@ class Some(Generic[_T]):
         Returns the value wrapped by `Some`.
         """
     @classmethod
-    def __class_getitem__(cls, __item: Any) -> Type[Self]: ...
+    def __class_getitem__(cls, item: Any, /) -> Type[Self]: ...
 
 @final
 class SchemaValidator:
diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index bef04bc3a..ba8ce15ad 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -225,13 +225,13 @@ def simple_ser_schema(type: ExpectedSerializationTypes) -> SimpleSerSchema:
     return SimpleSerSchema(type=type)
 
 
-# (__input_value: Any) -> Any
+# (input_value: Any, /) -> Any
 GeneralPlainNoInfoSerializerFunction = Callable[[Any], Any]
-# (__input_value: Any, __info: FieldSerializationInfo) -> Any
+# (input_value: Any, info: FieldSerializationInfo, /) -> Any
 GeneralPlainInfoSerializerFunction = Callable[[Any, SerializationInfo], Any]
-# (__model: Any, __input_value: Any) -> Any
+# (model: Any, input_value: Any, /) -> Any
 FieldPlainNoInfoSerializerFunction = Callable[[Any, Any], Any]
-# (__model: Any, __input_value: Any, __info: FieldSerializationInfo) -> Any
+# (model: Any, input_value: Any, info: FieldSerializationInfo, /) -> Any
 FieldPlainInfoSerializerFunction = Callable[[Any, Any, FieldSerializationInfo], Any]
 SerializerFunction = Union[
     GeneralPlainNoInfoSerializerFunction,
@@ -275,7 +275,7 @@ def plain_serializer_function_ser_schema(
         function: The function to use for serialization
         is_field_serializer: Whether the serializer is for a field, e.g. takes `model` as the first argument,
             and `info` includes `field_name`
-        info_arg: Whether the function takes an `__info` argument
+        info_arg: Whether the function takes an `info` argument
         return_schema: Schema to use for serializing return value
         when_used: When the function should be called
     """
@@ -293,16 +293,16 @@ def plain_serializer_function_ser_schema(
 
 
 class SerializerFunctionWrapHandler(Protocol):  # pragma: no cover
-    def __call__(self, __input_value: Any, __index_key: int | str | None = None) -> Any: ...
+    def __call__(self, input_value: Any, index_key: int | str | None = None, /) -> Any: ...
 
 
-# (__input_value: Any, __serializer: SerializerFunctionWrapHandler) -> Any
+# (input_value: Any, serializer: SerializerFunctionWrapHandler, /) -> Any
 GeneralWrapNoInfoSerializerFunction = Callable[[Any, SerializerFunctionWrapHandler], Any]
-# (__input_value: Any, __serializer: SerializerFunctionWrapHandler, __info: SerializationInfo) -> Any
+# (input_value: Any, serializer: SerializerFunctionWrapHandler, info: SerializationInfo, /) -> Any
 GeneralWrapInfoSerializerFunction = Callable[[Any, SerializerFunctionWrapHandler, SerializationInfo], Any]
-# (__model: Any, __input_value: Any, __serializer: SerializerFunctionWrapHandler) -> Any
+# (model: Any, input_value: Any, serializer: SerializerFunctionWrapHandler, /) -> Any
 FieldWrapNoInfoSerializerFunction = Callable[[Any, Any, SerializerFunctionWrapHandler], Any]
-# (__model: Any, __input_value: Any, __serializer: SerializerFunctionWrapHandler, __info: FieldSerializationInfo) -> Any
+# (model: Any, input_value: Any, serializer: SerializerFunctionWrapHandler, info: FieldSerializationInfo, /) -> Any
 FieldWrapInfoSerializerFunction = Callable[[Any, Any, SerializerFunctionWrapHandler, FieldSerializationInfo], Any]
 WrapSerializerFunction = Union[
     GeneralWrapNoInfoSerializerFunction,
@@ -338,7 +338,7 @@ def wrap_serializer_function_ser_schema(
         function: The function to use for serialization
         is_field_serializer: Whether the serializer is for a field, e.g. takes `model` as the first argument,
             and `info` includes `field_name`
-        info_arg: Whether the function takes an `__info` argument
+        info_arg: Whether the function takes an `info` argument
         schema: The schema to use for the inner serialization
         return_schema: Schema to use for serializing return value
         when_used: When the function should be called
@@ -1767,7 +1767,7 @@ def dict_schema(
     )
 
 
-# (__input_value: Any) -> Any
+# (input_value: Any, /) -> Any
 NoInfoValidatorFunction = Callable[[Any], Any]
 
 
@@ -1776,7 +1776,7 @@ class NoInfoValidatorFunctionSchema(TypedDict):
     function: NoInfoValidatorFunction
 
 
-# (__input_value: Any, __info: ValidationInfo) -> Any
+# (input_value: Any, info: ValidationInfo, /) -> Any
 WithInfoValidatorFunction = Callable[[Any, ValidationInfo], Any]
 
 
@@ -1990,7 +1990,7 @@ def __call__(self, input_value: Any, outer_location: str | int | None = None) ->
         ...
 
 
-# (__input_value: Any, __validator: ValidatorFunctionWrapHandler) -> Any
+# (input_value: Any, validator: ValidatorFunctionWrapHandler, /) -> Any
 NoInfoWrapValidatorFunction = Callable[[Any, ValidatorFunctionWrapHandler], Any]
 
 
@@ -1999,7 +1999,7 @@ class NoInfoWrapValidatorFunctionSchema(TypedDict):
     function: NoInfoWrapValidatorFunction
 
 
-# (__input_value: Any, __validator: ValidatorFunctionWrapHandler, __info: ValidationInfo) -> Any
+# (input_value: Any, validator: ValidatorFunctionWrapHandler, info: ValidationInfo, /) -> Any
 WithInfoWrapValidatorFunction = Callable[[Any, ValidatorFunctionWrapHandler, ValidationInfo], Any]
 
 
diff --git a/tests/test_typing.py b/tests/test_typing.py
index 00f58e31f..63d17a790 100644
--- a/tests/test_typing.py
+++ b/tests/test_typing.py
@@ -221,8 +221,8 @@ def test_type_error():
 
 
 def test_ser_function_plain():
-    def f(__input: Any, __info: core_schema.SerializationInfo) -> str:
-        return str(__info)
+    def f(input: Any, info: core_schema.SerializationInfo, /) -> str:
+        return str(info)
 
     s = SchemaSerializer(
         core_schema.any_schema(
@@ -239,9 +239,9 @@ def f(__input: Any, __info: core_schema.SerializationInfo) -> str:
 
 def test_ser_function_wrap():
     def f(
-        __input: Any, __serialize: core_schema.SerializerFunctionWrapHandler, __info: core_schema.SerializationInfo
+        input: Any, serialize: core_schema.SerializerFunctionWrapHandler, info: core_schema.SerializationInfo, /
     ) -> str:
-        return f'{__serialize} {__info}'
+        return f'{serialize} {info}'
 
     s = SchemaSerializer(
         core_schema.any_schema(
diff --git a/tests/validators/test_model_fields.py b/tests/validators/test_model_fields.py
index e21f50008..8a22d96c3 100644
--- a/tests/validators/test_model_fields.py
+++ b/tests/validators/test_model_fields.py
@@ -32,8 +32,8 @@ def __iter__(self):
     def __len__(self) -> int:
         return len(self._d)
 
-    def __getitem__(self, __k):
-        return self._d[__k]
+    def __getitem__(self, k, /):
+        return self._d[k]
 
     def __repr__(self):
         return 'Map({})'.format(', '.join(f'{k}={v!r}' for k, v in self._d.items()))
@@ -1188,9 +1188,9 @@ class Source:
         a = 1
         b = 2
 
-        def __getattribute__(self, __name: str) -> Any:
-            accessed.append(__name)
-            return super().__getattribute__(__name)
+        def __getattribute__(self, name: str, /) -> Any:
+            accessed.append(name)
+            return super().__getattribute__(name)
 
     assert v.validate_python(Source()) == ({'a': 1}, None, {'a'})
     assert 'a' in accessed and 'b' not in accessed
diff --git a/tests/validators/test_typed_dict.py b/tests/validators/test_typed_dict.py
index 8fb25cff6..dc18cd86e 100644
--- a/tests/validators/test_typed_dict.py
+++ b/tests/validators/test_typed_dict.py
@@ -32,8 +32,8 @@ def __iter__(self):
     def __len__(self) -> int:
         return len(self._d)
 
-    def __getitem__(self, __k):
-        return self._d[__k]
+    def __getitem__(self, k, /):
+        return self._d[k]
 
     def __repr__(self):
         return 'Map({})'.format(', '.join(f'{k}={v!r}' for k, v in self._d.items()))

From c6301fe5966b98b11970df49129e34f76616c9dc Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Tue, 5 Mar 2024 11:56:21 -0600
Subject: [PATCH 225/550] Fix parsing BigInt from str (#1204)

---
 src/input/input_json.rs      | 5 +----
 src/input/input_string.rs    | 7 ++-----
 tests/validators/test_int.py | 8 ++++++++
 3 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/src/input/input_json.rs b/src/input/input_json.rs
index cd4ac919c..dde73cf65 100644
--- a/src/input/input_json.rs
+++ b/src/input/input_json.rs
@@ -370,10 +370,7 @@ impl<'a> Input<'a> for String {
     }
 
     fn validate_int(&'a self, _strict: bool) -> ValResult<ValidationMatch<EitherInt<'a>>> {
-        match self.parse() {
-            Ok(i) => Ok(ValidationMatch::lax(EitherInt::I64(i))),
-            Err(_) => Err(ValError::new(ErrorTypeDefaults::IntParsing, self)),
-        }
+        str_as_int(self, self).map(ValidationMatch::lax)
     }
 
     fn validate_float(&'a self, _strict: bool) -> ValResult<ValidationMatch<EitherFloat<'a>>> {
diff --git a/src/input/input_string.rs b/src/input/input_string.rs
index cd5931b24..f6c33d784 100644
--- a/src/input/input_string.rs
+++ b/src/input/input_string.rs
@@ -11,7 +11,7 @@ use crate::validators::decimal::create_decimal;
 use super::datetime::{
     bytes_as_date, bytes_as_datetime, bytes_as_time, bytes_as_timedelta, EitherDate, EitherDateTime, EitherTime,
 };
-use super::shared::{str_as_bool, str_as_float};
+use super::shared::{str_as_bool, str_as_float, str_as_int};
 use super::{
     BorrowInput, EitherBytes, EitherFloat, EitherInt, EitherString, EitherTimedelta, GenericArguments, GenericIterable,
     GenericIterator, GenericMapping, Input, ValidationMatch,
@@ -112,10 +112,7 @@ impl<'a> Input<'a> for StringMapping<'a> {
 
     fn validate_int(&'a self, _strict: bool) -> ValResult<ValidationMatch<EitherInt<'a>>> {
         match self {
-            Self::String(s) => match py_string_str(s)?.parse() {
-                Ok(i) => Ok(ValidationMatch::strict(EitherInt::I64(i))),
-                Err(_) => Err(ValError::new(ErrorTypeDefaults::IntParsing, self)),
-            },
+            Self::String(s) => str_as_int(self, py_string_str(s)?).map(ValidationMatch::strict),
             Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::IntType, self)),
         }
     }
diff --git a/tests/validators/test_int.py b/tests/validators/test_int.py
index 24928718d..c5ccd7957 100644
--- a/tests/validators/test_int.py
+++ b/tests/validators/test_int.py
@@ -504,3 +504,11 @@ def test_allow_inf_nan_false_json() -> None:
         v.validate_json('Infinity')
     with pytest.raises(ValidationError, match=r'Input should be a finite number \[type=finite_number'):
         v.validate_json('-Infinity')
+
+
+def test_json_big_int_key():
+    v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'int'}, 'values_schema': {'type': 'str'}})
+    big_integer = 1433352099889938534014333520998899385340
+    assert v.validate_python({big_integer: 'x'}) == {big_integer: 'x'}
+    assert v.validate_json('{"' + str(big_integer) + '": "x"}') == {big_integer: 'x'}
+    assert v.validate_strings({str(big_integer): 'x'}) == {big_integer: 'x'}

From 1083986b5e948778cd09e01a6e05c7b2fc670d8a Mon Sep 17 00:00:00 2001
From: ornariece <ornariece@gmail.com>
Date: Wed, 6 Mar 2024 11:58:44 +0100
Subject: [PATCH 226/550] ability to pass context to serialization
 (pydantic#7143) (#1215)

Co-authored-by: ornariece <37-ornariece@users.noreply.git.malined.com>
---
 python/pydantic_core/_pydantic_core.pyi       | 22 +++++--
 python/pydantic_core/core_schema.py           |  4 ++
 src/errors/validation_exception.rs            |  2 +-
 src/serializers/extra.rs                      | 12 +++-
 src/serializers/infer.rs                      |  2 +
 src/serializers/mod.rs                        | 18 ++++--
 src/serializers/type_serializers/function.rs  | 61 ++++++++++++++++++-
 src/serializers/type_serializers/generator.rs | 29 +++++++++
 src/validators/function.rs                    | 12 ++++
 tests/serializers/test_functions.py           | 26 ++++++--
 tests/test.rs                                 |  6 +-
 tests/test_typing.py                          |  4 +-
 12 files changed, 177 insertions(+), 21 deletions(-)

diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index a6001f63c..347589fd4 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -101,7 +101,7 @@ class SchemaValidator:
         *,
         strict: bool | None = None,
         from_attributes: bool | None = None,
-        context: 'dict[str, Any] | None' = None,
+        context: dict[str, Any] | None = None,
         self_instance: Any | None = None,
     ) -> Any:
         """
@@ -131,7 +131,7 @@ class SchemaValidator:
         *,
         strict: bool | None = None,
         from_attributes: bool | None = None,
-        context: 'dict[str, Any] | None' = None,
+        context: dict[str, Any] | None = None,
         self_instance: Any | None = None,
     ) -> bool:
         """
@@ -148,7 +148,7 @@ class SchemaValidator:
         input: str | bytes | bytearray,
         *,
         strict: bool | None = None,
-        context: 'dict[str, Any] | None' = None,
+        context: dict[str, Any] | None = None,
         self_instance: Any | None = None,
     ) -> Any:
         """
@@ -176,7 +176,7 @@ class SchemaValidator:
             The validated Python object.
         """
     def validate_strings(
-        self, input: _StringInput, *, strict: bool | None = None, context: 'dict[str, Any] | None' = None
+        self, input: _StringInput, *, strict: bool | None = None, context: dict[str, Any] | None = None
     ) -> Any:
         """
         Validate a string against the schema and return the validated Python object.
@@ -206,7 +206,7 @@ class SchemaValidator:
         *,
         strict: bool | None = None,
         from_attributes: bool | None = None,
-        context: 'dict[str, Any] | None' = None,
+        context: dict[str, Any] | None = None,
     ) -> dict[str, Any] | tuple[dict[str, Any], dict[str, Any] | None, set[str]]:
         """
         Validate an assignment to a field on a model.
@@ -278,6 +278,7 @@ class SchemaSerializer:
         round_trip: bool = False,
         warnings: bool = True,
         fallback: Callable[[Any], Any] | None = None,
+        context: dict[str, Any] | None = None,
     ) -> Any:
         """
         Serialize/marshal a Python object to a Python object including transforming and filtering data.
@@ -297,6 +298,8 @@ class SchemaSerializer:
             warnings: Whether to log warnings when invalid fields are encountered.
             fallback: A function to call when an unknown value is encountered,
                 if `None` a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
+            context: The context to use for serialization, this is passed to functional serializers as
+                [`info.context`][pydantic_core.core_schema.SerializationInfo.context].
 
         Raises:
             PydanticSerializationError: If serialization fails and no `fallback` function is provided.
@@ -318,6 +321,7 @@ class SchemaSerializer:
         round_trip: bool = False,
         warnings: bool = True,
         fallback: Callable[[Any], Any] | None = None,
+        context: dict[str, Any] | None = None,
     ) -> bytes:
         """
         Serialize a Python object to JSON including transforming and filtering data.
@@ -336,6 +340,8 @@ class SchemaSerializer:
             warnings: Whether to log warnings when invalid fields are encountered.
             fallback: A function to call when an unknown value is encountered,
                 if `None` a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
+            context: The context to use for serialization, this is passed to functional serializers as
+                [`info.context`][pydantic_core.core_schema.SerializationInfo.context].
 
         Raises:
             PydanticSerializationError: If serialization fails and no `fallback` function is provided.
@@ -358,6 +364,7 @@ def to_json(
     inf_nan_mode: Literal['null', 'constants'] = 'constants',
     serialize_unknown: bool = False,
     fallback: Callable[[Any], Any] | None = None,
+    context: dict[str, Any] | None = None,
 ) -> bytes:
     """
     Serialize a Python object to JSON including transforming and filtering data.
@@ -379,6 +386,8 @@ def to_json(
             `"<Unserializable {value_type} object>"` will be used.
         fallback: A function to call when an unknown value is encountered,
             if `None` a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
+        context: The context to use for serialization, this is passed to functional serializers as
+            [`info.context`][pydantic_core.core_schema.SerializationInfo.context].
 
     Raises:
         PydanticSerializationError: If serialization fails and no `fallback` function is provided.
@@ -419,6 +428,7 @@ def to_jsonable_python(
     inf_nan_mode: Literal['null', 'constants'] = 'constants',
     serialize_unknown: bool = False,
     fallback: Callable[[Any], Any] | None = None,
+    context: dict[str, Any] | None = None,
 ) -> Any:
     """
     Serialize/marshal a Python object to a JSON-serializable Python object including transforming and filtering data.
@@ -440,6 +450,8 @@ def to_jsonable_python(
             `"<Unserializable {value_type} object>"` will be used.
         fallback: A function to call when an unknown value is encountered,
             if `None` a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
+        context: The context to use for serialization, this is passed to functional serializers as
+            [`info.context`][pydantic_core.core_schema.SerializationInfo.context].
 
     Raises:
         PydanticSerializationError: If serialization fails and no `fallback` function is provided.
diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index ba8ce15ad..8e36e8da0 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -122,6 +122,10 @@ def include(self) -> IncExCall: ...
     @property
     def exclude(self) -> IncExCall: ...
 
+    @property
+    def context(self) -> Any | None:
+        """Current serialization context."""
+
     @property
     def mode(self) -> str: ...
 
diff --git a/src/errors/validation_exception.rs b/src/errors/validation_exception.rs
index 24626df29..e87f4b0d9 100644
--- a/src/errors/validation_exception.rs
+++ b/src/errors/validation_exception.rs
@@ -320,7 +320,7 @@ impl ValidationError {
         include_input: bool,
     ) -> PyResult<&'py PyString> {
         let state = SerializationState::new("iso8601", "utf8", "constants")?;
-        let extra = state.extra(py, &SerMode::Json, true, false, false, true, None);
+        let extra = state.extra(py, &SerMode::Json, true, false, false, true, None, None);
         let serializer = ValidationErrorSerializer {
             py,
             line_errors: &self.line_errors,
diff --git a/src/serializers/extra.rs b/src/serializers/extra.rs
index 8d598d46b..3cff3f370 100644
--- a/src/serializers/extra.rs
+++ b/src/serializers/extra.rs
@@ -45,6 +45,7 @@ impl SerializationState {
         round_trip: bool,
         serialize_unknown: bool,
         fallback: Option<&'py PyAny>,
+        context: Option<&'py PyAny>,
     ) -> Extra<'py> {
         Extra::new(
             py,
@@ -59,6 +60,7 @@ impl SerializationState {
             &self.rec_guard,
             serialize_unknown,
             fallback,
+            context,
         )
     }
 
@@ -90,6 +92,7 @@ pub(crate) struct Extra<'a> {
     pub field_name: Option<&'a str>,
     pub serialize_unknown: bool,
     pub fallback: Option<&'a PyAny>,
+    pub context: Option<&'a PyAny>,
 }
 
 impl<'a> Extra<'a> {
@@ -107,6 +110,7 @@ impl<'a> Extra<'a> {
         rec_guard: &'a SerRecursionState,
         serialize_unknown: bool,
         fallback: Option<&'a PyAny>,
+        context: Option<&'a PyAny>,
     ) -> Self {
         Self {
             mode,
@@ -124,6 +128,7 @@ impl<'a> Extra<'a> {
             field_name: None,
             serialize_unknown,
             fallback,
+            context,
         }
     }
 
@@ -178,10 +183,11 @@ pub(crate) struct ExtraOwned {
     config: SerializationConfig,
     rec_guard: SerRecursionState,
     check: SerCheck,
-    model: Option<PyObject>,
+    pub model: Option<PyObject>,
     field_name: Option<String>,
     serialize_unknown: bool,
-    fallback: Option<PyObject>,
+    pub fallback: Option<PyObject>,
+    pub context: Option<PyObject>,
 }
 
 impl ExtraOwned {
@@ -201,6 +207,7 @@ impl ExtraOwned {
             field_name: extra.field_name.map(ToString::to_string),
             serialize_unknown: extra.serialize_unknown,
             fallback: extra.fallback.map(Into::into),
+            context: extra.context.map(Into::into),
         }
     }
 
@@ -221,6 +228,7 @@ impl ExtraOwned {
             field_name: self.field_name.as_deref(),
             serialize_unknown: self.serialize_unknown,
             fallback: self.fallback.as_ref().map(|m| m.as_ref(py)),
+            context: self.context.as_ref().map(|m| m.as_ref(py)),
         }
     }
 }
diff --git a/src/serializers/infer.rs b/src/serializers/infer.rs
index edbe614e4..98ffc72b2 100644
--- a/src/serializers/infer.rs
+++ b/src/serializers/infer.rs
@@ -99,6 +99,7 @@ pub(crate) fn infer_to_python_known(
             extra.rec_guard,
             extra.serialize_unknown,
             extra.fallback,
+            extra.context,
         );
         serializer.serializer.to_python(value, include, exclude, &extra)
     };
@@ -468,6 +469,7 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
                 extra.rec_guard,
                 extra.serialize_unknown,
                 extra.fallback,
+                extra.context,
             );
             let pydantic_serializer =
                 PydanticSerializer::new(value, &extracted_serializer.serializer, include, exclude, &extra);
diff --git a/src/serializers/mod.rs b/src/serializers/mod.rs
index 7d9c5347c..3ed47a0a8 100644
--- a/src/serializers/mod.rs
+++ b/src/serializers/mod.rs
@@ -55,6 +55,7 @@ impl SchemaSerializer {
         rec_guard: &'a SerRecursionState,
         serialize_unknown: bool,
         fallback: Option<&'a PyAny>,
+        context: Option<&'a PyAny>,
     ) -> Extra<'b> {
         Extra::new(
             py,
@@ -69,6 +70,7 @@ impl SchemaSerializer {
             rec_guard,
             serialize_unknown,
             fallback,
+            context,
         )
     }
 }
@@ -95,7 +97,7 @@ impl SchemaSerializer {
     #[allow(clippy::too_many_arguments)]
     #[pyo3(signature = (value, *, mode = None, include = None, exclude = None, by_alias = true,
         exclude_unset = false, exclude_defaults = false, exclude_none = false, round_trip = false, warnings = true,
-        fallback = None))]
+        fallback = None, context = None))]
     pub fn to_python(
         &self,
         py: Python,
@@ -110,6 +112,7 @@ impl SchemaSerializer {
         round_trip: bool,
         warnings: bool,
         fallback: Option<&PyAny>,
+        context: Option<&PyAny>,
     ) -> PyResult<PyObject> {
         let mode: SerMode = mode.into();
         let warnings = CollectWarnings::new(warnings);
@@ -126,6 +129,7 @@ impl SchemaSerializer {
             &rec_guard,
             false,
             fallback,
+            context,
         );
         let v = self.serializer.to_python(value, include, exclude, &extra)?;
         warnings.final_check(py)?;
@@ -135,7 +139,7 @@ impl SchemaSerializer {
     #[allow(clippy::too_many_arguments)]
     #[pyo3(signature = (value, *, indent = None, include = None, exclude = None, by_alias = true,
         exclude_unset = false, exclude_defaults = false, exclude_none = false, round_trip = false, warnings = true,
-        fallback = None))]
+        fallback = None, context = None))]
     pub fn to_json(
         &self,
         py: Python,
@@ -150,6 +154,7 @@ impl SchemaSerializer {
         round_trip: bool,
         warnings: bool,
         fallback: Option<&PyAny>,
+        context: Option<&PyAny>,
     ) -> PyResult<PyObject> {
         let warnings = CollectWarnings::new(warnings);
         let rec_guard = SerRecursionState::default();
@@ -165,6 +170,7 @@ impl SchemaSerializer {
             &rec_guard,
             false,
             fallback,
+            context,
         );
         let bytes = to_json_bytes(
             value,
@@ -213,7 +219,7 @@ impl SchemaSerializer {
 #[pyfunction]
 #[pyo3(signature = (value, *, indent = None, include = None, exclude = None, by_alias = true,
     exclude_none = false, round_trip = false, timedelta_mode = "iso8601", bytes_mode = "utf8",
-    inf_nan_mode = "constants", serialize_unknown = false, fallback = None))]
+    inf_nan_mode = "constants", serialize_unknown = false, fallback = None, context = None))]
 pub fn to_json(
     py: Python,
     value: &PyAny,
@@ -228,6 +234,7 @@ pub fn to_json(
     inf_nan_mode: &str,
     serialize_unknown: bool,
     fallback: Option<&PyAny>,
+    context: Option<&PyAny>,
 ) -> PyResult<PyObject> {
     let state = SerializationState::new(timedelta_mode, bytes_mode, inf_nan_mode)?;
     let extra = state.extra(
@@ -238,6 +245,7 @@ pub fn to_json(
         round_trip,
         serialize_unknown,
         fallback,
+        context,
     );
     let serializer = type_serializers::any::AnySerializer.into();
     let bytes = to_json_bytes(value, &serializer, include, exclude, &extra, indent, 1024)?;
@@ -249,7 +257,7 @@ pub fn to_json(
 #[allow(clippy::too_many_arguments)]
 #[pyfunction]
 #[pyo3(signature = (value, *, include = None, exclude = None, by_alias = true, exclude_none = false, round_trip = false,
-    timedelta_mode = "iso8601", bytes_mode = "utf8", inf_nan_mode = "constants", serialize_unknown = false, fallback = None))]
+    timedelta_mode = "iso8601", bytes_mode = "utf8", inf_nan_mode = "constants", serialize_unknown = false, fallback = None, context = None))]
 pub fn to_jsonable_python(
     py: Python,
     value: &PyAny,
@@ -263,6 +271,7 @@ pub fn to_jsonable_python(
     inf_nan_mode: &str,
     serialize_unknown: bool,
     fallback: Option<&PyAny>,
+    context: Option<&PyAny>,
 ) -> PyResult<PyObject> {
     let state = SerializationState::new(timedelta_mode, bytes_mode, inf_nan_mode)?;
     let extra = state.extra(
@@ -273,6 +282,7 @@ pub fn to_jsonable_python(
         round_trip,
         serialize_unknown,
         fallback,
+        context,
     );
     let v = infer::infer_to_python(value, include, exclude, &extra)?;
     state.final_check(py)?;
diff --git a/src/serializers/type_serializers/function.rs b/src/serializers/type_serializers/function.rs
index cf4ef7710..170009383 100644
--- a/src/serializers/type_serializers/function.rs
+++ b/src/serializers/type_serializers/function.rs
@@ -1,9 +1,11 @@
 use std::borrow::Cow;
 
 use pyo3::exceptions::{PyAttributeError, PyRecursionError, PyRuntimeError};
+use pyo3::gc::PyVisit;
 use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
+use pyo3::PyTraverseError;
 
 use pyo3::types::PyString;
 
@@ -440,6 +442,33 @@ impl SerializationCallable {
             exclude: exclude.map(|v| v.into_py(py)),
         }
     }
+
+    fn __traverse__(&self, visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
+        if let Some(include) = &self.include {
+            visit.call(include)?;
+        }
+        if let Some(exclude) = &self.exclude {
+            visit.call(exclude)?;
+        }
+        if let Some(model) = &self.extra_owned.model {
+            visit.call(model)?;
+        }
+        if let Some(fallback) = &self.extra_owned.fallback {
+            visit.call(fallback)?;
+        }
+        if let Some(context) = &self.extra_owned.context {
+            visit.call(context)?;
+        }
+        Ok(())
+    }
+
+    fn __clear__(&mut self) {
+        self.include = None;
+        self.exclude = None;
+        self.extra_owned.model = None;
+        self.extra_owned.fallback = None;
+        self.extra_owned.context = None;
+    }
 }
 
 #[pymethods]
@@ -488,6 +517,8 @@ struct SerializationInfo {
     include: Option<PyObject>,
     #[pyo3(get)]
     exclude: Option<PyObject>,
+    #[pyo3(get)]
+    context: Option<PyObject>,
     _mode: SerMode,
     #[pyo3(get)]
     by_alias: bool,
@@ -515,6 +546,7 @@ impl SerializationInfo {
                 Some(field_name) => Ok(Self {
                     include: include.map(|i| i.into_py(py)),
                     exclude: exclude.map(|e| e.into_py(py)),
+                    context: extra.context.map(Into::into),
                     _mode: extra.mode.clone(),
                     by_alias: extra.by_alias,
                     exclude_unset: extra.exclude_unset,
@@ -531,6 +563,7 @@ impl SerializationInfo {
             Ok(Self {
                 include: include.map(|i| i.into_py(py)),
                 exclude: exclude.map(|e| e.into_py(py)),
+                context: extra.context.map(Into::into),
                 _mode: extra.mode.clone(),
                 by_alias: extra.by_alias,
                 exclude_unset: extra.exclude_unset,
@@ -541,6 +574,25 @@ impl SerializationInfo {
             })
         }
     }
+
+    fn __traverse__(&self, visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
+        if let Some(include) = &self.include {
+            visit.call(include)?;
+        }
+        if let Some(exclude) = &self.exclude {
+            visit.call(exclude)?;
+        }
+        if let Some(context) = &self.context {
+            visit.call(context)?;
+        }
+        Ok(())
+    }
+
+    fn __clear__(&mut self) {
+        self.include = None;
+        self.exclude = None;
+        self.context = None;
+    }
 }
 
 #[pymethods]
@@ -563,6 +615,9 @@ impl SerializationInfo {
         if let Some(ref exclude) = self.exclude {
             d.set_item("exclude", exclude)?;
         }
+        if let Some(ref context) = self.context {
+            d.set_item("context", context)?;
+        }
         d.set_item("mode", self.mode(py))?;
         d.set_item("by_alias", self.by_alias)?;
         d.set_item("exclude_unset", self.exclude_unset)?;
@@ -574,7 +629,7 @@ impl SerializationInfo {
 
     fn __repr__(&self, py: Python) -> PyResult<String> {
         Ok(format!(
-            "SerializationInfo(include={}, exclude={}, mode='{}', by_alias={}, exclude_unset={}, exclude_defaults={}, exclude_none={}, round_trip={})",
+            "SerializationInfo(include={}, exclude={}, context={}, mode='{}', by_alias={}, exclude_unset={}, exclude_defaults={}, exclude_none={}, round_trip={})",
             match self.include {
                 Some(ref include) => include.as_ref(py).repr()?.to_str()?,
                 None => "None",
@@ -583,6 +638,10 @@ impl SerializationInfo {
                 Some(ref exclude) => exclude.as_ref(py).repr()?.to_str()?,
                 None => "None",
             },
+            match self.context {
+                Some(ref context) => context.as_ref(py).repr()?.to_str()?,
+                None => "None",
+            },
             self._mode,
             py_bool(self.by_alias),
             py_bool(self.exclude_unset),
diff --git a/src/serializers/type_serializers/generator.rs b/src/serializers/type_serializers/generator.rs
index 48a01e939..4637bc44e 100644
--- a/src/serializers/type_serializers/generator.rs
+++ b/src/serializers/type_serializers/generator.rs
@@ -1,8 +1,10 @@
 use std::borrow::Cow;
 
+use pyo3::gc::PyVisit;
 use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyIterator};
+use pyo3::PyTraverseError;
 
 use serde::ser::SerializeSeq;
 
@@ -173,6 +175,33 @@ impl SerializationIterator {
             exclude: exclude.map(|v| v.into_py(py)),
         }
     }
+
+    fn __traverse__(&self, visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
+        if let Some(include) = &self.include {
+            visit.call(include)?;
+        }
+        if let Some(exclude) = &self.exclude {
+            visit.call(exclude)?;
+        }
+        if let Some(model) = &self.extra_owned.model {
+            visit.call(model)?;
+        }
+        if let Some(fallback) = &self.extra_owned.fallback {
+            visit.call(fallback)?;
+        }
+        if let Some(context) = &self.extra_owned.context {
+            visit.call(context)?;
+        }
+        Ok(())
+    }
+
+    fn __clear__(&mut self) {
+        self.include = None;
+        self.exclude = None;
+        self.extra_owned.model = None;
+        self.extra_owned.fallback = None;
+        self.extra_owned.context = None;
+    }
 }
 
 #[pymethods]
diff --git a/src/validators/function.rs b/src/validators/function.rs
index 34e0b6327..51195fbe4 100644
--- a/src/validators/function.rs
+++ b/src/validators/function.rs
@@ -480,6 +480,18 @@ impl ValidationInfo {
             mode: extra.input_type,
         }
     }
+
+    fn __traverse__(&self, visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
+        visit.call(&self.config)?;
+        if let Some(context) = &self.context {
+            visit.call(context)?;
+        }
+        Ok(())
+    }
+
+    fn __clear__(&mut self) {
+        self.context = None;
+    }
 }
 
 #[pymethods]
diff --git a/tests/serializers/test_functions.py b/tests/serializers/test_functions.py
index 8851a7d36..e9a59bad2 100644
--- a/tests/serializers/test_functions.py
+++ b/tests/serializers/test_functions.py
@@ -122,6 +122,18 @@ def double(value, info):
         'round_trip': False,
     }
 
+    assert s.to_python(1, context='context') == 2
+    # insert_assert(f_info)
+    assert f_info == {
+        'context': 'context',
+        'mode': 'python',
+        'by_alias': True,
+        'exclude_unset': False,
+        'exclude_defaults': False,
+        'exclude_none': False,
+        'round_trip': False,
+    }
+
 
 def test_function_error():
     def raise_error(value, _info):
@@ -212,23 +224,27 @@ def append_args(value, info):
         )
     )
     assert s.to_python(123) == (
-        "123 info=SerializationInfo(include=None, exclude=None, mode='python', by_alias=True, exclude_unset=False, "
+        "123 info=SerializationInfo(include=None, exclude=None, context=None, mode='python', by_alias=True, exclude_unset=False, "
         'exclude_defaults=False, exclude_none=False, round_trip=False)'
     )
     assert s.to_python(123, mode='other') == (
-        "123 info=SerializationInfo(include=None, exclude=None, mode='other', by_alias=True, exclude_unset=False, "
+        "123 info=SerializationInfo(include=None, exclude=None, context=None, mode='other', by_alias=True, exclude_unset=False, "
         'exclude_defaults=False, exclude_none=False, round_trip=False)'
     )
     assert s.to_python(123, include={'x'}) == (
-        "123 info=SerializationInfo(include={'x'}, exclude=None, mode='python', by_alias=True, exclude_unset=False, "
+        "123 info=SerializationInfo(include={'x'}, exclude=None, context=None, mode='python', by_alias=True, exclude_unset=False, "
+        'exclude_defaults=False, exclude_none=False, round_trip=False)'
+    )
+    assert s.to_python(123, context='context') == (
+        "123 info=SerializationInfo(include=None, exclude=None, context='context', mode='python', by_alias=True, exclude_unset=False, "
         'exclude_defaults=False, exclude_none=False, round_trip=False)'
     )
     assert s.to_python(123, mode='json', exclude={1: {2}}) == (
-        "123 info=SerializationInfo(include=None, exclude={1: {2}}, mode='json', by_alias=True, exclude_unset=False, "
+        "123 info=SerializationInfo(include=None, exclude={1: {2}}, context=None, mode='json', by_alias=True, exclude_unset=False, "
         'exclude_defaults=False, exclude_none=False, round_trip=False)'
     )
     assert s.to_json(123) == (
-        b"\"123 info=SerializationInfo(include=None, exclude=None, mode='json', by_alias=True, exclude_unset=False, "
+        b"\"123 info=SerializationInfo(include=None, exclude=None, context=None, mode='json', by_alias=True, exclude_unset=False, "
         b'exclude_defaults=False, exclude_none=False, round_trip=False)"'
     )
 
diff --git a/tests/test.rs b/tests/test.rs
index 4a5776e7d..597084b3b 100644
--- a/tests/test.rs
+++ b/tests/test.rs
@@ -79,7 +79,9 @@ a = A()
             let schema: &PyDict = locals.get_item("schema").unwrap().unwrap().extract().unwrap();
             let serialized: Vec<u8> = SchemaSerializer::py_new(py, schema, None)
                 .unwrap()
-                .to_json(py, a, None, None, None, true, false, false, false, false, true, None)
+                .to_json(
+                    py, a, None, None, None, true, false, false, false, false, true, None, None,
+                )
                 .unwrap()
                 .extract(py)
                 .unwrap();
@@ -187,6 +189,7 @@ dump_json_input_2 = {'a': 'something'}
                     false,
                     false,
                     None,
+                    None,
                 )
                 .unwrap();
             let serialization_result: &PyAny = binding.extract(py).unwrap();
@@ -208,6 +211,7 @@ dump_json_input_2 = {'a': 'something'}
                     false,
                     false,
                     None,
+                    None,
                 )
                 .unwrap();
             let serialization_result: &PyAny = binding.extract(py).unwrap();
diff --git a/tests/test_typing.py b/tests/test_typing.py
index 63d17a790..22ba1f6e3 100644
--- a/tests/test_typing.py
+++ b/tests/test_typing.py
@@ -232,7 +232,7 @@ def f(input: Any, info: core_schema.SerializationInfo, /) -> str:
         )
     )
     assert s.to_python(123) == (
-        "SerializationInfo(include=None, exclude=None, mode='python', by_alias=True, exclude_unset=False, "
+        "SerializationInfo(include=None, exclude=None, context=None, mode='python', by_alias=True, exclude_unset=False, "
         'exclude_defaults=False, exclude_none=False, round_trip=False)'
     )
 
@@ -253,7 +253,7 @@ def f(
     # insert_assert(s.to_python(123, mode='json'))
     assert s.to_python(123, mode='json') == (
         'SerializationCallable(serializer=str) '
-        "SerializationInfo(include=None, exclude=None, mode='json', by_alias=True, exclude_unset=False, "
+        "SerializationInfo(include=None, exclude=None, context=None, mode='json', by_alias=True, exclude_unset=False, "
         'exclude_defaults=False, exclude_none=False, round_trip=False)'
     )
 

From 4a533aa93da212e959572e28866afe551f811fa2 Mon Sep 17 00:00:00 2001
From: "Bernhard M. Wiedemann" <githubbmwprimary@lsmod.de>
Date: Tue, 12 Mar 2024 12:41:47 +0100
Subject: [PATCH 227/550] Make tests pass in 2032 (#1221)

---
 tests/benchmarks/test_micro_benchmarks.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/benchmarks/test_micro_benchmarks.py b/tests/benchmarks/test_micro_benchmarks.py
index 6086c5bd7..80b3e6a47 100644
--- a/tests/benchmarks/test_micro_benchmarks.py
+++ b/tests/benchmarks/test_micro_benchmarks.py
@@ -635,13 +635,13 @@ def test_date_from_datetime_str(self, benchmark, validator):
     def test_core_future(self, benchmark):
         v = SchemaValidator({'type': 'date', 'gt': date.today()})
 
-        benchmark(v.validate_python, date(2032, 1, 1))
+        benchmark(v.validate_python, date(2932, 1, 1))
 
     @pytest.mark.benchmark(group='date future')
     def test_core_future_str(self, benchmark):
         v = SchemaValidator({'type': 'date', 'gt': date.today()})
 
-        benchmark(v.validate_python, str(date(2032, 1, 1)))
+        benchmark(v.validate_python, str(date(2932, 1, 1)))
 
 
 class TestBenchmarkUnion:

From 71d54a243f52550847716cb4208944667ebc16ee Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Tue, 12 Mar 2024 19:57:39 +0000
Subject: [PATCH 228/550] update to PyO3 0.21 beta (#1222)

---
 Cargo.lock                                    |  60 +----
 Cargo.toml                                    |   8 +-
 benches/main.rs                               | 204 +++++++-------
 src/argument_markers.rs                       |   8 +-
 src/build_tools.rs                            |  28 +-
 src/errors/line_error.rs                      |  13 +-
 src/errors/location.rs                        |  10 +-
 src/errors/mod.rs                             |   4 +-
 src/errors/types.rs                           |  27 +-
 src/errors/validation_exception.rs            |  45 ++--
 src/errors/value_exception.rs                 |  18 +-
 src/input/datetime.rs                         |  91 ++++---
 src/input/input_abstract.rs                   |  18 +-
 src/input/input_json.rs                       |  16 +-
 src/input/input_python.rs                     | 222 +++++++--------
 src/input/input_string.rs                     |  28 +-
 src/input/return_enums.rs                     | 248 ++++++++---------
 src/input/shared.rs                           |  16 +-
 src/lib.rs                                    |  11 +-
 src/lookup_key.rs                             |  93 +++----
 src/serializers/computed_fields.rs            |  66 ++---
 src/serializers/config.rs                     |  33 ++-
 src/serializers/extra.rs                      |  45 ++--
 src/serializers/fields.rs                     | 138 +++++-----
 src/serializers/filter.rs                     | 136 +++++-----
 src/serializers/infer.rs                      | 252 +++++++++---------
 src/serializers/mod.rs                        |  56 ++--
 src/serializers/ob_type.rs                    | 119 +++++----
 src/serializers/shared.rs                     |  97 +++----
 src/serializers/type_serializers/any.rs       |  18 +-
 src/serializers/type_serializers/bytes.rs     |  18 +-
 src/serializers/type_serializers/dataclass.rs |  61 +++--
 .../type_serializers/datetime_etc.rs          |  30 +--
 src/serializers/type_serializers/decimal.rs   |  18 +-
 .../type_serializers/definitions.rs           |  40 +--
 src/serializers/type_serializers/dict.rs      |  58 ++--
 src/serializers/type_serializers/float.rs     |  18 +-
 src/serializers/type_serializers/format.rs    |  86 +++---
 src/serializers/type_serializers/function.rs  | 166 ++++++------
 src/serializers/type_serializers/generator.rs |  67 +++--
 src/serializers/type_serializers/json.rs      |  22 +-
 .../type_serializers/json_or_python.rs        |  26 +-
 src/serializers/type_serializers/list.rs      |  38 ++-
 src/serializers/type_serializers/literal.rs   |  42 +--
 src/serializers/type_serializers/model.rs     |  77 +++---
 src/serializers/type_serializers/nullable.rs  |  22 +-
 src/serializers/type_serializers/other.rs     |  42 +--
 .../type_serializers/set_frozenset.rs         |  30 +--
 src/serializers/type_serializers/simple.rs    |  44 +--
 src/serializers/type_serializers/string.rs    |  28 +-
 src/serializers/type_serializers/timedelta.rs |  18 +-
 src/serializers/type_serializers/tuple.rs     |  48 ++--
 .../type_serializers/typed_dict.rs            |  16 +-
 src/serializers/type_serializers/union.rs     |  32 +--
 src/serializers/type_serializers/url.rs       |  18 +-
 src/serializers/type_serializers/uuid.rs      |  20 +-
 .../type_serializers/with_default.rs          |  22 +-
 src/tools.rs                                  |  59 ++--
 src/url.rs                                    |  32 +--
 src/validators/any.rs                         |   4 +-
 src/validators/arguments.rs                   |  59 ++--
 src/validators/bool.rs                        |   4 +-
 src/validators/bytes.rs                       |   6 +-
 src/validators/call.rs                        |  30 ++-
 src/validators/callable.rs                    |   4 +-
 src/validators/chain.rs                       |  16 +-
 src/validators/custom_error.rs                |  12 +-
 src/validators/dataclass.rs                   | 144 +++++-----
 src/validators/date.rs                        |  10 +-
 src/validators/datetime.rs                    |  36 ++-
 src/validators/decimal.rs                     |  81 +++---
 src/validators/definitions.rs                 |  29 +-
 src/validators/dict.rs                        |  16 +-
 src/validators/float.rs                       |  12 +-
 src/validators/frozenset.rs                   |   4 +-
 src/validators/function.rs                    | 204 ++++++++------
 src/validators/generator.rs                   |  30 ++-
 src/validators/int.rs                         |   6 +-
 src/validators/is_instance.rs                 |  15 +-
 src/validators/is_subclass.rs                 |   8 +-
 src/validators/json.rs                        |   8 +-
 src/validators/json_or_python.rs              |  12 +-
 src/validators/lax_or_strict.rs               |   8 +-
 src/validators/list.rs                        |  10 +-
 src/validators/literal.rs                     |  18 +-
 src/validators/mod.rs                         | 127 ++++-----
 src/validators/model.rs                       | 125 ++++-----
 src/validators/model_fields.rs                |  71 ++---
 src/validators/none.rs                        |   4 +-
 src/validators/nullable.rs                    |   8 +-
 src/validators/set.rs                         |  10 +-
 src/validators/string.rs                      |  32 ++-
 src/validators/time.rs                        |  12 +-
 src/validators/timedelta.rs                   |  12 +-
 src/validators/tuple.rs                       |  28 +-
 src/validators/typed_dict.rs                  |  40 +--
 src/validators/union.rs                       | 100 +++----
 src/validators/url.rs                         |  10 +-
 src/validators/uuid.rs                        |  28 +-
 src/validators/validation_state.rs            |   9 +-
 src/validators/with_default.rs                |  26 +-
 tests/test.rs                                 |  72 +++--
 102 files changed, 2520 insertions(+), 2306 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index b74074c8d..667d15b1b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -148,32 +148,19 @@ checksum = "62b02a5381cc465bd3041d84623d0fa3b66738b52b8e2fc3bab8ad63ab032f4a"
 
 [[package]]
 name = "jiter"
-version = "0.0.6"
+version = "0.0.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87db066a99f69382be06d02313f8ce989996b53a04a8a70cfd1a6483a56227f7"
+checksum = "c2a1b6e316923afd3087ec73829f646a67c18f3a5bd61624247b05e652e4a99d"
 dependencies = [
  "ahash",
  "hashbrown",
- "lexical-core",
+ "lexical-parse-float",
  "num-bigint",
  "num-traits",
  "pyo3",
  "smallvec",
 ]
 
-[[package]]
-name = "lexical-core"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2cde5de06e8d4c2faabc400238f9ae1c74d5412d03a7bd067645ccbc47070e46"
-dependencies = [
- "lexical-parse-float",
- "lexical-parse-integer",
- "lexical-util",
- "lexical-write-float",
- "lexical-write-integer",
-]
-
 [[package]]
 name = "lexical-parse-float"
 version = "0.8.5"
@@ -204,27 +191,6 @@ dependencies = [
  "static_assertions",
 ]
 
-[[package]]
-name = "lexical-write-float"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "accabaa1c4581f05a3923d1b4cfd124c329352288b7b9da09e766b0668116862"
-dependencies = [
- "lexical-util",
- "lexical-write-integer",
- "static_assertions",
-]
-
-[[package]]
-name = "lexical-write-integer"
-version = "0.8.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1b6f3d1f4422866b68192d62f77bc5c700bee84f3069f2469d7bc8c77852446"
-dependencies = [
- "lexical-util",
- "static_assertions",
-]
-
 [[package]]
 name = "libc"
 version = "0.2.147"
@@ -363,9 +329,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.20.3"
+version = "0.21.0-beta.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "53bdbb96d49157e65d45cc287af5f32ffadd5f4761438b527b055fb0d4bb8233"
+checksum = "5d0c41d899f822e5f39186d6da130a822a0a43edb19992b51bf4ef6cd0b4cfd1"
 dependencies = [
  "cfg-if",
  "indoc",
@@ -382,9 +348,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.20.3"
+version = "0.21.0-beta.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "deaa5745de3f5231ce10517a1f5dd97d53e5a2fd77aa6b5842292085831d48d7"
+checksum = "5509c2aa78c7e770077e41ba86f806e60dcee812e924ccb2d6fe78c0a0128ce2"
 dependencies = [
  "once_cell",
  "python3-dll-a",
@@ -393,9 +359,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.20.3"
+version = "0.21.0-beta.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62b42531d03e08d4ef1f6e85a2ed422eb678b8cd62b762e53891c05faf0d4afa"
+checksum = "e6bb234a86ed619a661f3bb3c2493aaff9cb937e33e198d17f5f20a15881e155"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -403,9 +369,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.20.3"
+version = "0.21.0-beta.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7305c720fa01b8055ec95e484a6eca7a83c841267f0dd5280f0c8b8551d2c158"
+checksum = "f0b787de2c6832eb1eb393c9f82f976a5a87bda979780d9b853878846a8d2e4b"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -415,9 +381,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.20.3"
+version = "0.21.0-beta.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7c7e9b68bb9c3149c5b0cade5d07f953d6d125eb4337723c4ccdb665f1f96185"
+checksum = "5e3b7beed357786d2afe845871964e824ad8af0df38a403f7d01cdc81aadb211"
 dependencies = [
  "heck",
  "proc-macro2",
diff --git a/Cargo.toml b/Cargo.toml
index ea3e3d73c..f74976967 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -27,7 +27,7 @@ include = [
 rust-version = "1.70"
 
 [dependencies]
-pyo3 = { version = "0.20.3", features = ["generate-import-lib", "num-bigint"] }
+pyo3 = { version = "0.21.0-beta.0", features = ["generate-import-lib", "num-bigint"] }
 regex = "1.10.3"
 strum = { version = "0.25.0", features = ["derive"] }
 strum_macros = "0.26.1"
@@ -44,7 +44,7 @@ base64 = "0.21.7"
 num-bigint = "0.4.4"
 python3-dll-a = "0.2.7"
 uuid = "1.7.0"
-jiter = {version = "0.0.6", features = ["python"]}
+jiter = {version = "0.0.7", features = ["python"]}
 
 [lib]
 name = "_pydantic_core"
@@ -71,12 +71,12 @@ debug = true
 strip = false
 
 [dev-dependencies]
-pyo3 = { version = "0.20.3", features = ["auto-initialize"] }
+pyo3 = { version = "0.21.0-beta.0", features = ["auto-initialize"] }
 
 [build-dependencies]
 version_check = "0.9.4"
 # used where logic has to be version/distribution specific, e.g. pypy
-pyo3-build-config = { version = "0.20.2" }
+pyo3-build-config = { version = "0.21.0-beta.0" }
 
 [lints.clippy]
 dbg_macro = "warn"
diff --git a/benches/main.rs b/benches/main.rs
index 4b8a2b106..d1ef27a93 100644
--- a/benches/main.rs
+++ b/benches/main.rs
@@ -10,17 +10,17 @@ use pyo3::types::{PyDict, PyString};
 use _pydantic_core::{validate_core_schema, SchemaValidator};
 
 fn build_schema_validator_with_globals(py: Python, code: &str, globals: Option<&PyDict>) -> SchemaValidator {
-    let mut schema: &PyDict = py.eval(code, globals, None).unwrap().extract().unwrap();
-    schema = validate_core_schema(py, schema, None).unwrap().extract().unwrap();
-    SchemaValidator::py_new(py, schema, None).unwrap()
+    let mut schema = py.eval(code, globals, None).unwrap().extract().unwrap();
+    schema = validate_core_schema(&schema, None).unwrap().extract().unwrap();
+    SchemaValidator::py_new(py, &schema, None).unwrap()
 }
 
 fn build_schema_validator(py: Python, code: &str) -> SchemaValidator {
     build_schema_validator_with_globals(py, code, None)
 }
 
-fn json<'a>(py: Python<'a>, code: &'a str) -> &'a PyAny {
-    black_box(PyString::new(py, code))
+fn json<'a>(py: Python<'a>, code: &'a str) -> Bound<'a, PyAny> {
+    black_box(PyString::new_bound(py, code).into_any())
 }
 
 #[bench]
@@ -28,11 +28,11 @@ fn ints_json(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let validator = build_schema_validator(py, "{'type': 'int'}");
 
-        let result = validator.validate_json(py, json(py, "123"), None, None, None).unwrap();
+        let result = validator.validate_json(py, &json(py, "123"), None, None, None).unwrap();
         let result_int: i64 = result.extract(py).unwrap();
         assert_eq!(result_int, 123);
 
-        bench.iter(|| black_box(validator.validate_json(py, json(py, "123"), None, None, None).unwrap()))
+        bench.iter(|| black_box(validator.validate_json(py, &json(py, "123"), None, None, None).unwrap()))
     })
 }
 
@@ -41,14 +41,13 @@ fn ints_python(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let validator = build_schema_validator(py, "{'type': 'int'}");
 
-        let input = 123_i64.into_py(py);
-        let input = input.as_ref(py);
-        let result = validator.validate_python(py, input, None, None, None, None).unwrap();
+        let input = 123_i64.into_py(py).into_bound(py);
+        let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
         let result_int: i64 = result.extract(py).unwrap();
         assert_eq!(result_int, 123);
 
         let input = black_box(input);
-        bench.iter(|| black_box(validator.validate_python(py, input, None, None, None, None).unwrap()))
+        bench.iter(|| black_box(validator.validate_python(py, &input, None, None, None, None).unwrap()))
     })
 }
 
@@ -61,7 +60,7 @@ fn list_int_json(bench: &mut Bencher) {
             (0..100).map(|x| x.to_string()).collect::<Vec<String>>().join(",")
         );
 
-        bench.iter(|| black_box(validator.validate_json(py, json(py, &code), None, None, None).unwrap()))
+        bench.iter(|| black_box(validator.validate_json(py, &json(py, &code), None, None, None).unwrap()))
     })
 }
 
@@ -80,9 +79,9 @@ fn list_int_input(py: Python<'_>) -> (SchemaValidator, PyObject) {
 fn list_int_python(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let (validator, input) = list_int_input(py);
-        let input = black_box(input.as_ref(py));
+        let input = black_box(input.bind(py));
         bench.iter(|| {
-            let v = validator.validate_python(py, input, None, None, None, None).unwrap();
+            let v = validator.validate_python(py, &input, None, None, None, None).unwrap();
             black_box(v)
         })
     })
@@ -92,12 +91,12 @@ fn list_int_python(bench: &mut Bencher) {
 fn list_int_python_isinstance(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let (validator, input) = list_int_input(py);
-        let input = black_box(input.as_ref(py));
-        let v = validator.isinstance_python(py, input, None, None, None, None).unwrap();
+        let input = black_box(input.bind(py));
+        let v = validator.isinstance_python(py, &input, None, None, None, None).unwrap();
         assert!(v);
 
         bench.iter(|| {
-            let v = validator.isinstance_python(py, input, None, None, None, None).unwrap();
+            let v = validator.isinstance_python(py, &input, None, None, None, None).unwrap();
             black_box(v)
         })
     })
@@ -115,7 +114,7 @@ fn list_error_json(bench: &mut Bencher) {
                 .join(", ")
         );
 
-        match validator.validate_json(py, json(py, &code), None, None, None) {
+        match validator.validate_json(py, &json(py, &code), None, None, None) {
             Ok(_) => panic!("unexpectedly valid"),
             Err(e) => {
                 let v = e.value(py);
@@ -127,7 +126,7 @@ fn list_error_json(bench: &mut Bencher) {
         };
 
         bench.iter(
-            || match validator.validate_json(py, json(py, &code), None, None, None) {
+            || match validator.validate_json(py, &json(py, &code), None, None, None) {
                 Ok(_) => panic!("unexpectedly valid"),
                 Err(e) => black_box(e),
             },
@@ -145,9 +144,9 @@ fn list_error_python_input(py: Python<'_>) -> (SchemaValidator, PyObject) {
             .join(", ")
     );
 
-    let input = py.eval(&code, None, None).unwrap();
+    let input = py.eval(&code, None, None).unwrap().extract().unwrap();
 
-    match validator.validate_python(py, input, None, None, None, None) {
+    match validator.validate_python(py, &input, None, None, None, None) {
         Ok(_) => panic!("unexpectedly valid"),
         Err(e) => {
             let v = e.value(py);
@@ -165,9 +164,9 @@ fn list_error_python(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let (validator, input) = list_error_python_input(py);
 
-        let input = black_box(input.as_ref(py));
+        let input = black_box(input.bind(py));
         bench.iter(|| {
-            let result = validator.validate_python(py, input, None, None, None, None);
+            let result = validator.validate_python(py, &input, None, None, None, None);
 
             match result {
                 Ok(_) => panic!("unexpectedly valid"),
@@ -181,14 +180,12 @@ fn list_error_python(bench: &mut Bencher) {
 fn list_error_python_isinstance(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let (validator, input) = list_error_python_input(py);
-        let r = validator
-            .isinstance_python(py, black_box(input.as_ref(py)), None, None, None, None)
-            .unwrap();
+        let input = black_box(input.bind(py));
+        let r = validator.isinstance_python(py, &input, None, None, None, None).unwrap();
         assert!(!r);
 
-        let input = black_box(input.as_ref(py));
         bench.iter(|| {
-            black_box(validator.isinstance_python(py, input, None, None, None, None).unwrap());
+            black_box(validator.isinstance_python(py, &input, None, None, None, None).unwrap());
         })
     })
 }
@@ -202,7 +199,7 @@ fn list_any_json(bench: &mut Bencher) {
             (0..100).map(|x| x.to_string()).collect::<Vec<String>>().join(",")
         );
 
-        bench.iter(|| black_box(validator.validate_json(py, json(py, &code), None, None, None).unwrap()))
+        bench.iter(|| black_box(validator.validate_json(py, &json(py, &code), None, None, None).unwrap()))
     })
 }
 
@@ -214,10 +211,10 @@ fn list_any_python(bench: &mut Bencher) {
             "[{}]",
             (0..100).map(|x| x.to_string()).collect::<Vec<String>>().join(",")
         );
-        let input = py.eval(&code, None, None).unwrap();
-        let input = black_box(input);
+        let input = py.eval(&code, None, None).unwrap().to_object(py);
+        let input = black_box(input.bind(py));
         bench.iter(|| {
-            let v = validator.validate_python(py, input, None, None, None, None).unwrap();
+            let v = validator.validate_python(py, &input, None, None, None, None).unwrap();
             black_box(v)
         })
     })
@@ -247,7 +244,7 @@ fn dict_json(bench: &mut Bencher) {
                 .join(", ")
         );
 
-        bench.iter(|| black_box(validator.validate_json(py, json(py, &code), None, None, None).unwrap()))
+        bench.iter(|| black_box(validator.validate_json(py, &json(py, &code), None, None, None).unwrap()))
     })
 }
 
@@ -266,10 +263,10 @@ fn dict_python(bench: &mut Bencher) {
                 .collect::<Vec<String>>()
                 .join(", ")
         );
-        let input = py.eval(&code, None, None).unwrap();
-        let input = black_box(input);
+        let input = py.eval(&code, None, None).unwrap().to_object(py);
+        let input = black_box(input.bind(py));
         bench.iter(|| {
-            let v = validator.validate_python(py, input, None, None, None, None).unwrap();
+            let v = validator.validate_python(py, &input, None, None, None, None).unwrap();
             black_box(v)
         })
     })
@@ -295,9 +292,9 @@ fn dict_value_error(bench: &mut Bencher) {
                 .join(", ")
         );
 
-        let input = py.eval(&code, None, None).unwrap();
+        let input = py.eval(&code, None, None).unwrap().to_object(py).into_bound(py);
 
-        match validator.validate_python(py, input, None, None, None, None) {
+        match validator.validate_python(py, &input, None, None, None, None) {
             Ok(_) => panic!("unexpectedly valid"),
             Err(e) => {
                 let v = e.value(py);
@@ -310,7 +307,7 @@ fn dict_value_error(bench: &mut Bencher) {
 
         let input = black_box(input);
         bench.iter(|| {
-            let result = validator.validate_python(py, input, None, None, None, None);
+            let result = validator.validate_python(py, &input, None, None, None, None);
 
             match result {
                 Ok(_) => panic!("unexpectedly valid"),
@@ -345,7 +342,7 @@ fn typed_dict_json(bench: &mut Bencher) {
 
         let code = r#"{"a": 1, "b": 2, "c": 3, "d": 4, "e": 5, "f": 6, "g": 7, "h": 8, "i": 9, "j": 0}"#.to_string();
 
-        bench.iter(|| black_box(validator.validate_json(py, json(py, &code), None, None, None).unwrap()))
+        bench.iter(|| black_box(validator.validate_json(py, &json(py, &code), None, None, None).unwrap()))
     })
 }
 
@@ -373,10 +370,10 @@ fn typed_dict_python(bench: &mut Bencher) {
         );
 
         let code = r#"{"a": 1, "b": 2, "c": 3, "d": 4, "e": 5, "f": 6, "g": 7, "h": 8, "i": 9, "j": 0}"#.to_string();
-        let input = py.eval(&code, None, None).unwrap();
-        let input = black_box(input);
+        let input = py.eval(&code, None, None).unwrap().to_object(py);
+        let input = black_box(input.bind(py));
         bench.iter(|| {
-            let v = validator.validate_python(py, input, None, None, None, None).unwrap();
+            let v = validator.validate_python(py, &input, None, None, None, None).unwrap();
             black_box(v)
         })
     })
@@ -413,10 +410,10 @@ fn typed_dict_deep_error(bench: &mut Bencher) {
 
         let code = "{'field_a': '1', 'field_b': {'field_c': '2', 'field_d': {'field_e': '4', 'field_f': 'xx'}}}";
 
-        let input = py.eval(code, None, None).unwrap();
-        let input = black_box(input);
+        let input = py.eval(code, None, None).unwrap().to_object(py);
+        let input = black_box(input.bind(py));
 
-        match validator.validate_python(py, input, None, None, None, None) {
+        match validator.validate_python(py, &input, None, None, None, None) {
             Ok(_) => panic!("unexpectedly valid"),
             Err(e) => {
                 let v = e.value(py);
@@ -428,7 +425,7 @@ fn typed_dict_deep_error(bench: &mut Bencher) {
         };
 
         bench.iter(|| {
-            let result = validator.validate_python(py, input, None, None, None, None);
+            let result = validator.validate_python(py, &input, None, None, None, None);
 
             match result {
                 Ok(_) => panic!("unexpectedly valid"),
@@ -444,16 +441,16 @@ fn complete_model(bench: &mut Bencher) {
         let sys_path = py.import("sys").unwrap().getattr("path").unwrap();
         sys_path.call_method1("append", ("./tests/benchmarks/",)).unwrap();
 
-        let complete_schema = py.import("complete_schema").unwrap();
+        let complete_schema = py.import_bound("complete_schema").unwrap();
         let mut schema = complete_schema.call_method0("schema").unwrap();
-        schema = validate_core_schema(py, schema, None).unwrap().extract().unwrap();
-        let validator = SchemaValidator::py_new(py, schema, None).unwrap();
+        schema = validate_core_schema(&schema, None).unwrap().extract().unwrap();
+        let validator = SchemaValidator::py_new(py, &schema, None).unwrap();
 
         let input = complete_schema.call_method0("input_data_lax").unwrap();
         let input = black_box(input);
 
         bench.iter(|| {
-            black_box(validator.validate_python(py, input, None, None, None, None).unwrap());
+            black_box(validator.validate_python(py, &input, None, None, None, None).unwrap());
         })
     })
 }
@@ -464,18 +461,18 @@ fn nested_model_using_definitions(bench: &mut Bencher) {
         let sys_path = py.import("sys").unwrap().getattr("path").unwrap();
         sys_path.call_method1("append", ("./tests/benchmarks/",)).unwrap();
 
-        let complete_schema = py.import("nested_schema").unwrap();
+        let complete_schema = py.import_bound("nested_schema").unwrap();
         let mut schema = complete_schema.call_method0("schema_using_defs").unwrap();
-        schema = validate_core_schema(py, schema, None).unwrap().extract().unwrap();
-        let validator = SchemaValidator::py_new(py, schema, None).unwrap();
+        schema = validate_core_schema(&schema, None).unwrap().extract().unwrap();
+        let validator = SchemaValidator::py_new(py, &schema, None).unwrap();
 
         let input = complete_schema.call_method0("input_data_valid").unwrap();
         let input = black_box(input);
 
-        validator.validate_python(py, input, None, None, None, None).unwrap();
+        validator.validate_python(py, &input, None, None, None, None).unwrap();
 
         bench.iter(|| {
-            black_box(validator.validate_python(py, input, None, None, None, None).unwrap());
+            black_box(validator.validate_python(py, &input, None, None, None, None).unwrap());
         })
     })
 }
@@ -486,18 +483,18 @@ fn nested_model_inlined(bench: &mut Bencher) {
         let sys_path = py.import("sys").unwrap().getattr("path").unwrap();
         sys_path.call_method1("append", ("./tests/benchmarks/",)).unwrap();
 
-        let complete_schema = py.import("nested_schema").unwrap();
+        let complete_schema = py.import_bound("nested_schema").unwrap();
         let mut schema = complete_schema.call_method0("inlined_schema").unwrap();
-        schema = validate_core_schema(py, schema, None).unwrap().extract().unwrap();
-        let validator = SchemaValidator::py_new(py, schema, None).unwrap();
+        schema = validate_core_schema(&schema, None).unwrap().extract().unwrap();
+        let validator = SchemaValidator::py_new(py, &schema, None).unwrap();
 
         let input = complete_schema.call_method0("input_data_valid").unwrap();
         let input = black_box(input);
 
-        validator.validate_python(py, input, None, None, None, None).unwrap();
+        validator.validate_python(py, &input, None, None, None, None).unwrap();
 
         bench.iter(|| {
-            black_box(validator.validate_python(py, input, None, None, None, None).unwrap());
+            black_box(validator.validate_python(py, &input, None, None, None, None).unwrap());
         })
     })
 }
@@ -508,13 +505,13 @@ fn literal_ints_few_python(bench: &mut Bencher) {
         let validator = build_schema_validator(py, "{'type': 'literal', 'expected': list(range(5))}");
 
         let input = 4_i64.into_py(py);
-        let input = input.as_ref(py);
-        let result = validator.validate_python(py, input, None, None, None, None).unwrap();
+        let input = input.bind(py);
+        let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
         let result_int: i64 = result.extract(py).unwrap();
         assert_eq!(result_int, 4);
 
         let input = black_box(input);
-        bench.iter(|| black_box(validator.validate_python(py, input, None, None, None, None).unwrap()))
+        bench.iter(|| black_box(validator.validate_python(py, &input, None, None, None, None).unwrap()))
     })
 }
 
@@ -524,13 +521,14 @@ fn literal_strings_few_small_python(bench: &mut Bencher) {
         let validator = build_schema_validator(py, "{'type': 'literal', 'expected': [f'{idx}' for idx in range(5)]}");
 
         let input = py.eval("'4'", None, None).unwrap();
+        let input = input.to_object(py).into_bound(py);
         let input_str: String = input.extract().unwrap();
-        let result = validator.validate_python(py, input, None, None, None, None).unwrap();
+        let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
         let result_str: String = result.extract(py).unwrap();
         assert_eq!(result_str, input_str);
 
         let input = black_box(input);
-        bench.iter(|| black_box(validator.validate_python(py, input, None, None, None, None).unwrap()))
+        bench.iter(|| black_box(validator.validate_python(py, &input, None, None, None, None).unwrap()))
     })
 }
 
@@ -543,20 +541,21 @@ fn literal_strings_few_large_python(bench: &mut Bencher) {
         );
 
         let input = py.eval("'a' * 25 + '4'", None, None).unwrap();
+        let input = input.to_object(py).into_bound(py);
         let input_str: String = input.extract().unwrap();
-        let result = validator.validate_python(py, input, None, None, None, None).unwrap();
+        let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
         let result_str: String = result.extract(py).unwrap();
         assert_eq!(result_str, input_str);
 
         let input = black_box(input);
-        bench.iter(|| black_box(validator.validate_python(py, input, None, None, None, None).unwrap()))
+        bench.iter(|| black_box(validator.validate_python(py, &input, None, None, None, None).unwrap()))
     })
 }
 
 #[bench]
 fn literal_enums_few_python(bench: &mut Bencher) {
     Python::with_gil(|py| {
-        let globals = PyDict::new(py);
+        let globals = PyDict::new_bound(py);
         py.run(
             r#"
 from enum import Enum
@@ -567,7 +566,7 @@ class Foo(Enum):
     v3 = object()
     v4 = object()
 "#,
-            Some(globals),
+            Some(globals.as_gil_ref()),
             None,
         )
         .unwrap();
@@ -575,15 +574,16 @@ class Foo(Enum):
         let validator = build_schema_validator_with_globals(
             py,
             "{'type': 'literal', 'expected': [Foo.v1, Foo.v2, Foo.v3, Foo.v4]}",
-            Some(globals),
+            Some(globals.as_gil_ref()),
         );
 
-        let input = py.eval("Foo.v4", Some(globals), None).unwrap();
-        let result = validator.validate_python(py, input, None, None, None, None).unwrap();
+        let input = py.eval("Foo.v4", Some(globals.as_gil_ref()), None).unwrap();
+        let input = input.to_object(py).into_bound(py);
+        let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
         assert!(input.eq(result).unwrap());
 
         let input = black_box(input);
-        bench.iter(|| black_box(validator.validate_python(py, input, None, None, None, None).unwrap()))
+        bench.iter(|| black_box(validator.validate_python(py, &input, None, None, None, None).unwrap()))
     })
 }
 
@@ -592,14 +592,13 @@ fn literal_ints_many_python(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let validator = build_schema_validator(py, "{'type': 'literal', 'expected': list(range(100))}");
 
-        let input = 99_i64.into_py(py);
-        let input = input.as_ref(py);
-        let result = validator.validate_python(py, input, None, None, None, None).unwrap();
+        let input = 99_i64.into_py(py).into_bound(py);
+        let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
         let result_int: i64 = result.extract(py).unwrap();
         assert_eq!(result_int, 99);
 
         let input = black_box(input);
-        bench.iter(|| black_box(validator.validate_python(py, input, None, None, None, None).unwrap()))
+        bench.iter(|| black_box(validator.validate_python(py, &input, None, None, None, None).unwrap()))
     })
 }
 
@@ -609,13 +608,14 @@ fn literal_strings_many_small_python(bench: &mut Bencher) {
         let validator = build_schema_validator(py, "{'type': 'literal', 'expected': [f'{idx}' for idx in range(100)]}");
 
         let input = py.eval("'99'", None, None).unwrap();
+        let input = input.to_object(py).into_bound(py);
         let input_str: String = input.extract().unwrap();
-        let result = validator.validate_python(py, input, None, None, None, None).unwrap();
+        let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
         let result_str: String = result.extract(py).unwrap();
         assert_eq!(result_str, input_str);
 
         let input = black_box(input);
-        bench.iter(|| black_box(validator.validate_python(py, input, None, None, None, None).unwrap()))
+        bench.iter(|| black_box(validator.validate_python(py, &input, None, None, None, None).unwrap()))
     })
 }
 
@@ -628,13 +628,14 @@ fn literal_strings_many_large_python(bench: &mut Bencher) {
         );
 
         let input = py.eval("'a' * 25 + '99'", None, None).unwrap();
+        let input = input.to_object(py).into_bound(py);
         let input_str: String = input.extract().unwrap();
-        let result = validator.validate_python(py, input, None, None, None, None).unwrap();
+        let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
         let result_str: String = result.extract(py).unwrap();
         assert_eq!(result_str, input_str);
 
         let input = black_box(input);
-        bench.iter(|| black_box(validator.validate_python(py, input, None, None, None, None).unwrap()))
+        bench.iter(|| black_box(validator.validate_python(py, &input, None, None, None, None).unwrap()))
     })
 }
 
@@ -644,12 +645,13 @@ fn literal_ints_many_json(bench: &mut Bencher) {
         let validator = build_schema_validator(py, "{'type': 'literal', 'expected': list(range(100))}");
 
         let input_json = py.eval("'99'", None, None).unwrap();
-        let result = validator.validate_json(py, input_json, None, None, None).unwrap();
+        let input_json = input_json.to_object(py).into_bound(py);
+        let result = validator.validate_json(py, &input_json, None, None, None).unwrap();
         let result_int: i64 = result.extract(py).unwrap();
         assert_eq!(result_int, 99);
 
         let input_json = black_box(input_json);
-        bench.iter(|| black_box(validator.validate_json(py, input_json, None, None, None).unwrap()))
+        bench.iter(|| black_box(validator.validate_json(py, &input_json, None, None, None).unwrap()))
     })
 }
 
@@ -662,21 +664,23 @@ fn literal_strings_many_large_json(bench: &mut Bencher) {
         );
 
         let input = py.eval("'a' * 25 + '99'", None, None).unwrap();
+        let input = input.to_object(py).into_bound(py);
         let input_json = py.eval("'\"' + 'a' * 25 + '99' + '\"'", None, None).unwrap();
+        let input_json = input_json.to_object(py).into_bound(py);
         let input_str: String = input.extract().unwrap();
-        let result = validator.validate_json(py, input_json, None, None, None).unwrap();
+        let result = validator.validate_json(py, &input_json, None, None, None).unwrap();
         let result_str: String = result.extract(py).unwrap();
         assert_eq!(result_str, input_str);
 
         let input_json = black_box(input_json);
-        bench.iter(|| black_box(validator.validate_json(py, input_json, None, None, None).unwrap()))
+        bench.iter(|| black_box(validator.validate_json(py, &input_json, None, None, None).unwrap()))
     })
 }
 
 #[bench]
 fn literal_mixed_few_python(bench: &mut Bencher) {
     Python::with_gil(|py| {
-        let globals = PyDict::new(py);
+        let globals = PyDict::new_bound(py);
         py.run(
             r#"
 from enum import Enum
@@ -687,58 +691,62 @@ class Foo(Enum):
     v3 = object()
     v4 = object()
 "#,
-            Some(globals),
+            Some(globals.as_gil_ref()),
             None,
         )
         .unwrap();
         let validator = build_schema_validator_with_globals(
             py,
             "{'type': 'literal', 'expected': [None, 'null', -1, Foo.v4]}",
-            Some(globals),
+            Some(globals.as_gil_ref()),
         );
 
         // String
         {
             let input = py.eval("'null'", None, None).unwrap();
+            let input = input.to_object(py).into_bound(py);
             let input_str: String = input.extract().unwrap();
-            let result = validator.validate_python(py, input, None, None, None, None).unwrap();
+            let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
             let result_str: String = result.extract(py).unwrap();
             assert_eq!(result_str, input_str);
 
             let input = black_box(input);
-            bench.iter(|| black_box(validator.validate_python(py, input, None, None, None, None).unwrap()))
+            bench.iter(|| black_box(validator.validate_python(py, &input, None, None, None, None).unwrap()))
         }
 
         // Int
         {
             let input = py.eval("-1", None, None).unwrap();
+            let input = input.to_object(py).into_bound(py);
             let input_int: i64 = input.extract().unwrap();
-            let result = validator.validate_python(py, input, None, None, None, None).unwrap();
+            let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
             let result_int: i64 = result.extract(py).unwrap();
             assert_eq!(result_int, input_int);
 
             let input = black_box(input);
-            bench.iter(|| black_box(validator.validate_python(py, input, None, None, None, None).unwrap()))
+            bench.iter(|| black_box(validator.validate_python(py, &input, None, None, None, None).unwrap()))
         }
 
         // None
         {
             let input = py.eval("None", None, None).unwrap();
-            let result = validator.validate_python(py, input, None, None, None, None).unwrap();
+            let input = input.to_object(py).into_bound(py);
+            let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
             assert!(input.eq(result).unwrap());
 
             let input = black_box(input);
-            bench.iter(|| black_box(validator.validate_python(py, input, None, None, None, None).unwrap()))
+            bench.iter(|| black_box(validator.validate_python(py, &input, None, None, None, None).unwrap()))
         }
 
         // Enum
         {
-            let input = py.eval("Foo.v4", Some(globals), None).unwrap();
-            let result = validator.validate_python(py, input, None, None, None, None).unwrap();
+            let input = py.eval("Foo.v4", Some(globals.as_gil_ref()), None).unwrap();
+            let input = input.to_object(py).into_bound(py);
+            let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
             assert!(input.eq(result).unwrap());
 
             let input = black_box(input);
-            bench.iter(|| black_box(validator.validate_python(py, input, None, None, None, None).unwrap()))
+            bench.iter(|| black_box(validator.validate_python(py, &input, None, None, None, None).unwrap()))
         }
     })
 }
diff --git a/src/argument_markers.rs b/src/argument_markers.rs
index 3e73fb629..748dd0ae2 100644
--- a/src/argument_markers.rs
+++ b/src/argument_markers.rs
@@ -15,9 +15,9 @@ pub struct ArgsKwargs {
 
 impl ArgsKwargs {
     fn eq(&self, py: Python, other: &Self) -> PyResult<bool> {
-        if self.args.as_ref(py).eq(other.args.as_ref(py))? {
+        if self.args.bind(py).eq(other.args.bind(py))? {
             match (&self.kwargs, &other.kwargs) {
-                (Some(d1), Some(d2)) => d1.as_ref(py).eq(d2.as_ref(py)),
+                (Some(d1), Some(d2)) => d1.bind(py).eq(d2.bind(py)),
                 (None, None) => Ok(true),
                 _ => Ok(false),
             }
@@ -55,9 +55,9 @@ impl ArgsKwargs {
     }
 
     pub fn __repr__(&self, py: Python) -> String {
-        let args = safe_repr(self.args.as_ref(py));
+        let args = safe_repr(self.args.bind(py));
         match self.kwargs {
-            Some(ref d) => format!("ArgsKwargs({args}, {})", safe_repr(d.as_ref(py))),
+            Some(ref d) => format!("ArgsKwargs({args}, {})", safe_repr(d.bind(py))),
             None => format!("ArgsKwargs({args})"),
         }
     }
diff --git a/src/build_tools.rs b/src/build_tools.rs
index c242f97a3..23c88970b 100644
--- a/src/build_tools.rs
+++ b/src/build_tools.rs
@@ -12,10 +12,10 @@ use crate::tools::SchemaDict;
 use crate::ValidationError;
 
 pub fn schema_or_config<'py, T>(
-    schema: &'py PyDict,
-    config: Option<&'py PyDict>,
-    schema_key: &PyString,
-    config_key: &PyString,
+    schema: &Bound<'py, PyDict>,
+    config: Option<&Bound<'py, PyDict>>,
+    schema_key: &Bound<'py, PyString>,
+    config_key: &Bound<'py, PyString>,
 ) -> PyResult<Option<T>>
 where
     T: FromPyObject<'py>,
@@ -30,9 +30,9 @@ where
 }
 
 pub fn schema_or_config_same<'py, T>(
-    schema: &'py PyDict,
-    config: Option<&'py PyDict>,
-    key: &PyString,
+    schema: &Bound<'py, PyDict>,
+    config: Option<&Bound<'py, PyDict>>,
+    key: &Bound<'py, PyString>,
 ) -> PyResult<Option<T>>
 where
     T: FromPyObject<'py>,
@@ -40,7 +40,7 @@ where
     schema_or_config(schema, config, key, key)
 }
 
-pub fn is_strict(schema: &PyDict, config: Option<&PyDict>) -> PyResult<bool> {
+pub fn is_strict(schema: &Bound<'_, PyDict>, config: Option<&Bound<'_, PyDict>>) -> PyResult<bool> {
     let py = schema.py();
     Ok(schema_or_config_same(schema, config, intern!(py, "strict"))?.unwrap_or(false))
 }
@@ -90,7 +90,7 @@ impl SchemaError {
                     ValidationError::new(line_errors, "Schema".to_object(py), InputType::Python, false);
                 let schema_error = SchemaError(SchemaErrorEnum::ValidationError(validation_error));
                 match Py::new(py, schema_error) {
-                    Ok(err) => PyErr::from_value(err.into_ref(py)),
+                    Ok(err) => PyErr::from_value_bound(err.into_bound(py).into_any()),
                     Err(err) => err,
                 }
             }
@@ -124,7 +124,7 @@ impl SchemaError {
 
     fn errors(&self, py: Python) -> PyResult<Py<PyList>> {
         match &self.0 {
-            SchemaErrorEnum::Message(_) => Ok(PyList::empty(py).into_py(py)),
+            SchemaErrorEnum::Message(_) => Ok(PyList::empty_bound(py).unbind()),
             SchemaErrorEnum::ValidationError(error) => error.errors(py, false, false, true),
         }
     }
@@ -174,18 +174,18 @@ pub(crate) enum ExtraBehavior {
 impl ExtraBehavior {
     pub fn from_schema_or_config(
         py: Python,
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         default: Self,
     ) -> PyResult<Self> {
-        let extra_behavior = schema_or_config::<Option<&str>>(
+        let extra_behavior = schema_or_config::<Option<Bound<'_, PyString>>>(
             schema,
             config,
             intern!(py, "extra_behavior"),
             intern!(py, "extra_fields_behavior"),
         )?
         .flatten();
-        let res = match extra_behavior {
+        let res = match extra_behavior.as_ref().map(|s| s.to_str()).transpose()? {
             Some("allow") => Self::Allow,
             Some("ignore") => Self::Ignore,
             Some("forbid") => Self::Forbid,
diff --git a/src/errors/line_error.rs b/src/errors/line_error.rs
index 2a48bfaf4..ecd429409 100644
--- a/src/errors/line_error.rs
+++ b/src/errors/line_error.rs
@@ -1,6 +1,7 @@
 use pyo3::exceptions::PyTypeError;
 use pyo3::prelude::*;
-use pyo3::PyDowncastError;
+use pyo3::DowncastError;
+use pyo3::DowncastIntoError;
 
 use jiter::JsonValue;
 
@@ -35,8 +36,14 @@ impl From<PyErr> for ValError {
     }
 }
 
-impl From<PyDowncastError<'_>> for ValError {
-    fn from(py_downcast: PyDowncastError) -> Self {
+impl From<DowncastError<'_, '_>> for ValError {
+    fn from(py_downcast: DowncastError) -> Self {
+        Self::InternalErr(PyTypeError::new_err(py_downcast.to_string()))
+    }
+}
+
+impl From<DowncastIntoError<'_>> for ValError {
+    fn from(py_downcast: DowncastIntoError) -> Self {
         Self::InternalErr(PyTypeError::new_err(py_downcast.to_string()))
     }
 }
diff --git a/src/errors/location.rs b/src/errors/location.rs
index 55bab0017..138d327ce 100644
--- a/src/errors/location.rs
+++ b/src/errors/location.rs
@@ -1,5 +1,5 @@
 use pyo3::exceptions::PyTypeError;
-use pyo3::once_cell::GILOnceCell;
+use pyo3::sync::GILOnceCell;
 use std::fmt;
 
 use pyo3::prelude::*;
@@ -126,9 +126,9 @@ static EMPTY_TUPLE: GILOnceCell<PyObject> = GILOnceCell::new();
 impl ToPyObject for Location {
     fn to_object(&self, py: Python<'_>) -> PyObject {
         match self {
-            Self::List(loc) => PyTuple::new(py, loc.iter().rev()).to_object(py),
+            Self::List(loc) => PyTuple::new_bound(py, loc.iter().rev()).to_object(py),
             Self::Empty => EMPTY_TUPLE
-                .get_or_init(py, || PyTuple::empty(py).to_object(py))
+                .get_or_init(py, || PyTuple::empty_bound(py).to_object(py))
                 .clone_ref(py),
         }
     }
@@ -193,12 +193,12 @@ impl Serialize for Location {
     }
 }
 
-impl TryFrom<Option<&PyAny>> for Location {
+impl TryFrom<Option<&Bound<'_, PyAny>>> for Location {
     type Error = PyErr;
 
     /// Only ever called by ValidationError -> PyLineError to convert user input to our internal Location
     /// Thus this expects the location to *not* be reversed and reverses it before storing it.
-    fn try_from(location: Option<&PyAny>) -> PyResult<Self> {
+    fn try_from(location: Option<&Bound<'_, PyAny>>) -> PyResult<Self> {
         if let Some(location) = location {
             let mut loc_vec: Vec<LocItem> = if let Ok(tuple) = location.downcast::<PyTuple>() {
                 tuple.iter().map(Into::into).collect()
diff --git a/src/errors/mod.rs b/src/errors/mod.rs
index de6650527..bee5f7225 100644
--- a/src/errors/mod.rs
+++ b/src/errors/mod.rs
@@ -13,8 +13,8 @@ pub use self::validation_exception::ValidationError;
 pub use self::value_exception::{PydanticCustomError, PydanticKnownError, PydanticOmit, PydanticUseDefault};
 
 pub fn py_err_string(py: Python, err: PyErr) -> String {
-    let value = err.value(py);
-    match value.get_type().name() {
+    let value = err.value_bound(py);
+    match value.get_type().qualname() {
         Ok(type_name) => match value.str() {
             Ok(py_str) => {
                 let str_cow = py_str.to_string_lossy();
diff --git a/src/errors/types.rs b/src/errors/types.rs
index eddd7dbaa..a77ed6a8e 100644
--- a/src/errors/types.rs
+++ b/src/errors/types.rs
@@ -3,8 +3,8 @@ use std::borrow::Cow;
 use std::fmt;
 
 use pyo3::exceptions::{PyKeyError, PyTypeError};
-use pyo3::once_cell::GILOnceCell;
 use pyo3::prelude::*;
+use pyo3::sync::GILOnceCell;
 use pyo3::types::{PyDict, PyList};
 
 use ahash::AHashMap;
@@ -18,11 +18,11 @@ use crate::tools::{extract_i64, py_err, py_error_type};
 use super::PydanticCustomError;
 
 #[pyfunction]
-pub fn list_all_errors(py: Python) -> PyResult<&PyList> {
-    let mut errors: Vec<&PyDict> = Vec::with_capacity(100);
+pub fn list_all_errors(py: Python) -> PyResult<Bound<'_, PyList>> {
+    let mut errors: Vec<Bound<'_, PyDict>> = Vec::with_capacity(100);
     for error_type in ErrorType::iter() {
         if !matches!(error_type, ErrorType::CustomError { .. }) {
-            let d = PyDict::new(py);
+            let d = PyDict::new_bound(py);
             d.set_item("type", error_type.to_string())?;
             let message_template_python = error_type.message_template_python();
             d.set_item("message_template_python", message_template_python)?;
@@ -39,7 +39,7 @@ pub fn list_all_errors(py: Python) -> PyResult<&PyList> {
             errors.push(d);
         }
     }
-    Ok(PyList::new(py, errors))
+    Ok(PyList::new_bound(py, errors))
 }
 
 fn field_from_context<'py, T: FromPyObject<'py>>(
@@ -121,7 +121,8 @@ macro_rules! error_types {
                 }
             }
 
-            fn py_dict_update_ctx(&self, py: Python, dict: &PyDict) -> PyResult<bool> {
+            fn py_dict_update_ctx(&self, py: Python, dict: &Bound<'_, PyDict>) -> PyResult<bool> {
+                use pyo3::types::PyMapping;
                 match self {
                     $(
                         Self::$item { context, $($key,)* } => {
@@ -129,7 +130,7 @@ macro_rules! error_types {
                                 dict.set_item::<&str, Py<PyAny>>(stringify!($key), $key.to_object(py))?;
                             )*
                             if let Some(ctx) = context {
-                                dict.update(ctx.as_ref(py).downcast()?)?;
+                                dict.update(ctx.bind(py).downcast::<PyMapping>()?)?;
                                 Ok(true)
                             } else {
                                 Ok(false)
@@ -669,20 +670,20 @@ impl ErrorType {
             Self::ValueError { error, .. } => {
                 let error = &error
                     .as_ref()
-                    .map_or(Cow::Borrowed("None"), |v| Cow::Owned(v.as_ref(py).to_string()));
+                    .map_or(Cow::Borrowed("None"), |v| Cow::Owned(v.bind(py).to_string()));
                 render!(tmpl, error)
             }
             Self::AssertionError { error, .. } => {
                 let error = &error
                     .as_ref()
-                    .map_or(Cow::Borrowed("None"), |v| Cow::Owned(v.as_ref(py).to_string()));
+                    .map_or(Cow::Borrowed("None"), |v| Cow::Owned(v.bind(py).to_string()));
                 render!(tmpl, error)
             }
             Self::CustomError {
                 message_template,
                 context,
                 ..
-            } => PydanticCustomError::format_message(message_template, context.as_ref().map(|c| c.as_ref(py))),
+            } => PydanticCustomError::format_message(message_template, context.as_ref().map(|c| c.bind(py))),
             Self::LiteralError { expected, .. } => render!(tmpl, expected),
             Self::DateParsing { error, .. } => render!(tmpl, error),
             Self::DateFromDatetimeParsing { error, .. } => render!(tmpl, error),
@@ -729,8 +730,8 @@ impl ErrorType {
     }
 
     pub fn py_dict(&self, py: Python) -> PyResult<Option<Py<PyDict>>> {
-        let dict = PyDict::new(py);
-        let custom_ctx_used = self.py_dict_update_ctx(py, dict)?;
+        let dict = PyDict::new_bound(py);
+        let custom_ctx_used = self.py_dict_update_ctx(py, &dict)?;
 
         if let Self::CustomError { .. } = self {
             if custom_ctx_used {
@@ -785,7 +786,7 @@ impl From<Int> for Number {
 }
 
 impl FromPyObject<'_> for Number {
-    fn extract(obj: &PyAny) -> PyResult<Self> {
+    fn extract_bound(obj: &Bound<'_, PyAny>) -> PyResult<Self> {
         if let Some(int) = extract_i64(obj) {
             Ok(Number::Int(int))
         } else if let Ok(float) = obj.extract::<f64>() {
diff --git a/src/errors/validation_exception.rs b/src/errors/validation_exception.rs
index e87f4b0d9..059763a21 100644
--- a/src/errors/validation_exception.rs
+++ b/src/errors/validation_exception.rs
@@ -5,8 +5,8 @@ use std::str::from_utf8;
 use pyo3::exceptions::{PyKeyError, PyTypeError, PyValueError};
 use pyo3::ffi;
 use pyo3::intern;
-use pyo3::once_cell::GILOnceCell;
 use pyo3::prelude::*;
+use pyo3::sync::GILOnceCell;
 use pyo3::types::{PyDict, PyList, PyString};
 use serde::ser::{Error, SerializeMap, SerializeSeq};
 use serde::{Serialize, Serializer};
@@ -73,7 +73,7 @@ impl ValidationError {
                                 return cause_problem;
                             }
                         }
-                        PyErr::from_value(err.as_ref(py))
+                        PyErr::from_value_bound(err.into_bound(py).into_any())
                     }
                     Err(err) => err,
                 }
@@ -202,9 +202,9 @@ fn include_url_env(py: Python) -> bool {
         match std::env::var_os("PYDANTIC_ERRORS_OMIT_URL") {
             Some(val) => {
                 // We don't care whether warning succeeded or not, hence the assignment
-                let _ = PyErr::warn(
+                let _ = PyErr::warn_bound(
                     py,
-                    py.get_type::<pyo3::exceptions::PyDeprecationWarning>(),
+                    &py.get_type_bound::<pyo3::exceptions::PyDeprecationWarning>(),
                     "PYDANTIC_ERRORS_OMIT_URL is deprecated, use PYDANTIC_ERRORS_INCLUDE_URL instead",
                     1,
                 );
@@ -253,14 +253,17 @@ impl ValidationError {
     fn from_exception_data(
         py: Python,
         title: PyObject,
-        line_errors: &PyList,
+        line_errors: Bound<'_, PyList>,
         input_type: &str,
         hide_input: bool,
     ) -> PyResult<Py<Self>> {
         Py::new(
             py,
             Self {
-                line_errors: line_errors.iter().map(PyLineError::try_from).collect::<PyResult<_>>()?,
+                line_errors: line_errors
+                    .iter()
+                    .map(|error| PyLineError::try_from(&error))
+                    .collect::<PyResult<_>>()?,
                 title,
                 input_type: InputType::try_from(input_type)?,
                 hide_input,
@@ -287,7 +290,7 @@ impl ValidationError {
     ) -> PyResult<Py<PyList>> {
         let url_prefix = get_url_prefix(py, include_url);
         let mut iteration_error = None;
-        let list = PyList::new(
+        let list = PyList::new_bound(
             py,
             // PyList::new takes ExactSizeIterator, so if an error occurs during iteration we
             // fill the list with None before returning the error; the list will then be thrown
@@ -318,7 +321,7 @@ impl ValidationError {
         include_url: bool,
         include_context: bool,
         include_input: bool,
-    ) -> PyResult<&'py PyString> {
+    ) -> PyResult<Bound<'py, PyString>> {
         let state = SerializationState::new("iso8601", "utf8", "constants")?;
         let extra = state.extra(py, &SerMode::Json, true, false, false, true, None, None);
         let serializer = ValidationErrorSerializer {
@@ -347,7 +350,7 @@ impl ValidationError {
             }
         };
         let s = from_utf8(&bytes).map_err(json_py_err)?;
-        Ok(PyString::new(py, s))
+        Ok(PyString::new_bound(py, s))
     }
 
     fn __repr__(&self, py: Python) -> String {
@@ -358,12 +361,12 @@ impl ValidationError {
         self.__repr__(py)
     }
 
-    fn __reduce__(slf: &PyCell<Self>) -> PyResult<(&PyAny, PyObject)> {
+    fn __reduce__<'py>(slf: &Bound<'py, Self>) -> PyResult<(Bound<'py, PyAny>, PyObject)> {
         let py = slf.py();
         let callable = slf.getattr("from_exception_data")?;
         let borrow = slf.try_borrow()?;
         let args = (
-            borrow.title.as_ref(py),
+            borrow.title.bind(py),
             borrow.errors(py, include_url_env(py), true, true)?,
             borrow.input_type.into_py(py),
             borrow.hide_input,
@@ -463,11 +466,11 @@ impl From<PyLineError> for ValLineError {
     }
 }
 
-impl TryFrom<&PyAny> for PyLineError {
+impl TryFrom<&Bound<'_, PyAny>> for PyLineError {
     type Error = PyErr;
 
-    fn try_from(value: &PyAny) -> PyResult<Self> {
-        let dict: &PyDict = value.downcast()?;
+    fn try_from(value: &Bound<'_, PyAny>) -> PyResult<Self> {
+        let dict = value.downcast::<PyDict>()?;
         let py = value.py();
 
         let type_raw = dict
@@ -485,7 +488,7 @@ impl TryFrom<&PyAny> for PyLineError {
             ));
         };
 
-        let location = Location::try_from(dict.get_item("loc")?)?;
+        let location = Location::try_from(dict.get_item("loc")?.as_ref())?;
 
         let input_value = match dict.get_item("input")? {
             Some(i) => i.into_py(py),
@@ -513,7 +516,7 @@ impl PyLineError {
         input_type: InputType,
         include_input: bool,
     ) -> PyResult<PyObject> {
-        let dict = PyDict::new(py);
+        let dict = PyDict::new_bound(py);
         dict.set_item("type", self.error_type.type_string())?;
         dict.set_item("loc", self.location.to_object(py))?;
         dict.set_item("msg", self.error_type.render_message(py, input_type)?)?;
@@ -555,11 +558,11 @@ impl PyLineError {
         write!(output, "  {message} [type={}", self.error_type.type_string())?;
 
         if !hide_input {
-            let input_value = self.input_value.as_ref(py);
+            let input_value = self.input_value.bind(py);
             let input_str = safe_repr(input_value);
-            truncate_input_value!(output, &input_str);
+            truncate_input_value!(output, &input_str.to_cow());
 
-            if let Ok(type_) = input_value.get_type().name() {
+            if let Ok(type_) = input_value.get_type().qualname() {
                 write!(output, ", input_type={type_}")?;
             }
         }
@@ -663,13 +666,13 @@ impl<'py> Serialize for PyLineErrorSerializer<'py> {
         if self.include_input {
             map.serialize_entry(
                 "input",
-                &self.extra.serialize_infer(self.line_error.input_value.as_ref(py)),
+                &self.extra.serialize_infer(self.line_error.input_value.bind(py)),
             )?;
         }
 
         if self.include_context {
             if let Some(context) = self.line_error.error_type.py_dict(py).map_err(py_err_json::<S>)? {
-                map.serialize_entry("ctx", &self.extra.serialize_infer(context.as_ref(py)))?;
+                map.serialize_entry("ctx", &self.extra.serialize_infer(context.bind(py)))?;
             }
         }
         if let Some(url_prefix) = self.url_prefix {
diff --git a/src/errors/value_exception.rs b/src/errors/value_exception.rs
index 3152044d1..e69fc0a9c 100644
--- a/src/errors/value_exception.rs
+++ b/src/errors/value_exception.rs
@@ -89,7 +89,7 @@ impl PydanticCustomError {
     }
 
     pub fn message(&self, py: Python) -> PyResult<String> {
-        Self::format_message(&self.message_template, self.context.as_ref().map(|c| c.as_ref(py)))
+        Self::format_message(&self.message_template, self.context.as_ref().map(|c| c.bind(py)))
     }
 
     fn __str__(&self, py: Python) -> PyResult<String> {
@@ -99,7 +99,7 @@ impl PydanticCustomError {
     fn __repr__(&self, py: Python) -> PyResult<String> {
         let msg = self.message(py)?;
         match self.context.as_ref() {
-            Some(ctx) => Ok(format!("{msg} [type={}, context={}]", self.error_type, ctx.as_ref(py))),
+            Some(ctx) => Ok(format!("{msg} [type={}, context={}]", self.error_type, ctx.bind(py))),
             None => Ok(format!("{msg} [type={}, context=None]", self.error_type)),
         }
     }
@@ -115,14 +115,14 @@ impl PydanticCustomError {
         ValError::new(error_type, input)
     }
 
-    pub fn format_message(message_template: &str, context: Option<&PyDict>) -> PyResult<String> {
+    pub fn format_message(message_template: &str, context: Option<&Bound<'_, PyDict>>) -> PyResult<String> {
         let mut message = message_template.to_string();
         if let Some(ctx) = context {
-            for (key, value) in ctx {
-                let key: &PyString = key.downcast()?;
+            for (key, value) in ctx.iter() {
+                let key = key.downcast::<PyString>()?;
                 if let Ok(py_str) = value.downcast::<PyString>() {
                     message = message.replace(&format!("{{{}}}", key.to_str()?), py_str.to_str()?);
-                } else if let Some(value_int) = extract_i64(value) {
+                } else if let Some(value_int) = extract_i64(&value) {
                     message = message.replace(&format!("{{{}}}", key.to_str()?), &value_int.to_string());
                 } else {
                     // fallback for anything else just in case
@@ -174,11 +174,7 @@ impl PydanticKnownError {
     fn __repr__(&self, py: Python) -> PyResult<String> {
         let msg = self.message(py)?;
         match self.context(py)?.as_ref() {
-            Some(ctx) => Ok(format!(
-                "{msg} [type={}, context={}]",
-                self.error_type(),
-                ctx.as_ref(py)
-            )),
+            Some(ctx) => Ok(format!("{msg} [type={}, context={}]", self.error_type(), ctx.bind(py))),
             None => Ok(format!("{msg} [type={}, context=None]", self.error_type())),
         }
     }
diff --git a/src/input/datetime.rs b/src/input/datetime.rs
index ebb5675f2..9dcf9006e 100644
--- a/src/input/datetime.rs
+++ b/src/input/datetime.rs
@@ -20,7 +20,7 @@ use crate::tools::py_err;
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub enum EitherDate<'a> {
     Raw(Date),
-    Py(&'a PyDate),
+    Py(Bound<'a, PyDate>),
 }
 
 impl<'a> From<Date> for EitherDate<'a> {
@@ -29,13 +29,13 @@ impl<'a> From<Date> for EitherDate<'a> {
     }
 }
 
-impl<'a> From<&'a PyDate> for EitherDate<'a> {
-    fn from(date: &'a PyDate) -> Self {
+impl<'a> From<Bound<'a, PyDate>> for EitherDate<'a> {
+    fn from(date: Bound<'a, PyDate>) -> Self {
         Self::Py(date)
     }
 }
 
-pub fn pydate_as_date(py_date: &PyAny) -> PyResult<Date> {
+pub fn pydate_as_date(py_date: &Bound<'_, PyAny>) -> PyResult<Date> {
     let py = py_date.py();
     Ok(Date {
         year: py_date.getattr(intern!(py, "year"))?.extract()?,
@@ -55,7 +55,7 @@ impl<'a> EitherDate<'a> {
     pub fn try_into_py(self, py: Python<'_>) -> PyResult<PyObject> {
         let date = match self {
             Self::Py(date) => Ok(date),
-            Self::Raw(date) => PyDate::new(py, date.year.into(), date.month, date.day),
+            Self::Raw(date) => PyDate::new_bound(py, date.year.into(), date.month, date.day),
         }?;
         Ok(date.into_py(py))
     }
@@ -64,7 +64,7 @@ impl<'a> EitherDate<'a> {
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub enum EitherTime<'a> {
     Raw(Time),
-    Py(&'a PyTime),
+    Py(Bound<'a, PyTime>),
 }
 
 impl<'a> From<Time> for EitherTime<'a> {
@@ -73,8 +73,8 @@ impl<'a> From<Time> for EitherTime<'a> {
     }
 }
 
-impl<'a> From<&'a PyTime> for EitherTime<'a> {
-    fn from(time: &'a PyTime) -> Self {
+impl<'a> From<Bound<'a, PyTime>> for EitherTime<'a> {
+    fn from(time: Bound<'a, PyTime>) -> Self {
         Self::Py(time)
     }
 }
@@ -82,8 +82,8 @@ impl<'a> From<&'a PyTime> for EitherTime<'a> {
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub enum EitherTimedelta<'a> {
     Raw(Duration),
-    PyExact(&'a PyDelta),
-    PySubclass(&'a PyDelta),
+    PyExact(Bound<'a, PyDelta>),
+    PySubclass(Bound<'a, PyDelta>),
 }
 
 impl<'a> From<Duration> for EitherTimedelta<'a> {
@@ -101,29 +101,29 @@ impl<'a> EitherTimedelta<'a> {
         }
     }
 
-    pub fn try_into_py(&self, py: Python<'a>) -> PyResult<&'a PyDelta> {
+    pub fn try_into_py(&self, py: Python<'a>) -> PyResult<Bound<'a, PyDelta>> {
         match self {
-            Self::PyExact(timedelta) => Ok(*timedelta),
-            Self::PySubclass(timedelta) => Ok(*timedelta),
+            Self::PyExact(timedelta) => Ok(timedelta.clone()),
+            Self::PySubclass(timedelta) => Ok(timedelta.clone()),
             Self::Raw(duration) => duration_as_pytimedelta(py, duration),
         }
     }
 }
 
-impl<'a> TryFrom<&'a PyAny> for EitherTimedelta<'a> {
+impl<'a> TryFrom<&'_ Bound<'a, PyAny>> for EitherTimedelta<'a> {
     type Error = PyErr;
 
-    fn try_from(value: &'a PyAny) -> PyResult<Self> {
-        if let Ok(dt) = <PyDelta as PyTryFrom>::try_from_exact(value) {
-            Ok(EitherTimedelta::PyExact(dt))
+    fn try_from(value: &Bound<'a, PyAny>) -> PyResult<Self> {
+        if let Ok(dt) = value.downcast_exact() {
+            Ok(EitherTimedelta::PyExact(dt.clone()))
         } else {
-            let dt = value.downcast::<PyDelta>()?;
-            Ok(EitherTimedelta::PySubclass(dt))
+            let dt = value.downcast()?;
+            Ok(EitherTimedelta::PySubclass(dt.clone()))
         }
     }
 }
 
-pub fn pytimedelta_exact_as_duration(py_timedelta: &PyDelta) -> Duration {
+pub fn pytimedelta_exact_as_duration(py_timedelta: &Bound<'_, PyDelta>) -> Duration {
     // see https://docs.python.org/3/c-api/datetime.html#c.PyDateTime_DELTA_GET_DAYS
     // days can be negative, but seconds and microseconds are always positive.
     let mut days = py_timedelta.get_days(); // -999999999 to 999999999
@@ -146,7 +146,7 @@ pub fn pytimedelta_exact_as_duration(py_timedelta: &PyDelta) -> Duration {
     Duration::new(positive, days as u32, seconds as u32, microseconds as u32).unwrap()
 }
 
-pub fn pytimedelta_subclass_as_duration(py_timedelta: &PyDelta) -> PyResult<Duration> {
+pub fn pytimedelta_subclass_as_duration(py_timedelta: &Bound<'_, PyDelta>) -> PyResult<Duration> {
     let total_seconds: f64 = py_timedelta
         .call_method0(intern!(py_timedelta.py(), "total_seconds"))?
         .extract()?;
@@ -162,9 +162,9 @@ pub fn pytimedelta_subclass_as_duration(py_timedelta: &PyDelta) -> PyResult<Dura
         .map_err(|err| PyValueError::new_err(err.to_string()))
 }
 
-pub fn duration_as_pytimedelta<'py>(py: Python<'py>, duration: &Duration) -> PyResult<&'py PyDelta> {
+pub fn duration_as_pytimedelta<'py>(py: Python<'py>, duration: &Duration) -> PyResult<Bound<'py, PyDelta>> {
     let sign = if duration.positive { 1 } else { -1 };
-    PyDelta::new(
+    PyDelta::new_bound(
         py,
         sign * duration.day as i32,
         sign * duration.second as i32,
@@ -173,16 +173,16 @@ pub fn duration_as_pytimedelta<'py>(py: Python<'py>, duration: &Duration) -> PyR
     )
 }
 
-pub fn pytime_as_time(py_time: &PyAny, py_dt: Option<&PyAny>) -> PyResult<Time> {
+pub fn pytime_as_time(py_time: &Bound<'_, PyAny>, py_dt: Option<&Bound<'_, PyAny>>) -> PyResult<Time> {
     let py = py_time.py();
 
     let tzinfo = py_time.getattr(intern!(py, "tzinfo"))?;
-    let tz_offset: Option<i32> = if tzinfo.is_none() {
+    let tz_offset: Option<i32> = if PyAnyMethods::is_none(&tzinfo) {
         None
     } else {
         let offset_delta = tzinfo.call_method1(intern!(py, "utcoffset"), (py_dt,))?;
         // as per the docs, utcoffset() can return None
-        if offset_delta.is_none() {
+        if PyAnyMethods::is_none(&offset_delta) {
             None
         } else {
             let offset_seconds: f64 = offset_delta.call_method0(intern!(py, "total_seconds"))?.extract()?;
@@ -210,25 +210,24 @@ impl<'a> EitherTime<'a> {
     pub fn try_into_py(self, py: Python<'_>) -> PyResult<PyObject> {
         let time = match self {
             Self::Py(time) => Ok(time),
-            Self::Raw(time) => PyTime::new(
+            Self::Raw(time) => PyTime::new_bound(
                 py,
                 time.hour,
                 time.minute,
                 time.second,
                 time.microsecond,
-                time_as_tzinfo(py, &time)?,
+                time_as_tzinfo(py, &time)?.as_ref(),
             ),
         }?;
         Ok(time.into_py(py))
     }
 }
 
-fn time_as_tzinfo<'py>(py: Python<'py>, time: &Time) -> PyResult<Option<&'py PyTzInfo>> {
+fn time_as_tzinfo<'py>(py: Python<'py>, time: &Time) -> PyResult<Option<Bound<'py, PyTzInfo>>> {
     match time.tz_offset {
         Some(offset) => {
             let tz_info: TzInfo = offset.try_into()?;
-            let py_tz_info = Py::new(py, tz_info)?.to_object(py).into_ref(py);
-            Ok(Some(py_tz_info.extract()?))
+            Ok(Some(Bound::new(py, tz_info)?.into_any().downcast_into()?))
         }
         None => Ok(None),
     }
@@ -237,7 +236,7 @@ fn time_as_tzinfo<'py>(py: Python<'py>, time: &Time) -> PyResult<Option<&'py PyT
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub enum EitherDateTime<'a> {
     Raw(DateTime),
-    Py(&'a PyDateTime),
+    Py(Bound<'a, PyDateTime>),
 }
 
 impl<'a> From<DateTime> for EitherDateTime<'a> {
@@ -246,13 +245,13 @@ impl<'a> From<DateTime> for EitherDateTime<'a> {
     }
 }
 
-impl<'a> From<&'a PyDateTime> for EitherDateTime<'a> {
-    fn from(dt: &'a PyDateTime) -> Self {
+impl<'a> From<Bound<'a, PyDateTime>> for EitherDateTime<'a> {
+    fn from(dt: Bound<'a, PyDateTime>) -> Self {
         Self::Py(dt)
     }
 }
 
-pub fn pydatetime_as_datetime(py_dt: &PyAny) -> PyResult<DateTime> {
+pub fn pydatetime_as_datetime(py_dt: &Bound<'_, PyAny>) -> PyResult<DateTime> {
     Ok(DateTime {
         date: pydate_as_date(py_dt)?,
         time: pytime_as_time(py_dt, Some(py_dt))?,
@@ -269,7 +268,7 @@ impl<'a> EitherDateTime<'a> {
 
     pub fn try_into_py(self, py: Python<'a>) -> PyResult<PyObject> {
         let dt = match self {
-            Self::Raw(datetime) => PyDateTime::new(
+            Self::Raw(datetime) => PyDateTime::new_bound(
                 py,
                 datetime.date.year.into(),
                 datetime.date.month,
@@ -278,9 +277,9 @@ impl<'a> EitherDateTime<'a> {
                 datetime.time.minute,
                 datetime.time.second,
                 datetime.time.microsecond,
-                time_as_tzinfo(py, &datetime.time)?,
+                time_as_tzinfo(py, &datetime.time)?.as_ref(),
             )?,
-            Self::Py(dt) => dt,
+            Self::Py(dt) => dt.clone(),
         };
         Ok(dt.into_py(py))
     }
@@ -391,9 +390,9 @@ pub fn float_as_datetime<'a>(input: &'a impl Input<'a>, timestamp: f64) -> ValRe
     int_as_datetime(input, timestamp.floor() as i64, microseconds.round() as u32)
 }
 
-pub fn date_as_datetime(date: &PyDate) -> PyResult<EitherDateTime> {
+pub fn date_as_datetime<'py>(date: &Bound<'py, PyDate>) -> PyResult<EitherDateTime<'py>> {
     let py = date.py();
-    let dt = PyDateTime::new(
+    let dt = PyDateTime::new_bound(
         py,
         date.getattr(intern!(py, "year"))?.extract()?,
         date.getattr(intern!(py, "month"))?.extract()?,
@@ -516,21 +515,21 @@ impl TzInfo {
         Self::try_from(seconds.trunc() as i32)
     }
 
-    fn utcoffset<'py>(&self, py: Python<'py>, _dt: &PyAny) -> PyResult<&'py PyDelta> {
-        PyDelta::new(py, 0, self.seconds, 0, true)
+    fn utcoffset<'py>(&self, py: Python<'py>, _dt: &Bound<'_, PyAny>) -> PyResult<Bound<'py, PyDelta>> {
+        PyDelta::new_bound(py, 0, self.seconds, 0, true)
     }
 
-    fn tzname(&self, _dt: &PyAny) -> String {
+    fn tzname(&self, _dt: &Bound<'_, PyAny>) -> String {
         self.__str__()
     }
 
-    fn dst(&self, _dt: &PyAny) -> Option<&PyDelta> {
+    fn dst(&self, _dt: &Bound<'_, PyAny>) -> Option<&PyDelta> {
         None
     }
 
-    fn fromutc<'py>(&self, dt: &'py PyDateTime) -> PyResult<&'py PyAny> {
+    fn fromutc<'py>(&self, dt: &Bound<'py, PyDateTime>) -> PyResult<Bound<'py, PyAny>> {
         let py = dt.py();
-        dt.call_method1("__add__", (self.utcoffset(py, py.None().as_ref(py))?,))
+        dt.call_method1("__add__", (self.utcoffset(py, py.None().bind(py))?,))
     }
 
     fn __repr__(&self) -> String {
diff --git a/src/input/input_abstract.rs b/src/input/input_abstract.rs
index 6ce1479f6..249161343 100644
--- a/src/input/input_abstract.rs
+++ b/src/input/input_abstract.rs
@@ -22,9 +22,9 @@ pub enum InputType {
 impl IntoPy<PyObject> for InputType {
     fn into_py(self, py: Python<'_>) -> PyObject {
         match self {
-            Self::Json => intern!(py, "json").into(),
-            Self::Python => intern!(py, "python").into(),
-            Self::String => intern!(py, "string").into(),
+            Self::Json => intern!(py, "json").into_py(py),
+            Self::Python => intern!(py, "python").into_py(py),
+            Self::String => intern!(py, "string").into_py(py),
         }
     }
 }
@@ -57,7 +57,7 @@ pub trait Input<'a>: fmt::Debug + ToPyObject + Into<LocItem> + Sized {
         false
     }
 
-    fn input_is_instance(&self, _class: &PyType) -> Option<&PyAny> {
+    fn input_is_instance(&self, _class: &Bound<'_, PyType>) -> Option<&Bound<'a, PyAny>> {
         None
     }
 
@@ -65,9 +65,9 @@ pub trait Input<'a>: fmt::Debug + ToPyObject + Into<LocItem> + Sized {
         false
     }
 
-    fn as_kwargs(&'a self, py: Python<'a>) -> Option<&'a PyDict>;
+    fn as_kwargs(&self, py: Python<'a>) -> Option<Bound<'a, PyDict>>;
 
-    fn input_is_subclass(&self, _class: &PyType) -> PyResult<bool> {
+    fn input_is_subclass(&self, _class: &Bound<'_, PyType>) -> PyResult<bool> {
         Ok(false)
     }
 
@@ -119,16 +119,16 @@ pub trait Input<'a>: fmt::Debug + ToPyObject + Into<LocItem> + Sized {
 
     fn validate_float(&'a self, strict: bool) -> ValResult<ValidationMatch<EitherFloat<'a>>>;
 
-    fn validate_decimal(&'a self, strict: bool, py: Python<'a>) -> ValResult<&'a PyAny> {
+    fn validate_decimal(&'a self, strict: bool, py: Python<'a>) -> ValResult<Bound<'a, PyAny>> {
         if strict {
             self.strict_decimal(py)
         } else {
             self.lax_decimal(py)
         }
     }
-    fn strict_decimal(&'a self, py: Python<'a>) -> ValResult<&'a PyAny>;
+    fn strict_decimal(&'a self, py: Python<'a>) -> ValResult<Bound<'a, PyAny>>;
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn lax_decimal(&'a self, py: Python<'a>) -> ValResult<&'a PyAny> {
+    fn lax_decimal(&'a self, py: Python<'a>) -> ValResult<Bound<'a, PyAny>> {
         self.strict_decimal(py)
     }
 
diff --git a/src/input/input_json.rs b/src/input/input_json.rs
index dde73cf65..6cc21f98c 100644
--- a/src/input/input_json.rs
+++ b/src/input/input_json.rs
@@ -47,10 +47,10 @@ impl<'a> Input<'a> for JsonValue {
         matches!(self, JsonValue::Null)
     }
 
-    fn as_kwargs(&'a self, py: Python<'a>) -> Option<&'a PyDict> {
+    fn as_kwargs(&self, py: Python<'a>) -> Option<Bound<'a, PyDict>> {
         match self {
             JsonValue::Object(object) => {
-                let dict = PyDict::new(py);
+                let dict = PyDict::new_bound(py);
                 for (k, v) in object.iter() {
                     dict.set_item(k, v.to_object(py)).unwrap();
                 }
@@ -154,12 +154,12 @@ impl<'a> Input<'a> for JsonValue {
         }
     }
 
-    fn strict_decimal(&'a self, py: Python<'a>) -> ValResult<&'a PyAny> {
+    fn strict_decimal(&'a self, py: Python<'a>) -> ValResult<Bound<'a, PyAny>> {
         match self {
-            JsonValue::Float(f) => create_decimal(PyString::new(py, &f.to_string()), self, py),
+            JsonValue::Float(f) => create_decimal(&PyString::new_bound(py, &f.to_string()), self),
 
             JsonValue::Str(..) | JsonValue::Int(..) | JsonValue::BigInt(..) => {
-                create_decimal(self.to_object(py).into_ref(py), self, py)
+                create_decimal(self.to_object(py).bind(py), self)
             }
             _ => Err(ValError::new(ErrorTypeDefaults::DecimalType, self)),
         }
@@ -327,7 +327,7 @@ impl<'a> Input<'a> for String {
         InputValue::Json(JsonValue::Str(self.clone()))
     }
 
-    fn as_kwargs(&'a self, _py: Python<'a>) -> Option<&'a PyDict> {
+    fn as_kwargs(&self, _py: Python<'a>) -> Option<Bound<'a, PyDict>> {
         None
     }
 
@@ -377,8 +377,8 @@ impl<'a> Input<'a> for String {
         str_as_float(self, self).map(ValidationMatch::lax)
     }
 
-    fn strict_decimal(&'a self, py: Python<'a>) -> ValResult<&'a PyAny> {
-        create_decimal(self.to_object(py).into_ref(py), self, py)
+    fn strict_decimal(&'a self, py: Python<'a>) -> ValResult<Bound<'a, PyAny>> {
+        create_decimal(self.to_object(py).bind(py), self)
     }
 
     #[cfg_attr(has_coverage_attribute, coverage(off))]
diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index fd93820ef..471eb8de7 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -1,6 +1,7 @@
 use std::borrow::Cow;
 use std::str::from_utf8;
 
+use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::{
     PyBool, PyByteArray, PyBytes, PyDate, PyDateTime, PyDict, PyFloat, PyFrozenSet, PyInt, PyIterator, PyList,
@@ -8,7 +9,6 @@ use pyo3::types::{
 };
 #[cfg(not(PyPy))]
 use pyo3::types::{PyDictItems, PyDictKeys, PyDictValues};
-use pyo3::{intern, PyTypeInfo};
 
 use speedate::MicrosecondsPrecisionOverflowBehavior;
 
@@ -34,18 +34,18 @@ use super::{
 
 #[cfg(not(PyPy))]
 macro_rules! extract_dict_keys {
-    ($py:expr, $obj:ident) => {
+    ($py:expr, $obj:expr) => {
         $obj.downcast::<PyDictKeys>()
             .ok()
-            .map(|v| PyIterator::from_object(v).unwrap())
+            .map(|v| PyIterator::from_bound_object(v).unwrap())
     };
 }
 
 #[cfg(PyPy)]
 macro_rules! extract_dict_keys {
-    ($py:expr, $obj:ident) => {
+    ($py:expr, $obj:expr) => {
         if is_dict_keys_type($obj) {
-            Some(PyIterator::from_object($obj).unwrap())
+            Some(PyIterator::from_bound_object($obj).unwrap())
         } else {
             None
         }
@@ -54,18 +54,18 @@ macro_rules! extract_dict_keys {
 
 #[cfg(not(PyPy))]
 macro_rules! extract_dict_values {
-    ($py:expr, $obj:ident) => {
+    ($py:expr, $obj:expr) => {
         $obj.downcast::<PyDictValues>()
             .ok()
-            .map(|v| PyIterator::from_object(v).unwrap())
+            .map(|v| PyIterator::from_bound_object(v).unwrap())
     };
 }
 
 #[cfg(PyPy)]
 macro_rules! extract_dict_values {
-    ($py:expr, $obj:ident) => {
+    ($py:expr, $obj:expr) => {
         if is_dict_values_type($obj) {
-            Some(PyIterator::from_object($obj).unwrap())
+            Some(PyIterator::from_bound_object($obj).unwrap())
         } else {
             None
         }
@@ -74,26 +74,26 @@ macro_rules! extract_dict_values {
 
 #[cfg(not(PyPy))]
 macro_rules! extract_dict_items {
-    ($py:expr, $obj:ident) => {
+    ($py:expr, $obj:expr) => {
         $obj.downcast::<PyDictItems>()
             .ok()
-            .map(|v| PyIterator::from_object(v).unwrap())
+            .map(|v| PyIterator::from_bound_object(v).unwrap())
     };
 }
 
 #[cfg(PyPy)]
 macro_rules! extract_dict_items {
-    ($py:expr, $obj:ident) => {
+    ($py:expr, $obj:expr) => {
         if is_dict_items_type($obj) {
-            Some(PyIterator::from_object($obj).unwrap())
+            Some(PyIterator::from_bound_object($obj).unwrap())
         } else {
             None
         }
     };
 }
 
-impl From<&PyAny> for LocItem {
-    fn from(py_any: &PyAny) -> Self {
+impl From<&Bound<'_, PyAny>> for LocItem {
+    fn from(py_any: &Bound<'_, PyAny>) -> Self {
         if let Ok(py_str) = py_any.downcast::<PyString>() {
             py_str.to_string_lossy().as_ref().into()
         } else if let Some(key_int) = extract_i64(py_any) {
@@ -104,15 +104,15 @@ impl From<&PyAny> for LocItem {
     }
 }
 
-impl From<PyAny> for LocItem {
-    fn from(py_any: PyAny) -> Self {
+impl From<Bound<'_, PyAny>> for LocItem {
+    fn from(py_any: Bound<'_, PyAny>) -> Self {
         (&py_any).into()
     }
 }
 
-impl<'a> Input<'a> for PyAny {
+impl<'a> Input<'a> for Bound<'a, PyAny> {
     fn as_error_value(&self) -> InputValue {
-        InputValue::Python(self.into())
+        InputValue::Python(self.clone().into())
     }
 
     fn identity(&self) -> Option<usize> {
@@ -120,10 +120,10 @@ impl<'a> Input<'a> for PyAny {
     }
 
     fn is_none(&self) -> bool {
-        self.is_none()
+        PyAnyMethods::is_none(self)
     }
 
-    fn input_is_instance(&self, class: &PyType) -> Option<&PyAny> {
+    fn input_is_instance(&self, class: &Bound<'_, PyType>) -> Option<&Bound<'a, PyAny>> {
         if self.is_instance(class).unwrap_or(false) {
             Some(self)
         } else {
@@ -135,11 +135,11 @@ impl<'a> Input<'a> for PyAny {
         true
     }
 
-    fn as_kwargs(&'a self, _py: Python<'a>) -> Option<&'a PyDict> {
-        self.downcast::<PyDict>().ok()
+    fn as_kwargs(&self, _py: Python<'a>) -> Option<Bound<'a, PyDict>> {
+        self.downcast::<PyDict>().ok().map(Clone::clone)
     }
 
-    fn input_is_subclass(&self, class: &PyType) -> PyResult<bool> {
+    fn input_is_subclass(&self, class: &Bound<'_, PyType>) -> PyResult<bool> {
         match self.downcast::<PyType>() {
             Ok(py_type) => py_type.is_subclass(class),
             Err(_) => Ok(false),
@@ -160,13 +160,13 @@ impl<'a> Input<'a> for PyAny {
 
     fn validate_args(&'a self) -> ValResult<GenericArguments<'a>> {
         if let Ok(dict) = self.downcast::<PyDict>() {
-            Ok(PyArgs::new(None, Some(dict)).into())
+            Ok(PyArgs::new(None, Some(dict.clone())).into())
         } else if let Ok(args_kwargs) = self.extract::<ArgsKwargs>() {
-            let args = args_kwargs.args.into_ref(self.py());
-            let kwargs = args_kwargs.kwargs.map(|d| d.into_ref(self.py()));
+            let args = args_kwargs.args.into_bound(self.py());
+            let kwargs = args_kwargs.kwargs.map(|d| d.into_bound(self.py()));
             Ok(PyArgs::new(Some(args), kwargs).into())
         } else if let Ok(tuple) = self.downcast::<PyTuple>() {
-            Ok(PyArgs::new(Some(tuple), None).into())
+            Ok(PyArgs::new(Some(tuple.clone()), None).into())
         } else if let Ok(list) = self.downcast::<PyList>() {
             Ok(PyArgs::new(Some(list.to_tuple()), None).into())
         } else {
@@ -176,10 +176,10 @@ impl<'a> Input<'a> for PyAny {
 
     fn validate_dataclass_args(&'a self, class_name: &str) -> ValResult<GenericArguments<'a>> {
         if let Ok(dict) = self.downcast::<PyDict>() {
-            Ok(PyArgs::new(None, Some(dict)).into())
+            Ok(PyArgs::new(None, Some(dict.clone())).into())
         } else if let Ok(args_kwargs) = self.extract::<ArgsKwargs>() {
-            let args = args_kwargs.args.into_ref(self.py());
-            let kwargs = args_kwargs.kwargs.map(|d| d.into_ref(self.py()));
+            let args = args_kwargs.args.into_bound(self.py());
+            let kwargs = args_kwargs.kwargs.map(|d| d.into_bound(self.py()));
             Ok(PyArgs::new(Some(args), kwargs).into())
         } else {
             let class_name = class_name.to_string();
@@ -199,7 +199,7 @@ impl<'a> Input<'a> for PyAny {
         coerce_numbers_to_str: bool,
     ) -> ValResult<ValidationMatch<EitherString<'a>>> {
         if let Ok(py_str) = self.downcast_exact::<PyString>() {
-            return Ok(ValidationMatch::exact(py_str.into()));
+            return Ok(ValidationMatch::exact(py_str.clone().into()));
         } else if let Ok(py_str) = self.downcast::<PyString>() {
             // force to a rust string to make sure behavior is consistent whether or not we go via a
             // rust string in StrConstrainedValidator - e.g. to_lower
@@ -219,17 +219,17 @@ impl<'a> Input<'a> for PyAny {
                     match from_utf8(unsafe { py_byte_array.as_bytes() }) {
                         // Why Python not Rust? to avoid an unnecessary allocation on the Rust side, the
                         // final output needs to be Python anyway.
-                        Ok(s) => Ok(PyString::new(self.py(), s).into()),
+                        Ok(s) => Ok(PyString::new_bound(self.py(), s).into()),
                         Err(_) => Err(ValError::new(ErrorTypeDefaults::StringUnicode, self)),
                     }
-                } else if coerce_numbers_to_str && !PyBool::is_exact_type_of(self) && {
+                } else if coerce_numbers_to_str && !self.is_exact_instance_of::<PyBool>() && {
                     let py = self.py();
-                    let decimal_type: Py<PyType> = get_decimal_type(py);
+                    let decimal_type = get_decimal_type(py);
 
                     // only allow int, float, and decimal (not bool)
                     self.is_instance_of::<PyInt>()
                         || self.is_instance_of::<PyFloat>()
-                        || self.is_instance(decimal_type.as_ref(py)).unwrap_or_default()
+                        || self.is_instance(decimal_type).unwrap_or_default()
                 } {
                     Ok(self.str()?.into())
                 } else if let Some(enum_val) = maybe_as_enum(self) {
@@ -293,7 +293,7 @@ impl<'a> Input<'a> for PyAny {
 
     fn validate_int(&'a self, strict: bool) -> ValResult<ValidationMatch<EitherInt<'a>>> {
         if self.is_exact_instance_of::<PyInt>() {
-            return Ok(ValidationMatch::exact(EitherInt::Py(self)));
+            return Ok(ValidationMatch::exact(EitherInt::Py(self.clone())));
         } else if self.is_instance_of::<PyInt>() {
             // bools are a subclass of int, so check for bool type in this specific case
             let exactness = if self.is_instance_of::<PyBool>() {
@@ -316,7 +316,7 @@ impl<'a> Input<'a> for PyAny {
                 } else if self.is_exact_instance_of::<PyFloat>() {
                     float_as_int(self, self.extract::<f64>()?)
                 } else if let Ok(decimal) = self.strict_decimal(self.py()) {
-                    decimal_as_int(self.py(), self, decimal)
+                    decimal_as_int(self, &decimal)
                 } else if let Ok(float) = self.extract::<f64>() {
                     float_as_int(self, float)
                 } else if let Some(enum_val) = maybe_as_enum(self) {
@@ -332,16 +332,16 @@ impl<'a> Input<'a> for PyAny {
     }
 
     fn exact_int(&'a self) -> ValResult<EitherInt<'a>> {
-        if PyInt::is_exact_type_of(self) {
-            Ok(EitherInt::Py(self))
+        if self.is_exact_instance_of::<PyInt>() {
+            Ok(EitherInt::Py(self.clone()))
         } else {
             Err(ValError::new(ErrorTypeDefaults::IntType, self))
         }
     }
 
     fn exact_str(&'a self) -> ValResult<EitherString<'a>> {
-        if let Ok(py_str) = <PyString as PyTryFrom>::try_from_exact(self) {
-            Ok(EitherString::Py(py_str))
+        if let Ok(py_str) = self.downcast_exact() {
+            Ok(EitherString::Py(py_str.clone()))
         } else {
             Err(ValError::new(ErrorTypeDefaults::IntType, self))
         }
@@ -349,7 +349,7 @@ impl<'a> Input<'a> for PyAny {
 
     fn validate_float(&'a self, strict: bool) -> ValResult<ValidationMatch<EitherFloat<'a>>> {
         if let Ok(float) = self.downcast_exact::<PyFloat>() {
-            return Ok(ValidationMatch::exact(EitherFloat::Py(float)));
+            return Ok(ValidationMatch::exact(EitherFloat::Py(float.clone())));
         }
 
         if !strict {
@@ -374,44 +374,42 @@ impl<'a> Input<'a> for PyAny {
         Err(ValError::new(ErrorTypeDefaults::FloatType, self))
     }
 
-    fn strict_decimal(&'a self, py: Python<'a>) -> ValResult<&'a PyAny> {
-        let decimal_type_obj: Py<PyType> = get_decimal_type(py);
-        let decimal_type = decimal_type_obj.as_ref(py);
+    fn strict_decimal(&'a self, py: Python<'a>) -> ValResult<Bound<'a, PyAny>> {
+        let decimal_type = get_decimal_type(py);
         // Fast path for existing decimal objects
         if self.is_exact_instance(decimal_type) {
-            return Ok(self);
+            return Ok(self.clone());
         }
 
         // Try subclasses of decimals, they will be upcast to Decimal
         if self.is_instance(decimal_type)? {
-            return create_decimal(self, self, py);
+            return create_decimal(self, self);
         }
 
         Err(ValError::new(
             ErrorType::IsInstanceOf {
-                class: decimal_type.name().unwrap_or("Decimal").to_string(),
+                class: decimal_type.qualname().unwrap_or_else(|_| "Decimal".to_owned()),
                 context: None,
             },
             self,
         ))
     }
 
-    fn lax_decimal(&'a self, py: Python<'a>) -> ValResult<&'a PyAny> {
-        let decimal_type_obj: Py<PyType> = get_decimal_type(py);
-        let decimal_type = decimal_type_obj.as_ref(py);
+    fn lax_decimal(&'a self, py: Python<'a>) -> ValResult<Bound<'a, PyAny>> {
+        let decimal_type = get_decimal_type(py);
         // Fast path for existing decimal objects
         if self.is_exact_instance(decimal_type) {
-            return Ok(self);
+            return Ok(self.clone());
         }
 
         if self.is_instance_of::<PyString>() || (self.is_instance_of::<PyInt>() && !self.is_instance_of::<PyBool>()) {
             // checking isinstance for str / int / bool is fast compared to decimal / float
-            create_decimal(self, self, py)
+            create_decimal(self, self)
         } else if self.is_instance(decimal_type)? {
             // upcast subclasses to decimal
-            return create_decimal(self, self, py);
+            return create_decimal(self, self);
         } else if self.is_instance_of::<PyFloat>() {
-            create_decimal(self.str()?, self, py)
+            create_decimal(self.str()?.as_any(), self)
         } else {
             Err(ValError::new(ErrorTypeDefaults::DecimalType, self))
         }
@@ -419,7 +417,7 @@ impl<'a> Input<'a> for PyAny {
 
     fn strict_dict(&'a self) -> ValResult<GenericMapping<'a>> {
         if let Ok(dict) = self.downcast::<PyDict>() {
-            Ok(dict.into())
+            Ok(dict.clone().into())
         } else {
             Err(ValError::new(ErrorTypeDefaults::DictType, self))
         }
@@ -427,9 +425,9 @@ impl<'a> Input<'a> for PyAny {
 
     fn lax_dict(&'a self) -> ValResult<GenericMapping<'a>> {
         if let Ok(dict) = self.downcast::<PyDict>() {
-            Ok(dict.into())
+            Ok(dict.clone().into())
         } else if let Ok(mapping) = self.downcast::<PyMapping>() {
-            Ok(mapping.into())
+            Ok(mapping.clone().into())
         } else {
             Err(ValError::new(ErrorTypeDefaults::DictType, self))
         }
@@ -439,17 +437,17 @@ impl<'a> Input<'a> for PyAny {
         if from_attributes {
             // if from_attributes, first try a dict, then mapping then from_attributes
             if let Ok(dict) = self.downcast::<PyDict>() {
-                return Ok(dict.into());
+                return Ok(dict.clone().into());
             } else if !strict {
                 if let Ok(mapping) = self.downcast::<PyMapping>() {
-                    return Ok(mapping.into());
+                    return Ok(mapping.clone().into());
                 }
             }
 
             if from_attributes_applicable(self) {
-                Ok(self.into())
-            } else if let Ok((obj, kwargs)) = self.extract::<(&PyAny, &PyDict)>() {
-                if from_attributes_applicable(obj) {
+                Ok(self.clone().into())
+            } else if let Ok((obj, kwargs)) = self.extract() {
+                if from_attributes_applicable(&obj) {
                     Ok(GenericMapping::PyGetAttr(obj, Some(kwargs)))
                 } else {
                     Err(ValError::new(ErrorTypeDefaults::ModelAttributesType, self))
@@ -548,15 +546,15 @@ impl<'a> Input<'a> for PyAny {
     fn extract_generic_iterable(&'a self) -> ValResult<GenericIterable<'a>> {
         // Handle concrete non-overlapping types first, then abstract types
         if let Ok(iterable) = self.downcast::<PyList>() {
-            Ok(GenericIterable::List(iterable))
+            Ok(GenericIterable::List(iterable.clone()))
         } else if let Ok(iterable) = self.downcast::<PyTuple>() {
-            Ok(GenericIterable::Tuple(iterable))
+            Ok(GenericIterable::Tuple(iterable.clone()))
         } else if let Ok(iterable) = self.downcast::<PySet>() {
-            Ok(GenericIterable::Set(iterable))
+            Ok(GenericIterable::Set(iterable.clone()))
         } else if let Ok(iterable) = self.downcast::<PyFrozenSet>() {
-            Ok(GenericIterable::FrozenSet(iterable))
+            Ok(GenericIterable::FrozenSet(iterable.clone()))
         } else if let Ok(iterable) = self.downcast::<PyDict>() {
-            Ok(GenericIterable::Dict(iterable))
+            Ok(GenericIterable::Dict(iterable.clone()))
         } else if let Some(iterable) = extract_dict_keys!(self.py(), self) {
             Ok(GenericIterable::DictKeys(iterable))
         } else if let Some(iterable) = extract_dict_values!(self.py(), self) {
@@ -564,15 +562,15 @@ impl<'a> Input<'a> for PyAny {
         } else if let Some(iterable) = extract_dict_items!(self.py(), self) {
             Ok(GenericIterable::DictItems(iterable))
         } else if let Ok(iterable) = self.downcast::<PyMapping>() {
-            Ok(GenericIterable::Mapping(iterable))
+            Ok(GenericIterable::Mapping(iterable.clone()))
         } else if let Ok(iterable) = self.downcast::<PyString>() {
-            Ok(GenericIterable::PyString(iterable))
+            Ok(GenericIterable::PyString(iterable.clone()))
         } else if let Ok(iterable) = self.downcast::<PyBytes>() {
-            Ok(GenericIterable::Bytes(iterable))
+            Ok(GenericIterable::Bytes(iterable.clone()))
         } else if let Ok(iterable) = self.downcast::<PyByteArray>() {
-            Ok(GenericIterable::PyByteArray(iterable))
+            Ok(GenericIterable::PyByteArray(iterable.clone()))
         } else if let Ok(iterable) = self.downcast::<PySequence>() {
-            Ok(GenericIterable::Sequence(iterable))
+            Ok(GenericIterable::Sequence(iterable.clone()))
         } else if let Ok(iterable) = self.iter() {
             Ok(GenericIterable::Iterator(iterable))
         } else {
@@ -590,13 +588,13 @@ impl<'a> Input<'a> for PyAny {
 
     fn validate_date(&self, strict: bool) -> ValResult<ValidationMatch<EitherDate>> {
         if let Ok(date) = self.downcast_exact::<PyDate>() {
-            Ok(ValidationMatch::exact(date.into()))
-        } else if PyDateTime::is_type_of(self) {
+            Ok(ValidationMatch::exact(date.clone().into()))
+        } else if self.is_instance_of::<PyDateTime>() {
             // have to check if it's a datetime first, otherwise the line below converts to a date
             // even if we later try coercion from a datetime, we don't want to return a datetime now
             Err(ValError::new(ErrorTypeDefaults::DateType, self))
         } else if let Ok(date) = self.downcast::<PyDate>() {
-            Ok(ValidationMatch::strict(date.into()))
+            Ok(ValidationMatch::strict(date.clone().into()))
         } else if let Some(bytes) = {
             if strict {
                 None
@@ -621,9 +619,9 @@ impl<'a> Input<'a> for PyAny {
         microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
     ) -> ValResult<ValidationMatch<EitherTime>> {
         if let Ok(time) = self.downcast_exact::<PyTime>() {
-            return Ok(ValidationMatch::exact(time.into()));
+            return Ok(ValidationMatch::exact(time.clone().into()));
         } else if let Ok(time) = self.downcast::<PyTime>() {
-            return Ok(ValidationMatch::strict(time.into()));
+            return Ok(ValidationMatch::strict(time.clone().into()));
         }
 
         'lax: {
@@ -633,7 +631,7 @@ impl<'a> Input<'a> for PyAny {
                     bytes_as_time(self, str.as_bytes(), microseconds_overflow_behavior)
                 } else if let Ok(py_bytes) = self.downcast::<PyBytes>() {
                     bytes_as_time(self, py_bytes.as_bytes(), microseconds_overflow_behavior)
-                } else if PyBool::is_exact_type_of(self) {
+                } else if self.is_exact_instance_of::<PyBool>() {
                     Err(ValError::new(ErrorTypeDefaults::TimeType, self))
                 } else if let Some(int) = extract_i64(self) {
                     int_as_time(self, int, 0)
@@ -655,9 +653,9 @@ impl<'a> Input<'a> for PyAny {
         microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
     ) -> ValResult<ValidationMatch<EitherDateTime>> {
         if let Ok(dt) = self.downcast_exact::<PyDateTime>() {
-            return Ok(ValidationMatch::exact(dt.into()));
+            return Ok(ValidationMatch::exact(dt.clone().into()));
         } else if let Ok(dt) = self.downcast::<PyDateTime>() {
-            return Ok(ValidationMatch::strict(dt.into()));
+            return Ok(ValidationMatch::strict(dt.clone().into()));
         }
 
         'lax: {
@@ -667,7 +665,7 @@ impl<'a> Input<'a> for PyAny {
                     bytes_as_datetime(self, str.as_bytes(), microseconds_overflow_behavior)
                 } else if let Ok(py_bytes) = self.downcast::<PyBytes>() {
                     bytes_as_datetime(self, py_bytes.as_bytes(), microseconds_overflow_behavior)
-                } else if PyBool::is_exact_type_of(self) {
+                } else if self.is_exact_instance_of::<PyBool>() {
                     Err(ValError::new(ErrorTypeDefaults::DatetimeType, self))
                 } else if let Some(int) = extract_i64(self) {
                     int_as_datetime(self, int, 0)
@@ -721,8 +719,15 @@ impl<'a> Input<'a> for PyAny {
     }
 }
 
-impl BorrowInput for &'_ PyAny {
-    type Input<'a> = PyAny where Self: 'a;
+impl BorrowInput for Bound<'_, PyAny> {
+    type Input<'a> = Bound<'a, PyAny> where Self: 'a;
+    fn borrow_input(&self) -> &Self::Input<'_> {
+        self
+    }
+}
+
+impl BorrowInput for Borrowed<'_, '_, PyAny> {
+    type Input<'a> = Bound<'a, PyAny> where Self: 'a;
     fn borrow_input(&self) -> &Self::Input<'_> {
         self
     }
@@ -730,23 +735,24 @@ impl BorrowInput for &'_ PyAny {
 
 /// Best effort check of whether it's likely to make sense to inspect obj for attributes and iterate over it
 /// with `obj.dir()`
-fn from_attributes_applicable(obj: &PyAny) -> bool {
-    let module_name = match obj.get_type().getattr(intern!(obj.py(), "__module__")) {
-        Ok(module) => match module.extract::<&str>() {
-            Ok(s) => s,
-            Err(_) => return false,
-        },
-        Err(_) => return false,
+fn from_attributes_applicable(obj: &Bound<'_, PyAny>) -> bool {
+    let Some(module_name) = obj
+        .get_type()
+        .getattr(intern!(obj.py(), "__module__"))
+        .ok()
+        .and_then(|module_name| module_name.downcast_into::<PyString>().ok())
+    else {
+        return false;
     };
     // I don't think it's a very good list at all! But it doesn't have to be at perfect, it just needs to avoid
     // the most egregious foot guns, it's mostly just to catch "builtins"
     // still happy to add more or do something completely different if anyone has a better idea???
     // dbg!(obj, module_name);
-    !matches!(module_name, "builtins" | "datetime" | "collections")
+    !matches!(module_name.to_str(), Ok("builtins" | "datetime" | "collections"))
 }
 
 /// Utility for extracting a string from a PyAny, if possible.
-fn maybe_as_string(v: &PyAny, unicode_error: ErrorType) -> ValResult<Option<Cow<str>>> {
+fn maybe_as_string<'a>(v: &'a Bound<'_, PyAny>, unicode_error: ErrorType) -> ValResult<Option<Cow<'a, str>>> {
     if let Ok(py_string) = v.downcast::<PyString>() {
         let str = py_string_str(py_string)?;
         Ok(Some(Cow::Borrowed(str)))
@@ -761,11 +767,11 @@ fn maybe_as_string(v: &PyAny, unicode_error: ErrorType) -> ValResult<Option<Cow<
 }
 
 /// Utility for extracting an enum value, if possible.
-fn maybe_as_enum(v: &PyAny) -> Option<&PyAny> {
+fn maybe_as_enum<'py>(v: &Bound<'py, PyAny>) -> Option<Bound<'py, PyAny>> {
     let py = v.py();
     let enum_meta_object = get_enum_meta_object(py);
     let meta_type = v.get_type().get_type();
-    if meta_type.is(&enum_meta_object) {
+    if meta_type.is(enum_meta_object) {
         v.getattr(intern!(py, "value")).ok()
     } else {
         None
@@ -773,55 +779,55 @@ fn maybe_as_enum(v: &PyAny) -> Option<&PyAny> {
 }
 
 #[cfg(PyPy)]
-static DICT_KEYS_TYPE: pyo3::once_cell::GILOnceCell<Py<PyType>> = pyo3::once_cell::GILOnceCell::new();
+static DICT_KEYS_TYPE: pyo3::sync::GILOnceCell<Py<PyType>> = pyo3::sync::GILOnceCell::new();
 
 #[cfg(PyPy)]
-fn is_dict_keys_type(v: &PyAny) -> bool {
+fn is_dict_keys_type(v: &Bound<'_, PyAny>) -> bool {
     let py = v.py();
     let keys_type = DICT_KEYS_TYPE
         .get_or_init(py, || {
             py.eval("type({}.keys())", None, None)
                 .unwrap()
-                .extract::<&PyType>()
+                .downcast::<PyType>()
                 .unwrap()
                 .into()
         })
-        .as_ref(py);
+        .bind(py);
     v.is_instance(keys_type).unwrap_or(false)
 }
 
 #[cfg(PyPy)]
-static DICT_VALUES_TYPE: pyo3::once_cell::GILOnceCell<Py<PyType>> = pyo3::once_cell::GILOnceCell::new();
+static DICT_VALUES_TYPE: pyo3::sync::GILOnceCell<Py<PyType>> = pyo3::sync::GILOnceCell::new();
 
 #[cfg(PyPy)]
-fn is_dict_values_type(v: &PyAny) -> bool {
+fn is_dict_values_type(v: &Bound<'_, PyAny>) -> bool {
     let py = v.py();
     let values_type = DICT_VALUES_TYPE
         .get_or_init(py, || {
             py.eval("type({}.values())", None, None)
                 .unwrap()
-                .extract::<&PyType>()
+                .downcast::<PyType>()
                 .unwrap()
                 .into()
         })
-        .as_ref(py);
+        .bind(py);
     v.is_instance(values_type).unwrap_or(false)
 }
 
 #[cfg(PyPy)]
-static DICT_ITEMS_TYPE: pyo3::once_cell::GILOnceCell<Py<PyType>> = pyo3::once_cell::GILOnceCell::new();
+static DICT_ITEMS_TYPE: pyo3::sync::GILOnceCell<Py<PyType>> = pyo3::sync::GILOnceCell::new();
 
 #[cfg(PyPy)]
-fn is_dict_items_type(v: &PyAny) -> bool {
+fn is_dict_items_type(v: &Bound<'_, PyAny>) -> bool {
     let py = v.py();
     let items_type = DICT_ITEMS_TYPE
         .get_or_init(py, || {
             py.eval("type({}.items())", None, None)
                 .unwrap()
-                .extract::<&PyType>()
+                .downcast::<PyType>()
                 .unwrap()
                 .into()
         })
-        .as_ref(py);
+        .bind(py);
     v.is_instance(items_type).unwrap_or(false)
 }
diff --git a/src/input/input_string.rs b/src/input/input_string.rs
index f6c33d784..6cc0226ac 100644
--- a/src/input/input_string.rs
+++ b/src/input/input_string.rs
@@ -19,8 +19,8 @@ use super::{
 
 #[derive(Debug, Clone)]
 pub enum StringMapping<'py> {
-    String(&'py PyString),
-    Mapping(&'py PyDict),
+    String(Bound<'py, PyString>),
+    Mapping(Bound<'py, PyDict>),
 }
 
 impl<'py> ToPyObject for StringMapping<'py> {
@@ -33,19 +33,19 @@ impl<'py> ToPyObject for StringMapping<'py> {
 }
 
 impl<'py> StringMapping<'py> {
-    pub fn new_key(py_key: &'py PyAny) -> ValResult<StringMapping> {
+    pub fn new_key(py_key: &Bound<'py, PyAny>) -> ValResult<Self> {
         if let Ok(py_str) = py_key.downcast::<PyString>() {
-            Ok(Self::String(py_str))
+            Ok(Self::String(py_str.clone()))
         } else {
             Err(ValError::new(ErrorTypeDefaults::StringType, py_key))
         }
     }
 
-    pub fn new_value(py_value: &'py PyAny) -> ValResult<Self> {
+    pub fn new_value(py_value: &Bound<'py, PyAny>) -> ValResult<Self> {
         if let Ok(py_str) = py_value.downcast::<PyString>() {
-            Ok(Self::String(py_str))
+            Ok(Self::String(py_str.clone()))
         } else if let Ok(value) = py_value.downcast::<PyDict>() {
-            Ok(Self::Mapping(value))
+            Ok(Self::Mapping(value.clone()))
         } else {
             Err(ValError::new(ErrorTypeDefaults::StringType, py_value))
         }
@@ -56,7 +56,7 @@ impl From<StringMapping<'_>> for LocItem {
     fn from(string_mapping: StringMapping<'_>) -> Self {
         match string_mapping {
             StringMapping::String(s) => s.to_string_lossy().as_ref().into(),
-            StringMapping::Mapping(d) => safe_repr(d).to_string().into(),
+            StringMapping::Mapping(d) => safe_repr(&d).to_string().into(),
         }
     }
 }
@@ -69,7 +69,7 @@ impl<'a> Input<'a> for StringMapping<'a> {
         }
     }
 
-    fn as_kwargs(&'a self, _py: Python<'a>) -> Option<&'a PyDict> {
+    fn as_kwargs(&self, _py: Python<'a>) -> Option<Bound<'a, PyDict>> {
         None
     }
 
@@ -81,7 +81,7 @@ impl<'a> Input<'a> for StringMapping<'a> {
     fn validate_dataclass_args(&'a self, _dataclass_name: &str) -> ValResult<GenericArguments<'a>> {
         match self {
             StringMapping::String(_) => Err(ValError::new(ErrorTypeDefaults::ArgumentsType, self)),
-            StringMapping::Mapping(m) => Ok(GenericArguments::StringMapping(m)),
+            StringMapping::Mapping(m) => Ok(GenericArguments::StringMapping(m.clone())),
         }
     }
 
@@ -91,7 +91,7 @@ impl<'a> Input<'a> for StringMapping<'a> {
         _coerce_numbers_to_str: bool,
     ) -> ValResult<ValidationMatch<EitherString<'a>>> {
         match self {
-            Self::String(s) => Ok(ValidationMatch::strict((*s).into())),
+            Self::String(s) => Ok(ValidationMatch::strict(s.clone().into())),
             Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::StringType, self)),
         }
     }
@@ -124,9 +124,9 @@ impl<'a> Input<'a> for StringMapping<'a> {
         }
     }
 
-    fn strict_decimal(&'a self, py: Python<'a>) -> ValResult<&'a PyAny> {
+    fn strict_decimal(&'a self, _py: Python<'a>) -> ValResult<Bound<'a, PyAny>> {
         match self {
-            Self::String(s) => create_decimal(s, self, py),
+            Self::String(s) => create_decimal(s, self),
             Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::DecimalType, self)),
         }
     }
@@ -134,7 +134,7 @@ impl<'a> Input<'a> for StringMapping<'a> {
     fn strict_dict(&'a self) -> ValResult<GenericMapping<'a>> {
         match self {
             Self::String(_) => Err(ValError::new(ErrorTypeDefaults::DictType, self)),
-            Self::Mapping(d) => Ok(GenericMapping::StringMapping(d)),
+            Self::Mapping(d) => Ok(GenericMapping::StringMapping(d.clone())),
         }
     }
 
diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index b323383b7..9e881c10d 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -9,17 +9,15 @@ use num_bigint::BigInt;
 
 use pyo3::exceptions::PyTypeError;
 use pyo3::prelude::*;
-use pyo3::types::iter::PyDictIterator;
+use pyo3::types::iter::{BoundDictIterator, BoundListIterator};
 use pyo3::types::{
     PyByteArray, PyBytes, PyDict, PyFloat, PyFrozenSet, PyIterator, PyList, PyMapping, PySequence, PySet, PyString,
     PyTuple,
 };
-use pyo3::{ffi, intern, PyNativeType};
+use pyo3::{ffi, intern};
 
 #[cfg(not(PyPy))]
 use pyo3::types::PyFunction;
-#[cfg(not(PyPy))]
-use pyo3::PyTypeInfo;
 use serde::{ser::Error, Serialize, Serializer};
 
 use crate::errors::{py_err_string, ErrorType, ErrorTypeDefaults, InputValue, ValError, ValLineError, ValResult};
@@ -27,7 +25,7 @@ use crate::tools::{extract_i64, py_err};
 use crate::validators::{CombinedValidator, Exactness, ValidationState, Validator};
 
 use super::input_string::StringMapping;
-use super::{py_error_on_minusone, Input};
+use super::{py_error_on_minusone, BorrowInput, Input};
 
 pub struct ValidationMatch<T>(T, Exactness);
 
@@ -67,22 +65,22 @@ impl<T> ValidationMatch<T> {
 /// This mostly matches python's definition of `Collection`.
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub enum GenericIterable<'a> {
-    List(&'a PyList),
-    Tuple(&'a PyTuple),
-    Set(&'a PySet),
-    FrozenSet(&'a PyFrozenSet),
-    Dict(&'a PyDict),
+    List(Bound<'a, PyList>),
+    Tuple(Bound<'a, PyTuple>),
+    Set(Bound<'a, PySet>),
+    FrozenSet(Bound<'a, PyFrozenSet>),
+    Dict(Bound<'a, PyDict>),
     // Treat dict values / keys / items as generic iterators
     // since PyPy doesn't export the concrete types
-    DictKeys(&'a PyIterator),
-    DictValues(&'a PyIterator),
-    DictItems(&'a PyIterator),
-    Mapping(&'a PyMapping),
-    PyString(&'a PyString),
-    Bytes(&'a PyBytes),
-    PyByteArray(&'a PyByteArray),
-    Sequence(&'a PySequence),
-    Iterator(&'a PyIterator),
+    DictKeys(Bound<'a, PyIterator>),
+    DictValues(Bound<'a, PyIterator>),
+    DictItems(Bound<'a, PyIterator>),
+    Mapping(Bound<'a, PyMapping>),
+    PyString(Bound<'a, PyString>),
+    Bytes(Bound<'a, PyBytes>),
+    PyByteArray(Bound<'a, PyByteArray>),
+    Sequence(Bound<'a, PySequence>),
+    Iterator(Bound<'a, PyIterator>),
     JsonArray(&'a [JsonValue]),
     JsonObject(&'a JsonObject),
     JsonString(&'a String),
@@ -92,10 +90,10 @@ impl<'a, 'py: 'a> GenericIterable<'a> {
     pub fn as_sequence_iterator(
         &self,
         py: Python<'py>,
-    ) -> PyResult<Box<dyn Iterator<Item = PyResult<&'a PyAny>> + 'a>> {
+    ) -> PyResult<Box<dyn Iterator<Item = PyResult<Bound<'a, PyAny>>> + 'a>> {
         match self {
-            GenericIterable::List(iter) => Ok(Box::new(iter.iter().map(Ok))),
-            GenericIterable::Tuple(iter) => Ok(Box::new(iter.iter().map(Ok))),
+            GenericIterable::List(iter) => Ok(Box::new(iter.clone().into_iter().map(Ok))),
+            GenericIterable::Tuple(iter) => Ok(Box::new(iter.clone().into_iter().map(Ok))),
             GenericIterable::Set(iter) => Ok(Box::new(iter.iter().map(Ok))),
             GenericIterable::FrozenSet(iter) => Ok(Box::new(iter.iter().map(Ok))),
             // Note that this iterates over only the keys, just like doing iter({}) in Python
@@ -111,28 +109,18 @@ impl<'a, 'py: 'a> GenericIterable<'a> {
             GenericIterable::Sequence(iter) => Ok(Box::new(iter.iter()?)),
             GenericIterable::Iterator(iter) => Ok(Box::new(iter.iter()?)),
             GenericIterable::JsonArray(iter) => Ok(Box::new(iter.iter().map(move |v| {
-                let v = v.to_object(py);
-                Ok(v.into_ref(py))
+                let v = v.to_object(py).into_bound(py);
+                Ok(v)
             }))),
             // Note that this iterates over only the keys, just like doing iter({}) in Python, just for consistency
             GenericIterable::JsonObject(iter) => Ok(Box::new(
-                iter.iter().map(move |(k, _)| Ok(k.to_object(py).into_ref(py))),
+                iter.iter().map(move |(k, _)| Ok(k.to_object(py).into_bound(py))),
             )),
-            GenericIterable::JsonString(s) => Ok(Box::new(PyString::new(py, s).iter()?)),
+            GenericIterable::JsonString(s) => Ok(Box::new(PyString::new_bound(py, s).iter()?)),
         }
     }
 }
 
-macro_rules! derive_from {
-    ($enum:ident, $key:ident, $type:ty $(, $extra_types:ident )*) => {
-        impl<'a> From<&'a $type> for $enum<'a> {
-            fn from(s: &'a $type) -> $enum<'a> {
-                Self::$key(s $(, $extra_types )*)
-            }
-        }
-    };
-}
-
 #[derive(Debug)]
 struct MaxLengthCheck<'a, INPUT> {
     current_length: usize,
@@ -188,7 +176,7 @@ macro_rules! any_next_error {
 #[allow(clippy::too_many_arguments)]
 fn validate_iter_to_vec<'a, 's>(
     py: Python<'a>,
-    iter: impl Iterator<Item = PyResult<&'a (impl Input<'a> + 'a)>>,
+    iter: impl Iterator<Item = PyResult<impl BorrowInput>>,
     capacity: usize,
     mut max_length_check: MaxLengthCheck<'a, impl Input<'a>>,
     validator: &'s CombinedValidator,
@@ -198,7 +186,7 @@ fn validate_iter_to_vec<'a, 's>(
     let mut errors: Vec<ValLineError> = Vec::new();
     for (index, item_result) in iter.enumerate() {
         let item = item_result.map_err(|e| any_next_error!(py, e, max_length_check.input, index))?;
-        match validator.validate(py, item, state) {
+        match validator.validate(py, item.borrow_input(), state) {
             Ok(item) => {
                 max_length_check.incr()?;
                 output.push(item);
@@ -225,7 +213,7 @@ pub trait BuildSet {
     fn build_len(&self) -> usize;
 }
 
-impl BuildSet for &PySet {
+impl BuildSet for Bound<'_, PySet> {
     fn build_add(&self, item: PyObject) -> PyResult<()> {
         self.add(item)
     }
@@ -235,7 +223,7 @@ impl BuildSet for &PySet {
     }
 }
 
-impl BuildSet for &PyFrozenSet {
+impl BuildSet for Bound<'_, PyFrozenSet> {
     fn build_add(&self, item: PyObject) -> PyResult<()> {
         py_error_on_minusone(self.py(), unsafe {
             // Safety: self.as_ptr() the _only_ pointer to the `frozenset`, and it's allowed
@@ -252,8 +240,8 @@ impl BuildSet for &PyFrozenSet {
 #[allow(clippy::too_many_arguments)]
 fn validate_iter_to_set<'a, 's>(
     py: Python<'a>,
-    set: impl BuildSet,
-    iter: impl Iterator<Item = PyResult<&'a (impl Input<'a> + 'a)>>,
+    set: &impl BuildSet,
+    iter: impl Iterator<Item = PyResult<impl BorrowInput>>,
     input: &'a (impl Input<'a> + 'a),
     field_type: &'static str,
     max_length: Option<usize>,
@@ -263,7 +251,7 @@ fn validate_iter_to_set<'a, 's>(
     let mut errors: Vec<ValLineError> = Vec::new();
     for (index, item_result) in iter.enumerate() {
         let item = item_result.map_err(|e| any_next_error!(py, e, input, index))?;
-        match validator.validate(py, item, state) {
+        match validator.validate(py, item.borrow_input(), state) {
             Ok(item) => {
                 set.build_add(item)?;
                 if let Some(max_length) = max_length {
@@ -301,14 +289,14 @@ fn validate_iter_to_set<'a, 's>(
 fn no_validator_iter_to_vec<'a, 's>(
     py: Python<'a>,
     input: &'a (impl Input<'a> + 'a),
-    iter: impl Iterator<Item = PyResult<&'a (impl Input<'a> + 'a)>>,
+    iter: impl Iterator<Item = PyResult<impl BorrowInput>>,
     mut max_length_check: MaxLengthCheck<'a, impl Input<'a>>,
 ) -> ValResult<Vec<PyObject>> {
     iter.enumerate()
         .map(|(index, result)| {
             let v = result.map_err(|e| any_next_error!(py, e, input, index))?;
             max_length_check.incr()?;
-            Ok(v.to_object(py))
+            Ok(v.borrow_input().to_object(py))
         })
         .collect()
 }
@@ -375,7 +363,7 @@ impl<'a> GenericIterable<'a> {
     pub fn validate_to_set<'s>(
         &'s self,
         py: Python<'a>,
-        set: impl BuildSet,
+        set: &impl BuildSet,
         input: &'a impl Input<'a>,
         max_length: Option<usize>,
         field_type: &'static str,
@@ -439,30 +427,45 @@ impl<'a> GenericIterable<'a> {
 
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub enum GenericMapping<'a> {
-    PyDict(&'a PyDict),
-    PyMapping(&'a PyMapping),
-    StringMapping(&'a PyDict),
-    PyGetAttr(&'a PyAny, Option<&'a PyDict>),
+    PyDict(Bound<'a, PyDict>),
+    PyMapping(Bound<'a, PyMapping>),
+    StringMapping(Bound<'a, PyDict>),
+    PyGetAttr(Bound<'a, PyAny>, Option<Bound<'a, PyDict>>),
     JsonObject(&'a JsonObject),
 }
 
+macro_rules! derive_from {
+    ($enum:ident, $key:ident, $type:ty $(, $extra_types:ident )*) => {
+        impl<'a> From<Bound<'a, $type>> for $enum<'a> {
+            fn from(s: Bound<'a, $type>) -> $enum<'a> {
+                Self::$key(s $(, $extra_types )*)
+            }
+        }
+    };
+}
+
 derive_from!(GenericMapping, PyDict, PyDict);
 derive_from!(GenericMapping, PyMapping, PyMapping);
 derive_from!(GenericMapping, PyGetAttr, PyAny, None);
-derive_from!(GenericMapping, JsonObject, JsonObject);
+
+impl<'a> From<&'a JsonObject> for GenericMapping<'a> {
+    fn from(s: &'a JsonObject) -> GenericMapping<'a> {
+        Self::JsonObject(s)
+    }
+}
 
 pub struct DictGenericIterator<'py> {
-    dict_iter: PyDictIterator<'py>,
+    dict_iter: BoundDictIterator<'py>,
 }
 
 impl<'py> DictGenericIterator<'py> {
-    pub fn new(dict: &'py PyDict) -> ValResult<Self> {
+    pub fn new(dict: &Bound<'py, PyDict>) -> ValResult<Self> {
         Ok(Self { dict_iter: dict.iter() })
     }
 }
 
 impl<'py> Iterator for DictGenericIterator<'py> {
-    type Item = ValResult<(&'py PyAny, &'py PyAny)>;
+    type Item = ValResult<(Bound<'py, PyAny>, Bound<'py, PyAny>)>;
 
     fn next(&mut self) -> Option<Self::Item> {
         self.dict_iter.next().map(Ok)
@@ -471,8 +474,8 @@ impl<'py> Iterator for DictGenericIterator<'py> {
 }
 
 pub struct MappingGenericIterator<'py> {
-    input: &'py PyAny,
-    iter: &'py PyIterator,
+    input: Bound<'py, PyAny>,
+    iter: Bound<'py, PyIterator>,
 }
 
 fn mapping_err<'py>(err: PyErr, py: Python<'py>, input: &'py impl Input<'py>) -> ValError {
@@ -486,22 +489,25 @@ fn mapping_err<'py>(err: PyErr, py: Python<'py>, input: &'py impl Input<'py>) ->
 }
 
 impl<'py> MappingGenericIterator<'py> {
-    pub fn new(mapping: &'py PyMapping) -> ValResult<Self> {
+    pub fn new(mapping: &Bound<'py, PyMapping>) -> ValResult<Self> {
         let py = mapping.py();
-        let input: &PyAny = mapping;
+        let input = mapping.as_any();
         let iter = mapping
             .items()
             .map_err(|e| mapping_err(e, py, input))?
             .iter()
             .map_err(|e| mapping_err(e, py, input))?;
-        Ok(Self { input, iter })
+        Ok(Self {
+            input: input.clone(),
+            iter,
+        })
     }
 }
 
 const MAPPING_TUPLE_ERROR: &str = "Mapping items must be tuples of (key, value) pairs";
 
 impl<'py> Iterator for MappingGenericIterator<'py> {
-    type Item = ValResult<(&'py PyAny, &'py PyAny)>;
+    type Item = ValResult<(Bound<'py, PyAny>, Bound<'py, PyAny>)>;
 
     fn next(&mut self) -> Option<Self::Item> {
         Some(match self.iter.next()? {
@@ -511,20 +517,20 @@ impl<'py> Iterator for MappingGenericIterator<'py> {
                         error: MAPPING_TUPLE_ERROR.into(),
                         context: None,
                     },
-                    self.input,
+                    &self.input,
                 )
             }),
-            Err(e) => Err(mapping_err(e, self.iter.py(), self.input)),
+            Err(e) => Err(mapping_err(e, self.iter.py(), &self.input)),
         })
     }
 }
 
 pub struct StringMappingGenericIterator<'py> {
-    dict_iter: PyDictIterator<'py>,
+    dict_iter: BoundDictIterator<'py>,
 }
 
 impl<'py> StringMappingGenericIterator<'py> {
-    pub fn new(dict: &'py PyDict) -> ValResult<Self> {
+    pub fn new(dict: &Bound<'py, PyDict>) -> ValResult<Self> {
         Ok(Self { dict_iter: dict.iter() })
     }
 }
@@ -536,11 +542,11 @@ impl<'py> Iterator for StringMappingGenericIterator<'py> {
     fn next(&mut self) -> Option<Self::Item> {
         match self.dict_iter.next() {
             Some((py_key, py_value)) => {
-                let key = match StringMapping::new_key(py_key) {
+                let key = match StringMapping::new_key(&py_key) {
                     Ok(key) => key,
                     Err(e) => return Some(Err(e)),
                 };
-                let value = match StringMapping::new_value(py_value) {
+                let value = match StringMapping::new_value(&py_value) {
                     Ok(value) => value,
                     Err(e) => return Some(Err(e)),
                 };
@@ -552,22 +558,22 @@ impl<'py> Iterator for StringMappingGenericIterator<'py> {
 }
 
 pub struct AttributesGenericIterator<'py> {
-    object: &'py PyAny,
-    // PyO3 should export this type upstream
-    attributes_iterator: <&'py PyList as IntoIterator>::IntoIter,
+    object: Bound<'py, PyAny>,
+    attributes_iterator: BoundListIterator<'py>,
 }
 
 impl<'py> AttributesGenericIterator<'py> {
-    pub fn new(py_any: &'py PyAny) -> ValResult<Self> {
+    pub fn new(py_any: &Bound<'py, PyAny>) -> ValResult<Self> {
+        let attributes_iterator = py_any.dir().into_iter();
         Ok(Self {
-            object: py_any,
-            attributes_iterator: py_any.dir().into_iter(),
+            object: py_any.clone(),
+            attributes_iterator,
         })
     }
 }
 
 impl<'py> Iterator for AttributesGenericIterator<'py> {
-    type Item = ValResult<(&'py PyAny, &'py PyAny)>;
+    type Item = ValResult<(Bound<'py, PyAny>, Bound<'py, PyAny>)>;
 
     fn next(&mut self) -> Option<Self::Item> {
         // loop until we find an attribute who's name does not start with underscore,
@@ -588,7 +594,7 @@ impl<'py> Iterator for AttributesGenericIterator<'py> {
                 // I think that's better than including static methods in the yielded attributes,
                 // if someone really wants fields, they can use an explicit field, or a function to modify input
                 #[cfg(not(PyPy))]
-                if !is_bound && !PyFunction::is_type_of(attr) {
+                if !is_bound && !attr.is_instance_of::<PyFunction>() {
                     return Some(Ok((name, attr)));
                 }
                 // MASSIVE HACK! PyFunction doesn't exist for PyPy,
@@ -639,11 +645,11 @@ impl From<JsonArray> for GenericIterator {
     }
 }
 
-impl From<&PyAny> for GenericIterator {
-    fn from(obj: &PyAny) -> Self {
+impl From<&Bound<'_, PyAny>> for GenericIterator {
+    fn from(obj: &Bound<'_, PyAny>) -> Self {
         let py_iter = GenericPyIterator {
-            obj: obj.to_object(obj.py()),
-            iter: obj.iter().unwrap().into_py(obj.py()),
+            obj: obj.clone().into(),
+            iter: obj.iter().unwrap().into(),
             index: 0,
         };
         Self::PyIterator(py_iter)
@@ -658,8 +664,10 @@ pub struct GenericPyIterator {
 }
 
 impl GenericPyIterator {
-    pub fn next<'a>(&'a mut self, py: Python<'a>) -> PyResult<Option<(&'a PyAny, usize)>> {
-        match self.iter.as_ref(py).next() {
+    pub fn next<'py>(&mut self, py: Python<'py>) -> PyResult<Option<(Bound<'py, PyAny>, usize)>> {
+        // TODO: .to_owned() is a workaround for PyO3 not allowing `.next()` to be called on
+        // the reference
+        match self.iter.bind(py).to_owned().next() {
             Some(Ok(next)) => {
                 let a = (next, self.index);
                 self.index += 1;
@@ -709,13 +717,13 @@ impl GenericJsonIterator {
 }
 
 #[cfg_attr(debug_assertions, derive(Debug))]
-pub struct PyArgs<'a> {
-    pub args: Option<&'a PyTuple>,
-    pub kwargs: Option<&'a PyDict>,
+pub struct PyArgs<'py> {
+    pub args: Option<Bound<'py, PyTuple>>,
+    pub kwargs: Option<Bound<'py, PyDict>>,
 }
 
-impl<'a> PyArgs<'a> {
-    pub fn new(args: Option<&'a PyTuple>, kwargs: Option<&'a PyDict>) -> Self {
+impl<'py> PyArgs<'py> {
+    pub fn new(args: Option<Bound<'py, PyTuple>>, kwargs: Option<Bound<'py, PyDict>>) -> Self {
         Self { args, kwargs }
     }
 }
@@ -736,7 +744,7 @@ impl<'a> JsonArgs<'a> {
 pub enum GenericArguments<'a> {
     Py(PyArgs<'a>),
     Json(JsonArgs<'a>),
-    StringMapping(&'a PyDict),
+    StringMapping(Bound<'a, PyDict>),
 }
 
 impl<'a> From<PyArgs<'a>> for GenericArguments<'a> {
@@ -754,7 +762,7 @@ impl<'a> From<JsonArgs<'a>> for GenericArguments<'a> {
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub enum EitherString<'a> {
     Cow(Cow<'a, str>),
-    Py(&'a PyString),
+    Py(Bound<'a, PyString>),
 }
 
 impl<'a> EitherString<'a> {
@@ -765,10 +773,10 @@ impl<'a> EitherString<'a> {
         }
     }
 
-    pub fn as_py_string(&'a self, py: Python<'a>) -> &'a PyString {
+    pub fn as_py_string(&'a self, py: Python<'a>) -> Bound<'a, PyString> {
         match self {
-            Self::Cow(cow) => PyString::new(py, cow),
-            Self::Py(py_string) => py_string,
+            Self::Cow(cow) => PyString::new_bound(py, cow),
+            Self::Py(py_string) => py_string.clone(),
         }
     }
 }
@@ -785,8 +793,8 @@ impl<'a> From<String> for EitherString<'a> {
     }
 }
 
-impl<'a> From<&'a PyString> for EitherString<'a> {
-    fn from(date: &'a PyString) -> Self {
+impl<'a> From<Bound<'a, PyString>> for EitherString<'a> {
+    fn from(date: Bound<'a, PyString>) -> Self {
         Self::Py(date)
     }
 }
@@ -797,33 +805,36 @@ impl<'a> IntoPy<PyObject> for EitherString<'a> {
     }
 }
 
-pub fn py_string_str(py_str: &PyString) -> ValResult<&str> {
-    py_str
-        .to_str()
-        .map_err(|_| ValError::new_custom_input(ErrorTypeDefaults::StringUnicode, InputValue::Python(py_str.into())))
+pub fn py_string_str<'a>(py_str: &'a Bound<'_, PyString>) -> ValResult<&'a str> {
+    py_str.to_str().map_err(|_| {
+        ValError::new_custom_input(
+            ErrorTypeDefaults::StringUnicode,
+            InputValue::Python(py_str.clone().into()),
+        )
+    })
 }
 
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub enum EitherBytes<'a> {
     Cow(Cow<'a, [u8]>),
-    Py(&'a PyBytes),
+    Py(Bound<'a, PyBytes>),
 }
 
 impl<'a> From<Vec<u8>> for EitherBytes<'a> {
-    fn from(date: Vec<u8>) -> Self {
-        Self::Cow(Cow::Owned(date))
+    fn from(bytes: Vec<u8>) -> Self {
+        Self::Cow(Cow::Owned(bytes))
     }
 }
 
 impl<'a> From<&'a [u8]> for EitherBytes<'a> {
-    fn from(date: &'a [u8]) -> Self {
-        Self::Cow(Cow::Borrowed(date))
+    fn from(bytes: &'a [u8]) -> Self {
+        Self::Cow(Cow::Borrowed(bytes))
     }
 }
 
-impl<'a> From<&'a PyBytes> for EitherBytes<'a> {
-    fn from(date: &'a PyBytes) -> Self {
-        Self::Py(date)
+impl<'a> From<&'_ Bound<'a, PyBytes>> for EitherBytes<'a> {
+    fn from(bytes: &'_ Bound<'a, PyBytes>) -> Self {
+        Self::Py(bytes.clone())
     }
 }
 
@@ -846,7 +857,7 @@ impl<'a> EitherBytes<'a> {
 impl<'a> IntoPy<PyObject> for EitherBytes<'a> {
     fn into_py(self, py: Python<'_>) -> PyObject {
         match self {
-            EitherBytes::Cow(bytes) => PyBytes::new(py, &bytes).into_py(py),
+            EitherBytes::Cow(bytes) => PyBytes::new_bound(py, &bytes).into_py(py),
             EitherBytes::Py(py_bytes) => py_bytes.into_py(py),
         }
     }
@@ -857,11 +868,11 @@ pub enum EitherInt<'a> {
     I64(i64),
     U64(u64),
     BigInt(BigInt),
-    Py(&'a PyAny),
+    Py(Bound<'a, PyAny>),
 }
 
 impl<'a> EitherInt<'a> {
-    pub fn upcast(py_any: &'a PyAny) -> ValResult<Self> {
+    pub fn upcast(py_any: &Bound<'a, PyAny>) -> ValResult<Self> {
         // Safety: we know that py_any is a python int
         if let Some(int_64) = extract_i64(py_any) {
             Ok(Self::I64(int_64))
@@ -875,21 +886,18 @@ impl<'a> EitherInt<'a> {
             EitherInt::I64(i) => Ok(i),
             EitherInt::U64(u) => match i64::try_from(u) {
                 Ok(u) => Ok(u),
-                Err(_) => Err(ValError::new(
-                    ErrorTypeDefaults::IntParsingSize,
-                    u.into_py(py).into_ref(py),
-                )),
+                Err(_) => Err(ValError::new(ErrorTypeDefaults::IntParsingSize, u.into_py(py).bind(py))),
             },
             EitherInt::BigInt(u) => match i64::try_from(u) {
                 Ok(u) => Ok(u),
                 Err(e) => Err(ValError::new(
                     ErrorTypeDefaults::IntParsingSize,
-                    e.into_original().into_py(py).into_ref(py),
+                    e.into_original().into_py(py).bind(py),
                 )),
             },
             EitherInt::Py(i) => i
                 .extract()
-                .map_err(|_| ValError::new(ErrorTypeDefaults::IntParsingSize, i)),
+                .map_err(|_| ValError::new(ErrorTypeDefaults::IntParsingSize, &i)),
         }
     }
 
@@ -903,7 +911,7 @@ impl<'a> EitherInt<'a> {
             EitherInt::BigInt(b) => Ok(Int::Big(b.clone())),
             EitherInt::Py(i) => i
                 .extract()
-                .map_err(|_| ValError::new(ErrorTypeDefaults::IntParsingSize, *i)),
+                .map_err(|_| ValError::new(ErrorTypeDefaults::IntParsingSize, i)),
         }
     }
 
@@ -945,16 +953,16 @@ impl<'a> IntoPy<PyObject> for EitherInt<'a> {
 }
 
 #[cfg_attr(debug_assertions, derive(Debug))]
-#[derive(Copy, Clone)]
+#[derive(Clone)]
 pub enum EitherFloat<'a> {
     F64(f64),
-    Py(&'a PyFloat),
+    Py(Bound<'a, PyFloat>),
 }
 
 impl<'a> EitherFloat<'a> {
-    pub fn as_f64(self) -> f64 {
+    pub fn as_f64(&self) -> f64 {
         match self {
-            EitherFloat::F64(f) => f,
+            EitherFloat::F64(f) => *f,
             EitherFloat::Py(f) => f.value(),
         }
     }
@@ -1019,8 +1027,8 @@ impl<'a> Rem for &'a Int {
     }
 }
 
-impl<'a> FromPyObject<'a> for Int {
-    fn extract(obj: &'a PyAny) -> PyResult<Self> {
+impl FromPyObject<'_> for Int {
+    fn extract_bound(obj: &Bound<'_, PyAny>) -> PyResult<Self> {
         if let Some(i) = extract_i64(obj) {
             Ok(Int::I64(i))
         } else if let Ok(b) = obj.extract::<BigInt>() {
diff --git a/src/input/shared.rs b/src/input/shared.rs
index c81dff1e8..8771d4c01 100644
--- a/src/input/shared.rs
+++ b/src/input/shared.rs
@@ -1,5 +1,6 @@
+use pyo3::prelude::*;
 use pyo3::sync::GILOnceCell;
-use pyo3::{intern, Py, PyAny, Python, ToPyObject};
+use pyo3::{intern, Py, PyAny, Python};
 
 use num_bigint::BigInt;
 
@@ -8,15 +9,15 @@ use crate::errors::{ErrorTypeDefaults, ValError, ValResult};
 use super::{EitherFloat, EitherInt, Input};
 static ENUM_META_OBJECT: GILOnceCell<Py<PyAny>> = GILOnceCell::new();
 
-pub fn get_enum_meta_object(py: Python) -> Py<PyAny> {
+pub fn get_enum_meta_object(py: Python) -> &Bound<'_, PyAny> {
     ENUM_META_OBJECT
         .get_or_init(py, || {
-            py.import(intern!(py, "enum"))
+            py.import_bound(intern!(py, "enum"))
                 .and_then(|enum_module| enum_module.getattr(intern!(py, "EnumMeta")))
                 .unwrap()
-                .to_object(py)
+                .into()
         })
-        .clone()
+        .bind(py)
 }
 
 pub fn str_as_bool<'a>(input: &'a impl Input<'a>, str: &str) -> ValResult<bool> {
@@ -142,13 +143,14 @@ pub fn float_as_int<'a>(input: &'a impl Input<'a>, float: f64) -> ValResult<Eith
     }
 }
 
-pub fn decimal_as_int<'a>(py: Python, input: &'a impl Input<'a>, decimal: &'a PyAny) -> ValResult<EitherInt<'a>> {
+pub fn decimal_as_int<'a>(input: &'a impl Input<'a>, decimal: &Bound<'a, PyAny>) -> ValResult<EitherInt<'a>> {
+    let py = decimal.py();
     if !decimal.call_method0(intern!(py, "is_finite"))?.extract::<bool>()? {
         return Err(ValError::new(ErrorTypeDefaults::FiniteNumber, input));
     }
     let (numerator, denominator) = decimal
         .call_method0(intern!(py, "as_integer_ratio"))?
-        .extract::<(&PyAny, &PyAny)>()?;
+        .extract::<(Bound<'_, PyAny>, Bound<'_, PyAny>)>()?;
     if denominator.extract::<i64>().map_or(true, |d| d != 1) {
         return Err(ValError::new(ErrorTypeDefaults::IntFromFloat, input));
     }
diff --git a/src/lib.rs b/src/lib.rs
index de4a6d9bd..93fd91252 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -39,7 +39,12 @@ pub use validators::{validate_core_schema, PySome, SchemaValidator};
 use crate::input::Input;
 
 #[pyfunction(signature = (data, *, allow_inf_nan=true, cache_strings=true))]
-pub fn from_json(py: Python, data: &PyAny, allow_inf_nan: bool, cache_strings: bool) -> PyResult<PyObject> {
+pub fn from_json<'py>(
+    py: Python<'py>,
+    data: &Bound<'_, PyAny>,
+    allow_inf_nan: bool,
+    cache_strings: bool,
+) -> PyResult<Bound<'py, PyAny>> {
     let v_match = data
         .validate_bytes(false)
         .map_err(|_| PyTypeError::new_err("Expected bytes, bytearray or str"))?;
@@ -68,7 +73,7 @@ fn get_pydantic_version(py: Python<'_>) -> Option<&'static str> {
 
     PYDANTIC_VERSION
         .get_or_init(py, || {
-            py.import("pydantic")
+            py.import_bound("pydantic")
                 .and_then(|pydantic| pydantic.getattr("__version__")?.extract())
                 .ok()
         })
@@ -84,7 +89,7 @@ pub fn build_info() -> String {
 }
 
 #[pymodule]
-fn _pydantic_core(py: Python, m: &PyModule) -> PyResult<()> {
+fn _pydantic_core(py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
     m.add("__version__", get_pydantic_core_version())?;
     m.add("build_profile", env!("PROFILE"))?;
     m.add("build_info", build_info())?;
diff --git a/src/lookup_key.rs b/src/lookup_key.rs
index d4fba403f..3a92a447c 100644
--- a/src/lookup_key.rs
+++ b/src/lookup_key.rs
@@ -52,22 +52,23 @@ impl fmt::Display for LookupKey {
 }
 
 impl LookupKey {
-    pub fn from_py(py: Python, value: &PyAny, alt_alias: Option<&str>) -> PyResult<Self> {
+    pub fn from_py(py: Python, value: &Bound<'_, PyAny>, alt_alias: Option<&str>) -> PyResult<Self> {
         if let Ok(alias_py) = value.downcast::<PyString>() {
-            let alias: &str = alias_py.extract()?;
+            let alias: String = alias_py.extract()?;
+            let path1 = LookupPath::from_str(py, &alias, Some(alias_py.clone()));
             match alt_alias {
                 Some(alt_alias) => Ok(Self::Choice {
                     key1: alias.to_string(),
-                    py_key1: alias_py.into_py(py),
-                    path1: LookupPath::from_str(py, alias, Some(alias_py)),
+                    py_key1: alias_py.clone().into(),
+                    path1,
                     key2: alt_alias.to_string(),
-                    py_key2: PyString::new(py, alt_alias).into(),
+                    py_key2: PyString::new_bound(py, alt_alias).into(),
                     path2: LookupPath::from_str(py, alt_alias, None),
                 }),
-                None => Ok(Self::simple(py, alias, Some(alias_py))),
+                None => Ok(Self::simple(py, &alias, Some(alias_py.clone()))),
             }
         } else {
-            let list: &PyList = value.downcast()?;
+            let list = value.downcast::<PyList>()?;
             let first = match list.get_item(0) {
                 Ok(v) => v,
                 Err(_) => return py_schema_err!("Lookup paths should have at least one element"),
@@ -76,7 +77,9 @@ impl LookupKey {
                 // list of strings rather than list of lists
                 vec![LookupPath::from_list(list)?]
             } else {
-                list.iter().map(LookupPath::from_list).collect::<PyResult<_>>()?
+                list.iter()
+                    .map(|elem| LookupPath::from_list(&elem))
+                    .collect::<PyResult<_>>()?
             };
 
             if let Some(alt_alias) = alt_alias {
@@ -90,10 +93,10 @@ impl LookupKey {
         Self::simple(py, key, None)
     }
 
-    fn simple(py: Python, key: &str, opt_py_key: Option<&PyString>) -> Self {
-        let py_key = match opt_py_key {
-            Some(py_key) => py_key,
-            None => PyString::new(py, key),
+    fn simple(py: Python, key: &str, opt_py_key: Option<Bound<'_, PyString>>) -> Self {
+        let py_key = match &opt_py_key {
+            Some(py_key) => py_key.clone(),
+            None => PyString::new_bound(py, key),
         };
         Self::Simple {
             key: key.to_string(),
@@ -102,10 +105,10 @@ impl LookupKey {
         }
     }
 
-    pub fn py_get_dict_item<'data, 's>(
+    pub fn py_get_dict_item<'py, 's>(
         &'s self,
-        dict: &'data PyDict,
-    ) -> ValResult<Option<(&'s LookupPath, &'data PyAny)>> {
+        dict: &Bound<'py, PyDict>,
+    ) -> ValResult<Option<(&'s LookupPath, Bound<'py, PyAny>)>> {
         match self {
             Self::Simple { py_key, path, .. } => match dict.get_item(py_key)? {
                 Some(value) => Ok(Some((path, value))),
@@ -128,7 +131,7 @@ impl LookupKey {
                 for path in path_choices {
                     // iterate over the path and plug each value into the py_any from the last step, starting with dict
                     // this could just be a loop but should be somewhat faster with a functional design
-                    if let Some(v) = path.iter().try_fold(dict as &PyAny, |d, loc| loc.py_get_item(d)) {
+                    if let Some(v) = path.iter().try_fold((**dict).clone(), |d, loc| loc.py_get_item(&d)) {
                         // Successfully found an item, return it
                         return Ok(Some((path, v)));
                     }
@@ -139,22 +142,22 @@ impl LookupKey {
         }
     }
 
-    pub fn py_get_string_mapping_item<'data, 's>(
+    pub fn py_get_string_mapping_item<'py, 's>(
         &'s self,
-        dict: &'data PyDict,
-    ) -> ValResult<Option<(&'s LookupPath, StringMapping<'data>)>> {
+        dict: &Bound<'py, PyDict>,
+    ) -> ValResult<Option<(&'s LookupPath, StringMapping<'py>)>> {
         if let Some((path, py_any)) = self.py_get_dict_item(dict)? {
-            let value = StringMapping::new_value(py_any)?;
+            let value = StringMapping::new_value(&py_any)?;
             Ok(Some((path, value)))
         } else {
             Ok(None)
         }
     }
 
-    pub fn py_get_mapping_item<'data, 's>(
+    pub fn py_get_mapping_item<'py, 's>(
         &'s self,
-        dict: &'data PyMapping,
-    ) -> ValResult<Option<(&'s LookupPath, &'data PyAny)>> {
+        dict: &Bound<'py, PyMapping>,
+    ) -> ValResult<Option<(&'s LookupPath, Bound<'py, PyAny>)>> {
         match self {
             Self::Simple { py_key, path, .. } => match dict.get_item(py_key) {
                 Ok(value) => Ok(Some((path, value))),
@@ -177,7 +180,7 @@ impl LookupKey {
                 for path in path_choices {
                     // iterate over the path and plug each value into the py_any from the last step, starting with dict
                     // this could just be a loop but should be somewhat faster with a functional design
-                    if let Some(v) = path.iter().try_fold(dict as &PyAny, |d, loc| loc.py_get_item(d)) {
+                    if let Some(v) = path.iter().try_fold((**dict).clone(), |d, loc| loc.py_get_item(&d)) {
                         // Successfully found an item, return it
                         return Ok(Some((path, v)));
                     }
@@ -188,11 +191,11 @@ impl LookupKey {
         }
     }
 
-    pub fn py_get_attr<'data, 's>(
+    pub fn py_get_attr<'py, 's>(
         &'s self,
-        obj: &'data PyAny,
-        kwargs: Option<&'data PyDict>,
-    ) -> ValResult<Option<(&'s LookupPath, &'data PyAny)>> {
+        obj: &Bound<'py, PyAny>,
+        kwargs: Option<&Bound<'py, PyDict>>,
+    ) -> ValResult<Option<(&'s LookupPath, Bound<'py, PyAny>)>> {
         match self._py_get_attr(obj, kwargs) {
             Ok(v) => Ok(v),
             Err(err) => {
@@ -205,11 +208,11 @@ impl LookupKey {
         }
     }
 
-    pub fn _py_get_attr<'data, 's>(
+    pub fn _py_get_attr<'py, 's>(
         &'s self,
-        obj: &'data PyAny,
-        kwargs: Option<&'data PyDict>,
-    ) -> PyResult<Option<(&'s LookupPath, &'data PyAny)>> {
+        obj: &Bound<'py, PyAny>,
+        kwargs: Option<&Bound<'py, PyDict>>,
+    ) -> PyResult<Option<(&'s LookupPath, Bound<'py, PyAny>)>> {
         if let Some(dict) = kwargs {
             if let Ok(Some(item)) = self.py_get_dict_item(dict) {
                 return Ok(Some(item));
@@ -238,9 +241,9 @@ impl LookupKey {
                 'outer: for path in path_choices {
                     // similar to above, but using `py_get_attrs`, we can't use try_fold because of the extra Err
                     // so we have to loop manually
-                    let mut v = obj;
+                    let mut v = obj.clone();
                     for loc in path.iter() {
-                        v = match loc.py_get_attrs(v) {
+                        v = match loc.py_get_attrs(&v) {
                             Ok(Some(v)) => v,
                             Ok(None) => {
                                 continue 'outer;
@@ -340,20 +343,20 @@ impl fmt::Display for LookupPath {
 }
 
 impl LookupPath {
-    fn from_str(py: Python, key: &str, py_key: Option<&PyString>) -> Self {
+    fn from_str(py: Python, key: &str, py_key: Option<Bound<'_, PyString>>) -> Self {
         let py_key = match py_key {
             Some(py_key) => py_key,
-            None => PyString::new(py, key),
+            None => PyString::new_bound(py, key),
         };
         Self(vec![PathItem::S(key.to_string(), py_key.into())])
     }
 
-    fn from_list(obj: &PyAny) -> PyResult<LookupPath> {
+    fn from_list(obj: &Bound<'_, PyAny>) -> PyResult<LookupPath> {
         let v = obj
-            .extract::<&PyList>()?
+            .downcast::<PyList>()?
             .iter()
             .enumerate()
-            .map(|(index, obj)| PathItem::from_py(index, obj))
+            .map(|(index, obj)| PathItem::from_py(index, &obj))
             .collect::<PyResult<Vec<PathItem>>>()?;
 
         if v.is_empty() {
@@ -419,10 +422,10 @@ impl ToPyObject for PathItem {
 }
 
 impl PathItem {
-    pub fn from_py(index: usize, obj: &PyAny) -> PyResult<Self> {
+    pub fn from_py(index: usize, obj: &Bound<'_, PyAny>) -> PyResult<Self> {
         if let Ok(py_str_key) = obj.downcast::<PyString>() {
             let str_key = py_str_key.to_str()?.to_string();
-            Ok(Self::S(str_key, py_str_key.into()))
+            Ok(Self::S(str_key, py_str_key.clone().into()))
         } else if let Ok(usize_key) = obj.extract::<usize>() {
             if index == 0 {
                 py_err!(PyTypeError; "The first item in an alias path should be a string")
@@ -440,7 +443,7 @@ impl PathItem {
         }
     }
 
-    pub fn py_get_item<'a>(&self, py_any: &'a PyAny) -> Option<&'a PyAny> {
+    pub fn py_get_item<'py>(&self, py_any: &Bound<'py, PyAny>) -> Option<Bound<'py, PyAny>> {
         // we definitely don't want to index strings, so explicitly omit this case
         if py_any.downcast::<PyString>().is_ok() {
             None
@@ -457,7 +460,7 @@ impl PathItem {
         }
     }
 
-    pub fn py_get_attrs<'a>(&self, obj: &'a PyAny) -> PyResult<Option<&'a PyAny>> {
+    pub fn py_get_attrs<'py>(&self, obj: &Bound<'py, PyAny>) -> PyResult<Option<Bound<'py, PyAny>>> {
         match self {
             Self::S(_, py_key) => {
                 // if obj is a dict, we want to use get_item, not getattr
@@ -500,11 +503,11 @@ impl PathItem {
 
 /// wrapper around `getattr` that returns `Ok(None)` for attribute errors, but returns other errors
 /// We don't check `try_from_attributes` because that check was performed on the top level object before we got here
-fn py_get_attrs<'a>(obj: &'a PyAny, attr_name: &Py<PyString>) -> PyResult<Option<&'a PyAny>> {
+fn py_get_attrs<'py>(obj: &Bound<'py, PyAny>, attr_name: &Py<PyString>) -> PyResult<Option<Bound<'py, PyAny>>> {
     match obj.getattr(attr_name.extract::<&PyString>(obj.py())?) {
         Ok(attr) => Ok(Some(attr)),
         Err(err) => {
-            if err.get_type(obj.py()).is_subclass_of::<PyAttributeError>()? {
+            if err.get_type_bound(obj.py()).is_subclass_of::<PyAttributeError>()? {
                 Ok(None)
             } else {
                 Err(err)
diff --git a/src/serializers/computed_fields.rs b/src/serializers/computed_fields.rs
index 43e284fdd..25c5d32e8 100644
--- a/src/serializers/computed_fields.rs
+++ b/src/serializers/computed_fields.rs
@@ -19,15 +19,15 @@ pub(super) struct ComputedFields(Vec<ComputedField>);
 
 impl ComputedFields {
     pub fn new(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<Option<Self>> {
         let py = schema.py();
-        if let Some(computed_fields) = schema.get_as::<&PyList>(intern!(py, "computed_fields"))? {
+        if let Some(computed_fields) = schema.get_as::<Bound<'_, PyList>>(intern!(py, "computed_fields"))? {
             let computed_fields = computed_fields
                 .iter()
-                .map(|field| ComputedField::new(field, config, definitions))
+                .map(|field| ComputedField::new(&field, config, definitions))
                 .collect::<PyResult<Vec<_>>>()?;
             Ok(Some(Self(computed_fields)))
         } else {
@@ -41,11 +41,11 @@ impl ComputedFields {
 
     pub fn to_python(
         &self,
-        model: &PyAny,
-        output_dict: &PyDict,
+        model: &Bound<'_, PyAny>,
+        output_dict: &Bound<'_, PyDict>,
         filter: &SchemaFilter<isize>,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<()> {
         if extra.round_trip {
@@ -60,11 +60,11 @@ impl ComputedFields {
 
     pub fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        model: &PyAny,
+        model: &Bound<'_, PyAny>,
         map: &mut S::SerializeMap,
         filter: &SchemaFilter<isize>,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<(), S::Error> {
         if extra.round_trip {
@@ -72,7 +72,7 @@ impl ComputedFields {
             return Ok(());
         }
         for computed_field in &self.0 {
-            let property_name_py = computed_field.property_name_py.as_ref(model.py());
+            let property_name_py = computed_field.property_name_py.bind(model.py());
             let value = model.getattr(property_name_py).map_err(py_err_se_err)?;
             if extra.exclude_none && value.is_none() {
                 continue;
@@ -84,8 +84,8 @@ impl ComputedFields {
                 let cfs = ComputedFieldSerializer {
                     model,
                     computed_field,
-                    include: next_include,
-                    exclude: next_exclude,
+                    include: next_include.as_ref(),
+                    exclude: next_exclude.as_ref(),
                     extra,
                 };
                 let key = match extra.by_alias {
@@ -110,17 +110,19 @@ struct ComputedField {
 
 impl ComputedField {
     pub fn new(
-        schema: &PyAny,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyAny>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<Self> {
         let py = schema.py();
-        let schema: &PyDict = schema.downcast()?;
-        let property_name: &PyString = schema.get_as_req(intern!(py, "property_name"))?;
+        let schema: &Bound<'_, PyDict> = schema.downcast()?;
+        let property_name: Bound<'_, PyString> = schema.get_as_req(intern!(py, "property_name"))?;
         let return_schema = schema.get_as_req(intern!(py, "return_schema"))?;
-        let serializer = CombinedSerializer::build(return_schema, config, definitions)
+        let serializer = CombinedSerializer::build(&return_schema, config, definitions)
             .map_err(|e| py_schema_error_type!("Computed field `{}`:\n  {}", property_name, e))?;
-        let alias_py: &PyString = schema.get_as(intern!(py, "alias"))?.unwrap_or(property_name);
+        let alias_py = schema
+            .get_as(intern!(py, "alias"))?
+            .unwrap_or_else(|| property_name.clone());
         Ok(Self {
             property_name: property_name.extract()?,
             property_name_py: property_name.into_py(py),
@@ -132,27 +134,27 @@ impl ComputedField {
 
     fn to_python(
         &self,
-        model: &PyAny,
-        output_dict: &PyDict,
+        model: &Bound<'_, PyAny>,
+        output_dict: &Bound<'_, PyDict>,
         filter: &SchemaFilter<isize>,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<()> {
         let py = model.py();
-        let property_name_py = self.property_name_py.as_ref(py);
+        let property_name_py = self.property_name_py.bind(py);
 
         if let Some((next_include, next_exclude)) = filter.key_filter(property_name_py, include, exclude)? {
             let next_value = model.getattr(property_name_py)?;
 
             let value = self
                 .serializer
-                .to_python(next_value, next_include, next_exclude, extra)?;
+                .to_python(&next_value, next_include.as_ref(), next_exclude.as_ref(), extra)?;
             if extra.exclude_none && value.is_none(py) {
                 return Ok(());
             }
             let key = match extra.by_alias {
-                true => self.alias_py.as_ref(py),
+                true => self.alias_py.bind(py),
                 false => property_name_py,
             };
             output_dict.set_item(key, value)?;
@@ -162,10 +164,10 @@ impl ComputedField {
 }
 
 pub(crate) struct ComputedFieldSerializer<'py> {
-    model: &'py PyAny,
+    model: &'py Bound<'py, PyAny>,
     computed_field: &'py ComputedField,
-    include: Option<&'py PyAny>,
-    exclude: Option<&'py PyAny>,
+    include: Option<&'py Bound<'py, PyAny>>,
+    exclude: Option<&'py Bound<'py, PyAny>>,
     extra: &'py Extra<'py>,
 }
 
@@ -182,10 +184,10 @@ impl_py_gc_traverse!(ComputedFieldSerializer<'_> { computed_field });
 impl<'py> Serialize for ComputedFieldSerializer<'py> {
     fn serialize<S: serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
         let py = self.model.py();
-        let property_name_py = self.computed_field.property_name_py.as_ref(py);
+        let property_name_py = self.computed_field.property_name_py.bind(py);
         let next_value = self.model.getattr(property_name_py).map_err(py_err_se_err)?;
         let s = PydanticSerializer::new(
-            next_value,
+            &next_value,
             &self.computed_field.serializer,
             self.include,
             self.exclude,
diff --git a/src/serializers/config.rs b/src/serializers/config.rs
index 422ee4162..2863d68d9 100644
--- a/src/serializers/config.rs
+++ b/src/serializers/config.rs
@@ -2,9 +2,9 @@ use std::borrow::Cow;
 use std::str::{from_utf8, FromStr, Utf8Error};
 
 use base64::Engine;
+use pyo3::intern;
 use pyo3::prelude::*;
-use pyo3::types::{PyDelta, PyDict};
-use pyo3::{intern, PyNativeType};
+use pyo3::types::{PyDelta, PyDict, PyString};
 
 use serde::ser::Error;
 
@@ -23,7 +23,7 @@ pub(crate) struct SerializationConfig {
 }
 
 impl SerializationConfig {
-    pub fn from_config(config: Option<&PyDict>) -> PyResult<Self> {
+    pub fn from_config(config: Option<&Bound<'_, PyDict>>) -> PyResult<Self> {
         let timedelta_mode = TimedeltaMode::from_config(config)?;
         let bytes_mode = BytesMode::from_config(config)?;
         let inf_nan_mode = InfNanMode::from_config(config)?;
@@ -44,7 +44,7 @@ impl SerializationConfig {
 }
 
 pub trait FromConfig {
-    fn from_config(config: Option<&PyDict>) -> PyResult<Self>
+    fn from_config(config: Option<&Bound<'_, PyDict>>) -> PyResult<Self>
     where
         Self: Sized;
 }
@@ -72,12 +72,12 @@ macro_rules! serialization_mode {
         }
 
         impl FromConfig for $name {
-            fn from_config(config: Option<&PyDict>) -> PyResult<Self> {
+            fn from_config(config: Option<&Bound<'_, PyDict>>) -> PyResult<Self> {
                 let Some(config_dict) = config else {
                     return Ok(Self::default());
                 };
-                let raw_mode = config_dict.get_as::<&str>(intern!(config_dict.py(), $config_key))?;
-                raw_mode.map_or_else(|| Ok(Self::default()), Self::from_str)
+                let raw_mode = config_dict.get_as::<Bound<'_, PyString>>(intern!(config_dict.py(), $config_key))?;
+                raw_mode.map_or_else(|| Ok(Self::default()), |raw| Self::from_str(&raw.to_cow()?))
             }
         }
 
@@ -107,7 +107,7 @@ serialization_mode! {
 }
 
 impl TimedeltaMode {
-    fn total_seconds(py_timedelta: &PyDelta) -> PyResult<&PyAny> {
+    fn total_seconds<'py>(py_timedelta: &Bound<'py, PyDelta>) -> PyResult<Bound<'py, PyAny>> {
         py_timedelta.call_method0(intern!(py_timedelta.py(), "total_seconds"))
     }
 
@@ -121,7 +121,7 @@ impl TimedeltaMode {
                 // convert to int via a py timedelta not duration since we know this this case the input would have
                 // been a py timedelta
                 let py_timedelta = either_delta.try_into_py(py)?;
-                let seconds = Self::total_seconds(py_timedelta)?;
+                let seconds = Self::total_seconds(&py_timedelta)?;
                 Ok(seconds.into_py(py))
             }
         }
@@ -135,7 +135,7 @@ impl TimedeltaMode {
             }
             Self::Float => {
                 let py_timedelta = either_delta.try_into_py(py)?;
-                let seconds: f64 = Self::total_seconds(py_timedelta)?.extract()?;
+                let seconds: f64 = Self::total_seconds(&py_timedelta)?.extract()?;
                 Ok(seconds.to_string().into())
             }
         }
@@ -154,7 +154,7 @@ impl TimedeltaMode {
             }
             Self::Float => {
                 let py_timedelta = either_delta.try_into_py(py).map_err(py_err_se_err)?;
-                let seconds = Self::total_seconds(py_timedelta).map_err(py_err_se_err)?;
+                let seconds = Self::total_seconds(&py_timedelta).map_err(py_err_se_err)?;
                 let seconds: f64 = seconds.extract().map_err(py_err_se_err)?;
                 serializer.serialize_f64(seconds)
             }
@@ -163,7 +163,7 @@ impl TimedeltaMode {
 }
 
 impl BytesMode {
-    pub fn bytes_to_string<'py>(&self, py: Python, bytes: &'py [u8]) -> PyResult<Cow<'py, str>> {
+    pub fn bytes_to_string<'a>(&self, py: Python, bytes: &'a [u8]) -> PyResult<Cow<'a, str>> {
         match self {
             Self::Utf8 => from_utf8(bytes)
                 .map_err(|err| utf8_py_error(py, err, bytes))
@@ -190,15 +190,14 @@ impl BytesMode {
 }
 
 pub fn utf8_py_error(py: Python, err: Utf8Error, data: &[u8]) -> PyErr {
-    match pyo3::exceptions::PyUnicodeDecodeError::new_utf8(py, data, err) {
-        Ok(decode_err) => PyErr::from_value(decode_err),
+    match pyo3::exceptions::PyUnicodeDecodeError::new_utf8_bound(py, data, err) {
+        Ok(decode_err) => PyErr::from_value_bound(decode_err.into_any()),
         Err(err) => err,
     }
 }
 
 impl FromPyObject<'_> for InfNanMode {
-    fn extract(ob: &'_ PyAny) -> PyResult<Self> {
-        let s = ob.extract::<&str>()?;
-        Self::from_str(s)
+    fn extract_bound(ob: &Bound<'_, PyAny>) -> PyResult<Self> {
+        Self::from_str(ob.downcast::<PyString>()?.to_str()?)
     }
 }
diff --git a/src/serializers/extra.rs b/src/serializers/extra.rs
index 3cff3f370..4067892cf 100644
--- a/src/serializers/extra.rs
+++ b/src/serializers/extra.rs
@@ -44,8 +44,8 @@ impl SerializationState {
         exclude_none: bool,
         round_trip: bool,
         serialize_unknown: bool,
-        fallback: Option<&'py PyAny>,
-        context: Option<&'py PyAny>,
+        fallback: Option<&'py Bound<'py, PyAny>>,
+        context: Option<&'py Bound<'py, PyAny>>,
     ) -> Extra<'py> {
         Extra::new(
             py,
@@ -88,11 +88,11 @@ pub(crate) struct Extra<'a> {
     // data representing the current model field
     // that is being serialized, if this is a model serializer
     // it will be None otherwise
-    pub model: Option<&'a PyAny>,
+    pub model: Option<&'a Bound<'a, PyAny>>,
     pub field_name: Option<&'a str>,
     pub serialize_unknown: bool,
-    pub fallback: Option<&'a PyAny>,
-    pub context: Option<&'a PyAny>,
+    pub fallback: Option<&'a Bound<'a, PyAny>>,
+    pub context: Option<&'a Bound<'a, PyAny>>,
 }
 
 impl<'a> Extra<'a> {
@@ -109,8 +109,8 @@ impl<'a> Extra<'a> {
         config: &'a SerializationConfig,
         rec_guard: &'a SerRecursionState,
         serialize_unknown: bool,
-        fallback: Option<&'a PyAny>,
-        context: Option<&'a PyAny>,
+        fallback: Option<&'a Bound<'a, PyAny>>,
+        context: Option<&'a Bound<'a, PyAny>>,
     ) -> Self {
         Self {
             mode,
@@ -139,7 +139,7 @@ impl<'a> Extra<'a> {
         // See how validation has &mut ValidationState passed around; we should aim to refactor
         // to match that.
         self: &'x mut &'y Self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         def_ref_id: usize,
     ) -> PyResult<RecursionGuard<'x, &'y Self>> {
         RecursionGuard::new(self, value.as_ptr() as usize, def_ref_id).map_err(|e| match e {
@@ -148,7 +148,7 @@ impl<'a> Extra<'a> {
         })
     }
 
-    pub fn serialize_infer<'py>(&'py self, value: &'py PyAny) -> super::infer::SerializeInfer<'py> {
+    pub fn serialize_infer<'py>(&'py self, value: &'py Bound<'py, PyAny>) -> super::infer::SerializeInfer<'py> {
         super::infer::SerializeInfer::new(value, None, None, self)
     }
 }
@@ -203,11 +203,11 @@ impl ExtraOwned {
             config: extra.config.clone(),
             rec_guard: extra.rec_guard.clone(),
             check: extra.check,
-            model: extra.model.map(Into::into),
+            model: extra.model.map(|model| model.clone().into()),
             field_name: extra.field_name.map(ToString::to_string),
             serialize_unknown: extra.serialize_unknown,
-            fallback: extra.fallback.map(Into::into),
-            context: extra.context.map(Into::into),
+            fallback: extra.fallback.map(|fallback| fallback.clone().into()),
+            context: extra.context.map(|context| context.clone().into()),
         }
     }
 
@@ -224,11 +224,11 @@ impl ExtraOwned {
             config: &self.config,
             rec_guard: &self.rec_guard,
             check: self.check,
-            model: self.model.as_ref().map(|m| m.as_ref(py)),
+            model: self.model.as_ref().map(|m| m.bind(py)),
             field_name: self.field_name.as_deref(),
             serialize_unknown: self.serialize_unknown,
-            fallback: self.fallback.as_ref().map(|m| m.as_ref(py)),
-            context: self.context.as_ref().map(|m| m.as_ref(py)),
+            fallback: self.fallback.as_ref().map(|m| m.bind(py)),
+            context: self.context.as_ref().map(|m| m.bind(py)),
         }
     }
 }
@@ -299,7 +299,7 @@ impl CollectWarnings {
         }
     }
 
-    pub fn on_fallback_py(&self, field_type: &str, value: &PyAny, extra: &Extra) -> PyResult<()> {
+    pub fn on_fallback_py(&self, field_type: &str, value: &Bound<'_, PyAny>, extra: &Extra) -> PyResult<()> {
         // special case for None as it's very common e.g. as a default value
         if value.is_none() {
             Ok(())
@@ -314,7 +314,7 @@ impl CollectWarnings {
     pub fn on_fallback_ser<S: serde::ser::Serializer>(
         &self,
         field_type: &str,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         extra: &Extra,
     ) -> Result<(), S::Error> {
         // special case for None as it's very common e.g. as a default value
@@ -331,9 +331,12 @@ impl CollectWarnings {
         }
     }
 
-    fn fallback_warning(&self, field_type: &str, value: &PyAny) {
+    fn fallback_warning(&self, field_type: &str, value: &Bound<'_, PyAny>) {
         if self.active {
-            let type_name = value.get_type().name().unwrap_or("<unknown python object>");
+            let type_name = value
+                .get_type()
+                .qualname()
+                .unwrap_or_else(|_| "<unknown python object>".to_owned());
             self.add_warning(format!(
                 "Expected `{field_type}` but got `{type_name}` - serialized value may not be as expected"
             ));
@@ -354,8 +357,8 @@ impl CollectWarnings {
             match *self.warnings.borrow() {
                 Some(ref warnings) => {
                     let message = format!("Pydantic serializer warnings:\n  {}", warnings.join("\n  "));
-                    let user_warning_type = py.import("builtins")?.getattr("UserWarning")?;
-                    PyErr::warn(py, user_warning_type, &message, 0)
+                    let user_warning_type = py.import_bound("builtins")?.getattr("UserWarning")?;
+                    PyErr::warn_bound(py, &user_warning_type, &message, 0)
                 }
                 _ => Ok(()),
             }
diff --git a/src/serializers/fields.rs b/src/serializers/fields.rs
index 4d192d344..f2dc50eb7 100644
--- a/src/serializers/fields.rs
+++ b/src/serializers/fields.rs
@@ -39,7 +39,9 @@ impl SerField {
         serializer: Option<CombinedSerializer>,
         required: bool,
     ) -> Self {
-        let alias_py = alias.as_ref().map(|alias| PyString::new(py, alias.as_str()).into());
+        let alias_py = alias
+            .as_ref()
+            .map(|alias| PyString::new_bound(py, alias.as_str()).into());
         Self {
             key_py,
             alias,
@@ -49,13 +51,13 @@ impl SerField {
         }
     }
 
-    pub fn get_key_py<'py>(&'py self, py: Python<'py>, extra: &Extra) -> &'py PyAny {
+    pub fn get_key_py<'py>(&'py self, py: Python<'py>, extra: &Extra) -> &Bound<'py, PyAny> {
         if extra.by_alias {
             if let Some(ref alias_py) = self.alias_py {
-                return alias_py.as_ref(py);
+                return alias_py.bind(py);
             }
         }
-        self.key_py.as_ref(py)
+        self.key_py.bind(py)
     }
 
     pub fn get_key_json<'a>(&'a self, key_str: &'a str, extra: &Extra) -> Cow<'a, str> {
@@ -68,7 +70,7 @@ impl SerField {
     }
 }
 
-fn exclude_default(value: &PyAny, extra: &Extra, serializer: &CombinedSerializer) -> PyResult<bool> {
+fn exclude_default(value: &Bound<'_, PyAny>, extra: &Extra, serializer: &CombinedSerializer) -> PyResult<bool> {
     if extra.exclude_defaults {
         if let Some(default) = serializer.get_default(value.py())? {
             if value.eq(default)? {
@@ -128,10 +130,10 @@ impl GeneralFieldsSerializer {
         }
     }
 
-    fn extract_dicts<'a>(&self, value: &'a PyAny) -> Option<(&'a PyDict, Option<&'a PyDict>)> {
+    fn extract_dicts<'a>(&self, value: &Bound<'a, PyAny>) -> Option<(Bound<'a, PyDict>, Option<Bound<'a, PyDict>>)> {
         match self.mode {
             FieldsMode::ModelExtra => {
-                if let Ok((main_dict, extra_dict)) = value.extract::<(&PyDict, &PyDict)>() {
+                if let Ok((main_dict, extra_dict)) = value.extract() {
                     Some((main_dict, Some(extra_dict)))
                 } else {
                     None
@@ -139,7 +141,7 @@ impl GeneralFieldsSerializer {
             }
             _ => {
                 if let Ok(main_dict) = value.downcast::<PyDict>() {
-                    Some((main_dict, None))
+                    Some((main_dict.clone(), None))
                 } else {
                     None
                 }
@@ -150,19 +152,19 @@ impl GeneralFieldsSerializer {
     pub(crate) fn main_to_python<'py>(
         &self,
         py: Python<'py>,
-        main_iter: impl Iterator<Item = PyResult<(&'py PyAny, &'py PyAny)>>,
-        include: Option<&'py PyAny>,
-        exclude: Option<&'py PyAny>,
+        main_iter: impl Iterator<Item = PyResult<(Bound<'py, PyAny>, Bound<'py, PyAny>)>>,
+        include: Option<&Bound<'py, PyAny>>,
+        exclude: Option<&Bound<'py, PyAny>>,
         extra: Extra,
-    ) -> PyResult<&'py PyDict> {
-        let output_dict = PyDict::new(py);
+    ) -> PyResult<Bound<'py, PyDict>> {
+        let output_dict = PyDict::new_bound(py);
         let mut used_req_fields: usize = 0;
 
         // NOTE! we maintain the order of the input dict assuming that's right
         for result in main_iter {
             let (key, value) = result?;
-            let key_str = key_str(key)?;
-            let op_field = self.fields.get(key_str);
+            let key_str = key_str(&key)?;
+            let op_field = self.fields.get(key_str.as_ref());
             if extra.exclude_none && value.is_none() {
                 if let Some(field) = op_field {
                     if field.required {
@@ -172,14 +174,19 @@ impl GeneralFieldsSerializer {
                 continue;
             }
             let field_extra = Extra {
-                field_name: Some(key_str),
+                field_name: Some(&key_str),
                 ..extra
             };
-            if let Some((next_include, next_exclude)) = self.filter.key_filter(key, include, exclude)? {
+            if let Some((next_include, next_exclude)) = self.filter.key_filter(&key, include, exclude)? {
                 if let Some(field) = op_field {
                     if let Some(ref serializer) = field.serializer {
-                        if !exclude_default(value, &field_extra, serializer)? {
-                            let value = serializer.to_python(value, next_include, next_exclude, &field_extra)?;
+                        if !exclude_default(&value, &field_extra, serializer)? {
+                            let value = serializer.to_python(
+                                &value,
+                                next_include.as_ref(),
+                                next_exclude.as_ref(),
+                                &field_extra,
+                            )?;
                             let output_key = field.get_key_py(output_dict.py(), &field_extra);
                             output_dict.set_item(output_key, value)?;
                         }
@@ -190,8 +197,10 @@ impl GeneralFieldsSerializer {
                     }
                 } else if self.mode == FieldsMode::TypedDictAllow {
                     let value = match &self.extra_serializer {
-                        Some(serializer) => serializer.to_python(value, next_include, next_exclude, &field_extra)?,
-                        None => infer_to_python(value, next_include, next_exclude, &field_extra)?,
+                        Some(serializer) => {
+                            serializer.to_python(&value, next_include.as_ref(), next_exclude.as_ref(), &field_extra)?
+                        }
+                        None => infer_to_python(&value, next_include.as_ref(), next_exclude.as_ref(), &field_extra)?,
                     };
                     output_dict.set_item(key, value)?;
                 } else if field_extra.check == SerCheck::Strict {
@@ -214,11 +223,11 @@ impl GeneralFieldsSerializer {
 
     pub(crate) fn main_serde_serialize<'py, S: serde::ser::Serializer>(
         &self,
-        main_iter: impl Iterator<Item = PyResult<(&'py PyAny, &'py PyAny)>>,
+        main_iter: impl Iterator<Item = PyResult<(Bound<'py, PyAny>, Bound<'py, PyAny>)>>,
         expected_len: usize,
         serializer: S,
-        include: Option<&'py PyAny>,
-        exclude: Option<&'py PyAny>,
+        include: Option<&Bound<'py, PyAny>>,
+        exclude: Option<&Bound<'py, PyAny>>,
         extra: Extra,
     ) -> Result<S::SerializeMap, S::Error> {
         // NOTE! As above, we maintain the order of the input dict assuming that's right
@@ -230,26 +239,31 @@ impl GeneralFieldsSerializer {
             if extra.exclude_none && value.is_none() {
                 continue;
             }
-            let key_str = key_str(key).map_err(py_err_se_err)?;
+            let key_str = key_str(&key).map_err(py_err_se_err)?;
             let field_extra = Extra {
-                field_name: Some(key_str),
+                field_name: Some(&key_str),
                 ..extra
             };
 
-            let filter = self.filter.key_filter(key, include, exclude).map_err(py_err_se_err)?;
+            let filter = self.filter.key_filter(&key, include, exclude).map_err(py_err_se_err)?;
             if let Some((next_include, next_exclude)) = filter {
-                if let Some(field) = self.fields.get(key_str) {
+                if let Some(field) = self.fields.get(key_str.as_ref()) {
                     if let Some(ref serializer) = field.serializer {
-                        if !exclude_default(value, &field_extra, serializer).map_err(py_err_se_err)? {
-                            let s =
-                                PydanticSerializer::new(value, serializer, next_include, next_exclude, &field_extra);
-                            let output_key = field.get_key_json(key_str, &field_extra);
+                        if !exclude_default(&value, &field_extra, serializer).map_err(py_err_se_err)? {
+                            let s = PydanticSerializer::new(
+                                &value,
+                                serializer,
+                                next_include.as_ref(),
+                                next_exclude.as_ref(),
+                                &field_extra,
+                            );
+                            let output_key = field.get_key_json(&key_str, &field_extra);
                             map.serialize_entry(&output_key, &s)?;
                         }
                     }
                 } else if self.mode == FieldsMode::TypedDictAllow {
-                    let output_key = infer_json_key(key, &field_extra).map_err(py_err_se_err)?;
-                    let s = SerializeInfer::new(value, next_include, next_exclude, &field_extra);
+                    let output_key = infer_json_key(&key, &field_extra).map_err(py_err_se_err)?;
+                    let s = SerializeInfer::new(&value, next_include.as_ref(), next_exclude.as_ref(), &field_extra);
                     map.serialize_entry(&output_key, &s)?;
                 }
                 // no error case here since unions (which need the error case) use `to_python(..., mode='json')`
@@ -260,10 +274,10 @@ impl GeneralFieldsSerializer {
 
     pub(crate) fn add_computed_fields_python(
         &self,
-        model: Option<&PyAny>,
-        output_dict: &PyDict,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        model: Option<&Bound<'_, PyAny>>,
+        output_dict: &Bound<'_, PyDict>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<()> {
         if let Some(ref computed_fields) = self.computed_fields {
@@ -277,10 +291,10 @@ impl GeneralFieldsSerializer {
 
     pub(crate) fn add_computed_fields_json<S: serde::ser::Serializer>(
         &self,
-        model: Option<&PyAny>,
+        model: Option<&Bound<'_, PyAny>>,
         map: &mut S::SerializeMap,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<(), S::Error> {
         if let Some(ref computed_fields) = self.computed_fields {
@@ -304,9 +318,9 @@ impl_py_gc_traverse!(GeneralFieldsSerializer {
 impl TypeSerializer for GeneralFieldsSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         let py = value.py();
@@ -322,7 +336,7 @@ impl TypeSerializer for GeneralFieldsSerializer {
             return infer_to_python(value, include, exclude, &td_extra);
         };
 
-        let output_dict = self.main_to_python(py, dict_items(main_dict), include, exclude, td_extra)?;
+        let output_dict = self.main_to_python(py, dict_items(&main_dict), include, exclude, td_extra)?;
 
         // this is used to include `__pydantic_extra__` in serialization on models
         if let Some(extra_dict) = extra_dict {
@@ -330,29 +344,31 @@ impl TypeSerializer for GeneralFieldsSerializer {
                 if extra.exclude_none && value.is_none() {
                     continue;
                 }
-                if let Some((next_include, next_exclude)) = self.filter.key_filter(key, include, exclude)? {
+                if let Some((next_include, next_exclude)) = self.filter.key_filter(&key, include, exclude)? {
                     let value = match &self.extra_serializer {
-                        Some(serializer) => serializer.to_python(value, next_include, next_exclude, extra)?,
-                        None => infer_to_python(value, next_include, next_exclude, extra)?,
+                        Some(serializer) => {
+                            serializer.to_python(&value, next_include.as_ref(), next_exclude.as_ref(), extra)?
+                        }
+                        None => infer_to_python(&value, next_include.as_ref(), next_exclude.as_ref(), extra)?,
                     };
                     output_dict.set_item(key, value)?;
                 }
             }
         }
-        self.add_computed_fields_python(model, output_dict, include, exclude, extra)?;
+        self.add_computed_fields_python(model, &output_dict, include, exclude, extra)?;
         Ok(output_dict.into_py(py))
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         self._invalid_as_json_key(key, extra, "fields")
     }
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         let (main_dict, extra_dict) = if let Some(main_extra_dict) = self.extract_dicts(value) {
@@ -374,7 +390,7 @@ impl TypeSerializer for GeneralFieldsSerializer {
         // NOTE! As above, we maintain the order of the input dict assuming that's right
         // we don't both with `used_fields` here because on unions, `to_python(..., mode='json')` is used
         let mut map = self.main_serde_serialize(
-            dict_items(main_dict),
+            dict_items(&main_dict),
             expected_len,
             serializer,
             include,
@@ -388,10 +404,10 @@ impl TypeSerializer for GeneralFieldsSerializer {
                 if extra.exclude_none && value.is_none() {
                     continue;
                 }
-                let filter = self.filter.key_filter(key, include, exclude).map_err(py_err_se_err)?;
+                let filter = self.filter.key_filter(&key, include, exclude).map_err(py_err_se_err)?;
                 if let Some((next_include, next_exclude)) = filter {
-                    let output_key = infer_json_key(key, extra).map_err(py_err_se_err)?;
-                    let s = SerializeInfer::new(value, next_include, next_exclude, extra);
+                    let output_key = infer_json_key(&key, extra).map_err(py_err_se_err)?;
+                    let s = SerializeInfer::new(&value, next_include.as_ref(), next_exclude.as_ref(), extra);
                     map.serialize_entry(&output_key, &s)?;
                 }
             }
@@ -406,11 +422,13 @@ impl TypeSerializer for GeneralFieldsSerializer {
     }
 }
 
-fn key_str(key: &PyAny) -> PyResult<&str> {
-    key.downcast::<PyString>()?.to_str()
+fn key_str<'a>(key: &'a Bound<'_, PyAny>) -> PyResult<Cow<'a, str>> {
+    key.downcast::<PyString>()?.to_cow()
 }
 
-fn dict_items(main_dict: &PyDict) -> impl Iterator<Item = PyResult<(&PyAny, &PyAny)>> {
+fn dict_items<'py>(
+    main_dict: &'_ Bound<'py, PyDict>,
+) -> impl Iterator<Item = PyResult<(Bound<'py, PyAny>, Bound<'py, PyAny>)>> {
     // Collect items before iterating to prevent panic on dict mutation.
     // Use a SmallVec to avoid heap allocation for models with a reasonable number of fields.
     let main_items: SmallVec<[_; 16]> = main_dict.iter().collect();
diff --git a/src/serializers/filter.rs b/src/serializers/filter.rs
index 0efec56e8..4af04bb6c 100644
--- a/src/serializers/filter.rs
+++ b/src/serializers/filter.rs
@@ -15,48 +15,53 @@ pub(crate) struct SchemaFilter<T> {
     exclude: Option<AHashSet<T>>,
 }
 
-fn map_negative_index(value: &PyAny, len: Option<usize>) -> PyResult<&PyAny> {
+fn map_negative_index<'py>(value: &Bound<'py, PyAny>, len: Option<usize>) -> PyResult<Bound<'py, PyAny>> {
     let py = value.py();
     match len {
         Some(len) => Ok(value
             .call_method1(intern!(py, "__mod__"), (len,))
-            .map_or_else(|_| value, |v| v)),
+            .unwrap_or_else(|_| value.clone())),
         None => {
             // check that it's not negative
-            let negative = value.call_method1(intern!(py, "__lt__"), (0,))?.is_true()?;
+            let negative = value.call_method1(intern!(py, "__lt__"), (0,))?.is_truthy()?;
             if negative {
                 Err(PyValueError::new_err(
                     "Negative indices cannot be used to exclude items on unsized iterables",
                 ))
             } else {
-                Ok(value)
+                Ok(value.clone())
             }
         }
     }
 }
 
-fn map_negative_indices(include_or_exclude: &PyAny, len: Option<usize>) -> PyResult<&PyAny> {
+fn map_negative_indices<'py>(
+    include_or_exclude: &Bound<'py, PyAny>,
+    len: Option<usize>,
+) -> PyResult<Bound<'py, PyAny>> {
     let py = include_or_exclude.py();
     if let Ok(exclude_dict) = include_or_exclude.downcast::<PyDict>() {
-        let out = PyDict::new(py);
-        for (k, v) in exclude_dict {
-            out.set_item(map_negative_index(k, len)?, v)?;
+        let out = PyDict::new_bound(py);
+        for (k, v) in exclude_dict.iter() {
+            out.set_item(map_negative_index(&k, len)?, v)?;
         }
-        Ok(out)
+        Ok(out.into_any())
     } else if let Ok(exclude_set) = include_or_exclude.downcast::<PySet>() {
         let mut values = Vec::with_capacity(exclude_set.len());
-        for v in exclude_set {
-            values.push(map_negative_index(v, len)?);
+        for v in exclude_set.iter() {
+            values.push(map_negative_index(&v, len)?);
         }
-        Ok(PySet::new(py, values)?)
+        Ok(PySet::new_bound(py, &values)?.into_any())
     } else {
         // return as is and deal with the error later
-        Ok(include_or_exclude)
+        Ok(include_or_exclude.clone())
     }
 }
 
+type NextFilters<'py> = Option<(Option<Bound<'py, PyAny>>, Option<Bound<'py, PyAny>>)>;
+
 impl SchemaFilter<usize> {
-    pub fn from_schema(schema: &PyDict) -> PyResult<Self> {
+    pub fn from_schema(schema: &Bound<'_, PyDict>) -> PyResult<Self> {
         let py = schema.py();
         match schema.get_as::<&PyDict>(intern!(py, "serialization"))? {
             Some(ser) => {
@@ -90,33 +95,33 @@ impl SchemaFilter<usize> {
     pub fn index_filter<'py>(
         &self,
         index: usize,
-        include: Option<&'py PyAny>,
-        exclude: Option<&'py PyAny>,
+        include: Option<&Bound<'py, PyAny>>,
+        exclude: Option<&Bound<'py, PyAny>>,
         len: Option<usize>,
-    ) -> PyResult<Option<(Option<&'py PyAny>, Option<&'py PyAny>)>> {
+    ) -> PyResult<NextFilters<'py>> {
         let include = include.map(|v| map_negative_indices(v, len)).transpose()?;
         let exclude = exclude.map(|v| map_negative_indices(v, len)).transpose()?;
-        self.filter(index, index, include, exclude)
+        self.filter(index, index, include.as_ref(), exclude.as_ref())
     }
 }
 
 impl SchemaFilter<isize> {
-    pub fn from_set_hash(include: Option<&PyAny>, exclude: Option<&PyAny>) -> PyResult<Self> {
+    pub fn from_set_hash(include: Option<&Bound<'_, PyAny>>, exclude: Option<&Bound<'_, PyAny>>) -> PyResult<Self> {
         let include = Self::build_set_hashes(include)?;
         let exclude = Self::build_set_hashes(exclude)?;
         Ok(Self { include, exclude })
     }
 
-    fn build_set_hashes(v: Option<&PyAny>) -> PyResult<Option<AHashSet<isize>>> {
+    fn build_set_hashes(v: Option<&Bound<'_, PyAny>>) -> PyResult<Option<AHashSet<isize>>> {
         match v {
             Some(value) => {
                 if value.is_none() {
                     Ok(None)
                 } else {
-                    let py_set: &PySet = value.downcast()?;
+                    let py_set = value.downcast::<PySet>()?;
                     let mut set: AHashSet<isize> = AHashSet::with_capacity(py_set.len());
 
-                    for item in py_set {
+                    for item in py_set.iter() {
                         set.insert(item.hash()?);
                     }
                     Ok(Some(set))
@@ -128,10 +133,10 @@ impl SchemaFilter<isize> {
 
     pub fn key_filter<'py>(
         &self,
-        key: &PyAny,
-        include: Option<&'py PyAny>,
-        exclude: Option<&'py PyAny>,
-    ) -> PyResult<Option<(Option<&'py PyAny>, Option<&'py PyAny>)>> {
+        key: &Bound<'_, PyAny>,
+        include: Option<&Bound<'py, PyAny>>,
+        exclude: Option<&Bound<'py, PyAny>>,
+    ) -> PyResult<NextFilters<'py>> {
         let hash = key.hash()?;
         self.filter(key, hash, include, exclude)
     }
@@ -150,17 +155,17 @@ trait FilterLogic<T: Eq + Copy> {
         &self,
         py_key: impl ToPyObject + Copy,
         int_key: T,
-        include: Option<&'py PyAny>,
-        exclude: Option<&'py PyAny>,
-    ) -> PyResult<Option<(Option<&'py PyAny>, Option<&'py PyAny>)>> {
-        let mut next_exclude: Option<&PyAny> = None;
+        include: Option<&Bound<'py, PyAny>>,
+        exclude: Option<&Bound<'py, PyAny>>,
+    ) -> PyResult<NextFilters<'py>> {
+        let mut next_exclude = None;
         if let Some(exclude) = exclude {
             if exclude.is_none() {
                 // Do nothing; place this check at the top for performance in the common case
             } else if let Ok(exclude_dict) = exclude.downcast::<PyDict>() {
                 let op_exc_value = merge_all_value(exclude_dict, py_key)?;
                 if let Some(exc_value) = op_exc_value {
-                    if is_ellipsis_like(exc_value) {
+                    if is_ellipsis_like(&exc_value) {
                         // if the index is in exclude, and the exclude value is `None`, we want to omit this index/item
                         return Ok(None);
                     }
@@ -190,7 +195,7 @@ trait FilterLogic<T: Eq + Copy> {
 
                 if let Some(inc_value) = op_inc_value {
                     // if the index is in include, we definitely want to include this index
-                    return if is_ellipsis_like(inc_value) {
+                    return if is_ellipsis_like(&inc_value) {
                         Ok(Some((None, next_exclude)))
                     } else {
                         Ok(Some((Some(inc_value), next_exclude)))
@@ -262,10 +267,10 @@ impl AnyFilter {
 
     pub fn key_filter<'py>(
         &self,
-        key: &PyAny,
-        include: Option<&'py PyAny>,
-        exclude: Option<&'py PyAny>,
-    ) -> PyResult<Option<(Option<&'py PyAny>, Option<&'py PyAny>)>> {
+        key: &Bound<'_, PyAny>,
+        include: Option<&Bound<'py, PyAny>>,
+        exclude: Option<&Bound<'py, PyAny>>,
+    ) -> PyResult<NextFilters<'py>> {
         // just use 0 for the int_key, it's always ignored in the implementation here
         self.filter(key, 0, include, exclude)
     }
@@ -273,25 +278,25 @@ impl AnyFilter {
     pub fn index_filter<'py>(
         &self,
         index: usize,
-        include: Option<&'py PyAny>,
-        exclude: Option<&'py PyAny>,
+        include: Option<&Bound<'py, PyAny>>,
+        exclude: Option<&Bound<'py, PyAny>>,
         len: Option<usize>,
-    ) -> PyResult<Option<(Option<&'py PyAny>, Option<&'py PyAny>)>> {
+    ) -> PyResult<NextFilters<'py>> {
         let include = include.map(|v| map_negative_indices(v, len)).transpose()?;
         let exclude = exclude.map(|v| map_negative_indices(v, len)).transpose()?;
-        self.filter(index, index, include, exclude)
+        self.filter(index, index, include.as_ref(), exclude.as_ref())
     }
 }
 
 /// if a `__contains__` method exists, call it with the key and `__all__`, and return the result
 /// if it doesn't exist, or calling it fails (e.g. it's not a function), return `None`
-fn check_contains(obj: &PyAny, py_key: impl ToPyObject + Copy) -> PyResult<Option<bool>> {
+fn check_contains(obj: &Bound<'_, PyAny>, py_key: impl ToPyObject + Copy) -> PyResult<Option<bool>> {
     let py = obj.py();
     match obj.getattr(intern!(py, "__contains__")) {
         Ok(contains_method) => {
             if let Ok(result) = contains_method.call1((py_key.to_object(py),)) {
                 Ok(Some(
-                    result.is_true()? || contains_method.call1((intern!(py, "__all__"),))?.is_true()?,
+                    result.is_truthy()? || contains_method.call1((intern!(py, "__all__"),))?.is_truthy()?,
                 ))
             } else {
                 Ok(None)
@@ -315,8 +320,8 @@ where
 }
 
 /// detect both ellipsis and `True` to be compatible with pydantic V1
-fn is_ellipsis_like(v: &PyAny) -> bool {
-    v.is_ellipsis()
+fn is_ellipsis_like(v: &Bound<'_, PyAny>) -> bool {
+    v.is(&v.py().Ellipsis())
         || match v.downcast::<PyBool>() {
             Ok(b) => b.is_true(),
             Err(_) => false,
@@ -324,33 +329,36 @@ fn is_ellipsis_like(v: &PyAny) -> bool {
 }
 
 /// lookup the dict, for the key and "__all__" key, and merge them following the same rules as pydantic V1
-fn merge_all_value(dict: &PyDict, py_key: impl ToPyObject + Copy) -> PyResult<Option<&PyAny>> {
+fn merge_all_value<'py>(
+    dict: &Bound<'py, PyDict>,
+    py_key: impl ToPyObject + Copy,
+) -> PyResult<Option<Bound<'py, PyAny>>> {
     let op_item_value = dict.get_item(py_key)?;
     let op_all_value = dict.get_item(intern!(dict.py(), "__all__"))?;
 
     match (op_item_value, op_all_value) {
         (Some(item_value), Some(all_value)) => {
-            if is_ellipsis_like(item_value) || is_ellipsis_like(all_value) {
-                Ok(op_item_value)
+            if is_ellipsis_like(&item_value) || is_ellipsis_like(&all_value) {
+                Ok(Some(item_value))
             } else {
-                let item_dict = as_dict(item_value)?;
-                let item_dict_merged = merge_dicts(item_dict, all_value)?;
-                Ok(Some(item_dict_merged))
+                let item_dict = as_dict(&item_value)?;
+                let item_dict_merged = merge_dicts(&item_dict, &all_value)?;
+                Ok(Some(item_dict_merged.into_any()))
             }
         }
-        (Some(_), None) => Ok(op_item_value),
-        (None, Some(_)) => Ok(op_all_value),
+        (op_item_value @ Some(_), None) => Ok(op_item_value),
+        (None, op_all_value @ Some(_)) => Ok(op_all_value),
         (None, None) => Ok(None),
     }
 }
 
-fn as_dict(value: &PyAny) -> PyResult<&PyDict> {
+fn as_dict<'py>(value: &Bound<'py, PyAny>) -> PyResult<Bound<'py, PyDict>> {
     if let Ok(dict) = value.downcast::<PyDict>() {
         dict.copy()
     } else if let Ok(set) = value.downcast::<PySet>() {
         let py = value.py();
-        let dict = PyDict::new(py);
-        for item in set {
+        let dict = PyDict::new_bound(py);
+        for item in set.iter() {
             dict.set_item(item, py.Ellipsis())?;
         }
         Ok(dict)
@@ -361,26 +369,26 @@ fn as_dict(value: &PyAny) -> PyResult<&PyDict> {
     }
 }
 
-fn merge_dicts<'py>(item_dict: &'py PyDict, all_value: &'py PyAny) -> PyResult<&'py PyDict> {
+fn merge_dicts<'py>(item_dict: &Bound<'py, PyDict>, all_value: &Bound<'py, PyAny>) -> PyResult<Bound<'py, PyDict>> {
     let item_dict = item_dict.copy()?;
     if let Ok(all_dict) = all_value.downcast::<PyDict>() {
-        for (all_key, all_value) in all_dict {
-            if let Some(item_value) = item_dict.get_item(all_key)? {
-                if is_ellipsis_like(item_value) {
+        for (all_key, all_value) in all_dict.iter() {
+            if let Some(item_value) = item_dict.get_item(&all_key)? {
+                if is_ellipsis_like(&item_value) {
                     continue;
                 }
-                let item_value_dict = as_dict(item_value)?;
+                let item_value_dict = as_dict(&item_value)?;
                 // if the all value is an ellipsis, we don't overwrite the item value
-                if !is_ellipsis_like(all_value) {
-                    item_dict.set_item(all_key, merge_dicts(item_value_dict, all_value)?)?;
+                if !is_ellipsis_like(&all_value) {
+                    item_dict.set_item(all_key, merge_dicts(&item_value_dict, &all_value)?)?;
                 }
             } else {
                 item_dict.set_item(all_key, all_value)?;
             }
         }
     } else if let Ok(set) = all_value.downcast::<PySet>() {
-        for item in set {
-            if !item_dict.contains(item)? {
+        for item in set.iter() {
+            if !item_dict.contains(&item)? {
                 item_dict.set_item(item, set.py().Ellipsis())?;
             }
         }
diff --git a/src/serializers/infer.rs b/src/serializers/infer.rs
index 98ffc72b2..8be6bfd22 100644
--- a/src/serializers/infer.rs
+++ b/src/serializers/infer.rs
@@ -3,9 +3,8 @@ use std::borrow::Cow;
 use pyo3::exceptions::PyTypeError;
 use pyo3::intern;
 use pyo3::prelude::*;
-use pyo3::types::{
-    PyByteArray, PyBytes, PyDate, PyDateTime, PyDict, PyFrozenSet, PyIterator, PyList, PySet, PyString, PyTime, PyTuple,
-};
+use pyo3::pybacked::PyBackedStr;
+use pyo3::types::{PyByteArray, PyBytes, PyDict, PyFrozenSet, PyIterator, PyList, PySet, PyString, PyTuple};
 
 use serde::ser::{Error, Serialize, SerializeMap, SerializeSeq, Serializer};
 
@@ -23,9 +22,9 @@ use super::shared::{any_dataclass_iter, PydanticSerializer, TypeSerializer};
 use super::SchemaSerializer;
 
 pub(crate) fn infer_to_python(
-    value: &PyAny,
-    include: Option<&PyAny>,
-    exclude: Option<&PyAny>,
+    value: &Bound<'_, PyAny>,
+    include: Option<&Bound<'_, PyAny>>,
+    exclude: Option<&Bound<'_, PyAny>>,
     extra: &Extra,
 ) -> PyResult<PyObject> {
     infer_to_python_known(extra.ob_type_lookup.get_type(value), value, include, exclude, extra)
@@ -37,9 +36,9 @@ const INFER_DEF_REF_ID: usize = usize::MAX;
 
 pub(crate) fn infer_to_python_known(
     ob_type: ObType,
-    value: &PyAny,
-    include: Option<&PyAny>,
-    exclude: Option<&PyAny>,
+    value: &Bound<'_, PyAny>,
+    include: Option<&Bound<'_, PyAny>>,
+    exclude: Option<&Bound<'_, PyAny>>,
     mut extra: &Extra,
 ) -> PyResult<PyObject> {
     let py = value.py();
@@ -62,14 +61,14 @@ pub(crate) fn infer_to_python_known(
             value
                 .downcast::<$t>()?
                 .iter()
-                .map(|v| infer_to_python(v, None, None, extra))
+                .map(|v| infer_to_python(&v, None, None, extra))
                 .collect::<PyResult<Vec<PyObject>>>()?
         };
     }
 
     macro_rules! serialize_seq_filter {
         ($t:ty) => {{
-            let py_seq: &$t = value.downcast()?;
+            let py_seq = value.downcast::<$t>()?;
             let mut items = Vec::with_capacity(py_seq.len());
             let filter = AnyFilter::new();
             let len = value.len().ok();
@@ -77,7 +76,12 @@ pub(crate) fn infer_to_python_known(
             for (index, element) in py_seq.iter().enumerate() {
                 let op_next = filter.index_filter(index, include, exclude, len)?;
                 if let Some((next_include, next_exclude)) = op_next {
-                    items.push(infer_to_python(element, next_include, next_exclude, extra)?);
+                    items.push(infer_to_python(
+                        &element,
+                        next_include.as_ref(),
+                        next_exclude.as_ref(),
+                        extra,
+                    )?);
                 }
             }
             items
@@ -116,19 +120,19 @@ pub(crate) fn infer_to_python_known(
             ObType::Float | ObType::FloatSubclass => {
                 let v = value.extract::<f64>()?;
                 if (v.is_nan() || v.is_infinite()) && extra.config.inf_nan_mode == InfNanMode::Null {
-                    return Ok(py.None());
+                    return Ok(py.None().into_py(py));
                 }
                 v.into_py(py)
             }
             ObType::Decimal => value.to_string().into_py(py),
-            ObType::StrSubclass => value.extract::<&str>()?.into_py(py),
+            ObType::StrSubclass => value.downcast::<PyString>()?.to_str()?.into_py(py),
             ObType::Bytes => extra
                 .config
                 .bytes_mode
                 .bytes_to_string(py, value.downcast::<PyBytes>()?.as_bytes())
                 .map(|s| s.into_py(py))?,
             ObType::Bytearray => {
-                let py_byte_array: &PyByteArray = value.downcast()?;
+                let py_byte_array = value.downcast::<PyByteArray>()?;
                 // Safety: the GIL is held while bytes_to_string is running; it doesn't run
                 // arbitrary Python code, so py_byte_array cannot be mutated.
                 let bytes = unsafe { py_byte_array.as_bytes() };
@@ -140,39 +144,36 @@ pub(crate) fn infer_to_python_known(
             }
             ObType::Tuple => {
                 let elements = serialize_seq_filter!(PyTuple);
-                PyList::new(py, elements).into_py(py)
+                PyList::new_bound(py, elements).into_py(py)
             }
             ObType::List => {
                 let elements = serialize_seq_filter!(PyList);
-                PyList::new(py, elements).into_py(py)
+                PyList::new_bound(py, elements).into_py(py)
             }
             ObType::Set => {
                 let elements = serialize_seq!(PySet);
-                PyList::new(py, elements).into_py(py)
+                PyList::new_bound(py, elements).into_py(py)
             }
             ObType::Frozenset => {
                 let elements = serialize_seq!(PyFrozenSet);
-                PyList::new(py, elements).into_py(py)
+                PyList::new_bound(py, elements).into_py(py)
             }
             ObType::Dict => {
-                let dict: &PyDict = value.downcast()?;
+                let dict = value.downcast::<PyDict>()?;
                 serialize_pairs_python(py, dict.iter().map(Ok), include, exclude, extra, |k| {
-                    Ok(PyString::new(py, &infer_json_key(k, extra)?))
+                    Ok(PyString::new_bound(py, &infer_json_key(&k, extra)?).into_any())
                 })?
             }
             ObType::Datetime => {
-                let py_dt: &PyDateTime = value.downcast()?;
-                let iso_dt = super::type_serializers::datetime_etc::datetime_to_string(py_dt)?;
+                let iso_dt = super::type_serializers::datetime_etc::datetime_to_string(value.downcast()?)?;
                 iso_dt.into_py(py)
             }
             ObType::Date => {
-                let py_date: &PyDate = value.downcast()?;
-                let iso_date = super::type_serializers::datetime_etc::date_to_string(py_date)?;
+                let iso_date = super::type_serializers::datetime_etc::date_to_string(value.downcast()?)?;
                 iso_date.into_py(py)
             }
             ObType::Time => {
-                let py_time: &PyTime = value.downcast()?;
-                let iso_time = super::type_serializers::datetime_etc::time_to_string(py_time)?;
+                let iso_time = super::type_serializers::datetime_etc::time_to_string(value.downcast()?)?;
                 iso_time.into_py(py)
             }
             ObType::Timedelta => {
@@ -191,22 +192,21 @@ pub(crate) fn infer_to_python_known(
                 py_url.__str__().into_py(py)
             }
             ObType::Uuid => {
-                let py_uuid: &PyAny = value.downcast()?;
-                let uuid = super::type_serializers::uuid::uuid_to_string(py_uuid)?;
+                let uuid = super::type_serializers::uuid::uuid_to_string(value)?;
                 uuid.into_py(py)
             }
             ObType::PydanticSerializable => serialize_with_serializer()?,
             ObType::Dataclass => {
                 serialize_pairs_python(py, any_dataclass_iter(value)?.0, include, exclude, extra, |k| {
-                    Ok(PyString::new(py, &infer_json_key(k, extra)?))
+                    Ok(PyString::new_bound(py, &infer_json_key(&k, extra)?).into_any())
                 })?
             }
             ObType::Enum => {
                 let v = value.getattr(intern!(py, "value"))?;
-                infer_to_python(v, include, exclude, extra)?.into_py(py)
+                infer_to_python(&v, include, exclude, extra)?.into_py(py)
             }
             ObType::Generator => {
-                let py_seq: &PyIterator = value.downcast()?;
+                let py_seq = value.downcast::<PyIterator>()?;
                 let mut items = Vec::new();
                 let filter = AnyFilter::new();
 
@@ -214,17 +214,22 @@ pub(crate) fn infer_to_python_known(
                     let element = r?;
                     let op_next = filter.index_filter(index, include, exclude, None)?;
                     if let Some((next_include, next_exclude)) = op_next {
-                        items.push(infer_to_python(element, next_include, next_exclude, extra)?);
+                        items.push(infer_to_python(
+                            &element,
+                            next_include.as_ref(),
+                            next_exclude.as_ref(),
+                            extra,
+                        )?);
                     }
                 }
-                PyList::new(py, items).into_py(py)
+                PyList::new_bound(py, items).into_py(py)
             }
             ObType::Path => value.str()?.into_py(py),
             ObType::Pattern => value.getattr(intern!(py, "pattern"))?.into_py(py),
             ObType::Unknown => {
                 if let Some(fallback) = extra.fallback {
                     let next_value = fallback.call1((value,))?;
-                    let next_result = infer_to_python(next_value, include, exclude, extra);
+                    let next_result = infer_to_python(&next_value, include, exclude, extra);
                     return next_result;
                 } else if extra.serialize_unknown {
                     serialize_unknown(value).into_py(py)
@@ -236,22 +241,22 @@ pub(crate) fn infer_to_python_known(
         _ => match ob_type {
             ObType::Tuple => {
                 let elements = serialize_seq_filter!(PyTuple);
-                PyTuple::new(py, elements).into_py(py)
+                PyTuple::new_bound(py, elements).into_py(py)
             }
             ObType::List => {
                 let elements = serialize_seq_filter!(PyList);
-                PyList::new(py, elements).into_py(py)
+                PyList::new_bound(py, elements).into_py(py)
             }
             ObType::Set => {
                 let elements = serialize_seq!(PySet);
-                PySet::new(py, &elements)?.into_py(py)
+                PySet::new_bound(py, &elements)?.into_py(py)
             }
             ObType::Frozenset => {
                 let elements = serialize_seq!(PyFrozenSet);
-                PyFrozenSet::new(py, &elements)?.into_py(py)
+                PyFrozenSet::new_bound(py, &elements)?.into_py(py)
             }
             ObType::Dict => {
-                let dict: &PyDict = value.downcast()?;
+                let dict = value.downcast::<PyDict>()?;
                 serialize_pairs_python(py, dict.iter().map(Ok), include, exclude, extra, Ok)?
             }
             ObType::PydanticSerializable => serialize_with_serializer()?,
@@ -270,7 +275,7 @@ pub(crate) fn infer_to_python_known(
             ObType::Unknown => {
                 if let Some(fallback) = extra.fallback {
                     let next_value = fallback.call1((value,))?;
-                    let next_result = infer_to_python(next_value, include, exclude, extra);
+                    let next_result = infer_to_python(&next_value, include, exclude, extra);
                     return next_result;
                 }
                 value.into_py(py)
@@ -282,17 +287,17 @@ pub(crate) fn infer_to_python_known(
 }
 
 pub(crate) struct SerializeInfer<'py> {
-    value: &'py PyAny,
-    include: Option<&'py PyAny>,
-    exclude: Option<&'py PyAny>,
+    value: &'py Bound<'py, PyAny>,
+    include: Option<&'py Bound<'py, PyAny>>,
+    exclude: Option<&'py Bound<'py, PyAny>>,
     extra: &'py Extra<'py>,
 }
 
 impl<'py> SerializeInfer<'py> {
     pub(crate) fn new(
-        value: &'py PyAny,
-        include: Option<&'py PyAny>,
-        exclude: Option<&'py PyAny>,
+        value: &'py Bound<'py, PyAny>,
+        include: Option<&'py Bound<'py, PyAny>>,
+        exclude: Option<&'py Bound<'py, PyAny>>,
         extra: &'py Extra,
     ) -> Self {
         Self {
@@ -312,10 +317,10 @@ impl<'py> Serialize for SerializeInfer<'py> {
 }
 
 pub(crate) fn infer_serialize<S: Serializer>(
-    value: &PyAny,
+    value: &Bound<'_, PyAny>,
     serializer: S,
-    include: Option<&PyAny>,
-    exclude: Option<&PyAny>,
+    include: Option<&Bound<'_, PyAny>>,
+    exclude: Option<&Bound<'_, PyAny>>,
     extra: &Extra,
 ) -> Result<S::Ok, S::Error> {
     infer_serialize_known(
@@ -330,10 +335,10 @@ pub(crate) fn infer_serialize<S: Serializer>(
 
 pub(crate) fn infer_serialize_known<S: Serializer>(
     ob_type: ObType,
-    value: &PyAny,
+    value: &Bound<'_, PyAny>,
     serializer: S,
-    include: Option<&PyAny>,
-    exclude: Option<&PyAny>,
+    include: Option<&Bound<'_, PyAny>>,
+    exclude: Option<&Bound<'_, PyAny>>,
     mut extra: &Extra,
 ) -> Result<S::Ok, S::Error> {
     let extra_serialize_unknown = extra.serialize_unknown;
@@ -360,10 +365,10 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
 
     macro_rules! serialize_seq {
         ($t:ty) => {{
-            let py_seq: &$t = value.downcast().map_err(py_err_se_err)?;
+            let py_seq = value.downcast::<$t>().map_err(py_err_se_err)?;
             let mut seq = serializer.serialize_seq(Some(py_seq.len()))?;
-            for element in py_seq {
-                let item_serializer = SerializeInfer::new(element, include, exclude, extra);
+            for element in py_seq.iter() {
+                let item_serializer = SerializeInfer::new(&element, include, exclude, extra);
                 seq.serialize_element(&item_serializer)?
             }
             seq.end()
@@ -372,7 +377,7 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
 
     macro_rules! serialize_seq_filter {
         ($t:ty) => {{
-            let py_seq: &$t = value.downcast().map_err(py_err_se_err)?;
+            let py_seq = value.downcast::<$t>().map_err(py_err_se_err)?;
             let mut seq = serializer.serialize_seq(Some(py_seq.len()))?;
             let filter = AnyFilter::new();
             let len = value.len().ok();
@@ -382,7 +387,8 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
                     .index_filter(index, include, exclude, len)
                     .map_err(py_err_se_err)?;
                 if let Some((next_include, next_exclude)) = op_next {
-                    let item_serializer = SerializeInfer::new(element, next_include, next_exclude, extra);
+                    let item_serializer =
+                        SerializeInfer::new(&element, next_include.as_ref(), next_exclude.as_ref(), extra);
                     seq.serialize_element(&item_serializer)?
                 }
             }
@@ -397,15 +403,15 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
         ObType::Float | ObType::FloatSubclass => serialize!(f64),
         ObType::Decimal => value.to_string().serialize(serializer),
         ObType::Str | ObType::StrSubclass => {
-            let py_str: &PyString = value.downcast().map_err(py_err_se_err)?;
+            let py_str = value.downcast::<PyString>().map_err(py_err_se_err)?;
             super::type_serializers::string::serialize_py_str(py_str, serializer)
         }
         ObType::Bytes => {
-            let py_bytes: &PyBytes = value.downcast().map_err(py_err_se_err)?;
+            let py_bytes = value.downcast::<PyBytes>().map_err(py_err_se_err)?;
             extra.config.bytes_mode.serialize_bytes(py_bytes.as_bytes(), serializer)
         }
         ObType::Bytearray => {
-            let py_byte_array: &PyByteArray = value.downcast().map_err(py_err_se_err)?;
+            let py_byte_array = value.downcast::<PyByteArray>().map_err(py_err_se_err)?;
             // Safety: the GIL is held while serialize_bytes is running; it doesn't run
             // arbitrary Python code, so py_byte_array cannot be mutated.
             extra
@@ -422,17 +428,17 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
         ObType::Set => serialize_seq!(PySet),
         ObType::Frozenset => serialize_seq!(PyFrozenSet),
         ObType::Datetime => {
-            let py_dt: &PyDateTime = value.downcast().map_err(py_err_se_err)?;
+            let py_dt = value.downcast().map_err(py_err_se_err)?;
             let iso_dt = super::type_serializers::datetime_etc::datetime_to_string(py_dt).map_err(py_err_se_err)?;
             serializer.serialize_str(&iso_dt)
         }
         ObType::Date => {
-            let py_date: &PyDate = value.downcast().map_err(py_err_se_err)?;
+            let py_date = value.downcast().map_err(py_err_se_err)?;
             let iso_date = super::type_serializers::datetime_etc::date_to_string(py_date).map_err(py_err_se_err)?;
             serializer.serialize_str(&iso_date)
         }
         ObType::Time => {
-            let py_time: &PyTime = value.downcast().map_err(py_err_se_err)?;
+            let py_time = value.downcast().map_err(py_err_se_err)?;
             let iso_time = super::type_serializers::datetime_etc::time_to_string(py_time).map_err(py_err_se_err)?;
             serializer.serialize_str(&iso_time)
         }
@@ -480,16 +486,15 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
             serialize_pairs_json(pairs_iter, fields_dict.len(), serializer, include, exclude, extra)
         }
         ObType::Uuid => {
-            let py_uuid: &PyAny = value.downcast().map_err(py_err_se_err)?;
-            let uuid = super::type_serializers::uuid::uuid_to_string(py_uuid).map_err(py_err_se_err)?;
+            let uuid = super::type_serializers::uuid::uuid_to_string(value).map_err(py_err_se_err)?;
             serializer.serialize_str(&uuid)
         }
         ObType::Enum => {
             let v = value.getattr(intern!(value.py(), "value")).map_err(py_err_se_err)?;
-            infer_serialize(v, serializer, include, exclude, extra)
+            infer_serialize(&v, serializer, include, exclude, extra)
         }
         ObType::Generator => {
-            let py_seq: &PyIterator = value.downcast().map_err(py_err_se_err)?;
+            let py_seq = value.downcast::<PyIterator>().map_err(py_err_se_err)?;
             let mut seq = serializer.serialize_seq(None)?;
             let filter = AnyFilter::new();
             for (index, r) in py_seq.iter().map_err(py_err_se_err)?.enumerate() {
@@ -498,30 +503,31 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
                     .index_filter(index, include, exclude, None)
                     .map_err(py_err_se_err)?;
                 if let Some((next_include, next_exclude)) = op_next {
-                    let item_serializer = SerializeInfer::new(element, next_include, next_exclude, extra);
+                    let item_serializer =
+                        SerializeInfer::new(&element, next_include.as_ref(), next_exclude.as_ref(), extra);
                     seq.serialize_element(&item_serializer)?;
                 }
             }
             seq.end()
         }
         ObType::Path => {
-            let s = value.str().map_err(py_err_se_err)?.to_str().map_err(py_err_se_err)?;
-            serializer.serialize_str(s)
+            let s: PyBackedStr = value
+                .str()
+                .and_then(|value_str| value_str.extract())
+                .map_err(py_err_se_err)?;
+            serializer.serialize_str(&s)
         }
         ObType::Pattern => {
-            let s = value
+            let s: PyBackedStr = value
                 .getattr(intern!(value.py(), "pattern"))
-                .map_err(py_err_se_err)?
-                .str()
-                .map_err(py_err_se_err)?
-                .to_str()
+                .and_then(|pattern| pattern.str()?.extract())
                 .map_err(py_err_se_err)?;
-            serializer.serialize_str(s)
+            serializer.serialize_str(&s)
         }
         ObType::Unknown => {
             if let Some(fallback) = extra.fallback {
                 let next_value = fallback.call1((value,)).map_err(py_err_se_err)?;
-                let next_result = infer_serialize(next_value, serializer, include, exclude, extra);
+                let next_result = infer_serialize(&next_value, serializer, include, exclude, extra);
                 return next_result;
             } else if extra.serialize_unknown {
                 serializer.serialize_str(&serialize_unknown(value))
@@ -529,7 +535,7 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
                 let msg = format!(
                     "{}Unable to serialize unknown type: {}",
                     SERIALIZATION_ERR_MARKER,
-                    safe_repr(value.get_type()),
+                    safe_repr(&value.get_type()),
                 );
                 return Err(S::Error::custom(msg));
             }
@@ -538,29 +544,33 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
     ser_result
 }
 
-fn unknown_type_error(value: &PyAny) -> PyErr {
+fn unknown_type_error(value: &Bound<'_, PyAny>) -> PyErr {
     PydanticSerializationError::new_err(format!(
         "Unable to serialize unknown type: {}",
-        safe_repr(value.get_type())
+        safe_repr(&value.get_type())
     ))
 }
 
-fn serialize_unknown(value: &PyAny) -> Cow<str> {
+fn serialize_unknown<'py>(value: &Bound<'py, PyAny>) -> Cow<'py, str> {
     if let Ok(s) = value.str() {
-        s.to_string_lossy()
-    } else if let Ok(name) = value.get_type().name() {
+        s.to_string_lossy().into_owned().into()
+    } else if let Ok(name) = value.get_type().qualname() {
         format!("<Unserializable {name} object>").into()
     } else {
         "<Unserializable object>".into()
     }
 }
 
-pub(crate) fn infer_json_key<'py>(key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+pub(crate) fn infer_json_key<'a>(key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
     let ob_type = extra.ob_type_lookup.get_type(key);
     infer_json_key_known(ob_type, key, extra)
 }
 
-pub(crate) fn infer_json_key_known<'py>(ob_type: ObType, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+pub(crate) fn infer_json_key_known<'a>(
+    ob_type: ObType,
+    key: &'a Bound<'_, PyAny>,
+    extra: &Extra,
+) -> PyResult<Cow<'a, str>> {
     match ob_type {
         ObType::None => super::type_serializers::simple::none_json_key(),
         ObType::Int | ObType::IntSubclass | ObType::Float | ObType::FloatSubclass => {
@@ -569,15 +579,17 @@ pub(crate) fn infer_json_key_known<'py>(ob_type: ObType, key: &'py PyAny, extra:
         ObType::Decimal => Ok(Cow::Owned(key.to_string())),
         ObType::Bool => super::type_serializers::simple::bool_json_key(key),
         ObType::Str | ObType::StrSubclass => {
-            let py_str: &PyString = key.downcast()?;
-            Ok(Cow::Borrowed(py_str.to_str()?))
+            let py_str = key.downcast::<PyString>()?;
+            Ok(Cow::Owned(py_str.to_str()?.to_string()))
         }
         ObType::Bytes => extra
             .config
             .bytes_mode
-            .bytes_to_string(key.py(), key.downcast::<PyBytes>()?.as_bytes()),
+            .bytes_to_string(key.py(), key.downcast::<PyBytes>()?.as_bytes())
+            // FIXME it would be nice to have a "PyCow" which carries ownership of the Python type too
+            .map(|s| Cow::Owned(s.into_owned())),
         ObType::Bytearray => {
-            let py_byte_array: &PyByteArray = key.downcast()?;
+            let py_byte_array = key.downcast::<PyByteArray>()?;
             // Safety: the GIL is held while serialize_bytes is running; it doesn't run
             // arbitrary Python code, so py_byte_array cannot be mutated during the call.
             //
@@ -589,23 +601,19 @@ pub(crate) fn infer_json_key_known<'py>(ob_type: ObType, key: &'py PyAny, extra:
                 .map(|cow| Cow::Owned(cow.into_owned()))
         }
         ObType::Datetime => {
-            let py_dt: &PyDateTime = key.downcast()?;
-            let iso_dt = super::type_serializers::datetime_etc::datetime_to_string(py_dt)?;
+            let iso_dt = super::type_serializers::datetime_etc::datetime_to_string(key.downcast()?)?;
             Ok(Cow::Owned(iso_dt))
         }
         ObType::Date => {
-            let py_date: &PyDate = key.downcast()?;
-            let iso_date = super::type_serializers::datetime_etc::date_to_string(py_date)?;
+            let iso_date = super::type_serializers::datetime_etc::date_to_string(key.downcast()?)?;
             Ok(Cow::Owned(iso_date))
         }
         ObType::Time => {
-            let py_time: &PyTime = key.downcast()?;
-            let iso_time = super::type_serializers::datetime_etc::time_to_string(py_time)?;
+            let iso_time = super::type_serializers::datetime_etc::time_to_string(key.downcast()?)?;
             Ok(Cow::Owned(iso_time))
         }
         ObType::Uuid => {
-            let py_uuid: &PyAny = key.downcast()?;
-            let uuid = super::type_serializers::uuid::uuid_to_string(py_uuid)?;
+            let uuid = super::type_serializers::uuid::uuid_to_string(key)?;
             Ok(Cow::Owned(uuid))
         }
         ObType::Timedelta => {
@@ -622,8 +630,8 @@ pub(crate) fn infer_json_key_known<'py>(ob_type: ObType, key: &'py PyAny, extra:
         }
         ObType::Tuple => {
             let mut key_build = super::type_serializers::tuple::KeyBuilder::new();
-            for element in key.downcast::<PyTuple>()? {
-                key_build.push(&infer_json_key(element, extra)?);
+            for element in key.downcast::<PyTuple>()?.iter_borrowed() {
+                key_build.push(&infer_json_key(&element, extra)?);
             }
             Ok(Cow::Owned(key_build.finish()))
         }
@@ -638,16 +646,22 @@ pub(crate) fn infer_json_key_known<'py>(ob_type: ObType, key: &'py PyAny, extra:
         }
         ObType::Enum => {
             let k = key.getattr(intern!(key.py(), "value"))?;
-            infer_json_key(k, extra)
+            infer_json_key(&k, extra).map(|cow| Cow::Owned(cow.into_owned()))
         }
-        ObType::Path => Ok(key.str()?.to_string_lossy()),
-        ObType::Pattern => Ok(key.getattr(intern!(key.py(), "pattern"))?.str()?.to_string_lossy()),
+        ObType::Path => {
+            // FIXME it would be nice to have a "PyCow" which carries ownership of the Python type too
+            Ok(Cow::Owned(key.str()?.to_string_lossy().into_owned()))
+        }
+        ObType::Pattern => Ok(Cow::Owned(
+            key.getattr(intern!(key.py(), "pattern"))?
+                .str()?
+                .to_string_lossy()
+                .into_owned(),
+        )),
         ObType::Unknown => {
             if let Some(fallback) = extra.fallback {
                 let next_key = fallback.call1((key,))?;
-                // totally unnecessary step to placate rust's lifetime rules
-                let next_key = next_key.to_object(key.py()).into_ref(key.py());
-                infer_json_key(next_key, extra)
+                infer_json_key(&next_key, extra).map(|cow| Cow::Owned(cow.into_owned()))
             } else if extra.serialize_unknown {
                 Ok(serialize_unknown(key))
             } else {
@@ -659,21 +673,21 @@ pub(crate) fn infer_json_key_known<'py>(ob_type: ObType, key: &'py PyAny, extra:
 
 fn serialize_pairs_python<'py>(
     py: Python,
-    pairs_iter: impl Iterator<Item = PyResult<(&'py PyAny, &'py PyAny)>>,
-    include: Option<&PyAny>,
-    exclude: Option<&PyAny>,
+    pairs_iter: impl Iterator<Item = PyResult<(Bound<'py, PyAny>, Bound<'py, PyAny>)>>,
+    include: Option<&Bound<'_, PyAny>>,
+    exclude: Option<&Bound<'_, PyAny>>,
     extra: &Extra,
-    key_transform: impl Fn(&'py PyAny) -> PyResult<&'py PyAny>,
+    key_transform: impl Fn(Bound<'py, PyAny>) -> PyResult<Bound<'py, PyAny>>,
 ) -> PyResult<PyObject> {
-    let new_dict = PyDict::new(py);
+    let new_dict = PyDict::new_bound(py);
     let filter = AnyFilter::new();
 
     for result in pairs_iter {
         let (k, v) = result?;
-        let op_next = filter.key_filter(k, include, exclude)?;
+        let op_next = filter.key_filter(&k, include, exclude)?;
         if let Some((next_include, next_exclude)) = op_next {
             let k = key_transform(k)?;
-            let v = infer_to_python(v, next_include, next_exclude, extra)?;
+            let v = infer_to_python(&v, next_include.as_ref(), next_exclude.as_ref(), extra)?;
             new_dict.set_item(k, v)?;
         }
     }
@@ -681,11 +695,11 @@ fn serialize_pairs_python<'py>(
 }
 
 fn serialize_pairs_json<'py, S: Serializer>(
-    pairs_iter: impl Iterator<Item = PyResult<(&'py PyAny, &'py PyAny)>>,
+    pairs_iter: impl Iterator<Item = PyResult<(Bound<'py, PyAny>, Bound<'py, PyAny>)>>,
     iter_size: usize,
     serializer: S,
-    include: Option<&PyAny>,
-    exclude: Option<&PyAny>,
+    include: Option<&Bound<'_, PyAny>>,
+    exclude: Option<&Bound<'_, PyAny>>,
     extra: &Extra,
 ) -> Result<S::Ok, S::Error> {
     let mut map = serializer.serialize_map(Some(iter_size))?;
@@ -694,10 +708,10 @@ fn serialize_pairs_json<'py, S: Serializer>(
     for result in pairs_iter {
         let (key, value) = result.map_err(py_err_se_err)?;
 
-        let op_next = filter.key_filter(key, include, exclude).map_err(py_err_se_err)?;
+        let op_next = filter.key_filter(&key, include, exclude).map_err(py_err_se_err)?;
         if let Some((next_include, next_exclude)) = op_next {
-            let key = infer_json_key(key, extra).map_err(py_err_se_err)?;
-            let value_serializer = SerializeInfer::new(value, next_include, next_exclude, extra);
+            let key = infer_json_key(&key, extra).map_err(py_err_se_err)?;
+            let value_serializer = SerializeInfer::new(&value, next_include.as_ref(), next_exclude.as_ref(), extra);
             map.serialize_entry(&key, &value_serializer)?;
         }
     }
diff --git a/src/serializers/mod.rs b/src/serializers/mod.rs
index 3ed47a0a8..aef5be702 100644
--- a/src/serializers/mod.rs
+++ b/src/serializers/mod.rs
@@ -54,8 +54,8 @@ impl SchemaSerializer {
         round_trip: bool,
         rec_guard: &'a SerRecursionState,
         serialize_unknown: bool,
-        fallback: Option<&'a PyAny>,
-        context: Option<&'a PyAny>,
+        fallback: Option<&'a Bound<'a, PyAny>>,
+        context: Option<&'a Bound<'a, PyAny>>,
     ) -> Extra<'b> {
         Extra::new(
             py,
@@ -78,7 +78,7 @@ impl SchemaSerializer {
 #[pymethods]
 impl SchemaSerializer {
     #[new]
-    pub fn py_new(py: Python, schema: &PyDict, config: Option<&PyDict>) -> PyResult<Self> {
+    pub fn py_new(schema: Bound<'_, PyDict>, config: Option<&Bound<'_, PyDict>>) -> PyResult<Self> {
         let mut definitions_builder = DefinitionsBuilder::new();
         let serializer = CombinedSerializer::build(schema.downcast()?, config, &mut definitions_builder)?;
         Ok(Self {
@@ -86,9 +86,9 @@ impl SchemaSerializer {
             definitions: definitions_builder.finish()?,
             expected_json_size: AtomicUsize::new(1024),
             config: SerializationConfig::from_config(config)?,
-            py_schema: schema.into_py(py),
+            py_schema: schema.into(),
             py_config: match config {
-                Some(c) if !c.is_empty() => Some(c.into_py(py)),
+                Some(c) if !c.is_empty() => Some(c.clone().into()),
                 _ => None,
             },
         })
@@ -101,18 +101,18 @@ impl SchemaSerializer {
     pub fn to_python(
         &self,
         py: Python,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         mode: Option<&str>,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         by_alias: bool,
         exclude_unset: bool,
         exclude_defaults: bool,
         exclude_none: bool,
         round_trip: bool,
         warnings: bool,
-        fallback: Option<&PyAny>,
-        context: Option<&PyAny>,
+        fallback: Option<&Bound<'_, PyAny>>,
+        context: Option<&Bound<'_, PyAny>>,
     ) -> PyResult<PyObject> {
         let mode: SerMode = mode.into();
         let warnings = CollectWarnings::new(warnings);
@@ -143,18 +143,18 @@ impl SchemaSerializer {
     pub fn to_json(
         &self,
         py: Python,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         indent: Option<usize>,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         by_alias: bool,
         exclude_unset: bool,
         exclude_defaults: bool,
         exclude_none: bool,
         round_trip: bool,
         warnings: bool,
-        fallback: Option<&PyAny>,
-        context: Option<&PyAny>,
+        fallback: Option<&Bound<'_, PyAny>>,
+        context: Option<&Bound<'_, PyAny>>,
     ) -> PyResult<PyObject> {
         let warnings = CollectWarnings::new(warnings);
         let rec_guard = SerRecursionState::default();
@@ -185,11 +185,11 @@ impl SchemaSerializer {
         warnings.final_check(py)?;
 
         self.expected_json_size.store(bytes.len(), Ordering::Relaxed);
-        let py_bytes = PyBytes::new(py, &bytes);
+        let py_bytes = PyBytes::new_bound(py, &bytes);
         Ok(py_bytes.into())
     }
 
-    pub fn __reduce__(slf: &PyCell<Self>) -> PyResult<(PyObject, (PyObject, PyObject))> {
+    pub fn __reduce__(slf: &Bound<Self>) -> PyResult<(PyObject, (PyObject, PyObject))> {
         // Enables support for `pickle` serialization.
         let py = slf.py();
         let cls = slf.get_type().into();
@@ -222,10 +222,10 @@ impl SchemaSerializer {
     inf_nan_mode = "constants", serialize_unknown = false, fallback = None, context = None))]
 pub fn to_json(
     py: Python,
-    value: &PyAny,
+    value: &Bound<'_, PyAny>,
     indent: Option<usize>,
-    include: Option<&PyAny>,
-    exclude: Option<&PyAny>,
+    include: Option<&Bound<'_, PyAny>>,
+    exclude: Option<&Bound<'_, PyAny>>,
     by_alias: bool,
     exclude_none: bool,
     round_trip: bool,
@@ -233,8 +233,8 @@ pub fn to_json(
     bytes_mode: &str,
     inf_nan_mode: &str,
     serialize_unknown: bool,
-    fallback: Option<&PyAny>,
-    context: Option<&PyAny>,
+    fallback: Option<&Bound<'_, PyAny>>,
+    context: Option<&Bound<'_, PyAny>>,
 ) -> PyResult<PyObject> {
     let state = SerializationState::new(timedelta_mode, bytes_mode, inf_nan_mode)?;
     let extra = state.extra(
@@ -250,7 +250,7 @@ pub fn to_json(
     let serializer = type_serializers::any::AnySerializer.into();
     let bytes = to_json_bytes(value, &serializer, include, exclude, &extra, indent, 1024)?;
     state.final_check(py)?;
-    let py_bytes = PyBytes::new(py, &bytes);
+    let py_bytes = PyBytes::new_bound(py, &bytes);
     Ok(py_bytes.into())
 }
 
@@ -260,9 +260,9 @@ pub fn to_json(
     timedelta_mode = "iso8601", bytes_mode = "utf8", inf_nan_mode = "constants", serialize_unknown = false, fallback = None, context = None))]
 pub fn to_jsonable_python(
     py: Python,
-    value: &PyAny,
-    include: Option<&PyAny>,
-    exclude: Option<&PyAny>,
+    value: &Bound<'_, PyAny>,
+    include: Option<&Bound<'_, PyAny>>,
+    exclude: Option<&Bound<'_, PyAny>>,
     by_alias: bool,
     exclude_none: bool,
     round_trip: bool,
@@ -270,8 +270,8 @@ pub fn to_jsonable_python(
     bytes_mode: &str,
     inf_nan_mode: &str,
     serialize_unknown: bool,
-    fallback: Option<&PyAny>,
-    context: Option<&PyAny>,
+    fallback: Option<&Bound<'_, PyAny>>,
+    context: Option<&Bound<'_, PyAny>>,
 ) -> PyResult<PyObject> {
     let state = SerializationState::new(timedelta_mode, bytes_mode, inf_nan_mode)?;
     let extra = state.extra(
diff --git a/src/serializers/ob_type.rs b/src/serializers/ob_type.rs
index 924de001b..1eaa090a8 100644
--- a/src/serializers/ob_type.rs
+++ b/src/serializers/ob_type.rs
@@ -1,10 +1,10 @@
-use pyo3::once_cell::GILOnceCell;
 use pyo3::prelude::*;
+use pyo3::sync::GILOnceCell;
 use pyo3::types::{
     PyBool, PyByteArray, PyBytes, PyDate, PyDateTime, PyDelta, PyDict, PyFloat, PyFrozenSet, PyInt, PyIterator, PyList,
-    PySet, PyString, PyTime, PyTuple, PyType,
+    PyNone, PySet, PyString, PyTime, PyTuple, PyType,
 };
-use pyo3::{intern, AsPyPointer, PyTypeInfo};
+use pyo3::{intern, PyTypeInfo};
 
 use strum::Display;
 use strum_macros::EnumString;
@@ -62,13 +62,18 @@ pub enum IsType {
 impl ObTypeLookup {
     fn new(py: Python) -> Self {
         Self {
-            none: py.None().as_ref(py).get_type_ptr() as usize,
+            none: PyNone::type_object_raw(py) as usize,
             int: PyInt::type_object_raw(py) as usize,
             bool: PyBool::type_object_raw(py) as usize,
             float: PyFloat::type_object_raw(py) as usize,
             list: PyList::type_object_raw(py) as usize,
             dict: PyDict::type_object_raw(py) as usize,
-            decimal_object: py.import("decimal").unwrap().getattr("Decimal").unwrap().to_object(py),
+            decimal_object: py
+                .import_bound("decimal")
+                .unwrap()
+                .getattr("Decimal")
+                .unwrap()
+                .to_object(py),
             string: PyString::type_object_raw(py) as usize,
             bytes: PyBytes::type_object_raw(py) as usize,
             bytearray: PyByteArray::type_object_raw(py) as usize,
@@ -81,16 +86,21 @@ impl ObTypeLookup {
             timedelta: PyDelta::type_object_raw(py) as usize,
             url: PyUrl::type_object_raw(py) as usize,
             multi_host_url: PyMultiHostUrl::type_object_raw(py) as usize,
-            enum_object: py.import("enum").unwrap().getattr("Enum").unwrap().to_object(py),
+            enum_object: py.import_bound("enum").unwrap().getattr("Enum").unwrap().to_object(py),
             generator_object: py
-                .import("types")
+                .import_bound("types")
                 .unwrap()
                 .getattr("GeneratorType")
                 .unwrap()
                 .to_object(py),
-            path_object: py.import("pathlib").unwrap().getattr("Path").unwrap().to_object(py),
-            pattern_object: py.import("re").unwrap().getattr("Pattern").unwrap().to_object(py),
-            uuid_object: py.import("uuid").unwrap().getattr("UUID").unwrap().to_object(py),
+            path_object: py
+                .import_bound("pathlib")
+                .unwrap()
+                .getattr("Path")
+                .unwrap()
+                .to_object(py),
+            pattern_object: py.import_bound("re").unwrap().getattr("Pattern").unwrap().to_object(py),
+            uuid_object: py.import_bound("uuid").unwrap().getattr("UUID").unwrap().to_object(py),
         }
     }
 
@@ -98,8 +108,8 @@ impl ObTypeLookup {
         TYPE_LOOKUP.get_or_init(py, || Self::new(py))
     }
 
-    pub fn is_type(&self, value: &PyAny, expected_ob_type: ObType) -> IsType {
-        match self.ob_type_is_expected(Some(value), value.get_type(), &expected_ob_type) {
+    pub fn is_type(&self, value: &Bound<'_, PyAny>, expected_ob_type: ObType) -> IsType {
+        match self.ob_type_is_expected(Some(value), &value.get_type(), &expected_ob_type) {
             IsType::False => {
                 if expected_ob_type == self.fallback_isinstance(value) {
                     IsType::Subclass
@@ -111,7 +121,12 @@ impl ObTypeLookup {
         }
     }
 
-    fn ob_type_is_expected(&self, op_value: Option<&PyAny>, py_type: &PyType, expected_ob_type: &ObType) -> IsType {
+    fn ob_type_is_expected(
+        &self,
+        op_value: Option<&Bound<'_, PyAny>>,
+        py_type: &Bound<'_, PyType>,
+        expected_ob_type: &ObType,
+    ) -> IsType {
         let type_ptr = py_type.as_ptr();
         let ob_type = type_ptr as usize;
         let ans = match expected_ob_type {
@@ -166,7 +181,7 @@ impl ObTypeLookup {
             // it's not null
             match get_base_type(py_type) {
                 // as below, we don't want to tests for dataclass etc. again, so we pass None as op_value
-                Some(base_type) => match self.ob_type_is_expected(None, base_type, expected_ob_type) {
+                Some(base_type) => match self.ob_type_is_expected(None, &base_type, expected_ob_type) {
                     IsType::False => IsType::False,
                     _ => IsType::Subclass,
                 },
@@ -175,14 +190,14 @@ impl ObTypeLookup {
         }
     }
 
-    pub fn get_type(&self, value: &PyAny) -> ObType {
-        match self.lookup_by_ob_type(Some(value), value.get_type()) {
+    pub fn get_type(&self, value: &Bound<'_, PyAny>) -> ObType {
+        match self.lookup_by_ob_type(Some(value), &value.get_type()) {
             ObType::Unknown => self.fallback_isinstance(value),
             ob_type => ob_type,
         }
     }
 
-    fn lookup_by_ob_type(&self, op_value: Option<&PyAny>, py_type: &PyType) -> ObType {
+    fn lookup_by_ob_type(&self, op_value: Option<&Bound<'_, PyAny>>, py_type: &Bound<'_, PyType>) -> ObType {
         let ob_type = py_type.as_ptr() as usize;
         // this should be pretty fast, but still order is a bit important, so the most common types should come first
         // thus we don't follow the order of ObType
@@ -253,18 +268,18 @@ impl ObTypeLookup {
             // if `ob_type` didn't match any member of self, we try again with the next base type pointer
             match get_base_type(py_type) {
                 // we don't want to tests for dataclass etc. again, so we pass None as op_value
-                Some(base_type) => self.lookup_by_ob_type(None, base_type),
+                Some(base_type) => self.lookup_by_ob_type(None, &base_type),
                 None => ObType::Unknown,
             }
         }
     }
 
-    fn is_enum(&self, op_value: Option<&PyAny>, py_type: &PyType) -> bool {
+    fn is_enum(&self, op_value: Option<&Bound<'_, PyAny>>, py_type: &Bound<'_, PyType>) -> bool {
         // only test on the type itself, not base types
         if op_value.is_some() {
-            let enum_meta_type = self.enum_object.as_ref(py_type.py()).get_type();
+            let enum_meta_type = self.enum_object.bind(py_type.py()).get_type();
             let meta_type = py_type.get_type();
-            meta_type.is(enum_meta_type)
+            meta_type.is(&enum_meta_type)
         } else {
             false
         }
@@ -279,53 +294,53 @@ impl ObTypeLookup {
     /// In addition, some types have inheritance set as a bitflag on the type object:
     /// https://github.com/python/cpython/blob/v3.12.0rc1/Include/object.h#L546-L553
     /// Hence they come first
-    fn fallback_isinstance(&self, value: &PyAny) -> ObType {
+    fn fallback_isinstance(&self, value: &Bound<'_, PyAny>) -> ObType {
         let py = value.py();
-        if PyInt::is_type_of(value) {
+        if value.is_instance_of::<PyInt>() {
             ObType::IntSubclass
-        } else if PyString::is_type_of(value) {
+        } else if value.is_instance_of::<PyString>() {
             ObType::StrSubclass
-        } else if PyBytes::is_type_of(value) {
+        } else if value.is_instance_of::<PyBytes>() {
             ObType::Bytes
-        } else if PyList::is_type_of(value) {
+        } else if value.is_instance_of::<PyList>() {
             ObType::List
-        } else if PyTuple::is_type_of(value) {
+        } else if value.is_instance_of::<PyTuple>() {
             ObType::Tuple
-        } else if PyDict::is_type_of(value) {
+        } else if value.is_instance_of::<PyDict>() {
             ObType::Dict
-        } else if PyBool::is_type_of(value) {
+        } else if value.is_instance_of::<PyBool>() {
             ObType::Bool
-        } else if PyFloat::is_type_of(value) {
+        } else if value.is_instance_of::<PyFloat>() {
             ObType::FloatSubclass
-        } else if PyByteArray::is_type_of(value) {
+        } else if value.is_instance_of::<PyByteArray>() {
             ObType::Bytearray
-        } else if PySet::is_type_of(value) {
+        } else if value.is_instance_of::<PySet>() {
             ObType::Set
-        } else if PyFrozenSet::is_type_of(value) {
+        } else if value.is_instance_of::<PyFrozenSet>() {
             ObType::Frozenset
-        } else if PyDateTime::is_type_of(value) {
+        } else if value.is_instance_of::<PyDateTime>() {
             ObType::Datetime
-        } else if PyDate::is_type_of(value) {
+        } else if value.is_instance_of::<PyDate>() {
             ObType::Date
-        } else if PyTime::is_type_of(value) {
+        } else if value.is_instance_of::<PyTime>() {
             ObType::Time
-        } else if PyDelta::is_type_of(value) {
+        } else if value.is_instance_of::<PyDelta>() {
             ObType::Timedelta
-        } else if PyUrl::is_type_of(value) {
+        } else if value.is_instance_of::<PyUrl>() {
             ObType::Url
-        } else if PyMultiHostUrl::is_type_of(value) {
+        } else if value.is_instance_of::<PyMultiHostUrl>() {
             ObType::MultiHostUrl
-        } else if value.is_instance(self.decimal_object.as_ref(py)).unwrap_or(false) {
+        } else if value.is_instance(self.decimal_object.bind(py)).unwrap_or(false) {
             ObType::Decimal
-        } else if value.is_instance(self.uuid_object.as_ref(py)).unwrap_or(false) {
+        } else if value.is_instance(self.uuid_object.bind(py)).unwrap_or(false) {
             ObType::Uuid
-        } else if value.is_instance(self.enum_object.as_ref(py)).unwrap_or(false) {
+        } else if value.is_instance(self.enum_object.bind(py)).unwrap_or(false) {
             ObType::Enum
-        } else if value.is_instance(self.generator_object.as_ref(py)).unwrap_or(false) {
+        } else if value.is_instance(self.generator_object.bind(py)).unwrap_or(false) {
             ObType::Generator
-        } else if value.is_instance(self.path_object.as_ref(py)).unwrap_or(false) {
+        } else if value.is_instance(self.path_object.bind(py)).unwrap_or(false) {
             ObType::Path
-        } else if value.is_instance(self.pattern_object.as_ref(py)).unwrap_or(false) {
+        } else if value.is_instance(self.pattern_object.bind(py)).unwrap_or(false) {
             ObType::Pattern
         } else {
             ObType::Unknown
@@ -333,7 +348,7 @@ impl ObTypeLookup {
     }
 }
 
-fn is_dataclass(op_value: Option<&PyAny>) -> bool {
+fn is_dataclass(op_value: Option<&Bound<'_, PyAny>>) -> bool {
     if let Some(value) = op_value {
         value
             .hasattr(intern!(value.py(), "__dataclass_fields__"))
@@ -344,7 +359,7 @@ fn is_dataclass(op_value: Option<&PyAny>) -> bool {
     }
 }
 
-fn is_pydantic_serializable(op_value: Option<&PyAny>) -> bool {
+fn is_pydantic_serializable(op_value: Option<&Bound<'_, PyAny>>) -> bool {
     if let Some(value) = op_value {
         value
             .hasattr(intern!(value.py(), "__pydantic_serializer__"))
@@ -355,7 +370,7 @@ fn is_pydantic_serializable(op_value: Option<&PyAny>) -> bool {
     }
 }
 
-fn is_generator(op_value: Option<&PyAny>) -> bool {
+fn is_generator(op_value: Option<&Bound<'_, PyAny>>) -> bool {
     if let Some(value) = op_value {
         value.downcast::<PyIterator>().is_ok()
     } else {
@@ -432,8 +447,12 @@ impl PartialEq for ObType {
     }
 }
 
-fn get_base_type(py_type: &PyType) -> Option<&PyType> {
+fn get_base_type<'py>(py_type: &Bound<'py, PyType>) -> Option<Bound<'py, PyType>> {
     let base_type_ptr = unsafe { (*py_type.as_type_ptr()).tp_base };
     // Safety: `base_type_ptr` must be a valid pointer to a Python type object, or null.
-    unsafe { py_type.py().from_borrowed_ptr_or_opt(base_type_ptr.cast()) }
+    if base_type_ptr.is_null() {
+        None
+    } else {
+        Some(unsafe { PyType::from_borrowed_type_ptr(py_type.py(), base_type_ptr) })
+    }
 }
diff --git a/src/serializers/shared.rs b/src/serializers/shared.rs
index 7cfe6ce6e..3607df6d6 100644
--- a/src/serializers/shared.rs
+++ b/src/serializers/shared.rs
@@ -2,8 +2,8 @@ use std::borrow::Cow;
 use std::fmt::Debug;
 
 use pyo3::exceptions::PyTypeError;
-use pyo3::once_cell::GILOnceCell;
 use pyo3::prelude::*;
+use pyo3::sync::GILOnceCell;
 use pyo3::types::{PyDict, PyString};
 use pyo3::{intern, PyTraverseError, PyVisit};
 
@@ -27,8 +27,8 @@ pub(crate) trait BuildSerializer: Sized {
     const EXPECTED_TYPE: &'static str;
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer>;
 }
@@ -50,8 +50,8 @@ macro_rules! combined_serializer {
         impl CombinedSerializer {
             fn find_serializer(
                 lookup_type: &str,
-                schema: &PyDict,
-                config: Option<&PyDict>,
+                schema: &Bound<'_, PyDict>,
+                config: Option<&Bound<'_, PyDict>>,
                 definitions: &mut DefinitionsBuilder<CombinedSerializer>
             ) -> PyResult<CombinedSerializer> {
                 match lookup_type {
@@ -146,16 +146,16 @@ combined_serializer! {
 
 impl CombinedSerializer {
     fn _build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
         let type_key = intern!(py, "type");
 
-        if let Some(ser_schema) = schema.get_as::<&PyDict>(intern!(py, "serialization"))? {
-            let op_ser_type: Option<&str> = ser_schema.get_as(type_key)?;
-            match op_ser_type {
+        if let Some(ser_schema) = schema.get_as::<Bound<'_, PyDict>>(intern!(py, "serialization"))? {
+            let op_ser_type: Option<Bound<'_, PyString>> = ser_schema.get_as(type_key)?;
+            match op_ser_type.as_ref().map(|py_str| py_str.to_str()).transpose()? {
                 Some("function-plain") => {
                     // `function-plain` is a special case, not included in `find_serializer` since it means
                     // something different in `schema.type`
@@ -185,15 +185,15 @@ impl CombinedSerializer {
                 Some(ser_type) => {
                     // otherwise if `schema.serialization.type` is defined, use that with `find_serializer`
                     // instead of `schema.type`. In this case it's an error if a serializer isn't found.
-                    return Self::find_serializer(ser_type, ser_schema, config, definitions);
+                    return Self::find_serializer(ser_type, &ser_schema, config, definitions);
                 }
                 // if `schema.serialization.type` is None, fall back to `schema.type`
                 None => (),
             };
         }
 
-        let type_: &str = schema.get_as_req(type_key)?;
-        Self::find_serializer(type_, schema, config, definitions)
+        let type_: Bound<'_, PyString> = schema.get_as_req(type_key)?;
+        Self::find_serializer(type_.to_str()?, schema, config, definitions)
     }
 }
 
@@ -202,8 +202,8 @@ impl BuildSerializer for CombinedSerializer {
     const EXPECTED_TYPE: &'static str = "";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         Self::_build(schema, config, definitions)
@@ -257,20 +257,20 @@ impl PyGcTraverse for CombinedSerializer {
 pub(crate) trait TypeSerializer: Send + Sync + Clone + Debug {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject>;
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>>;
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>>;
 
-    fn _invalid_as_json_key<'py>(
+    fn _invalid_as_json_key<'a>(
         &self,
-        key: &'py PyAny,
+        key: &'a Bound<'_, PyAny>,
         extra: &Extra,
         expected_type: &'static str,
-    ) -> PyResult<Cow<'py, str>> {
+    ) -> PyResult<Cow<'a, str>> {
         match extra.ob_type_lookup.is_type(key, ObType::None) {
             IsType::Exact | IsType::Subclass => py_err!(PyTypeError; "`{}` not valid as object key", expected_type),
             IsType::False => {
@@ -282,10 +282,10 @@ pub(crate) trait TypeSerializer: Send + Sync + Clone + Debug {
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error>;
 
@@ -302,19 +302,19 @@ pub(crate) trait TypeSerializer: Send + Sync + Clone + Debug {
 }
 
 pub(crate) struct PydanticSerializer<'py> {
-    value: &'py PyAny,
+    value: &'py Bound<'py, PyAny>,
     serializer: &'py CombinedSerializer,
-    include: Option<&'py PyAny>,
-    exclude: Option<&'py PyAny>,
+    include: Option<&'py Bound<'py, PyAny>>,
+    exclude: Option<&'py Bound<'py, PyAny>>,
     extra: &'py Extra<'py>,
 }
 
 impl<'py> PydanticSerializer<'py> {
     pub(crate) fn new(
-        value: &'py PyAny,
+        value: &'py Bound<'py, PyAny>,
         serializer: &'py CombinedSerializer,
-        include: Option<&'py PyAny>,
-        exclude: Option<&'py PyAny>,
+        include: Option<&'py Bound<'py, PyAny>>,
+        exclude: Option<&'py Bound<'py, PyAny>>,
         extra: &'py Extra<'py>,
     ) -> Self {
         Self {
@@ -336,10 +336,10 @@ impl<'py> Serialize for PydanticSerializer<'py> {
 
 #[allow(clippy::too_many_arguments)]
 pub(crate) fn to_json_bytes(
-    value: &PyAny,
+    value: &Bound<'_, PyAny>,
     serializer: &CombinedSerializer,
-    include: Option<&PyAny>,
-    exclude: Option<&PyAny>,
+    include: Option<&Bound<'_, PyAny>>,
+    exclude: Option<&Bound<'_, PyAny>>,
     extra: &Extra,
     indent: Option<usize>,
     expected_json_size: usize,
@@ -364,18 +364,25 @@ pub(crate) fn to_json_bytes(
     Ok(bytes)
 }
 
-pub(super) fn any_dataclass_iter<'py>(
-    dataclass: &'py PyAny,
-) -> PyResult<(impl Iterator<Item = PyResult<(&'py PyAny, &'py PyAny)>> + 'py, &PyDict)> {
+pub(super) fn any_dataclass_iter<'a, 'py>(
+    dataclass: &'a Bound<'py, PyAny>,
+) -> PyResult<(
+    impl Iterator<Item = PyResult<(Bound<'py, PyAny>, Bound<'py, PyAny>)>> + 'a,
+    Bound<'py, PyDict>,
+)>
+where
+    'py: 'a,
+{
     let py = dataclass.py();
-    let fields: &PyDict = dataclass.getattr(intern!(py, "__dataclass_fields__"))?.downcast()?;
+    let fields = dataclass
+        .getattr(intern!(py, "__dataclass_fields__"))?
+        .downcast_into::<PyDict>()?;
     let field_type_marker = get_field_marker(py)?;
 
-    let next = move |(field_name, field): (&'py PyAny, &'py PyAny)| -> PyResult<Option<(&'py PyAny, &'py PyAny)>> {
+    let next = move |(field_name, field): (Bound<'py, PyAny>, Bound<'py, PyAny>)| -> PyResult<Option<(Bound<'py, PyAny>, Bound<'py, PyAny>)>> {
         let field_type = field.getattr(intern!(py, "_field_type"))?;
-        if field_type.is(field_type_marker) {
-            let field_name: &PyString = field_name.downcast()?;
-            let value = dataclass.getattr(field_name)?;
+        if field_type.is(&field_type_marker) {
+            let value = dataclass.getattr(field_name.downcast::<PyString>()?)?;
             Ok(Some((field_name, value)))
         } else {
             Ok(None)
@@ -388,9 +395,9 @@ pub(super) fn any_dataclass_iter<'py>(
 static DC_FIELD_MARKER: GILOnceCell<PyObject> = GILOnceCell::new();
 
 /// needed to match the logic from dataclasses.fields `tuple(f for f in fields.values() if f._field_type is _FIELD)`
-fn get_field_marker(py: Python<'_>) -> PyResult<&PyAny> {
+fn get_field_marker(py: Python<'_>) -> PyResult<Bound<'_, PyAny>> {
     let field_type_marker_obj = DC_FIELD_MARKER.get_or_try_init(py, || {
-        py.import("dataclasses")?.getattr("_FIELD").map(|f| f.into_py(py))
+        py.import_bound("dataclasses")?.getattr("_FIELD").map(|f| f.into_py(py))
     })?;
-    Ok(field_type_marker_obj.as_ref(py))
+    Ok(field_type_marker_obj.bind(py).clone())
 }
diff --git a/src/serializers/type_serializers/any.rs b/src/serializers/type_serializers/any.rs
index f8815f3ef..179e2885d 100644
--- a/src/serializers/type_serializers/any.rs
+++ b/src/serializers/type_serializers/any.rs
@@ -18,8 +18,8 @@ impl BuildSerializer for AnySerializer {
     const EXPECTED_TYPE: &'static str = "any";
 
     fn build(
-        _schema: &PyDict,
-        _config: Option<&PyDict>,
+        _schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         Ok(Self {}.into())
@@ -31,24 +31,24 @@ impl_py_gc_traverse!(AnySerializer {});
 impl TypeSerializer for AnySerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         infer_to_python(value, include, exclude, extra)
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         infer_json_key(key, extra)
     }
 
     fn serde_serialize<S: Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         infer_serialize(value, serializer, include, exclude, extra)
diff --git a/src/serializers/type_serializers/bytes.rs b/src/serializers/type_serializers/bytes.rs
index bd354aa75..4fc53e224 100644
--- a/src/serializers/type_serializers/bytes.rs
+++ b/src/serializers/type_serializers/bytes.rs
@@ -20,8 +20,8 @@ impl BuildSerializer for BytesSerializer {
     const EXPECTED_TYPE: &'static str = "bytes";
 
     fn build(
-        _schema: &PyDict,
-        config: Option<&PyDict>,
+        _schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let bytes_mode = BytesMode::from_config(config)?;
@@ -34,9 +34,9 @@ impl_py_gc_traverse!(BytesSerializer {});
 impl TypeSerializer for BytesSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         let py = value.py();
@@ -55,7 +55,7 @@ impl TypeSerializer for BytesSerializer {
         }
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         match key.downcast::<PyBytes>() {
             Ok(py_bytes) => self.bytes_mode.bytes_to_string(key.py(), py_bytes.as_bytes()),
             Err(_) => {
@@ -67,10 +67,10 @@ impl TypeSerializer for BytesSerializer {
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         match value.downcast::<PyBytes>() {
diff --git a/src/serializers/type_serializers/dataclass.rs b/src/serializers/type_serializers/dataclass.rs
index 93548bcba..2c4954d4d 100644
--- a/src/serializers/type_serializers/dataclass.rs
+++ b/src/serializers/type_serializers/dataclass.rs
@@ -22,13 +22,13 @@ impl BuildSerializer for DataclassArgsBuilder {
     const EXPECTED_TYPE: &'static str = "dataclass-args";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
 
-        let fields_list: &PyList = schema.get_as_req(intern!(py, "fields"))?;
+        let fields_list: Bound<'_, PyList> = schema.get_as_req(intern!(py, "fields"))?;
         let mut fields: AHashMap<String, SerField> = AHashMap::with_capacity(fields_list.len());
 
         let fields_mode = match ExtraBehavior::from_schema_or_config(py, schema, config, ExtraBehavior::Ignore)? {
@@ -37,16 +37,16 @@ impl BuildSerializer for DataclassArgsBuilder {
         };
 
         for (index, item) in fields_list.iter().enumerate() {
-            let field_info: &PyDict = item.downcast()?;
+            let field_info = item.downcast::<PyDict>()?;
             let name: String = field_info.get_as_req(intern!(py, "name"))?;
 
-            let key_py: Py<PyString> = PyString::new(py, &name).into_py(py);
+            let key_py: Py<PyString> = PyString::new_bound(py, &name).into();
 
             if field_info.get_as(intern!(py, "serialization_exclude"))? == Some(true) {
                 fields.insert(name, SerField::new(py, key_py, None, None, true));
             } else {
                 let schema = field_info.get_as_req(intern!(py, "schema"))?;
-                let serializer = CombinedSerializer::build(schema, config, definitions)
+                let serializer = CombinedSerializer::build(&schema, config, definitions)
                     .map_err(|e| py_schema_error_type!("Field `{}`:\n  {}", index, e))?;
 
                 let alias = field_info.get_as(intern!(py, "serialization_alias"))?;
@@ -72,8 +72,8 @@ impl BuildSerializer for DataclassSerializer {
     const EXPECTED_TYPE: &'static str = "dataclass";
 
     fn build(
-        schema: &PyDict,
-        _config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
@@ -82,8 +82,8 @@ impl BuildSerializer for DataclassSerializer {
         let config = schema.get_as(intern!(py, "config"))?;
 
         let class: &PyType = schema.get_as_req(intern!(py, "cls"))?;
-        let sub_schema: &PyDict = schema.get_as_req(intern!(py, "schema"))?;
-        let serializer = Box::new(CombinedSerializer::build(sub_schema, config, definitions)?);
+        let sub_schema = schema.get_as_req(intern!(py, "schema"))?;
+        let serializer = Box::new(CombinedSerializer::build(&sub_schema, config.as_ref(), definitions)?);
 
         let fields = schema
             .get_as_req::<&PyList>(intern!(py, "fields"))?
@@ -102,20 +102,20 @@ impl BuildSerializer for DataclassSerializer {
 }
 
 impl DataclassSerializer {
-    fn allow_value(&self, value: &PyAny, extra: &Extra) -> PyResult<bool> {
+    fn allow_value(&self, value: &Bound<'_, PyAny>, extra: &Extra) -> PyResult<bool> {
         match extra.check {
-            SerCheck::Strict => Ok(value.get_type().is(self.class.as_ref(value.py()))),
-            SerCheck::Lax => value.is_instance(self.class.as_ref(value.py())),
+            SerCheck::Strict => Ok(value.get_type().is(self.class.bind(value.py()))),
+            SerCheck::Lax => value.is_instance(self.class.bind(value.py())),
             SerCheck::None => value.hasattr(intern!(value.py(), "__dataclass_fields__")),
         }
     }
 
-    fn get_inner_value<'py>(&self, value: &'py PyAny) -> PyResult<&'py PyAny> {
+    fn get_inner_value<'py>(&self, value: &Bound<'py, PyAny>) -> PyResult<Bound<'py, PyDict>> {
         let py = value.py();
-        let dict = PyDict::new(py);
+        let dict = PyDict::new_bound(py);
 
         for field_name in &self.fields {
-            let field_name = field_name.as_ref(py);
+            let field_name = field_name.bind(py);
             dict.set_item(field_name, value.getattr(field_name)?)?;
         }
         Ok(dict)
@@ -127,9 +127,9 @@ impl_py_gc_traverse!(DataclassSerializer { class, serializer });
 impl TypeSerializer for DataclassSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         let dc_extra = Extra {
@@ -147,11 +147,11 @@ impl TypeSerializer for DataclassSerializer {
                     dc_extra,
                 )?;
 
-                fields_serializer.add_computed_fields_python(Some(value), output_dict, include, exclude, extra)?;
+                fields_serializer.add_computed_fields_python(Some(value), &output_dict, include, exclude, extra)?;
                 Ok(output_dict.into_py(py))
             } else {
                 let inner_value = self.get_inner_value(value)?;
-                self.serializer.to_python(inner_value, include, exclude, &dc_extra)
+                self.serializer.to_python(&inner_value, include, exclude, &dc_extra)
             }
         } else {
             extra.warnings.on_fallback_py(self.get_name(), value, &dc_extra)?;
@@ -159,7 +159,7 @@ impl TypeSerializer for DataclassSerializer {
         }
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         if self.allow_value(key, extra)? {
             infer_json_key_known(ObType::Dataclass, key, extra)
         } else {
@@ -170,10 +170,10 @@ impl TypeSerializer for DataclassSerializer {
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         let model = Some(value);
@@ -194,7 +194,7 @@ impl TypeSerializer for DataclassSerializer {
             } else {
                 let inner_value = self.get_inner_value(value).map_err(py_err_se_err)?;
                 self.serializer
-                    .serde_serialize(inner_value, serializer, include, exclude, extra)
+                    .serde_serialize(&inner_value, serializer, include, exclude, extra)
             }
         } else {
             extra.warnings.on_fallback_ser::<S>(self.get_name(), value, extra)?;
@@ -213,15 +213,14 @@ impl TypeSerializer for DataclassSerializer {
 
 fn known_dataclass_iter<'a, 'py>(
     fields: &'a [Py<PyString>],
-    dataclass: &'py PyAny,
-) -> impl Iterator<Item = PyResult<(&'py PyAny, &'py PyAny)>> + 'a
+    dataclass: &'a Bound<'py, PyAny>,
+) -> impl Iterator<Item = PyResult<(Bound<'py, PyAny>, Bound<'py, PyAny>)>> + 'a
 where
     'py: 'a,
 {
     let py = dataclass.py();
     fields.iter().map(move |field| {
-        let field_ref = field.clone_ref(py).into_ref(py);
-        let value = dataclass.getattr(field_ref)?;
-        Ok((field_ref as &PyAny, value))
+        let value = dataclass.getattr(field)?;
+        Ok((field.bind(py).clone().into_any(), value))
     })
 }
diff --git a/src/serializers/type_serializers/datetime_etc.rs b/src/serializers/type_serializers/datetime_etc.rs
index f3b33208b..a042ae99b 100644
--- a/src/serializers/type_serializers/datetime_etc.rs
+++ b/src/serializers/type_serializers/datetime_etc.rs
@@ -12,19 +12,19 @@ use super::{
     SerMode, TypeSerializer,
 };
 
-pub(crate) fn datetime_to_string(py_dt: &PyDateTime) -> PyResult<String> {
+pub(crate) fn datetime_to_string(py_dt: &Bound<'_, PyDateTime>) -> PyResult<String> {
     pydatetime_as_datetime(py_dt).map(|dt| dt.to_string())
 }
 
-pub(crate) fn date_to_string(py_date: &PyDate) -> PyResult<String> {
+pub(crate) fn date_to_string(py_date: &Bound<'_, PyDate>) -> PyResult<String> {
     pydate_as_date(py_date).map(|dt| dt.to_string())
 }
 
-pub(crate) fn time_to_string(py_time: &PyTime) -> PyResult<String> {
+pub(crate) fn time_to_string(py_time: &Bound<'_, PyTime>) -> PyResult<String> {
     pytime_as_time(py_time, None).map(|dt| dt.to_string())
 }
 
-fn downcast_date_reject_datetime(py_date: &PyAny) -> PyResult<&PyDate> {
+fn downcast_date_reject_datetime<'a, 'py>(py_date: &'a Bound<'py, PyAny>) -> PyResult<&'a Bound<'py, PyDate>> {
     if let Ok(py_date) = py_date.downcast::<PyDate>() {
         // because `datetime` is a subclass of `date` we have to check that the value is not a
         // `datetime` to avoid lossy serialization
@@ -45,8 +45,8 @@ macro_rules! build_serializer {
             const EXPECTED_TYPE: &'static str = $expected_type;
 
             fn build(
-                _schema: &PyDict,
-                _config: Option<&PyDict>,
+                _schema: &Bound<'_, PyDict>,
+                _config: Option<&Bound<'_, PyDict>>,
                 _definitions: &mut DefinitionsBuilder<CombinedSerializer>,
             ) -> PyResult<CombinedSerializer> {
                 Ok(Self {}.into())
@@ -58,9 +58,9 @@ macro_rules! build_serializer {
         impl TypeSerializer for $struct_name {
             fn to_python(
                 &self,
-                value: &PyAny,
-                include: Option<&PyAny>,
-                exclude: Option<&PyAny>,
+                value: &Bound<'_, PyAny>,
+                include: Option<&Bound<'_, PyAny>>,
+                exclude: Option<&Bound<'_, PyAny>>,
                 extra: &Extra,
             ) -> PyResult<PyObject> {
                 let py = value.py();
@@ -79,7 +79,7 @@ macro_rules! build_serializer {
                 }
             }
 
-            fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+            fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
                 match $downcast(key) {
                     Ok(py_value) => Ok(Cow::Owned($convert_func(py_value)?)),
                     Err(_) => {
@@ -91,10 +91,10 @@ macro_rules! build_serializer {
 
             fn serde_serialize<S: serde::ser::Serializer>(
                 &self,
-                value: &PyAny,
+                value: &Bound<'_, PyAny>,
                 serializer: S,
-                include: Option<&PyAny>,
-                exclude: Option<&PyAny>,
+                include: Option<&Bound<'_, PyAny>>,
+                exclude: Option<&Bound<'_, PyAny>>,
                 extra: &Extra,
             ) -> Result<S::Ok, S::Error> {
                 match $downcast(value) {
@@ -121,8 +121,8 @@ macro_rules! build_serializer {
 build_serializer!(
     DatetimeSerializer,
     "datetime",
-    PyAny::downcast::<PyDateTime>,
+    PyAnyMethods::downcast::<PyDateTime>,
     datetime_to_string
 );
 build_serializer!(DateSerializer, "date", downcast_date_reject_datetime, date_to_string);
-build_serializer!(TimeSerializer, "time", PyAny::downcast::<PyTime>, time_to_string);
+build_serializer!(TimeSerializer, "time", PyAnyMethods::downcast::<PyTime>, time_to_string);
diff --git a/src/serializers/type_serializers/decimal.rs b/src/serializers/type_serializers/decimal.rs
index 674fd5577..6237f53cb 100644
--- a/src/serializers/type_serializers/decimal.rs
+++ b/src/serializers/type_serializers/decimal.rs
@@ -18,8 +18,8 @@ impl BuildSerializer for DecimalSerializer {
     const EXPECTED_TYPE: &'static str = "decimal";
 
     fn build(
-        _schema: &PyDict,
-        _config: Option<&PyDict>,
+        _schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         Ok(Self {}.into())
@@ -31,9 +31,9 @@ impl_py_gc_traverse!(DecimalSerializer {});
 impl TypeSerializer for DecimalSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         let _py = value.py();
@@ -46,7 +46,7 @@ impl TypeSerializer for DecimalSerializer {
         }
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         match extra.ob_type_lookup.is_type(key, ObType::Decimal) {
             IsType::Exact | IsType::Subclass => infer_json_key_known(ObType::Decimal, key, extra),
             IsType::False => {
@@ -58,10 +58,10 @@ impl TypeSerializer for DecimalSerializer {
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         match extra.ob_type_lookup.is_type(value, ObType::Decimal) {
diff --git a/src/serializers/type_serializers/definitions.rs b/src/serializers/type_serializers/definitions.rs
index 3e2d48b19..071e50f8c 100644
--- a/src/serializers/type_serializers/definitions.rs
+++ b/src/serializers/type_serializers/definitions.rs
@@ -2,6 +2,7 @@ use std::borrow::Cow;
 
 use pyo3::intern;
 use pyo3::prelude::*;
+use pyo3::pybacked::PyBackedStr;
 use pyo3::types::{PyDict, PyList};
 
 use crate::definitions::DefinitionsBuilder;
@@ -18,24 +19,23 @@ impl BuildSerializer for DefinitionsSerializerBuilder {
     const EXPECTED_TYPE: &'static str = "definitions";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
 
-        let schema_definitions: &PyList = schema.get_as_req(intern!(py, "definitions"))?;
+        let schema_definitions: Bound<'_, PyList> = schema.get_as_req(intern!(py, "definitions"))?;
 
         for schema_definition in schema_definitions {
-            let reference = schema_definition
-                .extract::<&PyDict>()?
-                .get_as_req::<String>(intern!(py, "ref"))?;
-            let serializer = CombinedSerializer::build(schema_definition.downcast()?, config, definitions)?;
+            let schema = schema_definition.downcast()?;
+            let reference = schema.get_as_req::<String>(intern!(py, "ref"))?;
+            let serializer = CombinedSerializer::build(schema, config, definitions)?;
             definitions.add_definition(reference, serializer)?;
         }
 
-        let inner_schema: &PyDict = schema.get_as_req(intern!(py, "schema"))?;
-        CombinedSerializer::build(inner_schema, config, definitions)
+        let inner_schema = schema.get_as_req(intern!(py, "schema"))?;
+        CombinedSerializer::build(&inner_schema, config, definitions)
     }
 }
 
@@ -67,12 +67,12 @@ impl BuildSerializer for DefinitionRefSerializer {
     const EXPECTED_TYPE: &'static str = "definition-ref";
 
     fn build(
-        schema: &PyDict,
-        _config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
-        let schema_ref = schema.get_as_req(intern!(schema.py(), "schema_ref"))?;
-        let definition = definitions.get_definition(schema_ref);
+        let schema_ref: PyBackedStr = schema.get_as_req(intern!(schema.py(), "schema_ref"))?;
+        let definition = definitions.get_definition(&schema_ref);
         Ok(Self {
             definition,
             retry_with_lax_check: RecursionSafeCache::new(),
@@ -86,9 +86,9 @@ impl_py_gc_traverse!(DefinitionRefSerializer {});
 impl TypeSerializer for DefinitionRefSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         mut extra: &Extra,
     ) -> PyResult<PyObject> {
         self.definition.read(|comb_serializer| {
@@ -98,16 +98,16 @@ impl TypeSerializer for DefinitionRefSerializer {
         })
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         self.definition.read(|s| s.unwrap().json_key(key, extra))
     }
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         mut extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         self.definition.read(|comb_serializer| {
diff --git a/src/serializers/type_serializers/dict.rs b/src/serializers/type_serializers/dict.rs
index 89851752e..cf4458bd7 100644
--- a/src/serializers/type_serializers/dict.rs
+++ b/src/serializers/type_serializers/dict.rs
@@ -28,24 +28,24 @@ impl BuildSerializer for DictSerializer {
     const EXPECTED_TYPE: &'static str = "dict";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
-        let key_serializer = match schema.get_as::<&PyDict>(intern!(py, "keys_schema"))? {
-            Some(items_schema) => CombinedSerializer::build(items_schema, config, definitions)?,
+        let key_serializer = match schema.get_as(intern!(py, "keys_schema"))? {
+            Some(items_schema) => CombinedSerializer::build(&items_schema, config, definitions)?,
             None => AnySerializer::build(schema, config, definitions)?,
         };
-        let value_serializer = match schema.get_as::<&PyDict>(intern!(py, "values_schema"))? {
-            Some(items_schema) => CombinedSerializer::build(items_schema, config, definitions)?,
+        let value_serializer = match schema.get_as(intern!(py, "values_schema"))? {
+            Some(items_schema) => CombinedSerializer::build(&items_schema, config, definitions)?,
             None => AnySerializer::build(schema, config, definitions)?,
         };
-        let filter = match schema.get_as::<&PyDict>(intern!(py, "serialization"))? {
+        let filter = match schema.get_as::<Bound<'_, PyDict>>(intern!(py, "serialization"))? {
             Some(ser) => {
                 let include = ser.get_item(intern!(py, "include"))?;
                 let exclude = ser.get_item(intern!(py, "exclude"))?;
-                SchemaFilter::from_set_hash(include, exclude)?
+                SchemaFilter::from_set_hash(include.as_ref(), exclude.as_ref())?
             }
             None => SchemaFilter::default(),
         };
@@ -73,9 +73,9 @@ impl_py_gc_traverse!(DictSerializer {
 impl TypeSerializer for DictSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         let py = value.py();
@@ -83,15 +83,16 @@ impl TypeSerializer for DictSerializer {
             Ok(py_dict) => {
                 let value_serializer = self.value_serializer.as_ref();
 
-                let new_dict = PyDict::new(py);
-                for (key, value) in py_dict {
-                    let op_next = self.filter.key_filter(key, include, exclude)?;
+                let new_dict = PyDict::new_bound(py);
+                for (key, value) in py_dict.iter() {
+                    let op_next = self.filter.key_filter(&key, include, exclude)?;
                     if let Some((next_include, next_exclude)) = op_next {
                         let key = match extra.mode {
-                            SerMode::Json => self.key_serializer.json_key(key, extra)?.into_py(py),
-                            _ => self.key_serializer.to_python(key, None, None, extra)?,
+                            SerMode::Json => self.key_serializer.json_key(&key, extra)?.into_py(py),
+                            _ => self.key_serializer.to_python(&key, None, None, extra)?,
                         };
-                        let value = value_serializer.to_python(value, next_include, next_exclude, extra)?;
+                        let value =
+                            value_serializer.to_python(&value, next_include.as_ref(), next_exclude.as_ref(), extra)?;
                         new_dict.set_item(key, value)?;
                     }
                 }
@@ -104,16 +105,16 @@ impl TypeSerializer for DictSerializer {
         }
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         self._invalid_as_json_key(key, extra, Self::EXPECTED_TYPE)
     }
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         match value.downcast::<PyDict>() {
@@ -122,12 +123,17 @@ impl TypeSerializer for DictSerializer {
                 let key_serializer = self.key_serializer.as_ref();
                 let value_serializer = self.value_serializer.as_ref();
 
-                for (key, value) in py_dict {
-                    let op_next = self.filter.key_filter(key, include, exclude).map_err(py_err_se_err)?;
+                for (key, value) in py_dict.iter() {
+                    let op_next = self.filter.key_filter(&key, include, exclude).map_err(py_err_se_err)?;
                     if let Some((next_include, next_exclude)) = op_next {
-                        let key = key_serializer.json_key(key, extra).map_err(py_err_se_err)?;
-                        let value_serialize =
-                            PydanticSerializer::new(value, value_serializer, next_include, next_exclude, extra);
+                        let key = key_serializer.json_key(&key, extra).map_err(py_err_se_err)?;
+                        let value_serialize = PydanticSerializer::new(
+                            &value,
+                            value_serializer,
+                            next_include.as_ref(),
+                            next_exclude.as_ref(),
+                            extra,
+                        );
                         map.serialize_entry(&key, &value_serialize)?;
                     }
                 }
diff --git a/src/serializers/type_serializers/float.rs b/src/serializers/type_serializers/float.rs
index 23dcacf1a..7abf28999 100644
--- a/src/serializers/type_serializers/float.rs
+++ b/src/serializers/type_serializers/float.rs
@@ -24,8 +24,8 @@ impl BuildSerializer for FloatSerializer {
     const EXPECTED_TYPE: &'static str = "float";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let inf_nan_mode = config
@@ -41,9 +41,9 @@ impl_py_gc_traverse!(FloatSerializer {});
 impl TypeSerializer for FloatSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         let py = value.py();
@@ -63,7 +63,7 @@ impl TypeSerializer for FloatSerializer {
         }
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         match extra.ob_type_lookup.is_type(key, ObType::Float) {
             IsType::Exact | IsType::Subclass => to_str_json_key(key),
             IsType::False => {
@@ -75,10 +75,10 @@ impl TypeSerializer for FloatSerializer {
 
     fn serde_serialize<S: Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         match value.extract::<f64>() {
diff --git a/src/serializers/type_serializers/format.rs b/src/serializers/type_serializers/format.rs
index 2de5788e0..1991a2086 100644
--- a/src/serializers/type_serializers/format.rs
+++ b/src/serializers/type_serializers/format.rs
@@ -23,19 +23,19 @@ pub(super) enum WhenUsed {
 }
 
 impl WhenUsed {
-    pub fn new(schema: &PyDict, default: Self) -> PyResult<Self> {
-        let when_used = schema.get_as(intern!(schema.py(), "when_used"))?;
-        match when_used {
-            Some("always") => Ok(Self::Always),
-            Some("unless-none") => Ok(Self::UnlessNone),
-            Some("json") => Ok(Self::Json),
-            Some("json-unless-none") => Ok(Self::JsonUnlessNone),
-            Some(s) => py_schema_err!("Invalid value for `when_used`: {:?}", s),
+    pub fn new(schema: &Bound<'_, PyDict>, default: Self) -> PyResult<Self> {
+        let when_used = schema.get_as::<Bound<'_, PyString>>(intern!(schema.py(), "when_used"))?;
+        match when_used.as_ref().map(|s| s.to_str()) {
+            Some(Ok("always")) => Ok(Self::Always),
+            Some(Ok("unless-none")) => Ok(Self::UnlessNone),
+            Some(Ok("json")) => Ok(Self::Json),
+            Some(Ok("json-unless-none")) => Ok(Self::JsonUnlessNone),
+            Some(s) => py_schema_err!("Invalid value for `when_used`: {:?}", s?),
             None => Ok(default),
         }
     }
 
-    pub fn should_use(&self, value: &PyAny, extra: &Extra) -> bool {
+    pub fn should_use(&self, value: &Bound<'_, PyAny>, extra: &Extra) -> bool {
         match self {
             Self::Always => true,
             Self::UnlessNone => !value.is_none(),
@@ -45,7 +45,7 @@ impl WhenUsed {
     }
 
     /// Equivalent to `self.should_use` when we already know we're in JSON mode
-    pub fn should_use_json(&self, value: &PyAny) -> bool {
+    pub fn should_use_json(&self, value: &Bound<'_, PyAny>) -> bool {
         match self {
             Self::Always | Self::Json => true,
             _ => !value.is_none(),
@@ -64,21 +64,22 @@ impl BuildSerializer for FormatSerializer {
     const EXPECTED_TYPE: &'static str = "format";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
-        let formatting_string: &str = schema.get_as_req(intern!(py, "formatting_string"))?;
+        let formatting_string: Bound<'_, PyString> = schema.get_as_req(intern!(py, "formatting_string"))?;
+        let formatting_string = formatting_string.to_str()?;
         if formatting_string.is_empty() {
             ToStringSerializer::build(schema, config, definitions)
         } else {
             Ok(Self {
                 format_func: py
-                    .import(intern!(py, "builtins"))?
+                    .import_bound(intern!(py, "builtins"))?
                     .getattr(intern!(py, "format"))?
                     .into_py(py),
-                formatting_string: PyString::new(py, formatting_string).into_py(py),
+                formatting_string: PyString::new_bound(py, formatting_string).into(),
                 when_used: WhenUsed::new(schema, WhenUsed::JsonUnlessNone)?,
             }
             .into())
@@ -87,17 +88,17 @@ impl BuildSerializer for FormatSerializer {
 }
 
 impl FormatSerializer {
-    fn call(&self, value: &PyAny) -> Result<PyObject, String> {
+    fn call(&self, value: &Bound<'_, PyAny>) -> Result<PyObject, String> {
         let py = value.py();
         self.format_func
-            .call1(py, (value, self.formatting_string.as_ref(py)))
+            .call1(py, (value, &self.formatting_string))
             .map_err(|e| {
                 format!(
                     "Error calling `format(value, {})`: {}",
                     self.formatting_string
-                        .as_ref(py)
+                        .bind(py)
                         .repr()
-                        .unwrap_or_else(|_| intern!(py, "???")),
+                        .unwrap_or_else(|_| intern!(py, "???").clone()),
                     e
                 )
             })
@@ -109,9 +110,9 @@ impl_py_gc_traverse!(FormatSerializer { format_func });
 impl TypeSerializer for FormatSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        _include: Option<&PyAny>,
-        _exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        _include: Option<&Bound<'_, PyAny>>,
+        _exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         if self.when_used.should_use(value, extra) {
@@ -121,11 +122,14 @@ impl TypeSerializer for FormatSerializer {
         }
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, _extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'py>(&self, key: &Bound<'py, PyAny>, _extra: &Extra) -> PyResult<Cow<'py, str>> {
         if self.when_used.should_use_json(key) {
-            let v = self.call(key).map_err(PydanticSerializationError::new_err)?;
-            let py_str: &PyString = v.into_ref(key.py()).downcast()?;
-            Ok(Cow::Borrowed(py_str.to_str()?))
+            let py_str = self
+                .call(key)
+                .map_err(PydanticSerializationError::new_err)?
+                .into_bound(key.py())
+                .downcast_into::<PyString>()?;
+            Ok(Cow::Owned(py_str.to_str()?.to_owned()))
         } else {
             none_json_key()
         }
@@ -133,16 +137,16 @@ impl TypeSerializer for FormatSerializer {
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        _include: Option<&PyAny>,
-        _exclude: Option<&PyAny>,
+        _include: Option<&Bound<'_, PyAny>>,
+        _exclude: Option<&Bound<'_, PyAny>>,
         _extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         if self.when_used.should_use_json(value) {
             match self.call(value) {
                 Ok(v) => {
-                    let py_str: &PyString = v.downcast(value.py()).map_err(py_err_se_err)?;
+                    let py_str = v.bind(value.py()).downcast().map_err(py_err_se_err)?;
                     serialize_py_str(py_str, serializer)
                 }
                 Err(e) => Err(S::Error::custom(e)),
@@ -166,8 +170,8 @@ impl BuildSerializer for ToStringSerializer {
     const EXPECTED_TYPE: &'static str = "to-string";
 
     fn build(
-        schema: &PyDict,
-        _config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         Ok(Self {
@@ -182,9 +186,9 @@ impl_py_gc_traverse!(ToStringSerializer {});
 impl TypeSerializer for ToStringSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        _include: Option<&PyAny>,
-        _exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        _include: Option<&Bound<'_, PyAny>>,
+        _exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         if self.when_used.should_use(value, extra) {
@@ -194,9 +198,9 @@ impl TypeSerializer for ToStringSerializer {
         }
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, _extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'py>(&self, key: &Bound<'py, PyAny>, _extra: &Extra) -> PyResult<Cow<'py, str>> {
         if self.when_used.should_use_json(key) {
-            Ok(key.str()?.to_string_lossy())
+            Ok(Cow::Owned(key.str()?.to_string_lossy().into_owned()))
         } else {
             none_json_key()
         }
@@ -204,15 +208,15 @@ impl TypeSerializer for ToStringSerializer {
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        _include: Option<&PyAny>,
-        _exclude: Option<&PyAny>,
+        _include: Option<&Bound<'_, PyAny>>,
+        _exclude: Option<&Bound<'_, PyAny>>,
         _extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         if self.when_used.should_use_json(value) {
             let s = value.str().map_err(py_err_se_err)?;
-            serialize_py_str(s, serializer)
+            serialize_py_str(&s, serializer)
         } else {
             serializer.serialize_none()
         }
diff --git a/src/serializers/type_serializers/function.rs b/src/serializers/type_serializers/function.rs
index 170009383..415db806a 100644
--- a/src/serializers/type_serializers/function.rs
+++ b/src/serializers/type_serializers/function.rs
@@ -28,14 +28,14 @@ impl BuildSerializer for FunctionBeforeSerializerBuilder {
     const EXPECTED_TYPE: &'static str = "function-before";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
         // `before` schemas will obviously have type from `schema` since the validator is called second
         let schema = schema.get_as_req(intern!(py, "schema"))?;
-        CombinedSerializer::build(schema, config, definitions)
+        CombinedSerializer::build(&schema, config, definitions)
     }
 }
 
@@ -44,8 +44,8 @@ pub struct FunctionAfterSerializerBuilder;
 impl BuildSerializer for FunctionAfterSerializerBuilder {
     const EXPECTED_TYPE: &'static str = "function-after";
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
@@ -54,7 +54,7 @@ impl BuildSerializer for FunctionAfterSerializerBuilder {
         // be used for serialization. For convenience, the default is to assume the wrapped schema
         // should be used; the user/lib can override the serializer if necessary.
         let schema = schema.get_as_req(intern!(py, "schema"))?;
-        CombinedSerializer::build(schema, config, definitions)
+        CombinedSerializer::build(&schema, config, definitions)
     }
 }
 
@@ -63,8 +63,8 @@ pub struct FunctionPlainSerializerBuilder;
 impl BuildSerializer for FunctionPlainSerializerBuilder {
     const EXPECTED_TYPE: &'static str = "function-plain";
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         super::any::AnySerializer::build(schema, config, definitions)
@@ -84,8 +84,8 @@ pub struct FunctionPlainSerializer {
     info_arg: bool,
 }
 
-fn destructure_function_schema(schema: &PyDict) -> PyResult<(bool, bool, &PyAny)> {
-    let function: &PyAny = schema.get_as_req(intern!(schema.py(), "function"))?;
+fn destructure_function_schema<'py>(schema: &Bound<'py, PyDict>) -> PyResult<(bool, bool, Bound<'py, PyAny>)> {
+    let function = schema.get_as_req(intern!(schema.py(), "function"))?;
     let is_field_serializer: bool = schema
         .get_as(intern!(schema.py(), "is_field_serializer"))?
         .unwrap_or(false);
@@ -99,28 +99,28 @@ impl BuildSerializer for FunctionPlainSerializer {
     /// NOTE! `schema` here is the actual `CoreSchema`, not `schema.serialization` as in the other builders
     /// (done this way to match `FunctionWrapSerializer` which requires the full schema)
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
 
-        let ser_schema: &PyDict = schema.get_as_req(intern!(py, "serialization"))?;
+        let ser_schema = schema.get_as_req(intern!(py, "serialization"))?;
 
-        let (is_field_serializer, info_arg, function) = destructure_function_schema(ser_schema)?;
-        let function_name = function_name(function)?;
+        let (is_field_serializer, info_arg, function) = destructure_function_schema(&ser_schema)?;
+        let function_name = function_name(&function)?;
 
-        let return_serializer = match ser_schema.get_as::<&PyDict>(intern!(py, "return_schema"))? {
-            Some(s) => Box::new(CombinedSerializer::build(s, config, definitions)?),
+        let return_serializer = match ser_schema.get_as(intern!(py, "return_schema"))? {
+            Some(s) => Box::new(CombinedSerializer::build(&s, config, definitions)?),
             None => Box::new(AnySerializer::build(schema, config, definitions)?),
         };
 
-        let when_used = WhenUsed::new(ser_schema, WhenUsed::Always)?;
+        let when_used = WhenUsed::new(&ser_schema, WhenUsed::Always)?;
         let fallback_serializer = match when_used {
             WhenUsed::Always => None,
             _ => {
                 let new_schema = copy_outer_schema(schema)?;
-                Some(Box::new(CombinedSerializer::build(new_schema, config, definitions)?))
+                Some(Box::new(CombinedSerializer::build(&new_schema, config, definitions)?))
             }
         };
 
@@ -142,9 +142,9 @@ impl BuildSerializer for FunctionPlainSerializer {
 impl FunctionPlainSerializer {
     fn call(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<(bool, PyObject)> {
         let py = value.py();
@@ -181,7 +181,7 @@ impl FunctionPlainSerializer {
 }
 
 fn on_error(py: Python, err: PyErr, function_name: &str, extra: &Extra) -> PyResult<()> {
-    let exception = err.value(py);
+    let exception = err.value_bound(py);
     if let Ok(ser_err) = exception.extract::<PydanticSerializationUnexpectedValue>() {
         if extra.check.enabled() {
             Err(err)
@@ -205,20 +205,18 @@ macro_rules! function_type_serializer {
         impl TypeSerializer for $name {
             fn to_python(
                 &self,
-                value: &PyAny,
-                include: Option<&PyAny>,
-                exclude: Option<&PyAny>,
+                value: &Bound<'_, PyAny>,
+                include: Option<&Bound<'_, PyAny>>,
+                exclude: Option<&Bound<'_, PyAny>>,
                 extra: &Extra,
             ) -> PyResult<PyObject> {
                 let py = value.py();
                 match self.call(value, include, exclude, extra) {
                     // None for include/exclude here, as filtering should be done
-                    Ok((true, v)) => self
-                        .return_serializer
-                        .to_python(v.into_ref(py), None, None, extra),
+                    Ok((true, v)) => self.return_serializer.to_python(v.bind(py), None, None, extra),
                     Ok((false, v)) => self
                         .get_fallback_serializer()
-                        .to_python(v.into_ref(py), None, None, extra),
+                        .to_python(v.bind(py), None, None, extra),
                     Err(err) => {
                         on_error(py, err, &self.function_name, extra)?;
                         infer_to_python(value, include, exclude, extra)
@@ -226,11 +224,17 @@ macro_rules! function_type_serializer {
                 }
             }
 
-            fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+            fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
                 let py = key.py();
                 match self.call(key, None, None, extra) {
-                    Ok((true, v)) => self.return_serializer.json_key(v.into_ref(py), extra),
-                    Ok((false, v)) => self.get_fallback_serializer().json_key(v.into_ref(py), extra),
+                    Ok((true, v)) => self
+                        .return_serializer
+                        .json_key(v.bind(py), extra)
+                        .map(|cow| Cow::Owned(cow.into_owned())),
+                    Ok((false, v)) => self
+                        .get_fallback_serializer()
+                        .json_key(v.bind(py), extra)
+                        .map(|cow| Cow::Owned(cow.into_owned())),
                     Err(err) => {
                         on_error(py, err, &self.function_name, extra)?;
                         infer_json_key(key, extra)
@@ -240,22 +244,21 @@ macro_rules! function_type_serializer {
 
             fn serde_serialize<S: serde::ser::Serializer>(
                 &self,
-                value: &PyAny,
+                value: &Bound<'_, PyAny>,
                 serializer: S,
-                include: Option<&PyAny>,
-                exclude: Option<&PyAny>,
+                include: Option<&Bound<'_, PyAny>>,
+                exclude: Option<&Bound<'_, PyAny>>,
                 extra: &Extra,
             ) -> Result<S::Ok, S::Error> {
                 let py = value.py();
                 match self.call(value, include, exclude, extra) {
                     // None for include/exclude here, as filtering should be done
-                    Ok((true, v)) => {
-                        self.return_serializer
-                            .serde_serialize(v.into_ref(py), serializer, None, None, extra)
-                    }
+                    Ok((true, v)) => self
+                        .return_serializer
+                        .serde_serialize(v.bind(py), serializer, None, None, extra),
                     Ok((false, v)) => {
                         self.get_fallback_serializer()
-                            .serde_serialize(v.into_ref(py), serializer, None, None, extra)
+                            .serde_serialize(v.bind(py), serializer, None, None, extra)
                     }
                     Err(err) => {
                         on_error(py, err, &self.function_name, extra).map_err(py_err_se_err)?;
@@ -279,7 +282,7 @@ impl_py_gc_traverse!(FunctionPlainSerializer {
 
 function_type_serializer!(FunctionPlainSerializer);
 
-fn copy_outer_schema(schema: &PyDict) -> PyResult<&PyDict> {
+fn copy_outer_schema<'py>(schema: &Bound<'py, PyDict>) -> PyResult<Bound<'py, PyDict>> {
     let py = schema.py();
     // we copy the schema so we can modify it without affecting the original
     let schema_copy = schema.copy()?;
@@ -297,8 +300,8 @@ pub struct FunctionWrapSerializerBuilder;
 impl BuildSerializer for FunctionWrapSerializerBuilder {
     const EXPECTED_TYPE: &'static str = "function-wrap";
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
@@ -307,7 +310,7 @@ impl BuildSerializer for FunctionWrapSerializerBuilder {
         // schema should be used for serialization. For convenience, the default is to assume the
         // wrapped schema should be used; the user/lib can override the serializer if necessary.
         let schema = schema.get_as_req(intern!(py, "schema"))?;
-        CombinedSerializer::build(schema, config, definitions)
+        CombinedSerializer::build(&schema, config, definitions)
     }
 }
 
@@ -329,27 +332,27 @@ impl BuildSerializer for FunctionWrapSerializer {
     /// NOTE! `schema` here is the actual `CoreSchema`, not `schema.serialization` as in the other builders
     /// (done this way since we need the `CoreSchema`)
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
-        let ser_schema: &PyDict = schema.get_as_req(intern!(py, "serialization"))?;
+        let ser_schema = schema.get_as_req(intern!(py, "serialization"))?;
 
-        let (is_field_serializer, info_arg, function) = destructure_function_schema(ser_schema)?;
-        let function_name = function_name(function)?;
+        let (is_field_serializer, info_arg, function) = destructure_function_schema(&ser_schema)?;
+        let function_name = function_name(&function)?;
 
         // try to get `schema.serialization.schema`, otherwise use `schema` with `serialization` key removed
-        let inner_schema: &PyDict = if let Some(s) = ser_schema.get_as(intern!(py, "schema"))? {
+        let inner_schema = if let Some(s) = ser_schema.get_as(intern!(py, "schema"))? {
             s
         } else {
             copy_outer_schema(schema)?
         };
 
-        let serializer = CombinedSerializer::build(inner_schema, config, definitions)?;
+        let serializer = CombinedSerializer::build(&inner_schema, config, definitions)?;
 
-        let return_serializer = match ser_schema.get_as::<&PyDict>(intern!(py, "return_schema"))? {
-            Some(s) => CombinedSerializer::build(s, config, definitions)?,
+        let return_serializer = match ser_schema.get_as(intern!(py, "return_schema"))? {
+            Some(s) => CombinedSerializer::build(&s, config, definitions)?,
             None => AnySerializer::build(schema, config, definitions)?,
         };
 
@@ -360,7 +363,7 @@ impl BuildSerializer for FunctionWrapSerializer {
             function_name,
             name,
             return_serializer: Box::new(return_serializer),
-            when_used: WhenUsed::new(ser_schema, WhenUsed::Always)?,
+            when_used: WhenUsed::new(&ser_schema, WhenUsed::Always)?,
             is_field_serializer,
             info_arg,
         }
@@ -371,9 +374,9 @@ impl BuildSerializer for FunctionWrapSerializer {
 impl FunctionWrapSerializer {
     fn call(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<(bool, PyObject)> {
         let py = value.py();
@@ -430,8 +433,8 @@ impl SerializationCallable {
     pub fn new(
         py: Python,
         serializer: &CombinedSerializer,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Self {
         Self {
@@ -473,9 +476,14 @@ impl SerializationCallable {
 
 #[pymethods]
 impl SerializationCallable {
-    fn __call__(&mut self, py: Python, value: &PyAny, index_key: Option<&PyAny>) -> PyResult<Option<PyObject>> {
-        let include = self.include.as_ref().map(|o| o.as_ref(py));
-        let exclude = self.exclude.as_ref().map(|o| o.as_ref(py));
+    fn __call__(
+        &mut self,
+        py: Python,
+        value: &Bound<'_, PyAny>,
+        index_key: Option<&Bound<'_, PyAny>>,
+    ) -> PyResult<Option<PyObject>> {
+        let include = self.include.as_ref().map(|o| o.bind(py));
+        let exclude = self.exclude.as_ref().map(|o| o.bind(py));
         let extra = self.extra_owned.to_extra(py);
 
         if let Some(index_key) = index_key {
@@ -485,7 +493,9 @@ impl SerializationCallable {
                 self.filter.key_filter(index_key, include, exclude)?
             };
             if let Some((next_include, next_exclude)) = filter {
-                let v = self.serializer.to_python(value, next_include, next_exclude, &extra)?;
+                let v = self
+                    .serializer
+                    .to_python(value, next_include.as_ref(), next_exclude.as_ref(), &extra)?;
                 extra.warnings.final_check(py)?;
                 Ok(Some(v))
             } else {
@@ -536,8 +546,8 @@ struct SerializationInfo {
 impl SerializationInfo {
     fn new(
         py: Python,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
         is_field_serializer: bool,
     ) -> PyResult<Self> {
@@ -546,7 +556,7 @@ impl SerializationInfo {
                 Some(field_name) => Ok(Self {
                     include: include.map(|i| i.into_py(py)),
                     exclude: exclude.map(|e| e.into_py(py)),
-                    context: extra.context.map(Into::into),
+                    context: extra.context.map(|c| c.into_py(py)),
                     _mode: extra.mode.clone(),
                     by_alias: extra.by_alias,
                     exclude_unset: extra.exclude_unset,
@@ -563,7 +573,7 @@ impl SerializationInfo {
             Ok(Self {
                 include: include.map(|i| i.into_py(py)),
                 exclude: exclude.map(|e| e.into_py(py)),
-                context: extra.context.map(Into::into),
+                context: extra.context.map(|c| c.into_py(py)),
                 _mode: extra.mode.clone(),
                 by_alias: extra.by_alias,
                 exclude_unset: extra.exclude_unset,
@@ -607,8 +617,8 @@ impl SerializationInfo {
     }
 
     #[getter]
-    fn __dict__<'py>(&'py self, py: Python<'py>) -> PyResult<&'py PyDict> {
-        let d = PyDict::new(py);
+    fn __dict__<'py>(&'py self, py: Python<'py>) -> PyResult<Bound<'py, PyDict>> {
+        let d = PyDict::new_bound(py);
         if let Some(ref include) = self.include {
             d.set_item("include", include)?;
         }
@@ -631,16 +641,16 @@ impl SerializationInfo {
         Ok(format!(
             "SerializationInfo(include={}, exclude={}, context={}, mode='{}', by_alias={}, exclude_unset={}, exclude_defaults={}, exclude_none={}, round_trip={})",
             match self.include {
-                Some(ref include) => include.as_ref(py).repr()?.to_str()?,
-                None => "None",
+                Some(ref include) => include.bind(py).repr()?.to_str()?.to_owned(),
+                None => "None".to_owned(),
             },
             match self.exclude {
-                Some(ref exclude) => exclude.as_ref(py).repr()?.to_str()?,
-                None => "None",
+                Some(ref exclude) => exclude.bind(py).repr()?.to_str()?.to_owned(),
+                None => "None".to_owned(),
             },
             match self.context {
-                Some(ref context) => context.as_ref(py).repr()?.to_str()?,
-                None => "None",
+                Some(ref context) => context.bind(py).repr()?.to_str()?.to_owned(),
+                None => "None".to_owned(),
             },
             self._mode,
             py_bool(self.by_alias),
@@ -655,9 +665,9 @@ impl SerializationInfo {
         self.__repr__(py)
     }
     #[getter]
-    fn get_field_name<'py>(&self, py: Python<'py>) -> PyResult<&'py PyString> {
+    fn get_field_name<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyString>> {
         match self.field_name {
-            Some(ref field_name) => Ok(PyString::new(py, field_name)),
+            Some(ref field_name) => Ok(PyString::new_bound(py, field_name)),
             None => Err(PyAttributeError::new_err("No attribute named 'field_name'")),
         }
     }
diff --git a/src/serializers/type_serializers/generator.rs b/src/serializers/type_serializers/generator.rs
index 4637bc44e..d7d211456 100644
--- a/src/serializers/type_serializers/generator.rs
+++ b/src/serializers/type_serializers/generator.rs
@@ -27,13 +27,13 @@ impl BuildSerializer for GeneratorSerializer {
     const EXPECTED_TYPE: &'static str = "generator";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
-        let item_serializer = match schema.get_as::<&PyDict>(intern!(py, "items_schema"))? {
-            Some(items_schema) => CombinedSerializer::build(items_schema, config, definitions)?,
+        let item_serializer = match schema.get_as(intern!(py, "items_schema"))? {
+            Some(items_schema) => CombinedSerializer::build(&items_schema, config, definitions)?,
             None => AnySerializer::build(schema, config, definitions)?,
         };
         Ok(Self {
@@ -49,9 +49,9 @@ impl_py_gc_traverse!(GeneratorSerializer { item_serializer });
 impl TypeSerializer for GeneratorSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         match value.downcast::<PyIterator>() {
@@ -65,11 +65,16 @@ impl TypeSerializer for GeneratorSerializer {
                             Ok(len) => Vec::with_capacity(len),
                             Err(_) => Vec::new(),
                         };
-                        for (index, iter_result) in py_iter.enumerate() {
+                        for (index, iter_result) in py_iter.clone().enumerate() {
                             let element = iter_result?;
                             let op_next = self.filter.index_filter(index, include, exclude, None)?;
                             if let Some((next_include, next_exclude)) = op_next {
-                                items.push(item_serializer.to_python(element, next_include, next_exclude, extra)?);
+                                items.push(item_serializer.to_python(
+                                    &element,
+                                    next_include.as_ref(),
+                                    next_exclude.as_ref(),
+                                    extra,
+                                )?);
                             }
                         }
                         Ok(items.into_py(py))
@@ -94,16 +99,16 @@ impl TypeSerializer for GeneratorSerializer {
         }
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         self._invalid_as_json_key(key, extra, Self::EXPECTED_TYPE)
     }
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         match value.downcast::<PyIterator>() {
@@ -115,15 +120,20 @@ impl TypeSerializer for GeneratorSerializer {
                 let mut seq = serializer.serialize_seq(len)?;
                 let item_serializer = self.item_serializer.as_ref();
 
-                for (index, iter_result) in py_iter.enumerate() {
+                for (index, iter_result) in py_iter.clone().enumerate() {
                     let element = iter_result.map_err(py_err_se_err)?;
                     let op_next = self
                         .filter
                         .index_filter(index, include, exclude, None)
                         .map_err(py_err_se_err)?;
                     if let Some((next_include, next_exclude)) = op_next {
-                        let item_serialize =
-                            PydanticSerializer::new(element, item_serializer, next_include, next_exclude, extra);
+                        let item_serialize = PydanticSerializer::new(
+                            &element,
+                            item_serializer,
+                            next_include.as_ref(),
+                            next_exclude.as_ref(),
+                            extra,
+                        );
                         seq.serialize_element(&item_serialize)?;
                     }
                 }
@@ -157,22 +167,21 @@ pub(crate) struct SerializationIterator {
 
 impl SerializationIterator {
     pub fn new(
-        py_iter: &PyIterator,
+        py_iter: &Bound<'_, PyIterator>,
         item_serializer: CombinedSerializer,
         filter: SchemaFilter<usize>,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Self {
-        let py = py_iter.py();
         Self {
-            iterator: py_iter.into_py(py),
+            iterator: py_iter.clone().into(),
             index: 0,
             item_serializer,
             extra_owned: ExtraOwned::new(extra),
             filter,
-            include: include.map(|v| v.into_py(py)),
-            exclude: exclude.map(|v| v.into_py(py)),
+            include: include.map(|v| v.clone().into()),
+            exclude: exclude.map(|v| v.clone().into()),
         }
     }
 
@@ -211,12 +220,12 @@ impl SerializationIterator {
     }
 
     fn __next__(&mut self, py: Python) -> PyResult<Option<PyObject>> {
-        let iterator = self.iterator.as_ref(py);
-        let include = self.include.as_ref().map(|o| o.as_ref(py));
-        let exclude = self.exclude.as_ref().map(|o| o.as_ref(py));
+        let iterator = self.iterator.bind(py);
+        let include = self.include.as_ref().map(|o| o.bind(py));
+        let exclude = self.exclude.as_ref().map(|o| o.bind(py));
         let extra = self.extra_owned.to_extra(py);
 
-        for iter_result in iterator {
+        for iter_result in iterator.clone() {
             let element = iter_result?;
             let filter = self.filter.index_filter(self.index, include, exclude, None)?;
             self.index += 1;
@@ -224,7 +233,7 @@ impl SerializationIterator {
                 let v = self
                     .item_serializer
                     // TODO do we need error_on_fallback to be customizable?
-                    .to_python(element, next_include, next_exclude, &extra)?;
+                    .to_python(&element, next_include.as_ref(), next_exclude.as_ref(), &extra)?;
                 extra.warnings.final_check(py)?;
                 return Ok(Some(v));
             }
@@ -233,7 +242,7 @@ impl SerializationIterator {
     }
 
     fn __repr__(&self, py: Python) -> PyResult<String> {
-        let iterator = self.iterator.as_ref(py);
+        let iterator = self.iterator.bind(py);
         Ok(format!(
             "SerializationIterator(index={}, iterator={})",
             self.index,
diff --git a/src/serializers/type_serializers/json.rs b/src/serializers/type_serializers/json.rs
index cdca5c4fe..8bc87bb2c 100644
--- a/src/serializers/type_serializers/json.rs
+++ b/src/serializers/type_serializers/json.rs
@@ -25,14 +25,14 @@ impl BuildSerializer for JsonSerializer {
     const EXPECTED_TYPE: &'static str = "json";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
 
-        let serializer = match schema.get_as::<&PyDict>(intern!(py, "schema"))? {
-            Some(items_schema) => CombinedSerializer::build(items_schema, config, definitions)?,
+        let serializer = match schema.get_as(intern!(py, "schema"))? {
+            Some(items_schema) => CombinedSerializer::build(&items_schema, config, definitions)?,
             None => AnySerializer::build(schema, config, definitions)?,
         };
         Ok(Self {
@@ -47,9 +47,9 @@ impl_py_gc_traverse!(JsonSerializer { serializer });
 impl TypeSerializer for JsonSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         if extra.round_trip {
@@ -62,7 +62,7 @@ impl TypeSerializer for JsonSerializer {
         }
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         if extra.round_trip {
             let bytes = to_json_bytes(key, &self.serializer, None, None, extra, None, 0)?;
             let py = key.py();
@@ -75,10 +75,10 @@ impl TypeSerializer for JsonSerializer {
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         if extra.round_trip {
diff --git a/src/serializers/type_serializers/json_or_python.rs b/src/serializers/type_serializers/json_or_python.rs
index 9234abcc7..ce9a9c8c9 100644
--- a/src/serializers/type_serializers/json_or_python.rs
+++ b/src/serializers/type_serializers/json_or_python.rs
@@ -19,16 +19,16 @@ impl BuildSerializer for JsonOrPythonSerializer {
     const EXPECTED_TYPE: &'static str = "json-or-python";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
-        let json_schema: &PyDict = schema.get_as_req(intern!(py, "json_schema"))?;
-        let python_schema: &PyDict = schema.get_as_req(intern!(py, "python_schema"))?;
+        let json_schema = schema.get_as_req(intern!(py, "json_schema"))?;
+        let python_schema = schema.get_as_req(intern!(py, "python_schema"))?;
 
-        let json = CombinedSerializer::build(json_schema, config, definitions)?;
-        let python = CombinedSerializer::build(python_schema, config, definitions)?;
+        let json = CombinedSerializer::build(&json_schema, config, definitions)?;
+        let python = CombinedSerializer::build(&python_schema, config, definitions)?;
 
         let name = format!(
             "{}[json={}, python={}]",
@@ -50,24 +50,24 @@ impl_py_gc_traverse!(JsonOrPythonSerializer { json, python });
 impl TypeSerializer for JsonOrPythonSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         self.python.to_python(value, include, exclude, extra)
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         self.json.json_key(key, extra)
     }
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         self.json.serde_serialize(value, serializer, include, exclude, extra)
diff --git a/src/serializers/type_serializers/list.rs b/src/serializers/type_serializers/list.rs
index a71e3452a..44805f523 100644
--- a/src/serializers/type_serializers/list.rs
+++ b/src/serializers/type_serializers/list.rs
@@ -26,13 +26,13 @@ impl BuildSerializer for ListSerializer {
     const EXPECTED_TYPE: &'static str = "list";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
-        let item_serializer = match schema.get_as::<&PyDict>(intern!(py, "items_schema"))? {
-            Some(items_schema) => CombinedSerializer::build(items_schema, config, definitions)?,
+        let item_serializer = match schema.get_as(intern!(py, "items_schema"))? {
+            Some(items_schema) => CombinedSerializer::build(&items_schema, config, definitions)?,
             None => AnySerializer::build(schema, config, definitions)?,
         };
         let name = format!("{}[{}]", Self::EXPECTED_TYPE, item_serializer.get_name());
@@ -50,9 +50,9 @@ impl_py_gc_traverse!(ListSerializer { item_serializer });
 impl TypeSerializer for ListSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         match value.downcast::<PyList>() {
@@ -64,7 +64,12 @@ impl TypeSerializer for ListSerializer {
                 for (index, element) in py_list.iter().enumerate() {
                     let op_next = self.filter.index_filter(index, include, exclude, value.len().ok())?;
                     if let Some((next_include, next_exclude)) = op_next {
-                        items.push(item_serializer.to_python(element, next_include, next_exclude, extra)?);
+                        items.push(item_serializer.to_python(
+                            &element,
+                            next_include.as_ref(),
+                            next_exclude.as_ref(),
+                            extra,
+                        )?);
                     }
                 }
                 Ok(items.into_py(py))
@@ -76,16 +81,16 @@ impl TypeSerializer for ListSerializer {
         }
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         self._invalid_as_json_key(key, extra, Self::EXPECTED_TYPE)
     }
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         match value.downcast::<PyList>() {
@@ -99,8 +104,13 @@ impl TypeSerializer for ListSerializer {
                         .index_filter(index, include, exclude, Some(py_list.len()))
                         .map_err(py_err_se_err)?;
                     if let Some((next_include, next_exclude)) = op_next {
-                        let item_serialize =
-                            PydanticSerializer::new(element, item_serializer, next_include, next_exclude, extra);
+                        let item_serialize = PydanticSerializer::new(
+                            &element,
+                            item_serializer,
+                            next_include.as_ref(),
+                            next_exclude.as_ref(),
+                            extra,
+                        );
                         seq.serialize_element(&item_serialize)?;
                     }
                 }
diff --git a/src/serializers/type_serializers/literal.rs b/src/serializers/type_serializers/literal.rs
index d6b08afa5..d0b751e72 100644
--- a/src/serializers/type_serializers/literal.rs
+++ b/src/serializers/type_serializers/literal.rs
@@ -1,8 +1,8 @@
 use std::borrow::Cow;
 
+use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::{PyBool, PyDict, PyList, PyString};
-use pyo3::{intern, PyTypeInfo};
 
 use ahash::AHashSet;
 use serde::Serialize;
@@ -28,11 +28,11 @@ impl BuildSerializer for LiteralSerializer {
     const EXPECTED_TYPE: &'static str = "literal";
 
     fn build(
-        schema: &PyDict,
-        _config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
-        let expected: &PyList = schema.get_as_req(intern!(schema.py(), "expected"))?;
+        let expected: Bound<'_, PyList> = schema.get_as_req(intern!(schema.py(), "expected"))?;
 
         if expected.is_empty() {
             return py_schema_err!("`expected` should have length > 0");
@@ -40,13 +40,13 @@ impl BuildSerializer for LiteralSerializer {
         let mut expected_int = AHashSet::new();
         let mut expected_str = AHashSet::new();
         let py = expected.py();
-        let expected_py = PyList::empty(py);
+        let expected_py = PyList::empty_bound(py);
         let mut repr_args: Vec<String> = Vec::new();
         for item in expected {
             repr_args.push(item.repr()?.extract()?);
             if let Ok(bool) = item.downcast::<PyBool>() {
                 expected_py.append(bool)?;
-            } else if let Some(int) = extract_i64(item) {
+            } else if let Some(int) = extract_i64(&item) {
                 expected_int.insert(int);
             } else if let Ok(py_str) = item.downcast::<PyString>() {
                 expected_str.insert(py_str.to_str()?.to_string());
@@ -68,17 +68,17 @@ impl BuildSerializer for LiteralSerializer {
     }
 }
 
-enum OutputValue<'a> {
+enum OutputValue<'py> {
     OkInt(i64),
-    OkStr(&'a str),
+    OkStr(Bound<'py, PyString>),
     Ok,
     Fallback,
 }
 
 impl LiteralSerializer {
-    fn check<'a>(&self, value: &'a PyAny, extra: &Extra) -> PyResult<OutputValue<'a>> {
+    fn check<'py>(&self, value: &Bound<'py, PyAny>, extra: &Extra) -> PyResult<OutputValue<'py>> {
         if extra.check.enabled() {
-            if !self.expected_int.is_empty() && !PyBool::is_type_of(value) {
+            if !self.expected_int.is_empty() && !value.is_instance_of::<PyBool>() {
                 if let Some(int) = extract_i64(value) {
                     if self.expected_int.contains(&int) {
                         return Ok(OutputValue::OkInt(int));
@@ -89,13 +89,13 @@ impl LiteralSerializer {
                 if let Ok(py_str) = value.downcast::<PyString>() {
                     let s = py_str.to_str()?;
                     if self.expected_str.contains(s) {
-                        return Ok(OutputValue::OkStr(s));
+                        return Ok(OutputValue::OkStr(py_str.clone()));
                     }
                 }
             }
 
             if let Some(ref expected_py) = self.expected_py {
-                if expected_py.as_ref(value.py()).contains(value)? {
+                if expected_py.bind(value.py()).contains(value)? {
                     return Ok(OutputValue::Ok);
                 }
             }
@@ -111,9 +111,9 @@ impl_py_gc_traverse!(LiteralSerializer { expected_py });
 impl TypeSerializer for LiteralSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         let py = value.py();
@@ -134,10 +134,10 @@ impl TypeSerializer for LiteralSerializer {
         }
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         match self.check(key, extra)? {
             OutputValue::OkInt(int) => Ok(Cow::Owned(int.to_string())),
-            OutputValue::OkStr(s) => Ok(Cow::Borrowed(s)),
+            OutputValue::OkStr(s) => Ok(Cow::Owned(s.to_string_lossy().into_owned())),
             OutputValue::Ok => infer_json_key(key, extra),
             OutputValue::Fallback => {
                 extra.warnings.on_fallback_py(self.get_name(), key, extra)?;
@@ -148,15 +148,15 @@ impl TypeSerializer for LiteralSerializer {
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         match self.check(value, extra).map_err(py_err_se_err)? {
             OutputValue::OkInt(int) => int.serialize(serializer),
-            OutputValue::OkStr(s) => s.serialize(serializer),
+            OutputValue::OkStr(s) => s.to_string_lossy().serialize(serializer),
             OutputValue::Ok => infer_serialize(value, serializer, include, exclude, extra),
             OutputValue::Fallback => {
                 extra.warnings.on_fallback_ser::<S>(self.get_name(), value, extra)?;
diff --git a/src/serializers/type_serializers/model.rs b/src/serializers/type_serializers/model.rs
index 0d2d1d346..e40fa2f7f 100644
--- a/src/serializers/type_serializers/model.rs
+++ b/src/serializers/type_serializers/model.rs
@@ -25,8 +25,8 @@ impl BuildSerializer for ModelFieldsBuilder {
     const EXPECTED_TYPE: &'static str = "model-fields";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
@@ -36,21 +36,21 @@ impl BuildSerializer for ModelFieldsBuilder {
             false => FieldsMode::SimpleDict,
         };
 
-        let fields_dict: &PyDict = schema.get_as_req(intern!(py, "fields"))?;
+        let fields_dict: Bound<'_, PyDict> = schema.get_as_req(intern!(py, "fields"))?;
         let mut fields: AHashMap<String, SerField> = AHashMap::with_capacity(fields_dict.len());
 
         let extra_serializer = match (schema.get_item(intern!(py, "extras_schema"))?, &fields_mode) {
-            (Some(v), FieldsMode::ModelExtra) => Some(CombinedSerializer::build(v.extract()?, config, definitions)?),
+            (Some(v), FieldsMode::ModelExtra) => Some(CombinedSerializer::build(&v.extract()?, config, definitions)?),
             (Some(_), _) => return py_schema_err!("extras_schema can only be used if extra_behavior=allow"),
             (_, _) => None,
         };
 
         for (key, value) in fields_dict {
-            let key_py: &PyString = key.downcast()?;
+            let key_py = key.downcast_into::<PyString>()?;
             let key: String = key_py.extract()?;
-            let field_info: &PyDict = value.downcast()?;
+            let field_info = value.downcast()?;
 
-            let key_py: Py<PyString> = key_py.into_py(py);
+            let key_py: Py<PyString> = key_py.into();
 
             if field_info.get_as(intern!(py, "serialization_exclude"))? == Some(true) {
                 fields.insert(key, SerField::new(py, key_py, None, None, true));
@@ -58,7 +58,7 @@ impl BuildSerializer for ModelFieldsBuilder {
                 let alias: Option<String> = field_info.get_as(intern!(py, "serialization_alias"))?;
 
                 let schema = field_info.get_as_req(intern!(py, "schema"))?;
-                let serializer = CombinedSerializer::build(schema, config, definitions)
+                let serializer = CombinedSerializer::build(&schema, config, definitions)
                     .map_err(|e| py_schema_error_type!("Field `{}`:\n  {}", key, e))?;
 
                 fields.insert(key, SerField::new(py, key_py, alias, Some(serializer), true));
@@ -84,8 +84,8 @@ impl BuildSerializer for ModelSerializer {
     const EXPECTED_TYPE: &'static str = "model";
 
     fn build(
-        schema: &PyDict,
-        _config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
@@ -93,31 +93,32 @@ impl BuildSerializer for ModelSerializer {
         // models ignore the parent config and always use the config from this model
         let config = schema.get_as(intern!(py, "config"))?;
 
-        let class: &PyType = schema.get_as_req(intern!(py, "cls"))?;
-        let sub_schema: &PyDict = schema.get_as_req(intern!(py, "schema"))?;
-        let serializer = Box::new(CombinedSerializer::build(sub_schema, config, definitions)?);
+        let class: Py<PyType> = schema.get_as_req(intern!(py, "cls"))?;
+        let sub_schema = schema.get_as_req(intern!(py, "schema"))?;
+        let serializer = Box::new(CombinedSerializer::build(&sub_schema, config.as_ref(), definitions)?);
         let root_model = schema.get_as(intern!(py, "root_model"))?.unwrap_or(false);
+        let name = class.bind(py).getattr(intern!(py, "__name__"))?.extract()?;
 
         Ok(Self {
-            class: class.into(),
+            class,
             serializer,
-            has_extra: has_extra(schema, config)?,
+            has_extra: has_extra(schema, config.as_ref())?,
             root_model,
-            name: class.getattr(intern!(py, "__name__"))?.extract()?,
+            name,
         }
         .into())
     }
 }
 
-fn has_extra(schema: &PyDict, config: Option<&PyDict>) -> PyResult<bool> {
+fn has_extra(schema: &Bound<'_, PyDict>, config: Option<&Bound<'_, PyDict>>) -> PyResult<bool> {
     let py = schema.py();
     let extra_behaviour = ExtraBehavior::from_schema_or_config(py, schema, config, ExtraBehavior::Ignore)?;
     Ok(matches!(extra_behaviour, ExtraBehavior::Allow))
 }
 
 impl ModelSerializer {
-    fn allow_value(&self, value: &PyAny, extra: &Extra) -> PyResult<bool> {
-        let class = self.class.as_ref(value.py());
+    fn allow_value(&self, value: &Bound<'_, PyAny>, extra: &Extra) -> PyResult<bool> {
+        let class = self.class.bind(value.py());
         match extra.check {
             SerCheck::Strict => Ok(value.get_type().is(class)),
             SerCheck::Lax => value.is_instance(class),
@@ -125,16 +126,18 @@ impl ModelSerializer {
         }
     }
 
-    fn get_inner_value<'py>(&self, model: &'py PyAny, extra: &Extra) -> PyResult<&'py PyAny> {
+    fn get_inner_value<'py>(&self, model: &Bound<'py, PyAny>, extra: &Extra) -> PyResult<Bound<'py, PyAny>> {
         let py = model.py();
-        let mut attrs: &PyDict = model.getattr(intern!(py, "__dict__"))?.downcast()?;
+        let mut attrs = model.getattr(intern!(py, "__dict__"))?.downcast_into::<PyDict>()?;
 
         if extra.exclude_unset {
-            let fields_set: &PySet = model.getattr(intern!(py, "__pydantic_fields_set__"))?.downcast()?;
+            let fields_set = model
+                .getattr(intern!(py, "__pydantic_fields_set__"))?
+                .downcast_into::<PySet>()?;
 
             let new_attrs = attrs.copy()?;
             for key in new_attrs.keys() {
-                if !fields_set.contains(key)? {
+                if !fields_set.contains(&key)? {
                     new_attrs.del_item(key)?;
                 }
             }
@@ -143,10 +146,10 @@ impl ModelSerializer {
 
         if self.has_extra {
             let model_extra = model.getattr(intern!(py, "__pydantic_extra__"))?;
-            let py_tuple = (attrs, model_extra).to_object(py);
-            Ok(py_tuple.into_ref(py))
+            let py_tuple = (attrs, model_extra).to_object(py).into_bound(py);
+            Ok(py_tuple)
         } else {
-            Ok(attrs)
+            Ok(attrs.into_any())
         }
     }
 }
@@ -156,9 +159,9 @@ impl_py_gc_traverse!(ModelSerializer { class, serializer });
 impl TypeSerializer for ModelSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         let mut extra = Extra {
@@ -176,17 +179,17 @@ impl TypeSerializer for ModelSerializer {
                     original_err
                 }
             })?;
-            self.serializer.to_python(root, include, exclude, &extra)
+            self.serializer.to_python(&root, include, exclude, &extra)
         } else if self.allow_value(value, &extra)? {
             let inner_value = self.get_inner_value(value, &extra)?;
-            self.serializer.to_python(inner_value, include, exclude, &extra)
+            self.serializer.to_python(&inner_value, include, exclude, &extra)
         } else {
             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>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         if self.allow_value(key, extra)? {
             infer_json_key_known(ObType::PydanticSerializable, key, extra)
         } else {
@@ -197,10 +200,10 @@ impl TypeSerializer for ModelSerializer {
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         let mut extra = Extra {
@@ -213,11 +216,11 @@ impl TypeSerializer for ModelSerializer {
             let py = value.py();
             let root = value.getattr(intern!(py, ROOT_FIELD)).map_err(py_err_se_err)?;
             self.serializer
-                .serde_serialize(root, serializer, include, exclude, &extra)
+                .serde_serialize(&root, serializer, include, exclude, &extra)
         } else if self.allow_value(value, &extra).map_err(py_err_se_err)? {
             let inner_value = self.get_inner_value(value, &extra).map_err(py_err_se_err)?;
             self.serializer
-                .serde_serialize(inner_value, serializer, include, exclude, &extra)
+                .serde_serialize(&inner_value, serializer, include, exclude, &extra)
         } else {
             extra.warnings.on_fallback_ser::<S>(self.get_name(), value, &extra)?;
             infer_serialize(value, serializer, include, exclude, &extra)
diff --git a/src/serializers/type_serializers/nullable.rs b/src/serializers/type_serializers/nullable.rs
index 23349ec81..4abd56808 100644
--- a/src/serializers/type_serializers/nullable.rs
+++ b/src/serializers/type_serializers/nullable.rs
@@ -18,13 +18,13 @@ impl BuildSerializer for NullableSerializer {
     const EXPECTED_TYPE: &'static str = "nullable";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
-        let sub_schema = schema.get_as_req::<&PyDict>(intern!(schema.py(), "schema"))?;
+        let sub_schema = schema.get_as_req(intern!(schema.py(), "schema"))?;
         Ok(Self {
-            serializer: Box::new(CombinedSerializer::build(sub_schema, config, definitions)?),
+            serializer: Box::new(CombinedSerializer::build(&sub_schema, config, definitions)?),
         }
         .into())
     }
@@ -35,9 +35,9 @@ impl_py_gc_traverse!(NullableSerializer { serializer });
 impl TypeSerializer for NullableSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         let py = value.py();
@@ -48,7 +48,7 @@ impl TypeSerializer for NullableSerializer {
         }
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         match extra.ob_type_lookup.is_type(key, ObType::None) {
             IsType::Exact => infer_json_key_known(ObType::None, key, extra),
             _ => self.serializer.json_key(key, extra),
@@ -57,10 +57,10 @@ impl TypeSerializer for NullableSerializer {
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         match extra.ob_type_lookup.is_type(value, ObType::None) {
diff --git a/src/serializers/type_serializers/other.rs b/src/serializers/type_serializers/other.rs
index b978353b4..8ca67f80d 100644
--- a/src/serializers/type_serializers/other.rs
+++ b/src/serializers/type_serializers/other.rs
@@ -15,17 +15,17 @@ impl BuildSerializer for ChainBuilder {
     const EXPECTED_TYPE: &'static str = "chain";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let last_schema = schema
-            .get_as_req::<&PyList>(intern!(schema.py(), "steps"))?
+            .get_as_req::<Bound<'_, PyList>>(intern!(schema.py(), "steps"))?
             .iter()
             .last()
             .unwrap()
-            .downcast()?;
-        CombinedSerializer::build(last_schema, config, definitions)
+            .downcast_into()?;
+        CombinedSerializer::build(&last_schema, config, definitions)
     }
 }
 
@@ -35,12 +35,12 @@ impl BuildSerializer for CustomErrorBuilder {
     const EXPECTED_TYPE: &'static str = "custom-error";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
-        let sub_schema: &PyDict = schema.get_as_req(intern!(schema.py(), "schema"))?;
-        CombinedSerializer::build(sub_schema, config, definitions)
+        let sub_schema = schema.get_as_req(intern!(schema.py(), "schema"))?;
+        CombinedSerializer::build(&sub_schema, config, definitions)
     }
 }
 
@@ -50,13 +50,13 @@ impl BuildSerializer for CallBuilder {
     const EXPECTED_TYPE: &'static str = "call";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
-        let return_schema = schema.get_as::<&PyDict>(intern!(schema.py(), "return_schema"))?;
+        let return_schema = schema.get_as(intern!(schema.py(), "return_schema"))?;
         match return_schema {
-            Some(return_schema) => CombinedSerializer::build(return_schema, config, definitions),
+            Some(return_schema) => CombinedSerializer::build(&return_schema, config, definitions),
             None => AnySerializer::build(schema, config, definitions),
         }
     }
@@ -68,12 +68,12 @@ impl BuildSerializer for LaxOrStrictBuilder {
     const EXPECTED_TYPE: &'static str = "lax-or-strict";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
-        let strict_schema: &PyDict = schema.get_as_req(intern!(schema.py(), "strict_schema"))?;
-        CombinedSerializer::build(strict_schema, config, definitions)
+        let strict_schema = schema.get_as_req(intern!(schema.py(), "strict_schema"))?;
+        CombinedSerializer::build(&strict_schema, config, definitions)
     }
 }
 
@@ -83,8 +83,8 @@ impl BuildSerializer for ArgumentsBuilder {
     const EXPECTED_TYPE: &'static str = "arguments";
 
     fn build(
-        _schema: &PyDict,
-        _config: Option<&PyDict>,
+        _schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         py_schema_err!("`arguments` validators require a custom serializer")
@@ -99,8 +99,8 @@ macro_rules! any_build_serializer {
             const EXPECTED_TYPE: &'static str = $expected_type;
 
             fn build(
-                schema: &PyDict,
-                config: Option<&PyDict>,
+                schema: &Bound<'_, PyDict>,
+                config: Option<&Bound<'_, PyDict>>,
                 definitions: &mut DefinitionsBuilder<CombinedSerializer>,
             ) -> PyResult<CombinedSerializer> {
                 AnySerializer::build(schema, config, definitions)
diff --git a/src/serializers/type_serializers/set_frozenset.rs b/src/serializers/type_serializers/set_frozenset.rs
index b105dc123..5e3d5ae29 100644
--- a/src/serializers/type_serializers/set_frozenset.rs
+++ b/src/serializers/type_serializers/set_frozenset.rs
@@ -27,13 +27,13 @@ macro_rules! build_serializer {
             const EXPECTED_TYPE: &'static str = $expected_type;
 
             fn build(
-                schema: &PyDict,
-                config: Option<&PyDict>,
+                schema: &Bound<'_, PyDict>,
+                config: Option<&Bound<'_, PyDict>>,
                 definitions: &mut DefinitionsBuilder<CombinedSerializer>,
             ) -> PyResult<CombinedSerializer> {
                 let py = schema.py();
-                let item_serializer = match schema.get_as::<&PyDict>(intern!(py, "items_schema"))? {
-                    Some(items_schema) => CombinedSerializer::build(items_schema, config, definitions)?,
+                let item_serializer = match schema.get_as(intern!(py, "items_schema"))? {
+                    Some(items_schema) => CombinedSerializer::build(&items_schema, config, definitions)?,
                     None => AnySerializer::build(schema, config, definitions)?,
                 };
                 let name = format!("{}[{}]", Self::EXPECTED_TYPE, item_serializer.get_name());
@@ -50,9 +50,9 @@ macro_rules! build_serializer {
         impl TypeSerializer for $struct_name {
             fn to_python(
                 &self,
-                value: &PyAny,
-                include: Option<&PyAny>,
-                exclude: Option<&PyAny>,
+                value: &Bound<'_, PyAny>,
+                include: Option<&Bound<'_, PyAny>>,
+                exclude: Option<&Bound<'_, PyAny>>,
                 extra: &Extra,
             ) -> PyResult<PyObject> {
                 let py = value.py();
@@ -62,11 +62,11 @@ macro_rules! build_serializer {
 
                         let mut items = Vec::with_capacity(py_set.len());
                         for element in py_set.iter() {
-                            items.push(item_serializer.to_python(element, include, exclude, extra)?);
+                            items.push(item_serializer.to_python(&element, include, exclude, extra)?);
                         }
                         match extra.mode {
-                            SerMode::Json => Ok(PyList::new(py, items).into_py(py)),
-                            _ => Ok(<$py_type>::new(py, &items)?.into_py(py)),
+                            SerMode::Json => Ok(PyList::new_bound(py, items).into_py(py)),
+                            _ => Ok(<$py_type>::new_bound(py, &items)?.into_py(py)),
                         }
                     }
                     Err(_) => {
@@ -76,16 +76,16 @@ macro_rules! build_serializer {
                 }
             }
 
-            fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+            fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
                 self._invalid_as_json_key(key, extra, Self::EXPECTED_TYPE)
             }
 
             fn serde_serialize<S: serde::ser::Serializer>(
                 &self,
-                value: &PyAny,
+                value: &Bound<'_, PyAny>,
                 serializer: S,
-                include: Option<&PyAny>,
-                exclude: Option<&PyAny>,
+                include: Option<&Bound<'_, PyAny>>,
+                exclude: Option<&Bound<'_, PyAny>>,
                 extra: &Extra,
             ) -> Result<S::Ok, S::Error> {
                 match value.downcast::<$py_type>() {
@@ -95,7 +95,7 @@ macro_rules! build_serializer {
 
                         for value in py_set.iter() {
                             let item_serialize =
-                                PydanticSerializer::new(value, item_serializer, include, exclude, extra);
+                                PydanticSerializer::new(&value, item_serializer, include, exclude, extra);
                             seq.serialize_element(&item_serialize)?;
                         }
                         seq.end()
diff --git a/src/serializers/type_serializers/simple.rs b/src/serializers/type_serializers/simple.rs
index 65fbee146..e1d0f3c0b 100644
--- a/src/serializers/type_serializers/simple.rs
+++ b/src/serializers/type_serializers/simple.rs
@@ -20,8 +20,8 @@ impl BuildSerializer for NoneSerializer {
     const EXPECTED_TYPE: &'static str = "none";
 
     fn build(
-        _schema: &PyDict,
-        _config: Option<&PyDict>,
+        _schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         Ok(Self {}.into())
@@ -37,9 +37,9 @@ impl_py_gc_traverse!(NoneSerializer {});
 impl TypeSerializer for NoneSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         let py = value.py();
@@ -53,7 +53,7 @@ impl TypeSerializer for NoneSerializer {
         }
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         match extra.ob_type_lookup.is_type(key, ObType::None) {
             IsType::Exact => none_json_key(),
             _ => {
@@ -65,10 +65,10 @@ impl TypeSerializer for NoneSerializer {
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         match extra.ob_type_lookup.is_type(value, ObType::None) {
@@ -94,8 +94,8 @@ macro_rules! build_simple_serializer {
             const EXPECTED_TYPE: &'static str = $expected_type;
 
             fn build(
-                _schema: &PyDict,
-                _config: Option<&PyDict>,
+                _schema: &Bound<'_, PyDict>,
+                _config: Option<&Bound<'_, PyDict>>,
                 _definitions: &mut DefinitionsBuilder<CombinedSerializer>,
             ) -> PyResult<CombinedSerializer> {
                 Ok(Self {}.into())
@@ -107,9 +107,9 @@ macro_rules! build_simple_serializer {
         impl TypeSerializer for $struct_name {
             fn to_python(
                 &self,
-                value: &PyAny,
-                include: Option<&PyAny>,
-                exclude: Option<&PyAny>,
+                value: &Bound<'_, PyAny>,
+                include: Option<&Bound<'_, PyAny>>,
+                exclude: Option<&Bound<'_, PyAny>>,
                 extra: &Extra,
             ) -> PyResult<PyObject> {
                 let py = value.py();
@@ -132,7 +132,7 @@ macro_rules! build_simple_serializer {
                 }
             }
 
-            fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+            fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
                 match extra.ob_type_lookup.is_type(key, $ob_type) {
                     IsType::Exact | IsType::Subclass => $key_method(key),
                     IsType::False => {
@@ -144,10 +144,10 @@ macro_rules! build_simple_serializer {
 
             fn serde_serialize<S: serde::ser::Serializer>(
                 &self,
-                value: &PyAny,
+                value: &Bound<'_, PyAny>,
                 serializer: S,
-                include: Option<&PyAny>,
-                exclude: Option<&PyAny>,
+                include: Option<&Bound<'_, PyAny>>,
+                exclude: Option<&Bound<'_, PyAny>>,
                 extra: &Extra,
             ) -> Result<S::Ok, S::Error> {
                 match value.extract::<$rust_type>() {
@@ -172,14 +172,14 @@ macro_rules! build_simple_serializer {
     };
 }
 
-pub(crate) fn to_str_json_key(key: &PyAny) -> PyResult<Cow<str>> {
-    Ok(key.str()?.to_string_lossy())
+pub(crate) fn to_str_json_key<'py>(key: &Bound<'py, PyAny>) -> PyResult<Cow<'py, str>> {
+    Ok(Cow::Owned(key.str()?.to_string_lossy().into_owned()))
 }
 
 build_simple_serializer!(IntSerializer, "int", Int, ObType::Int, to_str_json_key, true);
 
-pub(crate) fn bool_json_key(key: &PyAny) -> PyResult<Cow<str>> {
-    let v = if key.is_true().unwrap_or(false) {
+pub(crate) fn bool_json_key<'py>(key: &Bound<'py, PyAny>) -> PyResult<Cow<'py, str>> {
+    let v = if key.is_truthy().unwrap_or(false) {
         "true"
     } else {
         "false"
diff --git a/src/serializers/type_serializers/string.rs b/src/serializers/type_serializers/string.rs
index 94405313b..48fba0e64 100644
--- a/src/serializers/type_serializers/string.rs
+++ b/src/serializers/type_serializers/string.rs
@@ -17,8 +17,8 @@ impl BuildSerializer for StrSerializer {
     const EXPECTED_TYPE: &'static str = "str";
 
     fn build(
-        _schema: &PyDict,
-        _config: Option<&PyDict>,
+        _schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         Ok(Self {}.into())
@@ -30,16 +30,16 @@ impl_py_gc_traverse!(StrSerializer {});
 impl TypeSerializer for StrSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, 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)),
+                SerMode::Json => Ok(value.downcast::<PyString>()?.to_str()?.into_py(py)),
                 _ => Ok(value.into_py(py)),
             },
             IsType::False => {
@@ -49,9 +49,10 @@ impl TypeSerializer for StrSerializer {
         }
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         if let Ok(py_str) = key.downcast::<PyString>() {
-            Ok(py_str.to_string_lossy())
+            // FIXME py cow to avoid the copy
+            Ok(Cow::Owned(py_str.to_string_lossy().into_owned()))
         } else {
             extra.warnings.on_fallback_py(self.get_name(), key, extra)?;
             infer_json_key(key, extra)
@@ -60,10 +61,10 @@ impl TypeSerializer for StrSerializer {
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         match value.downcast::<PyString>() {
@@ -80,7 +81,10 @@ impl TypeSerializer for StrSerializer {
     }
 }
 
-pub fn serialize_py_str<S: serde::ser::Serializer>(py_str: &PyString, serializer: S) -> Result<S::Ok, S::Error> {
+pub fn serialize_py_str<S: serde::ser::Serializer>(
+    py_str: &Bound<'_, PyString>,
+    serializer: S,
+) -> Result<S::Ok, S::Error> {
     let s = py_str.to_str().map_err(py_err_se_err)?;
     serializer.serialize_str(s)
 }
diff --git a/src/serializers/type_serializers/timedelta.rs b/src/serializers/type_serializers/timedelta.rs
index 042a8ffea..a28258e2a 100644
--- a/src/serializers/type_serializers/timedelta.rs
+++ b/src/serializers/type_serializers/timedelta.rs
@@ -21,8 +21,8 @@ impl BuildSerializer for TimeDeltaSerializer {
     const EXPECTED_TYPE: &'static str = "timedelta";
 
     fn build(
-        _schema: &PyDict,
-        config: Option<&PyDict>,
+        _schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let timedelta_mode = TimedeltaMode::from_config(config)?;
@@ -35,9 +35,9 @@ impl_py_gc_traverse!(TimeDeltaSerializer {});
 impl TypeSerializer for TimeDeltaSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         match extra.mode {
@@ -52,7 +52,7 @@ impl TypeSerializer for TimeDeltaSerializer {
         }
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         match EitherTimedelta::try_from(key) {
             Ok(either_timedelta) => self.timedelta_mode.json_key(key.py(), &either_timedelta),
             Err(_) => {
@@ -64,10 +64,10 @@ impl TypeSerializer for TimeDeltaSerializer {
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         match EitherTimedelta::try_from(value) {
diff --git a/src/serializers/type_serializers/tuple.rs b/src/serializers/type_serializers/tuple.rs
index 5890288d6..3dd5b1ca9 100644
--- a/src/serializers/type_serializers/tuple.rs
+++ b/src/serializers/type_serializers/tuple.rs
@@ -29,12 +29,12 @@ impl BuildSerializer for TupleSerializer {
     const EXPECTED_TYPE: &'static str = "tuple";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
-        let items: &PyList = schema.get_as_req(intern!(py, "items_schema"))?;
+        let items: Bound<'_, PyList> = schema.get_as_req(intern!(py, "items_schema"))?;
         let serializers: Vec<CombinedSerializer> = items
             .iter()
             .map(|item| CombinedSerializer::build(item.downcast()?, config, definitions))
@@ -62,9 +62,9 @@ impl_py_gc_traverse!(TupleSerializer { serializers });
 impl TypeSerializer for TupleSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         match value.downcast::<PyTuple>() {
@@ -77,13 +77,13 @@ impl TypeSerializer for TupleSerializer {
                 self.for_each_tuple_item_and_serializer(py_tuple, include, exclude, extra, |entry| {
                     entry
                         .serializer
-                        .to_python(entry.item, entry.include, entry.exclude, extra)
+                        .to_python(&entry.item, entry.include.as_ref(), entry.exclude.as_ref(), extra)
                         .map(|item| items.push(item))
                 })??;
 
                 match extra.mode {
-                    SerMode::Json => Ok(PyList::new(py, items).into_py(py)),
-                    _ => Ok(PyTuple::new(py, items).into_py(py)),
+                    SerMode::Json => Ok(PyList::new_bound(py, items).into_py(py)),
+                    _ => Ok(PyTuple::new_bound(py, items).into_py(py)),
                 }
             }
             Err(_) => {
@@ -93,7 +93,7 @@ impl TypeSerializer for TupleSerializer {
         }
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         match key.downcast::<PyTuple>() {
             Ok(py_tuple) => {
                 let mut key_builder = KeyBuilder::new();
@@ -101,7 +101,7 @@ impl TypeSerializer for TupleSerializer {
                 self.for_each_tuple_item_and_serializer(py_tuple, None, None, extra, |entry| {
                     entry
                         .serializer
-                        .json_key(entry.item, extra)
+                        .json_key(&entry.item, extra)
                         .map(|key| key_builder.push(&key))
                 })??;
 
@@ -116,25 +116,25 @@ impl TypeSerializer for TupleSerializer {
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         match value.downcast::<PyTuple>() {
             Ok(py_tuple) => {
-                let py_tuple: &PyTuple = py_tuple.downcast().map_err(py_err_se_err)?;
+                let py_tuple = py_tuple.downcast::<PyTuple>().map_err(py_err_se_err)?;
 
                 let n_items = py_tuple.len();
                 let mut seq = serializer.serialize_seq(Some(n_items))?;
 
                 self.for_each_tuple_item_and_serializer(py_tuple, include, exclude, extra, |entry| {
                     seq.serialize_element(&PydanticSerializer::new(
-                        entry.item,
+                        &entry.item,
                         entry.serializer,
-                        entry.include,
-                        entry.exclude,
+                        entry.include.as_ref(),
+                        entry.exclude.as_ref(),
                         extra,
                     ))
                 })
@@ -159,9 +159,9 @@ impl TypeSerializer for TupleSerializer {
 }
 
 struct TupleSerializerEntry<'a, 'py> {
-    item: &'py PyAny,
-    include: Option<&'py PyAny>,
-    exclude: Option<&'py PyAny>,
+    item: Bound<'py, PyAny>,
+    include: Option<Bound<'py, PyAny>>,
+    exclude: Option<Bound<'py, PyAny>>,
     serializer: &'a CombinedSerializer,
 }
 
@@ -174,9 +174,9 @@ impl TupleSerializer {
     /// levels of `Result`.
     fn for_each_tuple_item_and_serializer<E>(
         &self,
-        tuple: &PyTuple,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        tuple: &Bound<'_, PyTuple>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
         mut f: impl for<'a, 'py> FnMut(TupleSerializerEntry<'a, 'py>) -> Result<(), E>,
     ) -> PyResult<Result<(), E>> {
diff --git a/src/serializers/type_serializers/typed_dict.rs b/src/serializers/type_serializers/typed_dict.rs
index fbef3486a..90b448fb2 100644
--- a/src/serializers/type_serializers/typed_dict.rs
+++ b/src/serializers/type_serializers/typed_dict.rs
@@ -18,8 +18,8 @@ impl BuildSerializer for TypedDictBuilder {
     const EXPECTED_TYPE: &'static str = "typed-dict";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
@@ -32,23 +32,23 @@ impl BuildSerializer for TypedDictBuilder {
             _ => FieldsMode::SimpleDict,
         };
 
-        let fields_dict: &PyDict = schema.get_as_req(intern!(py, "fields"))?;
+        let fields_dict: Bound<'_, PyDict> = schema.get_as_req(intern!(py, "fields"))?;
         let mut fields: AHashMap<String, SerField> = AHashMap::with_capacity(fields_dict.len());
 
         let extra_serializer = match (schema.get_item(intern!(py, "extras_schema"))?, &fields_mode) {
             (Some(v), FieldsMode::TypedDictAllow) => {
-                Some(CombinedSerializer::build(v.extract()?, config, definitions)?)
+                Some(CombinedSerializer::build(&v.extract()?, config, definitions)?)
             }
             (Some(_), _) => return py_schema_err!("extras_schema can only be used if extra_behavior=allow"),
             (_, _) => None,
         };
 
         for (key, value) in fields_dict {
-            let key_py: &PyString = key.downcast()?;
+            let key_py = key.downcast_into::<PyString>()?;
             let key: String = key_py.extract()?;
-            let field_info: &PyDict = value.downcast()?;
+            let field_info = value.downcast()?;
 
-            let key_py: Py<PyString> = key_py.into_py(py);
+            let key_py: Py<PyString> = key_py.into();
             let required = field_info.get_as(intern!(py, "required"))?.unwrap_or(total);
 
             if field_info.get_as(intern!(py, "serialization_exclude"))? == Some(true) {
@@ -57,7 +57,7 @@ impl BuildSerializer for TypedDictBuilder {
                 let alias: Option<String> = field_info.get_as(intern!(py, "serialization_alias"))?;
 
                 let schema = field_info.get_as_req(intern!(py, "schema"))?;
-                let serializer = CombinedSerializer::build(schema, config, definitions)
+                let serializer = CombinedSerializer::build(&schema, config, definitions)
                     .map_err(|e| py_schema_error_type!("Field `{}`:\n  {}", key, e))?;
                 fields.insert(key, SerField::new(py, key_py, alias, Some(serializer), required));
             }
diff --git a/src/serializers/type_serializers/union.rs b/src/serializers/type_serializers/union.rs
index f05e2220e..51fc07e8d 100644
--- a/src/serializers/type_serializers/union.rs
+++ b/src/serializers/type_serializers/union.rs
@@ -23,16 +23,16 @@ impl BuildSerializer for UnionSerializer {
     const EXPECTED_TYPE: &'static str = "union";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
         let choices: Vec<CombinedSerializer> = schema
-            .get_as_req::<&PyList>(intern!(py, "choices"))?
+            .get_as_req::<Bound<'_, PyList>>(intern!(py, "choices"))?
             .iter()
             .map(|choice| {
-                let choice: &PyAny = match choice.downcast::<PyTuple>() {
+                let choice = match choice.downcast::<PyTuple>() {
                     Ok(py_tuple) => py_tuple.get_item(0)?,
                     Err(_) => choice,
                 };
@@ -70,9 +70,9 @@ impl_py_gc_traverse!(UnionSerializer { choices });
 impl TypeSerializer for UnionSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         // try the serializers in left to right order with error_on fallback=true
@@ -105,7 +105,7 @@ impl TypeSerializer for UnionSerializer {
         infer_to_python(value, include, exclude, extra)
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         let mut new_extra = extra.clone();
         new_extra.check = SerCheck::Strict;
         for comb_serializer in &self.choices {
@@ -136,10 +136,10 @@ impl TypeSerializer for UnionSerializer {
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         let py = value.py();
@@ -147,7 +147,7 @@ impl TypeSerializer for UnionSerializer {
         new_extra.check = SerCheck::Strict;
         for comb_serializer in &self.choices {
             match comb_serializer.to_python(value, include, exclude, &new_extra) {
-                Ok(v) => return infer_serialize(v.as_ref(py), serializer, None, None, extra),
+                Ok(v) => return infer_serialize(v.bind(py), serializer, None, None, extra),
                 Err(err) => match err.is_instance_of::<PydanticSerializationUnexpectedValue>(py) {
                     true => (),
                     false => return Err(py_err_se_err(err)),
@@ -158,7 +158,7 @@ impl TypeSerializer for UnionSerializer {
             new_extra.check = SerCheck::Lax;
             for comb_serializer in &self.choices {
                 match comb_serializer.to_python(value, include, exclude, &new_extra) {
-                    Ok(v) => return infer_serialize(v.as_ref(py), serializer, None, None, extra),
+                    Ok(v) => return infer_serialize(v.bind(py), serializer, None, None, extra),
                     Err(err) => match err.is_instance_of::<PydanticSerializationUnexpectedValue>(py) {
                         true => (),
                         false => return Err(py_err_se_err(err)),
@@ -186,11 +186,11 @@ impl BuildSerializer for TaggedUnionBuilder {
     const EXPECTED_TYPE: &'static str = "tagged-union";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
-        let schema_choices: &PyDict = schema.get_as_req(intern!(schema.py(), "choices"))?;
+        let schema_choices: Bound<'_, PyDict> = schema.get_as_req(intern!(schema.py(), "choices"))?;
         let mut choices: Vec<CombinedSerializer> = Vec::with_capacity(schema_choices.len());
 
         for (_, value) in schema_choices {
diff --git a/src/serializers/type_serializers/url.rs b/src/serializers/type_serializers/url.rs
index e4bbe3bdc..f7dccf017 100644
--- a/src/serializers/type_serializers/url.rs
+++ b/src/serializers/type_serializers/url.rs
@@ -21,8 +21,8 @@ macro_rules! build_serializer {
             const EXPECTED_TYPE: &'static str = $expected_type;
 
             fn build(
-                _schema: &PyDict,
-                _config: Option<&PyDict>,
+                _schema: &Bound<'_, PyDict>,
+                _config: Option<&Bound<'_, PyDict>>,
                 _definitions: &mut DefinitionsBuilder<CombinedSerializer>,
             ) -> PyResult<CombinedSerializer> {
                 Ok(Self {}.into())
@@ -34,9 +34,9 @@ macro_rules! build_serializer {
         impl TypeSerializer for $struct_name {
             fn to_python(
                 &self,
-                value: &PyAny,
-                include: Option<&PyAny>,
-                exclude: Option<&PyAny>,
+                value: &Bound<'_, PyAny>,
+                include: Option<&Bound<'_, PyAny>>,
+                exclude: Option<&Bound<'_, PyAny>>,
                 extra: &Extra,
             ) -> PyResult<PyObject> {
                 let py = value.py();
@@ -52,7 +52,7 @@ macro_rules! build_serializer {
                 }
             }
 
-            fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+            fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
                 match key.extract::<$extract>() {
                     Ok(py_url) => Ok(Cow::Owned(py_url.__str__().to_string())),
                     Err(_) => {
@@ -64,10 +64,10 @@ macro_rules! build_serializer {
 
             fn serde_serialize<S: serde::ser::Serializer>(
                 &self,
-                value: &PyAny,
+                value: &Bound<'_, PyAny>,
                 serializer: S,
-                include: Option<&PyAny>,
-                exclude: Option<&PyAny>,
+                include: Option<&Bound<'_, PyAny>>,
+                exclude: Option<&Bound<'_, PyAny>>,
                 extra: &Extra,
             ) -> Result<S::Ok, S::Error> {
                 match value.extract::<$extract>() {
diff --git a/src/serializers/type_serializers/uuid.rs b/src/serializers/type_serializers/uuid.rs
index 5b66ad241..b2b6572a7 100644
--- a/src/serializers/type_serializers/uuid.rs
+++ b/src/serializers/type_serializers/uuid.rs
@@ -10,7 +10,7 @@ use super::{
     IsType, ObType, SerMode, TypeSerializer,
 };
 
-pub(crate) fn uuid_to_string(py_uuid: &PyAny) -> PyResult<String> {
+pub(crate) fn uuid_to_string(py_uuid: &Bound<'_, PyAny>) -> PyResult<String> {
     Ok(py_uuid.str()?.to_string())
 }
 
@@ -23,8 +23,8 @@ impl BuildSerializer for UuidSerializer {
     const EXPECTED_TYPE: &'static str = "uuid";
 
     fn build(
-        _schema: &PyDict,
-        _config: Option<&PyDict>,
+        _schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         Ok(Self {}.into())
@@ -34,9 +34,9 @@ impl BuildSerializer for UuidSerializer {
 impl TypeSerializer for UuidSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         let py = value.py();
@@ -52,7 +52,7 @@ impl TypeSerializer for UuidSerializer {
         }
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         match extra.ob_type_lookup.is_type(key, ObType::Uuid) {
             IsType::Exact | IsType::Subclass => {
                 let str = uuid_to_string(key)?;
@@ -67,10 +67,10 @@ impl TypeSerializer for UuidSerializer {
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         match extra.ob_type_lookup.is_type(value, ObType::Uuid) {
diff --git a/src/serializers/type_serializers/with_default.rs b/src/serializers/type_serializers/with_default.rs
index d20c273a1..0e50e10a2 100644
--- a/src/serializers/type_serializers/with_default.rs
+++ b/src/serializers/type_serializers/with_default.rs
@@ -20,15 +20,15 @@ impl BuildSerializer for WithDefaultSerializer {
     const EXPECTED_TYPE: &'static str = "default";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
         let default = DefaultType::new(schema)?;
 
-        let sub_schema: &PyDict = schema.get_as_req(intern!(py, "schema"))?;
-        let serializer = Box::new(CombinedSerializer::build(sub_schema, config, definitions)?);
+        let sub_schema = schema.get_as_req(intern!(py, "schema"))?;
+        let serializer = Box::new(CombinedSerializer::build(&sub_schema, config, definitions)?);
 
         Ok(Self { default, serializer }.into())
     }
@@ -39,24 +39,24 @@ impl_py_gc_traverse!(WithDefaultSerializer { default, serializer });
 impl TypeSerializer for WithDefaultSerializer {
     fn to_python(
         &self,
-        value: &PyAny,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
         self.serializer.to_python(value, include, exclude, extra)
     }
 
-    fn json_key<'py>(&self, key: &'py PyAny, extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         self.serializer.json_key(key, extra)
     }
 
     fn serde_serialize<S: serde::ser::Serializer>(
         &self,
-        value: &PyAny,
+        value: &Bound<'_, PyAny>,
         serializer: S,
-        include: Option<&PyAny>,
-        exclude: Option<&PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         self.serializer
diff --git a/src/tools.rs b/src/tools.rs
index bdc41583c..a823311a0 100644
--- a/src/tools.rs
+++ b/src/tools.rs
@@ -6,39 +6,39 @@ use pyo3::types::{PyDict, PyString};
 use pyo3::{ffi, intern, FromPyObject};
 
 pub trait SchemaDict<'py> {
-    fn get_as<T>(&'py self, key: &PyString) -> PyResult<Option<T>>
+    fn get_as<T>(&self, key: &Bound<'_, PyString>) -> PyResult<Option<T>>
     where
         T: FromPyObject<'py>;
 
-    fn get_as_req<T>(&'py self, key: &PyString) -> PyResult<T>
+    fn get_as_req<T>(&self, key: &Bound<'_, PyString>) -> PyResult<T>
     where
         T: FromPyObject<'py>;
 }
 
-impl<'py> SchemaDict<'py> for PyDict {
-    fn get_as<T>(&'py self, key: &PyString) -> PyResult<Option<T>>
+impl<'py> SchemaDict<'py> for Bound<'py, PyDict> {
+    fn get_as<T>(&self, key: &Bound<'_, PyString>) -> PyResult<Option<T>>
     where
         T: FromPyObject<'py>,
     {
         match self.get_item(key)? {
-            Some(t) => Ok(Some(<T>::extract(t)?)),
+            Some(t) => t.extract().map(Some),
             None => Ok(None),
         }
     }
 
-    fn get_as_req<T>(&'py self, key: &PyString) -> PyResult<T>
+    fn get_as_req<T>(&self, key: &Bound<'_, PyString>) -> PyResult<T>
     where
         T: FromPyObject<'py>,
     {
         match self.get_item(key)? {
-            Some(t) => <T>::extract(t),
+            Some(t) => t.extract(),
             None => py_err!(PyKeyError; "{}", key),
         }
     }
 }
 
-impl<'py> SchemaDict<'py> for Option<&PyDict> {
-    fn get_as<T>(&'py self, key: &PyString) -> PyResult<Option<T>>
+impl<'py> SchemaDict<'py> for Option<&Bound<'py, PyDict>> {
+    fn get_as<T>(&self, key: &Bound<'_, PyString>) -> PyResult<Option<T>>
     where
         T: FromPyObject<'py>,
     {
@@ -49,7 +49,7 @@ impl<'py> SchemaDict<'py> for Option<&PyDict> {
     }
 
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn get_as_req<T>(&'py self, key: &PyString) -> PyResult<T>
+    fn get_as_req<T>(&self, key: &Bound<'_, PyString>) -> PyResult<T>
     where
         T: FromPyObject<'py>,
     {
@@ -82,27 +82,50 @@ macro_rules! py_err {
 }
 pub(crate) use py_err;
 
-pub fn function_name(f: &PyAny) -> PyResult<String> {
+pub fn function_name(f: &Bound<'_, PyAny>) -> PyResult<String> {
     match f.getattr(intern!(f.py(), "__name__")) {
         Ok(name) => name.extract(),
         _ => f.repr()?.extract(),
     }
 }
 
-pub fn safe_repr(v: &PyAny) -> Cow<str> {
+pub enum ReprOutput<'py> {
+    Python(Bound<'py, PyString>),
+    Fallback(String),
+}
+
+impl ReprOutput<'_> {
+    pub fn to_cow(&self) -> Cow<'_, str> {
+        match self {
+            ReprOutput::Python(s) => s.to_string_lossy(),
+            ReprOutput::Fallback(s) => s.into(),
+        }
+    }
+}
+
+impl std::fmt::Display for ReprOutput<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            ReprOutput::Python(s) => write!(f, "{}", s.to_string_lossy()),
+            ReprOutput::Fallback(s) => write!(f, "{s}"),
+        }
+    }
+}
+
+pub fn safe_repr<'py>(v: &Bound<'py, PyAny>) -> ReprOutput<'py> {
     if let Ok(s) = v.repr() {
-        s.to_string_lossy()
-    } else if let Ok(name) = v.get_type().name() {
-        format!("<unprintable {name} object>").into()
+        ReprOutput::Python(s)
+    } else if let Ok(name) = v.get_type().qualname() {
+        ReprOutput::Fallback(format!("<unprintable {name} object>"))
     } else {
-        "<unprintable object>".into()
+        ReprOutput::Fallback("<unprintable object>".to_owned())
     }
 }
 
 /// Extract an i64 from a python object more quickly, see
 /// https://github.com/PyO3/pyo3/pull/3742#discussion_r1451763928
 #[cfg(not(any(target_pointer_width = "32", windows, PyPy)))]
-pub fn extract_i64(obj: &PyAny) -> Option<i64> {
+pub fn extract_i64(obj: &Bound<'_, PyAny>) -> Option<i64> {
     let val = unsafe { ffi::PyLong_AsLong(obj.as_ptr()) };
     if val == -1 && PyErr::occurred(obj.py()) {
         unsafe { ffi::PyErr_Clear() };
@@ -113,7 +136,7 @@ pub fn extract_i64(obj: &PyAny) -> Option<i64> {
 }
 
 #[cfg(any(target_pointer_width = "32", windows, PyPy))]
-pub fn extract_i64(v: &PyAny) -> Option<i64> {
+pub fn extract_i64(v: &Bound<'_, PyAny>) -> Option<i64> {
     if v.is_instance_of::<pyo3::types::PyInt>() {
         v.extract().ok()
     } else {
diff --git a/src/url.rs b/src/url.rs
index b381e247d..6a6a921fe 100644
--- a/src/url.rs
+++ b/src/url.rs
@@ -5,8 +5,8 @@ use std::hash::{Hash, Hasher};
 
 use idna::punycode::decode_to_string;
 use pyo3::exceptions::PyValueError;
-use pyo3::once_cell::GILOnceCell;
 use pyo3::pyclass::CompareOp;
+use pyo3::sync::GILOnceCell;
 use pyo3::types::{PyDict, PyType};
 use pyo3::{intern, prelude::*};
 use url::Url;
@@ -34,15 +34,15 @@ impl PyUrl {
 }
 
 fn build_schema_validator(py: Python, schema_type: &str) -> SchemaValidator {
-    let schema: &PyDict = PyDict::new(py);
+    let schema = PyDict::new_bound(py);
     schema.set_item("type", schema_type).unwrap();
-    SchemaValidator::py_new(py, schema, None).unwrap()
+    SchemaValidator::py_new(py, &schema, None).unwrap()
 }
 
 #[pymethods]
 impl PyUrl {
     #[new]
-    pub fn py_new(py: Python, url: &PyAny) -> PyResult<Self> {
+    pub fn py_new(py: Python, url: &Bound<'_, PyAny>) -> PyResult<Self> {
         let schema_obj = SCHEMA_DEFINITION_URL
             .get_or_init(py, || build_schema_validator(py, "url"))
             .validate_python(py, url, None, None, None, None)?;
@@ -158,8 +158,8 @@ impl PyUrl {
     #[classmethod]
     #[pyo3(signature=(*, scheme, host, username=None, password=None, port=None, path=None, query=None, fragment=None))]
     #[allow(clippy::too_many_arguments)]
-    pub fn build<'a>(
-        cls: &'a PyType,
+    pub fn build<'py>(
+        cls: &Bound<'py, PyType>,
         scheme: &str,
         host: &str,
         username: Option<&str>,
@@ -168,7 +168,7 @@ impl PyUrl {
         path: Option<&str>,
         query: Option<&str>,
         fragment: Option<&str>,
-    ) -> PyResult<&'a PyAny> {
+    ) -> PyResult<Bound<'py, PyAny>> {
         let url_host = UrlHostParts {
             username: username.map(Into::into),
             password: password.map(Into::into),
@@ -218,7 +218,7 @@ static SCHEMA_DEFINITION_MULTI_HOST_URL: GILOnceCell<SchemaValidator> = GILOnceC
 #[pymethods]
 impl PyMultiHostUrl {
     #[new]
-    pub fn py_new(py: Python, url: &PyAny) -> PyResult<Self> {
+    pub fn py_new(py: Python, url: &Bound<'_, PyAny>) -> PyResult<Self> {
         let schema_obj = SCHEMA_DEFINITION_MULTI_HOST_URL
             .get_or_init(py, || build_schema_validator(py, "multi-host-url"))
             .validate_python(py, url, None, None, None, None)?;
@@ -230,7 +230,7 @@ impl PyMultiHostUrl {
         self.ref_url.scheme()
     }
 
-    pub fn hosts<'py>(&self, py: Python<'py>) -> PyResult<Vec<&'py PyDict>> {
+    pub fn hosts<'py>(&self, py: Python<'py>) -> PyResult<Vec<Bound<'py, PyDict>>> {
         if let Some(extra_urls) = &self.extra_urls {
             let mut hosts = Vec::with_capacity(extra_urls.len() + 1);
             for url in extra_urls {
@@ -358,8 +358,8 @@ impl PyMultiHostUrl {
     #[classmethod]
     #[pyo3(signature=(*, scheme, hosts=None, path=None, query=None, fragment=None, host=None, username=None, password=None, port=None))]
     #[allow(clippy::too_many_arguments)]
-    pub fn build<'a>(
-        cls: &'a PyType,
+    pub fn build<'py>(
+        cls: &Bound<'py, PyType>,
         scheme: &str,
         hosts: Option<Vec<UrlHostParts>>,
         path: Option<&str>,
@@ -370,7 +370,7 @@ impl PyMultiHostUrl {
         username: Option<&str>,
         password: Option<&str>,
         port: Option<u16>,
-    ) -> PyResult<&'a PyAny> {
+    ) -> PyResult<Bound<'py, PyAny>> {
         let mut url =
             if hosts.is_some() && (host.is_some() || username.is_some() || password.is_some() || port.is_some()) {
                 return Err(PyValueError::new_err(
@@ -434,7 +434,7 @@ impl UrlHostParts {
 }
 
 impl FromPyObject<'_> for UrlHostParts {
-    fn extract(ob: &'_ PyAny) -> PyResult<Self> {
+    fn extract_bound(ob: &Bound<'_, PyAny>) -> PyResult<Self> {
         let py = ob.py();
         let dict = ob.downcast::<PyDict>()?;
         Ok(UrlHostParts {
@@ -464,13 +464,13 @@ impl fmt::Display for UrlHostParts {
     }
 }
 
-fn host_to_dict<'a>(py: Python<'a>, lib_url: &Url) -> PyResult<&'a PyDict> {
-    let dict = PyDict::new(py);
+fn host_to_dict<'a>(py: Python<'a>, lib_url: &Url) -> PyResult<Bound<'a, PyDict>> {
+    let dict = PyDict::new_bound(py);
     dict.set_item(
         "username",
         match lib_url.username() {
             "" => py.None(),
-            user => user.into_py(py),
+            user => user.to_object(py),
         },
     )?;
     dict.set_item("password", lib_url.password())?;
diff --git a/src/validators/any.rs b/src/validators/any.rs
index 244117a01..61a58a09c 100644
--- a/src/validators/any.rs
+++ b/src/validators/any.rs
@@ -16,8 +16,8 @@ impl BuildValidator for AnyValidator {
     const EXPECTED_TYPE: &'static str = "any";
 
     fn build(
-        _schema: &PyDict,
-        _config: Option<&PyDict>,
+        _schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         Ok(Self.into())
diff --git a/src/validators/arguments.rs b/src/validators/arguments.rs
index 661aaf1e4..57c6e1fb7 100644
--- a/src/validators/arguments.rs
+++ b/src/validators/arguments.rs
@@ -7,7 +7,7 @@ use ahash::AHashSet;
 use crate::build_tools::py_schema_err;
 use crate::build_tools::{schema_or_config_same, ExtraBehavior};
 use crate::errors::{ErrorTypeDefaults, ValError, ValLineError, ValResult};
-use crate::input::{GenericArguments, Input, ValidationMatch};
+use crate::input::{BorrowInput, GenericArguments, Input, ValidationMatch};
 use crate::lookup_key::LookupKey;
 
 use crate::tools::SchemaDict;
@@ -38,26 +38,29 @@ impl BuildValidator for ArgumentsValidator {
     const EXPECTED_TYPE: &'static str = "arguments";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
 
         let populate_by_name = schema_or_config_same(schema, config, intern!(py, "populate_by_name"))?.unwrap_or(false);
 
-        let arguments_schema: &PyList = schema.get_as_req(intern!(py, "arguments_schema"))?;
+        let arguments_schema: Bound<'_, PyList> = schema.get_as_req(intern!(py, "arguments_schema"))?;
         let mut parameters: Vec<Parameter> = Vec::with_capacity(arguments_schema.len());
 
         let mut positional_params_count = 0;
         let mut had_default_arg = false;
 
         for (arg_index, arg) in arguments_schema.iter().enumerate() {
-            let arg: &PyDict = arg.downcast()?;
+            let arg = arg.downcast::<PyDict>()?;
 
             let name: String = arg.get_as_req(intern!(py, "name"))?;
-            let mode = arg
-                .get_as::<&str>(intern!(py, "mode"))?
+            let mode = arg.get_as::<Bound<'_, PyString>>(intern!(py, "mode"))?;
+            let mode = mode
+                .as_ref()
+                .map(|py_str| py_str.to_str())
+                .transpose()?
                 .unwrap_or("positional_or_keyword");
             let positional = mode == "positional_only" || mode == "positional_or_keyword";
             if positional {
@@ -70,16 +73,16 @@ impl BuildValidator for ArgumentsValidator {
                 kw_lookup_key = match arg.get_item(intern!(py, "alias"))? {
                     Some(alias) => {
                         let alt_alias = if populate_by_name { Some(name.as_str()) } else { None };
-                        Some(LookupKey::from_py(py, alias, alt_alias)?)
+                        Some(LookupKey::from_py(py, &alias, alt_alias)?)
                     }
                     None => Some(LookupKey::from_string(py, &name)),
                 };
-                kwarg_key = Some(PyString::new(py, &name).into());
+                kwarg_key = Some(PyString::new_bound(py, &name).into());
             }
 
-            let schema: &PyAny = arg.get_as_req(intern!(py, "schema"))?;
+            let schema = arg.get_as_req(intern!(py, "schema"))?;
 
-            let validator = match build_validator(schema, config, definitions) {
+            let validator = match build_validator(&schema, config, definitions) {
                 Ok(v) => v,
                 Err(err) => return py_schema_err!("Parameter '{}':\n  {}", name, err),
             };
@@ -112,11 +115,11 @@ impl BuildValidator for ArgumentsValidator {
             parameters,
             positional_params_count,
             var_args_validator: match schema.get_item(intern!(py, "var_args_schema"))? {
-                Some(v) => Some(Box::new(build_validator(v, config, definitions)?)),
+                Some(v) => Some(Box::new(build_validator(&v, config, definitions)?)),
                 None => None,
             },
             var_kwargs_validator: match schema.get_item(intern!(py, "var_kwargs_schema"))? {
-                Some(v) => Some(Box::new(build_validator(v, config, definitions)?)),
+                Some(v) => Some(Box::new(build_validator(&v, config, definitions)?)),
                 None => None,
             },
             loc_by_alias: config.get_as(intern!(py, "loc_by_alias"))?.unwrap_or(true),
@@ -172,7 +175,7 @@ impl Validator for ArgumentsValidator {
         let args = input.validate_args()?;
 
         let mut output_args: Vec<PyObject> = Vec::with_capacity(self.positional_params_count);
-        let output_kwargs = PyDict::new(py);
+        let output_kwargs = PyDict::new_bound(py);
         let mut errors: Vec<ValLineError> = Vec::new();
         let mut used_kwargs: AHashSet<&str> = AHashSet::with_capacity(self.parameters.len());
 
@@ -181,15 +184,15 @@ impl Validator for ArgumentsValidator {
                 // go through arguments getting the value from args or kwargs and validating it
                 for (index, parameter) in self.parameters.iter().enumerate() {
                     let mut pos_value = None;
-                    if let Some(args) = $args.args {
+                    if let Some(args) = &$args.args {
                         if parameter.positional {
                             pos_value = $get_macro!(args, index);
                         }
                     }
                     let mut kw_value = None;
-                    if let Some(kwargs) = $args.kwargs {
+                    if let Some(kwargs) = &$args.kwargs {
                         if let Some(ref lookup_key) = parameter.kw_lookup_key {
-                            if let Some((lookup_path, value)) = lookup_key.$get_method(kwargs)? {
+                            if let Some((lookup_path, value)) = lookup_key.$get_method(&kwargs)? {
                                 used_kwargs.insert(lookup_path.first_key());
                                 kw_value = Some((lookup_path, value));
                             }
@@ -200,12 +203,12 @@ impl Validator for ArgumentsValidator {
                         (Some(_), Some((_, kw_value))) => {
                             errors.push(ValLineError::new_with_loc(
                                 ErrorTypeDefaults::MultipleArgumentValues,
-                                kw_value,
+                                kw_value.borrow_input(),
                                 parameter.name.clone(),
                             ));
                         }
                         (Some(pos_value), None) => {
-                            match parameter.validator.validate(py, pos_value, state)
+                            match parameter.validator.validate(py, pos_value.borrow_input(), state)
                             {
                                 Ok(value) => output_args.push(value),
                                 Err(ValError::LineErrors(line_errors)) => {
@@ -215,7 +218,7 @@ impl Validator for ArgumentsValidator {
                             }
                         }
                         (None, Some((lookup_path, kw_value))) => {
-                            match parameter.validator.validate(py, kw_value, state)
+                            match parameter.validator.validate(py, kw_value.borrow_input(), state)
                             {
                                 Ok(value) => output_kwargs.set_item(parameter.kwarg_key.as_ref().unwrap(), value)?,
                                 Err(ValError::LineErrors(line_errors)) => {
@@ -257,7 +260,7 @@ impl Validator for ArgumentsValidator {
                     if len > self.positional_params_count {
                         if let Some(ref validator) = self.var_args_validator {
                             for (index, item) in $slice_macro!(args, self.positional_params_count, len).iter().enumerate() {
-                                match validator.validate(py, item, state) {
+                                match validator.validate(py, item.borrow_input(), state) {
                                     Ok(value) => output_args.push(value),
                                     Err(ValError::LineErrors(line_errors)) => {
                                         errors.extend(
@@ -273,7 +276,7 @@ impl Validator for ArgumentsValidator {
                             for (index, item) in $slice_macro!(args, self.positional_params_count, len).iter().enumerate() {
                                 errors.push(ValLineError::new_with_loc(
                                     ErrorTypeDefaults::UnexpectedPositionalArgument,
-                                    item,
+                                    item.borrow_input(),
                                     index + self.positional_params_count,
                                 ));
                             }
@@ -289,7 +292,7 @@ impl Validator for ArgumentsValidator {
                                 Err(ValError::LineErrors(line_errors)) => {
                                     for err in line_errors {
                                         errors.push(
-                                            err.with_outer_location(raw_key)
+                                            err.with_outer_location(raw_key.clone())
                                                 .with_type(ErrorTypeDefaults::InvalidKey),
                                         );
                                     }
@@ -299,11 +302,11 @@ impl Validator for ArgumentsValidator {
                             };
                             if !used_kwargs.contains(either_str.as_cow()?.as_ref()) {
                                 match self.var_kwargs_validator {
-                                    Some(ref validator) => match validator.validate(py, value, state) {
+                                    Some(ref validator) => match validator.validate(py, value.borrow_input(), state) {
                                         Ok(value) => output_kwargs.set_item(either_str.as_py_string(py), value)?,
                                         Err(ValError::LineErrors(line_errors)) => {
                                             for err in line_errors {
-                                                errors.push(err.with_outer_location(raw_key));
+                                                errors.push(err.with_outer_location(raw_key.clone()));
                                             }
                                         }
                                         Err(err) => return Err(err),
@@ -312,8 +315,8 @@ impl Validator for ArgumentsValidator {
                                         if let ExtraBehavior::Forbid = self.extra {
                                             errors.push(ValLineError::new_with_loc(
                                                 ErrorTypeDefaults::UnexpectedKeywordArgument,
-                                                value,
-                                                raw_key,
+                                                value.borrow_input(),
+                                                raw_key.clone(),
                                             ));
                                         }
                                     }
@@ -331,7 +334,7 @@ impl Validator for ArgumentsValidator {
         if !errors.is_empty() {
             Err(ValError::LineErrors(errors))
         } else {
-            Ok((PyTuple::new(py, output_args), output_kwargs).to_object(py))
+            Ok((PyTuple::new_bound(py, output_args), output_kwargs).to_object(py))
         }
     }
 
diff --git a/src/validators/bool.rs b/src/validators/bool.rs
index b2bb35e5d..97729ed60 100644
--- a/src/validators/bool.rs
+++ b/src/validators/bool.rs
@@ -16,8 +16,8 @@ impl BuildValidator for BoolValidator {
     const EXPECTED_TYPE: &'static str = "bool";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         Ok(Self {
diff --git a/src/validators/bytes.rs b/src/validators/bytes.rs
index 9dd07d7d3..16b41a05c 100644
--- a/src/validators/bytes.rs
+++ b/src/validators/bytes.rs
@@ -19,8 +19,8 @@ impl BuildValidator for BytesValidator {
     const EXPECTED_TYPE: &'static str = "bytes";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
@@ -106,7 +106,7 @@ impl Validator for BytesConstrainedValidator {
 }
 
 impl BytesConstrainedValidator {
-    fn build(schema: &PyDict, config: Option<&PyDict>) -> PyResult<CombinedValidator> {
+    fn build(schema: &Bound<'_, PyDict>, config: Option<&Bound<'_, PyDict>>) -> PyResult<CombinedValidator> {
         let py = schema.py();
         Ok(Self {
             strict: is_strict(schema, config)?,
diff --git a/src/validators/call.rs b/src/validators/call.rs
index 32b76f582..b0d966811 100644
--- a/src/validators/call.rs
+++ b/src/validators/call.rs
@@ -1,6 +1,7 @@
 use pyo3::exceptions::PyTypeError;
 use pyo3::intern;
 use pyo3::prelude::*;
+use pyo3::types::PyString;
 use pyo3::types::{PyDict, PyTuple};
 
 use crate::errors::ValResult;
@@ -23,22 +24,22 @@ impl BuildValidator for CallValidator {
     const EXPECTED_TYPE: &'static str = "call";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
 
-        let arguments_schema: &PyAny = schema.get_as_req(intern!(py, "arguments_schema"))?;
-        let arguments_validator = Box::new(build_validator(arguments_schema, config, definitions)?);
+        let arguments_schema = schema.get_as_req(intern!(py, "arguments_schema"))?;
+        let arguments_validator = Box::new(build_validator(&arguments_schema, config, definitions)?);
 
         let return_schema = schema.get_item(intern!(py, "return_schema"))?;
         let return_validator = match return_schema {
-            Some(return_schema) => Some(Box::new(build_validator(return_schema, config, definitions)?)),
+            Some(return_schema) => Some(Box::new(build_validator(&return_schema, config, definitions)?)),
             None => None,
         };
-        let function: &PyAny = schema.get_as_req(intern!(py, "function"))?;
-        let function_name: &str = match schema.get_as(intern!(py, "function_name"))? {
+        let function: Bound<'_, PyAny> = schema.get_as_req(intern!(py, "function"))?;
+        let function_name: Py<PyString> = match schema.get_as(intern!(py, "function_name"))? {
             Some(name) => name,
             None => {
                 match function.getattr(intern!(py, "__name__")) {
@@ -48,12 +49,13 @@ impl BuildValidator for CallValidator {
                         if let Ok(func) = function.getattr(intern!(py, "func")) {
                             func.getattr(intern!(py, "__name__"))?.extract()?
                         } else {
-                            "<unknown>"
+                            intern!(py, "<unknown>").clone().into()
                         }
                     }
                 }
             }
         };
+        let function_name = function_name.bind(py);
         let name = format!("{}[{function_name}]", Self::EXPECTED_TYPE);
 
         Ok(Self {
@@ -79,12 +81,12 @@ impl Validator for CallValidator {
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
-        let args = self.arguments_validator.validate(py, input, state)?;
+        let args = self.arguments_validator.validate(py, input, state)?.into_bound(py);
 
-        let return_value = if let Ok((args, kwargs)) = args.extract::<(&PyTuple, &PyDict)>(py) {
-            self.function.call(py, args, Some(kwargs))?
-        } else if let Ok(kwargs) = args.downcast::<PyDict>(py) {
-            self.function.call(py, (), Some(kwargs))?
+        let return_value = if let Ok((args, kwargs)) = args.extract::<(Bound<PyTuple>, Bound<PyDict>)>() {
+            self.function.call_bound(py, args, Some(&kwargs))?
+        } else if let Ok(kwargs) = args.downcast::<PyDict>() {
+            self.function.call_bound(py, (), Some(kwargs))?
         } else {
             let msg = "Arguments validator should return a tuple of (args, kwargs) or a dict of kwargs";
             return Err(PyTypeError::new_err(msg).into());
@@ -92,7 +94,7 @@ impl Validator for CallValidator {
 
         if let Some(return_validator) = &self.return_validator {
             return_validator
-                .validate(py, return_value.into_ref(py), state)
+                .validate(py, return_value.bind(py), state)
                 .map_err(|e| e.with_outer_location("return"))
         } else {
             Ok(return_value.to_object(py))
diff --git a/src/validators/callable.rs b/src/validators/callable.rs
index e05c99b12..90bc04957 100644
--- a/src/validators/callable.rs
+++ b/src/validators/callable.rs
@@ -14,8 +14,8 @@ impl BuildValidator for CallableValidator {
     const EXPECTED_TYPE: &'static str = "callable";
 
     fn build(
-        _schema: &PyDict,
-        _config: Option<&PyDict>,
+        _schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         Ok(Self.into())
diff --git a/src/validators/chain.rs b/src/validators/chain.rs
index 299801dea..0f368f477 100644
--- a/src/validators/chain.rs
+++ b/src/validators/chain.rs
@@ -20,14 +20,14 @@ impl BuildValidator for ChainValidator {
     const EXPECTED_TYPE: &'static str = "chain";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let steps: Vec<CombinedValidator> = schema
-            .get_as_req::<&PyList>(intern!(schema.py(), "steps"))?
+            .get_as_req::<Bound<'_, PyList>>(intern!(schema.py(), "steps"))?
             .iter()
-            .map(|step| build_validator_steps(step, config, definitions))
+            .map(|step| build_validator_steps(&step, config, definitions))
             .collect::<PyResult<Vec<Vec<CombinedValidator>>>>()?
             .into_iter()
             .flatten()
@@ -54,9 +54,9 @@ impl BuildValidator for ChainValidator {
 
 // either a vec of the steps from a nested `ChainValidator`, or a length-1 vec containing the validator
 // to be flattened into `steps` above
-fn build_validator_steps<'a>(
-    step: &'a PyAny,
-    config: Option<&'a PyDict>,
+fn build_validator_steps(
+    step: &Bound<'_, PyAny>,
+    config: Option<&Bound<'_, PyDict>>,
     definitions: &mut DefinitionsBuilder<CombinedValidator>,
 ) -> PyResult<Vec<CombinedValidator>> {
     let validator = build_validator(step, config, definitions)?;
@@ -80,7 +80,7 @@ impl Validator for ChainValidator {
         let first_step = steps_iter.next().unwrap();
         let value = first_step.validate(py, input, state)?;
 
-        steps_iter.try_fold(value, |v, step| step.validate(py, v.into_ref(py), state))
+        steps_iter.try_fold(value, |v, step| step.validate(py, v.bind(py), state))
     }
 
     fn get_name(&self) -> &str {
diff --git a/src/validators/custom_error.rs b/src/validators/custom_error.rs
index ec0af567a..0febcdca3 100644
--- a/src/validators/custom_error.rs
+++ b/src/validators/custom_error.rs
@@ -19,8 +19,8 @@ pub enum CustomError {
 
 impl CustomError {
     pub fn build(
-        schema: &PyDict,
-        _config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<Option<Self>> {
         let py = schema.py();
@@ -69,13 +69,13 @@ impl BuildValidator for CustomErrorValidator {
     const EXPECTED_TYPE: &'static str = "custom-error";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let custom_error = CustomError::build(schema, config, definitions)?.unwrap();
-        let schema: &PyAny = schema.get_as_req(intern!(schema.py(), "schema"))?;
-        let validator = Box::new(build_validator(schema, config, definitions)?);
+        let schema = schema.get_as_req(intern!(schema.py(), "schema"))?;
+        let validator = Box::new(build_validator(&schema, config, definitions)?);
         let name = format!("{}[{}]", Self::EXPECTED_TYPE, validator.get_name());
         Ok(Self {
             validator,
diff --git a/src/validators/dataclass.rs b/src/validators/dataclass.rs
index bfeac2115..648f53fdb 100644
--- a/src/validators/dataclass.rs
+++ b/src/validators/dataclass.rs
@@ -49,8 +49,8 @@ impl BuildValidator for DataclassArgsValidator {
     const EXPECTED_TYPE: &'static str = "dataclass-args";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
@@ -60,33 +60,33 @@ impl BuildValidator for DataclassArgsValidator {
         let extra_behavior = ExtraBehavior::from_schema_or_config(py, schema, config, ExtraBehavior::Ignore)?;
 
         let extras_validator = match (schema.get_item(intern!(py, "extras_schema"))?, &extra_behavior) {
-            (Some(v), ExtraBehavior::Allow) => Some(Box::new(build_validator(v, config, definitions)?)),
+            (Some(v), ExtraBehavior::Allow) => Some(Box::new(build_validator(&v, config, definitions)?)),
             (Some(_), _) => return py_schema_err!("extras_schema can only be used if extra_behavior=allow"),
             (_, _) => None,
         };
 
-        let fields_schema: &PyList = schema.get_as_req(intern!(py, "fields"))?;
+        let fields_schema: Bound<'_, PyList> = schema.get_as_req(intern!(py, "fields"))?;
         let mut fields: Vec<Field> = Vec::with_capacity(fields_schema.len());
 
         let mut positional_count = 0;
 
         for field in fields_schema {
-            let field: &PyDict = field.downcast()?;
+            let field = field.downcast::<PyDict>()?;
 
-            let py_name: &PyString = field.get_as_req(intern!(py, "name"))?;
+            let py_name: Bound<'_, PyString> = field.get_as_req(intern!(py, "name"))?;
             let name: String = py_name.extract()?;
 
             let lookup_key = match field.get_item(intern!(py, "validation_alias"))? {
                 Some(alias) => {
                     let alt_alias = if populate_by_name { Some(name.as_str()) } else { None };
-                    LookupKey::from_py(py, alias, alt_alias)?
+                    LookupKey::from_py(py, &alias, alt_alias)?
                 }
                 None => LookupKey::from_string(py, &name),
             };
 
-            let schema: &PyAny = field.get_as_req(intern!(py, "schema"))?;
+            let schema = field.get_as_req(intern!(py, "schema"))?;
 
-            let validator = match build_validator(schema, config, definitions) {
+            let validator = match build_validator(&schema, config, definitions) {
                 Ok(v) => v,
                 Err(err) => return py_schema_err!("Field '{}':\n  {}", name, err),
             };
@@ -149,7 +149,7 @@ impl Validator for DataclassArgsValidator {
     ) -> ValResult<PyObject> {
         let args = input.validate_dataclass_args(&self.dataclass_name)?;
 
-        let output_dict = PyDict::new(py);
+        let output_dict = PyDict::new_bound(py);
         let mut init_only_args = self.init_only_count.map(Vec::with_capacity);
 
         let mut errors: Vec<ValLineError> = Vec::new();
@@ -157,13 +157,13 @@ impl Validator for DataclassArgsValidator {
 
         state.with_new_extra(
             Extra {
-                data: Some(output_dict),
+                data: Some(output_dict.clone()),
                 ..*state.extra()
             },
             |state| {
                 macro_rules! set_item {
                     ($field:ident, $value:expr) => {{
-                        let py_name = $field.py_name.as_ref(py);
+                        let py_name = $field.py_name.bind(py);
                         if $field.init_only {
                             if let Some(ref mut init_only_args) = init_only_args {
                                 init_only_args.push($value);
@@ -196,15 +196,15 @@ impl Validator for DataclassArgsValidator {
                             };
 
                             let mut pos_value = None;
-                            if let Some(args) = $args.args {
+                            if let Some(args) = &$args.args {
                                 if !field.kw_only {
                                     pos_value = $get_macro!(args, index);
                                 }
                             }
 
                             let mut kw_value = None;
-                            if let Some(kwargs) = $args.kwargs {
-                                if let Some((lookup_path, value)) = field.lookup_key.$get_method(kwargs)? {
+                            if let Some(kwargs) = &$args.kwargs {
+                                if let Some((lookup_path, value)) = field.lookup_key.$get_method(&kwargs)? {
                                     used_keys.insert(lookup_path.first_key());
                                     kw_value = Some((lookup_path, value));
                                 }
@@ -225,7 +225,7 @@ impl Validator for DataclassArgsValidator {
                                     );
                                 }
                                 // found a positional argument, validate it
-                                (Some(pos_value), None) => match field.validator.validate(py, pos_value, state) {
+                                (Some(pos_value), None) => match field.validator.validate(py, pos_value.borrow_input(), state) {
                                     Ok(value) => set_item!(field, value),
                                     Err(ValError::LineErrors(line_errors)) => {
                                         errors.extend(
@@ -290,7 +290,7 @@ impl Validator for DataclassArgsValidator {
                                 {
                                     errors.push(ValLineError::new_with_loc(
                                         ErrorTypeDefaults::UnexpectedPositionalArgument,
-                                        item,
+                                        item.borrow_input(),
                                         index + self.positional_count,
                                     ));
                                 }
@@ -309,20 +309,20 @@ impl Validator for DataclassArgsValidator {
                                                         errors.push(
                                                             ValLineError::new_with_loc(
                                                                 ErrorTypeDefaults::UnexpectedKeywordArgument,
-                                                                value,
-                                                                raw_key,
+                                                                value.borrow_input(),
+                                                                raw_key.clone(),
                                                             ),
                                                         );
                                                     }
                                                     ExtraBehavior::Ignore => {}
                                                     ExtraBehavior::Allow => {
                                                         if let Some(ref validator) = self.extras_validator {
-                                                            match validator.validate(py, value, state) {
+                                                            match validator.validate(py, value.borrow_input(), state) {
                                                                 Ok(value) => output_dict
                                                                     .set_item(either_str.as_py_string(py), value)?,
                                                                 Err(ValError::LineErrors(line_errors)) => {
                                                                     for err in line_errors {
-                                                                        errors.push(err.with_outer_location(raw_key));
+                                                                        errors.push(err.with_outer_location(raw_key.clone()));
                                                                     }
                                                                 }
                                                                 Err(err) => return Err(err),
@@ -337,7 +337,7 @@ impl Validator for DataclassArgsValidator {
                                         Err(ValError::LineErrors(line_errors)) => {
                                             for err in line_errors {
                                                 errors.push(
-                                                    err.with_outer_location(raw_key)
+                                                    err.with_outer_location(raw_key.clone())
                                                         .with_type(ErrorTypeDefaults::InvalidKey),
                                                 );
                                             }
@@ -357,13 +357,13 @@ impl Validator for DataclassArgsValidator {
                         // StringMapping cannot pass positional args, so wrap the PyDict
                         // in a type with guaranteed empty args array for sake of the process
                         // macro
-                        struct StringMappingArgs<'a> {
-                            args: Option<&'a PyTuple>,
-                            kwargs: Option<&'a PyDict>,
+                        struct StringMappingArgs<'py> {
+                            args: Option<Bound<'py, PyTuple>>,
+                            kwargs: Option<Bound<'py, PyDict>>,
                         }
                         let a = StringMappingArgs {
                             args: None,
-                            kwargs: Some(a),
+                            kwargs: Some(a.clone()),
                         };
                         process!(a, py_get_string_mapping_item, py_get, py_slice);
                     }
@@ -373,7 +373,7 @@ impl Validator for DataclassArgsValidator {
         )?;
         if errors.is_empty() {
             if let Some(init_only_args) = init_only_args {
-                Ok((output_dict, PyTuple::new(py, init_only_args)).to_object(py))
+                Ok((output_dict, PyTuple::new_bound(py, init_only_args)).to_object(py))
             } else {
                 Ok((output_dict, py.None()).to_object(py))
             }
@@ -385,12 +385,12 @@ impl Validator for DataclassArgsValidator {
     fn validate_assignment<'data>(
         &self,
         py: Python<'data>,
-        obj: &'data PyAny,
-        field_name: &'data str,
-        field_value: &'data PyAny,
+        obj: &Bound<'data, PyAny>,
+        field_name: &str,
+        field_value: &Bound<'data, PyAny>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
-        let dict: &PyDict = obj.downcast()?;
+        let dict = obj.downcast::<PyDict>()?;
 
         let ok = |output: PyObject| {
             dict.set_item(field_name, output)?;
@@ -398,7 +398,7 @@ impl Validator for DataclassArgsValidator {
             // which doesn't make much sense in this context but we need to put something there
             // so that function validators that sit between DataclassValidator and DataclassArgsValidator
             // always get called the same shape of data.
-            Ok(PyTuple::new(py, vec![dict.to_object(py), py.None()]).into_py(py))
+            Ok(PyTuple::new_bound(py, vec![dict.to_object(py), py.None()]).into_py(py))
         };
 
         if let Some(field) = self.fields.iter().find(|f| f.name == field_name) {
@@ -413,13 +413,13 @@ impl Validator for DataclassArgsValidator {
             let data_dict = dict.copy()?;
             if let Err(err) = data_dict.del_item(field_name) {
                 // KeyError is fine here as the field might not be in the dict
-                if !err.get_type(py).is(PyType::new::<PyKeyError>(py)) {
+                if !err.get_type_bound(py).is(&PyType::new_bound::<PyKeyError>(py)) {
                     return Err(err.into());
                 }
             }
             match state.with_new_extra(
                 Extra {
-                    data: Some(data_dict),
+                    data: Some(data_dict.clone()),
                     ..*state.extra()
                 },
                 |state| field.validator.validate(py, field_value, state),
@@ -476,25 +476,26 @@ impl BuildValidator for DataclassValidator {
     const EXPECTED_TYPE: &'static str = "dataclass";
 
     fn build(
-        schema: &PyDict,
-        _config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
 
         // dataclasses ignore the parent config and always use the config from this dataclasses
         let config = schema.get_as(intern!(py, "config"))?;
+        let config = config.as_ref();
 
         let class: &PyType = schema.get_as_req(intern!(py, "cls"))?;
         let name = match schema.get_as_req::<String>(intern!(py, "cls_name")) {
             Ok(name) => name,
             Err(_) => class.getattr(intern!(py, "__name__"))?.extract()?,
         };
-        let sub_schema: &PyAny = schema.get_as_req(intern!(py, "schema"))?;
-        let validator = build_validator(sub_schema, config, definitions)?;
+        let sub_schema = schema.get_as_req(intern!(py, "schema"))?;
+        let validator = build_validator(&sub_schema, config, definitions)?;
 
         let post_init = if schema.get_as::<bool>(intern!(py, "post_init"))?.unwrap_or(false) {
-            Some(PyString::new(py, "__post_init__").into_py(py))
+            Some(PyString::new_bound(py, "__post_init__").into())
         } else {
             None
         };
@@ -511,11 +512,12 @@ impl BuildValidator for DataclassValidator {
             class: class.into(),
             fields,
             post_init,
-            revalidate: Revalidate::from_str(schema_or_config_same(
-                schema,
-                config,
-                intern!(py, "revalidate_instances"),
-            )?)?,
+            revalidate: Revalidate::from_str(
+                schema_or_config_same::<Bound<'_, PyString>>(schema, config, intern!(py, "revalidate_instances"))?
+                    .as_ref()
+                    .map(|s| s.to_str())
+                    .transpose()?,
+            )?,
             name,
             frozen: schema.get_as(intern!(py, "frozen"))?.unwrap_or(false),
             slots: schema.get_as(intern!(py, "slots"))?.unwrap_or(false),
@@ -539,14 +541,14 @@ impl Validator for DataclassValidator {
         }
 
         // same logic as on models
-        let class = self.class.as_ref(py);
+        let class = self.class.bind(py);
         if let Some(py_input) = input.input_is_instance(class) {
             if self.revalidate.should_revalidate(py_input, class) {
-                let input_dict: &PyAny = self.dataclass_to_dict(py, py_input)?;
-                let val_output = self.validator.validate(py, input_dict, state)?;
-                let dc = create_class(self.class.as_ref(py))?;
-                self.set_dict_call(py, dc.as_ref(py), val_output, input)?;
-                Ok(dc)
+                let input_dict = self.dataclass_to_dict(py_input)?;
+                let val_output = self.validator.validate(py, input_dict.as_any(), state)?;
+                let dc = create_class(self.class.bind(py))?;
+                self.set_dict_call(py, &dc, val_output, input)?;
+                Ok(dc.into())
             } else {
                 Ok(input.to_object(py))
             }
@@ -561,31 +563,31 @@ impl Validator for DataclassValidator {
         } else {
             let val_output = self.validator.validate(py, input, state)?;
             state.floor_exactness(Exactness::Strict);
-            let dc = create_class(self.class.as_ref(py))?;
-            self.set_dict_call(py, dc.as_ref(py), val_output, input)?;
-            Ok(dc)
+            let dc = create_class(self.class.bind(py))?;
+            self.set_dict_call(py, &dc, val_output, input)?;
+            Ok(dc.into())
         }
     }
 
     fn validate_assignment<'data>(
         &self,
         py: Python<'data>,
-        obj: &'data PyAny,
-        field_name: &'data str,
-        field_value: &'data PyAny,
+        obj: &Bound<'data, PyAny>,
+        field_name: &str,
+        field_value: &Bound<'data, PyAny>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         if self.frozen {
             return Err(ValError::new(ErrorTypeDefaults::FrozenInstance, field_value));
         }
 
-        let new_dict = self.dataclass_to_dict(py, obj)?;
+        let new_dict = self.dataclass_to_dict(obj)?;
 
         new_dict.set_item(field_name, field_value)?;
 
-        let val_assignment_result = self
-            .validator
-            .validate_assignment(py, new_dict, field_name, field_value, state)?;
+        let val_assignment_result =
+            self.validator
+                .validate_assignment(py, new_dict.as_any(), field_name, field_value, state)?;
 
         let (dc_dict, _): (&PyDict, PyObject) = val_assignment_result.extract(py)?;
 
@@ -611,7 +613,7 @@ impl DataclassValidator {
     fn validate_init<'s, 'data>(
         &'s self,
         py: Python<'data>,
-        self_instance: &'s PyAny,
+        self_instance: &Bound<'_, PyAny>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
@@ -625,11 +627,11 @@ impl DataclassValidator {
         Ok(self_instance.into_py(py))
     }
 
-    fn dataclass_to_dict<'py>(&self, py: Python<'py>, dc: &'py PyAny) -> PyResult<&'py PyDict> {
-        let dict = PyDict::new(py);
+    fn dataclass_to_dict<'py>(&self, dc: &Bound<'py, PyAny>) -> PyResult<Bound<'py, PyDict>> {
+        let py = dc.py();
+        let dict = PyDict::new_bound(py);
 
         for field_name in &self.fields {
-            let field_name = field_name.as_ref(py);
             dict.set_item(field_name, dc.getattr(field_name)?)?;
         }
         Ok(dict)
@@ -638,14 +640,14 @@ impl DataclassValidator {
     fn set_dict_call<'s, 'data>(
         &'s self,
         py: Python<'data>,
-        dc: &PyAny,
+        dc: &Bound<'_, PyAny>,
         val_output: PyObject,
         input: &'data impl Input<'data>,
     ) -> ValResult<()> {
-        let (dc_dict, post_init_kwargs): (&PyAny, &PyAny) = val_output.extract(py)?;
+        let (dc_dict, post_init_kwargs): (Bound<'_, PyAny>, Bound<'_, PyAny>) = val_output.extract(py)?;
         if self.slots {
-            let dc_dict: &PyDict = dc_dict.downcast()?;
-            for (key, value) in dc_dict {
+            let dc_dict = dc_dict.downcast::<PyDict>()?;
+            for (key, value) in dc_dict.iter() {
                 force_setattr(py, dc, key, value)?;
             }
         } else {
@@ -653,12 +655,12 @@ impl DataclassValidator {
         }
 
         if let Some(ref post_init) = self.post_init {
-            let post_init = post_init.as_ref(py);
-            let r = if post_init_kwargs.is_none() {
+            let post_init = post_init.bind(py);
+            let r = if PyAnyMethods::is_none(&post_init_kwargs) {
                 dc.call_method0(post_init)
             } else {
                 let args = post_init_kwargs.downcast::<PyTuple>()?;
-                dc.call_method1(post_init, args)
+                dc.call_method1(post_init, args.as_gil_ref())
             };
             r.map_err(|e| convert_err(py, e, input))?;
         }
diff --git a/src/validators/date.rs b/src/validators/date.rs
index 2329dcf2a..009878a62 100644
--- a/src/validators/date.rs
+++ b/src/validators/date.rs
@@ -24,8 +24,8 @@ impl BuildValidator for DateValidator {
     const EXPECTED_TYPE: &'static str = "date";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         Ok(Self {
@@ -158,7 +158,7 @@ struct DateConstraints {
 }
 
 impl DateConstraints {
-    fn from_py(schema: &PyDict) -> PyResult<Option<Self>> {
+    fn from_py(schema: &Bound<'_, PyDict>) -> PyResult<Option<Self>> {
         let py = schema.py();
         let c = Self {
             le: convert_pydate(schema, intern!(py, "le"))?,
@@ -175,8 +175,8 @@ impl DateConstraints {
     }
 }
 
-fn convert_pydate(schema: &PyDict, field: &PyString) -> PyResult<Option<Date>> {
-    match schema.get_as::<&PyDate>(field)? {
+fn convert_pydate(schema: &Bound<'_, PyDict>, field: &Bound<'_, PyString>) -> PyResult<Option<Date>> {
+    match schema.get_as::<Bound<'_, PyDate>>(field)? {
         Some(date) => Ok(Some(EitherDate::Py(date).as_raw()?)),
         None => Ok(None),
     }
diff --git a/src/validators/datetime.rs b/src/validators/datetime.rs
index 94dc7ba05..bd8944fb4 100644
--- a/src/validators/datetime.rs
+++ b/src/validators/datetime.rs
@@ -1,7 +1,7 @@
 use pyo3::intern;
-use pyo3::once_cell::GILOnceCell;
 use pyo3::prelude::*;
-use pyo3::types::{PyDateTime, PyDict, PyString};
+use pyo3::sync::GILOnceCell;
+use pyo3::types::{PyDict, PyString};
 use speedate::{DateTime, Time};
 use std::cmp::Ordering;
 use strum::EnumMessage;
@@ -24,14 +24,14 @@ pub struct DateTimeValidator {
 }
 
 pub(crate) fn extract_microseconds_precision(
-    schema: &PyDict,
-    config: Option<&PyDict>,
+    schema: &Bound<'_, PyDict>,
+    config: Option<&Bound<'_, PyDict>>,
 ) -> PyResult<speedate::MicrosecondsPrecisionOverflowBehavior> {
     schema_or_config_same(schema, config, intern!(schema.py(), "microseconds_precision"))?
         .map_or(
             Ok(speedate::MicrosecondsPrecisionOverflowBehavior::Truncate),
             |v: &PyString| {
-                speedate::MicrosecondsPrecisionOverflowBehavior::try_from(String::extract(v).unwrap().as_str())
+                speedate::MicrosecondsPrecisionOverflowBehavior::try_from(v.extract::<String>().unwrap().as_str())
             },
         )
         .map_err(|_| {
@@ -43,8 +43,8 @@ impl BuildValidator for DateTimeValidator {
     const EXPECTED_TYPE: &'static str = "datetime";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         Ok(Self {
@@ -191,7 +191,7 @@ struct DateTimeConstraints {
 }
 
 impl DateTimeConstraints {
-    fn from_py(schema: &PyDict) -> PyResult<Option<Self>> {
+    fn from_py(schema: &Bound<'_, PyDict>) -> PyResult<Option<Self>> {
         let py = schema.py();
         let c = Self {
             le: py_datetime_as_datetime(schema, intern!(py, "le"))?,
@@ -209,8 +209,8 @@ impl DateTimeConstraints {
     }
 }
 
-fn py_datetime_as_datetime(schema: &PyDict, field: &PyString) -> PyResult<Option<DateTime>> {
-    match schema.get_as::<&PyDateTime>(field)? {
+fn py_datetime_as_datetime(schema: &Bound<'_, PyDict>, field: &Bound<'_, PyString>) -> PyResult<Option<DateTime>> {
+    match schema.get_as(field)? {
         Some(dt) => Ok(Some(EitherDateTime::Py(dt).as_raw()?)),
         None => Ok(None),
     }
@@ -249,7 +249,7 @@ pub struct NowConstraint {
 static TIME_LOCALTIME: GILOnceCell<PyObject> = GILOnceCell::new();
 
 fn get_localtime(py: Python) -> PyResult<PyObject> {
-    Ok(py.import("time")?.getattr("localtime")?.into_py(py))
+    Ok(py.import_bound("time")?.getattr("localtime")?.into_py(py))
 }
 
 impl NowConstraint {
@@ -261,19 +261,15 @@ impl NowConstraint {
             Ok(utc_offset)
         } else {
             let localtime = TIME_LOCALTIME.get_or_init(py, || get_localtime(py).unwrap());
-            localtime
-                .as_ref(py)
-                .call0()?
-                .getattr(intern!(py, "tm_gmtoff"))?
-                .extract()
+            localtime.bind(py).call0()?.getattr(intern!(py, "tm_gmtoff"))?.extract()
         }
     }
 
-    pub fn from_py(schema: &PyDict) -> PyResult<Option<Self>> {
+    pub fn from_py(schema: &Bound<'_, PyDict>) -> PyResult<Option<Self>> {
         let py = schema.py();
-        match schema.get_as(intern!(py, "now_op"))? {
+        match schema.get_as::<Bound<'_, PyString>>(intern!(py, "now_op"))? {
             Some(op) => Ok(Some(Self {
-                op: NowOp::from_str(op)?,
+                op: NowOp::from_str(op.to_str()?)?,
                 utc_offset: schema.get_as(intern!(py, "now_utc_offset"))?,
             })),
             None => Ok(None),
@@ -296,7 +292,7 @@ impl TZConstraint {
         }
     }
 
-    pub(super) fn from_py(schema: &PyDict) -> PyResult<Option<Self>> {
+    pub(super) fn from_py(schema: &Bound<'_, PyDict>) -> PyResult<Option<Self>> {
         let py = schema.py();
         let tz_constraint = match schema.get_item(intern!(py, "tz_constraint"))? {
             Some(c) => c,
diff --git a/src/validators/decimal.rs b/src/validators/decimal.rs
index 85f81a38e..f4f292d76 100644
--- a/src/validators/decimal.rs
+++ b/src/validators/decimal.rs
@@ -16,17 +16,17 @@ use super::{BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationSta
 
 static DECIMAL_TYPE: GILOnceCell<Py<PyType>> = GILOnceCell::new();
 
-pub fn get_decimal_type(py: Python) -> Py<PyType> {
+pub fn get_decimal_type(py: Python) -> &Bound<'_, PyType> {
     DECIMAL_TYPE
         .get_or_init(py, || {
-            py.import("decimal")
+            py.import_bound("decimal")
                 .and_then(|decimal_module| decimal_module.getattr("Decimal"))
                 .unwrap()
                 .extract::<&PyType>()
                 .unwrap()
                 .into()
         })
-        .clone()
+        .bind(py)
 }
 
 #[derive(Debug, Clone)]
@@ -46,8 +46,8 @@ pub struct DecimalValidator {
 impl BuildValidator for DecimalValidator {
     const EXPECTED_TYPE: &'static str = "decimal";
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
@@ -83,12 +83,14 @@ impl_py_gc_traverse!(DecimalValidator {
     gt
 });
 
-fn extract_decimal_digits_info(decimal: &PyAny, normalized: bool, py: Python<'_>) -> ValResult<(u64, u64)> {
-    let mut normalized_decimal: Option<&PyAny> = None;
+fn extract_decimal_digits_info(decimal: &Bound<'_, PyAny>, normalized: bool) -> ValResult<(u64, u64)> {
+    let py = decimal.py();
+    let mut normalized_decimal: Option<Bound<'_, PyAny>> = None;
     if normalized {
-        normalized_decimal = Some(decimal.call_method0(intern!(py, "normalize")).unwrap_or(decimal));
+        normalized_decimal = decimal.call_method0(intern!(py, "normalize")).ok();
     }
-    let (_, digit_tuple, exponent): (&PyAny, &PyTuple, &PyAny) = normalized_decimal
+    let (_, digit_tuple, exponent): (Bound<'_, PyAny>, Bound<'_, PyTuple>, Bound<'_, PyAny>) = normalized_decimal
+        .as_ref()
         .unwrap_or(decimal)
         .call_method0(intern!(py, "as_tuple"))?
         .extract()?;
@@ -129,8 +131,8 @@ impl Validator for DecimalValidator {
             }
 
             if self.check_digits {
-                if let Ok((normalized_decimals, normalized_digits)) = extract_decimal_digits_info(decimal, true, py) {
-                    if let Ok((decimals, digits)) = extract_decimal_digits_info(decimal, false, py) {
+                if let Ok((normalized_decimals, normalized_digits)) = extract_decimal_digits_info(&decimal, true) {
+                    if let Ok((decimals, digits)) = extract_decimal_digits_info(&decimal, false) {
                         if let Some(max_digits) = self.max_digits {
                             if (digits > max_digits) & (normalized_digits > max_digits) {
                                 return Err(ValError::new(
@@ -181,20 +183,17 @@ impl Validator for DecimalValidator {
 
         if let Some(multiple_of) = &self.multiple_of {
             // fraction = (decimal / multiple_of) % 1
-            let fraction: &PyAny = unsafe {
-                let division = PyObject::from_owned_ptr_or_err(
-                    py,
-                    pyo3::ffi::PyNumber_TrueDivide(decimal.as_ptr(), multiple_of.as_ptr()),
-                )?;
+            let fraction = unsafe {
+                let division = decimal.div(multiple_of)?;
                 let one = 1.to_object(py);
-                py.from_owned_ptr_or_err(pyo3::ffi::PyNumber_Remainder(division.as_ptr(), one.as_ptr()))?
+                Bound::from_owned_ptr_or_err(py, pyo3::ffi::PyNumber_Remainder(division.as_ptr(), one.as_ptr()))?
             };
             let zero = 0.to_object(py);
             if !fraction.eq(&zero)? {
                 return Err(ValError::new(
                     ErrorType::MultipleOf {
                         multiple_of: multiple_of.to_string().into(),
-                        context: Some([("multiple_of", multiple_of)].into_py_dict(py).into()),
+                        context: Some([("multiple_of", multiple_of)].into_py_dict_bound(py).into()),
                     },
                     input,
                 ));
@@ -217,7 +216,7 @@ impl Validator for DecimalValidator {
                 return Err(ValError::new(
                     ErrorType::LessThanEqual {
                         le: Number::String(le.to_string()),
-                        context: Some([("le", le)].into_py_dict(py).into()),
+                        context: Some([("le", le)].into_py_dict_bound(py).into()),
                     },
                     input,
                 ));
@@ -228,7 +227,7 @@ impl Validator for DecimalValidator {
                 return Err(ValError::new(
                     ErrorType::LessThan {
                         lt: Number::String(lt.to_string()),
-                        context: Some([("lt", lt)].into_py_dict(py).into()),
+                        context: Some([("lt", lt)].into_py_dict_bound(py).into()),
                     },
                     input,
                 ));
@@ -239,7 +238,7 @@ impl Validator for DecimalValidator {
                 return Err(ValError::new(
                     ErrorType::GreaterThanEqual {
                         ge: Number::String(ge.to_string()),
-                        context: Some([("ge", ge)].into_py_dict(py).into()),
+                        context: Some([("ge", ge)].into_py_dict_bound(py).into()),
                     },
                     input,
                 ));
@@ -250,7 +249,7 @@ impl Validator for DecimalValidator {
                 return Err(ValError::new(
                     ErrorType::GreaterThan {
                         gt: Number::String(gt.to_string()),
-                        context: Some([("gt", gt)].into_py_dict(py).into()),
+                        context: Some([("gt", gt)].into_py_dict_bound(py).into()),
                     },
                     input,
                 ));
@@ -265,33 +264,25 @@ impl Validator for DecimalValidator {
     }
 }
 
-pub(crate) fn create_decimal<'a>(arg: &'a PyAny, input: &'a impl Input<'a>, py: Python<'a>) -> ValResult<&'a PyAny> {
-    let decimal_type_obj: Py<PyType> = get_decimal_type(py);
-    decimal_type_obj
-        .call1(py, (arg,))
-        .map_err(|e| {
-            let decimal_exception = match arg
-                .py()
-                .import("decimal")
-                .and_then(|decimal_module| decimal_module.getattr("DecimalException"))
-            {
-                Ok(decimal_exception) => decimal_exception,
-                Err(e) => return ValError::InternalErr(e),
-            };
-            handle_decimal_new_error(arg.py(), input.as_error_value(), e, decimal_exception)
-        })
-        .map(|v| v.into_ref(py))
+pub(crate) fn create_decimal<'a>(arg: &Bound<'a, PyAny>, input: &'a impl Input<'a>) -> ValResult<Bound<'a, PyAny>> {
+    let py = arg.py();
+    get_decimal_type(py).call1((arg,)).map_err(|e| {
+        let decimal_exception = match py
+            .import_bound("decimal")
+            .and_then(|decimal_module| decimal_module.getattr("DecimalException"))
+        {
+            Ok(decimal_exception) => decimal_exception,
+            Err(e) => return ValError::InternalErr(e),
+        };
+        handle_decimal_new_error(input.as_error_value(), e, decimal_exception)
+    })
 }
 
-fn handle_decimal_new_error<'a>(
-    py: Python<'a>,
-    input: InputValue,
-    error: PyErr,
-    decimal_exception: &'a PyAny,
-) -> ValError {
+fn handle_decimal_new_error(input: InputValue, error: PyErr, decimal_exception: Bound<'_, PyAny>) -> ValError {
+    let py = decimal_exception.py();
     if error.matches(py, decimal_exception) {
         ValError::new_custom_input(ErrorTypeDefaults::DecimalParsing, input)
-    } else if error.matches(py, PyTypeError::type_object(py)) {
+    } else if error.matches(py, PyTypeError::type_object_bound(py)) {
         ValError::new_custom_input(ErrorTypeDefaults::DecimalType, input)
     } else {
         ValError::InternalErr(error)
diff --git a/src/validators/definitions.rs b/src/validators/definitions.rs
index e4bc270c2..6e9b05a6b 100644
--- a/src/validators/definitions.rs
+++ b/src/validators/definitions.rs
@@ -1,5 +1,6 @@
 use pyo3::intern;
 use pyo3::prelude::*;
+use pyo3::types::PyString;
 use pyo3::types::{PyDict, PyList};
 
 use crate::definitions::DefinitionRef;
@@ -18,24 +19,24 @@ impl BuildValidator for DefinitionsValidatorBuilder {
     const EXPECTED_TYPE: &'static str = "definitions";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
 
-        let schema_definitions: &PyList = schema.get_as_req(intern!(py, "definitions"))?;
+        let schema_definitions: Bound<'_, PyList> = schema.get_as_req(intern!(py, "definitions"))?;
 
         for schema_definition in schema_definitions {
             let reference = schema_definition
-                .extract::<&PyDict>()?
+                .extract::<Bound<'_, PyDict>>()?
                 .get_as_req::<String>(intern!(py, "ref"))?;
-            let validator = build_validator(schema_definition, config, definitions)?;
+            let validator = build_validator(&schema_definition, config, definitions)?;
             definitions.add_definition(reference, validator)?;
         }
 
-        let inner_schema: &PyAny = schema.get_as_req(intern!(py, "schema"))?;
-        build_validator(inner_schema, config, definitions)
+        let inner_schema = schema.get_as_req(intern!(py, "schema"))?;
+        build_validator(&inner_schema, config, definitions)
     }
 }
 
@@ -54,13 +55,13 @@ impl BuildValidator for DefinitionRefValidator {
     const EXPECTED_TYPE: &'static str = "definition-ref";
 
     fn build(
-        schema: &PyDict,
-        _config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
-        let schema_ref = schema.get_as_req(intern!(schema.py(), "schema_ref"))?;
+        let schema_ref: Bound<'_, PyString> = schema.get_as_req(intern!(schema.py(), "schema_ref"))?;
 
-        let definition = definitions.get_definition(schema_ref);
+        let definition = definitions.get_definition(schema_ref.to_str()?);
         Ok(Self::new(definition).into())
     }
 }
@@ -90,9 +91,9 @@ impl Validator for DefinitionRefValidator {
     fn validate_assignment<'data>(
         &self,
         py: Python<'data>,
-        obj: &'data PyAny,
-        field_name: &'data str,
-        field_value: &'data PyAny,
+        obj: &Bound<'data, PyAny>,
+        field_name: &str,
+        field_value: &Bound<'data, PyAny>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         self.definition.read(|validator| {
diff --git a/src/validators/dict.rs b/src/validators/dict.rs
index 3f8ff820b..7f5337f9e 100644
--- a/src/validators/dict.rs
+++ b/src/validators/dict.rs
@@ -30,17 +30,17 @@ impl BuildValidator for DictValidator {
     const EXPECTED_TYPE: &'static str = "dict";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
         let key_validator = match schema.get_item(intern!(py, "keys_schema"))? {
-            Some(schema) => Box::new(build_validator(schema, config, definitions)?),
+            Some(schema) => Box::new(build_validator(&schema, config, definitions)?),
             None => Box::new(AnyValidator::build(schema, config, definitions)?),
         };
         let value_validator = match schema.get_item(intern!(py, "values_schema"))? {
-            Some(d) => Box::new(build_validator(d, config, definitions)?),
+            Some(d) => Box::new(build_validator(&d, config, definitions)?),
             None => Box::new(AnyValidator::build(schema, config, definitions)?),
         };
         let name = format!(
@@ -77,14 +77,14 @@ impl Validator for DictValidator {
         let dict = input.validate_dict(strict)?;
         match dict {
             GenericMapping::PyDict(py_dict) => {
-                self.validate_generic_mapping(py, input, DictGenericIterator::new(py_dict)?, state)
+                self.validate_generic_mapping(py, input, DictGenericIterator::new(&py_dict)?, state)
             }
             GenericMapping::PyMapping(mapping) => {
                 state.floor_exactness(super::Exactness::Lax);
-                self.validate_generic_mapping(py, input, MappingGenericIterator::new(mapping)?, state)
+                self.validate_generic_mapping(py, input, MappingGenericIterator::new(&mapping)?, state)
             }
             GenericMapping::StringMapping(dict) => {
-                self.validate_generic_mapping(py, input, StringMappingGenericIterator::new(dict)?, state)
+                self.validate_generic_mapping(py, input, StringMappingGenericIterator::new(&dict)?, state)
             }
             GenericMapping::PyGetAttr(_, _) => unreachable!(),
             GenericMapping::JsonObject(json_object) => {
@@ -111,7 +111,7 @@ impl DictValidator {
         >,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
-        let output = PyDict::new(py);
+        let output = PyDict::new_bound(py);
         let mut errors: Vec<ValLineError> = Vec::new();
 
         let key_validator = self.key_validator.as_ref();
diff --git a/src/validators/float.rs b/src/validators/float.rs
index 9bb293964..a1d1f485f 100644
--- a/src/validators/float.rs
+++ b/src/validators/float.rs
@@ -16,8 +16,8 @@ pub struct FloatBuilder;
 impl BuildValidator for FloatBuilder {
     const EXPECTED_TYPE: &'static str = "float";
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
@@ -48,8 +48,8 @@ impl BuildValidator for FloatValidator {
     const EXPECTED_TYPE: &'static str = "float";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
@@ -175,8 +175,8 @@ impl Validator for ConstrainedFloatValidator {
 impl BuildValidator for ConstrainedFloatValidator {
     const EXPECTED_TYPE: &'static str = "float";
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
diff --git a/src/validators/frozenset.rs b/src/validators/frozenset.rs
index ceb60eb9d..1d3b602e0 100644
--- a/src/validators/frozenset.rs
+++ b/src/validators/frozenset.rs
@@ -41,10 +41,10 @@ impl Validator for FrozenSetValidator {
             _ => Exactness::Lax,
         };
         state.floor_exactness(exactness);
-        let f_set = PyFrozenSet::empty(py)?;
+        let f_set = PyFrozenSet::empty_bound(py)?;
         collection.validate_to_set(
             py,
-            f_set,
+            &f_set,
             input,
             self.max_length,
             "Frozenset",
diff --git a/src/validators/function.rs b/src/validators/function.rs
index 51195fbe4..3cf298af2 100644
--- a/src/validators/function.rs
+++ b/src/validators/function.rs
@@ -26,11 +26,11 @@ struct FunctionInfo {
     pub info_arg: bool,
 }
 
-fn destructure_function_schema(schema: &PyDict) -> PyResult<FunctionInfo> {
-    let func_dict: &PyDict = schema.get_as_req(intern!(schema.py(), "function"))?;
-    let function: &PyAny = func_dict.get_as_req(intern!(schema.py(), "function"))?;
-    let func_type: &str = func_dict.get_as_req(intern!(schema.py(), "type"))?;
-    let info_arg = match func_type {
+fn destructure_function_schema(schema: &Bound<'_, PyDict>) -> PyResult<FunctionInfo> {
+    let func_dict: Bound<'_, PyDict> = schema.get_as_req(intern!(schema.py(), "function"))?;
+    let function = func_dict.get_as_req(intern!(schema.py(), "function"))?;
+    let func_type: Bound<'_, PyString> = func_dict.get_as_req(intern!(schema.py(), "type"))?;
+    let info_arg = match func_type.to_str()? {
         "with-info" => true,
         "no-info" => false,
         _ => unreachable!(),
@@ -39,7 +39,7 @@ fn destructure_function_schema(schema: &PyDict) -> PyResult<FunctionInfo> {
         .get_as::<&PyString>(intern!(schema.py(), "field_name"))?
         .map(Into::into);
     Ok(FunctionInfo {
-        function: function.into(),
+        function,
         field_name,
         info_arg,
     })
@@ -50,24 +50,24 @@ macro_rules! impl_build {
         impl BuildValidator for $impl_name {
             const EXPECTED_TYPE: &'static str = $name;
             fn build(
-                schema: &PyDict,
-                config: Option<&PyDict>,
+                schema: &Bound<'_, PyDict>,
+                config: Option<&Bound<'_, PyDict>>,
                 definitions: &mut DefinitionsBuilder<CombinedValidator>,
             ) -> PyResult<CombinedValidator> {
                 let py = schema.py();
-                let validator = build_validator(schema.get_as_req(intern!(py, "schema"))?, config, definitions)?;
+                let validator = build_validator(&schema.get_as_req(intern!(py, "schema"))?, config, definitions)?;
                 let func_info = destructure_function_schema(schema)?;
                 let name = format!(
                     "{}[{}(), {}]",
                     $name,
-                    function_name(func_info.function.as_ref(py))?,
+                    function_name(func_info.function.bind(py))?,
                     validator.get_name()
                 );
                 Ok(Self {
                     validator: Box::new(validator),
                     func: func_info.function,
                     config: match config {
-                        Some(c) => c.into(),
+                        Some(c) => c.clone().into(),
                         None => py.None(),
                     },
                     name,
@@ -80,46 +80,6 @@ macro_rules! impl_build {
     };
 }
 
-macro_rules! impl_validator {
-    ($name:ident) => {
-        impl_py_gc_traverse!($name {
-            validator,
-            func,
-            config
-        });
-
-        impl Validator for $name {
-            fn validate<'data>(
-                &self,
-                py: Python<'data>,
-                input: &'data impl Input<'data>,
-                state: &mut ValidationState<'_>,
-            ) -> ValResult<PyObject> {
-                let validate = |v, s: &mut ValidationState<'_>| self.validator.validate(py, v, s);
-                self._validate(validate, py, input, state)
-            }
-            fn validate_assignment<'data>(
-                &self,
-                py: Python<'data>,
-                obj: &'data PyAny,
-                field_name: &'data str,
-                field_value: &'data PyAny,
-                state: &mut ValidationState,
-            ) -> ValResult<PyObject> {
-                let validate = move |v, s: &mut ValidationState<'_>| {
-                    self.validator
-                        .validate_assignment(py, v, field_name, field_value, s)
-                };
-                self._validate(validate, py, obj, state)
-            }
-
-            fn get_name(&self) -> &str {
-                &self.name
-            }
-        }
-    };
-}
-
 #[derive(Debug)]
 pub struct FunctionBeforeValidator {
     validator: Box<CombinedValidator>,
@@ -135,7 +95,7 @@ impl_build!(FunctionBeforeValidator, "function-before");
 impl FunctionBeforeValidator {
     fn _validate<'s, 'data>(
         &'s self,
-        call: impl FnOnce(&'data PyAny, &mut ValidationState<'_>) -> ValResult<PyObject>,
+        call: impl FnOnce(Bound<'data, PyAny>, &mut ValidationState<'_>) -> ValResult<PyObject>,
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &'s mut ValidationState<'_>,
@@ -147,11 +107,44 @@ impl FunctionBeforeValidator {
             self.func.call1(py, (input.to_object(py),))
         };
         let value = r.map_err(|e| convert_err(py, e, input))?;
-        call(value.into_ref(py), state)
+        call(value.into_bound(py), state)
     }
 }
 
-impl_validator!(FunctionBeforeValidator);
+impl_py_gc_traverse!(FunctionBeforeValidator {
+    validator,
+    func,
+    config
+});
+
+impl Validator for FunctionBeforeValidator {
+    fn validate<'data>(
+        &self,
+        py: Python<'data>,
+        input: &'data impl Input<'data>,
+        state: &mut ValidationState<'_>,
+    ) -> ValResult<PyObject> {
+        let validate = |v, s: &mut ValidationState<'_>| self.validator.validate(py, &v, s);
+        self._validate(validate, py, input, state)
+    }
+    fn validate_assignment<'data>(
+        &self,
+        py: Python<'data>,
+        obj: &Bound<'data, PyAny>,
+        field_name: &str,
+        field_value: &Bound<'data, PyAny>,
+        state: &mut ValidationState,
+    ) -> ValResult<PyObject> {
+        let validate = move |v, s: &mut ValidationState<'_>| {
+            self.validator.validate_assignment(py, &v, field_name, field_value, s)
+        };
+        self._validate(validate, py, obj, state)
+    }
+
+    fn get_name(&self) -> &str {
+        &self.name
+    }
+}
 
 #[derive(Debug)]
 pub struct FunctionAfterValidator {
@@ -184,7 +177,39 @@ impl FunctionAfterValidator {
     }
 }
 
-impl_validator!(FunctionAfterValidator);
+impl_py_gc_traverse!(FunctionAfterValidator {
+    validator,
+    func,
+    config
+});
+
+impl Validator for FunctionAfterValidator {
+    fn validate<'data>(
+        &self,
+        py: Python<'data>,
+        input: &'data impl Input<'data>,
+        state: &mut ValidationState<'_>,
+    ) -> ValResult<PyObject> {
+        let validate = |v, s: &mut ValidationState<'_>| self.validator.validate(py, v, s);
+        self._validate(validate, py, input, state)
+    }
+    fn validate_assignment<'data>(
+        &self,
+        py: Python<'data>,
+        obj: &Bound<'data, PyAny>,
+        field_name: &str,
+        field_value: &Bound<'data, PyAny>,
+        state: &mut ValidationState,
+    ) -> ValResult<PyObject> {
+        let validate =
+            move |v, s: &mut ValidationState<'_>| self.validator.validate_assignment(py, v, field_name, field_value, s);
+        self._validate(validate, py, obj, state)
+    }
+
+    fn get_name(&self) -> &str {
+        &self.name
+    }
+}
 
 #[derive(Debug, Clone)]
 pub struct FunctionPlainValidator {
@@ -199,8 +224,8 @@ impl BuildValidator for FunctionPlainValidator {
     const EXPECTED_TYPE: &'static str = "function-plain";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
@@ -208,13 +233,10 @@ impl BuildValidator for FunctionPlainValidator {
         Ok(Self {
             func: function_info.function.clone(),
             config: match config {
-                Some(c) => c.into(),
+                Some(c) => c.clone().into(),
                 None => py.None(),
             },
-            name: format!(
-                "function-plain[{}()]",
-                function_name(function_info.function.as_ref(py))?
-            ),
+            name: format!("function-plain[{}()]", function_name(function_info.function.bind(py))?),
             field_name: function_info.field_name.clone(),
             info_arg: function_info.info_arg,
         }
@@ -261,12 +283,12 @@ impl BuildValidator for FunctionWrapValidator {
     const EXPECTED_TYPE: &'static str = "function-wrap";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
-        let validator = build_validator(schema.get_as_req(intern!(py, "schema"))?, config, definitions)?;
+        let validator = build_validator(&schema.get_as_req(intern!(py, "schema"))?, config, definitions)?;
         let function_info = destructure_function_schema(schema)?;
         let hide_input_in_errors: bool = config.get_as(intern!(py, "hide_input_in_errors"))?.unwrap_or(false);
         let validation_error_cause: bool = config.get_as(intern!(py, "validation_error_cause"))?.unwrap_or(false);
@@ -274,10 +296,10 @@ impl BuildValidator for FunctionWrapValidator {
             validator: Arc::new(validator),
             func: function_info.function.clone(),
             config: match config {
-                Some(c) => c.into(),
+                Some(c) => c.clone().into(),
                 None => py.None(),
             },
-            name: format!("function-wrap[{}()]", function_name(function_info.function.as_ref(py))?),
+            name: format!("function-wrap[{}()]", function_name(function_info.function.bind(py))?),
             field_name: function_info.field_name.clone(),
             info_arg: function_info.info_arg,
             hide_input_in_errors,
@@ -290,7 +312,7 @@ impl BuildValidator for FunctionWrapValidator {
 impl FunctionWrapValidator {
     fn _validate<'s, 'data>(
         &'s self,
-        handler: &'s PyAny,
+        handler: &Bound<'_, PyAny>,
         py: Python<'data>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
@@ -328,8 +350,8 @@ impl Validator for FunctionWrapValidator {
                 self.validation_error_cause,
             ),
         };
-        let handler = Py::new(py, handler)?.into_ref(py);
-        let result = self._validate(handler, py, input.to_object(py).into_ref(py), state);
+        let handler = Bound::new(py, handler)?;
+        let result = self._validate(handler.as_any(), py, input, state);
         state.exactness = handler.borrow_mut().validator.exactness;
         result
     }
@@ -337,9 +359,9 @@ impl Validator for FunctionWrapValidator {
     fn validate_assignment<'data>(
         &self,
         py: Python<'data>,
-        obj: &'data PyAny,
-        field_name: &'data str,
-        field_value: &'data PyAny,
+        obj: &Bound<'data, PyAny>,
+        field_name: &str,
+        field_value: &Bound<'data, PyAny>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         let handler = AssignmentValidatorCallable {
@@ -354,7 +376,7 @@ impl Validator for FunctionWrapValidator {
             updated_field_name: field_name.to_string(),
             updated_field_value: field_value.to_object(py),
         };
-        self._validate(Py::new(py, handler)?.into_ref(py), py, obj, state)
+        self._validate(Bound::new(py, handler)?.as_any(), py, obj, state)
     }
 
     fn get_name(&self) -> &str {
@@ -370,7 +392,12 @@ struct ValidatorCallable {
 
 #[pymethods]
 impl ValidatorCallable {
-    fn __call__(&mut self, py: Python, input_value: &PyAny, outer_location: Option<&PyAny>) -> PyResult<PyObject> {
+    fn __call__(
+        &mut self,
+        py: Python,
+        input_value: &Bound<'_, PyAny>,
+        outer_location: Option<&Bound<'_, PyAny>>,
+    ) -> PyResult<PyObject> {
         let outer_location = outer_location.map(Into::into);
         self.validator.validate(py, input_value, outer_location)
     }
@@ -398,13 +425,18 @@ struct AssignmentValidatorCallable {
 
 #[pymethods]
 impl AssignmentValidatorCallable {
-    fn __call__(&mut self, py: Python, input_value: &PyAny, outer_location: Option<&PyAny>) -> PyResult<PyObject> {
+    fn __call__(
+        &mut self,
+        py: Python,
+        input_value: &Bound<'_, PyAny>,
+        outer_location: Option<&Bound<'_, PyAny>>,
+    ) -> PyResult<PyObject> {
         let outer_location = outer_location.map(Into::into);
         self.validator.validate_assignment(
             py,
             input_value,
             self.updated_field_name.as_str(),
-            self.updated_field_value.as_ref(py),
+            self.updated_field_value.bind(py),
             outer_location,
         )
     }
@@ -440,18 +472,18 @@ macro_rules! py_err_string {
 /// as validation errors, `TypeError` is now considered as a runtime error to catch errors in function signatures
 pub fn convert_err<'a>(py: Python<'a>, err: PyErr, input: &'a impl Input<'a>) -> ValError {
     if err.is_instance_of::<PyValueError>(py) {
-        let error_value = err.value(py);
+        let error_value = err.value_bound(py);
         if let Ok(pydantic_value_error) = error_value.extract::<PydanticCustomError>() {
             pydantic_value_error.into_val_error(input)
         } else if let Ok(pydantic_error_type) = error_value.extract::<PydanticKnownError>() {
             pydantic_error_type.into_val_error(input)
-        } else if let Ok(validation_error) = err.value(py).extract::<ValidationError>() {
+        } else if let Ok(validation_error) = err.value_bound(py).extract::<ValidationError>() {
             validation_error.into_val_error()
         } else {
             py_err_string!(py, err, error_value, ValueError, input)
         }
     } else if err.is_instance_of::<PyAssertionError>(py) {
-        py_err_string!(py, err, err.value(py), AssertionError, input)
+        py_err_string!(py, err, err.value_bound(py), AssertionError, input)
     } else if err.is_instance_of::<PydanticOmit>(py) {
         ValError::Omit
     } else if err.is_instance_of::<PydanticUseDefault>(py) {
@@ -474,9 +506,9 @@ impl ValidationInfo {
     fn new(py: Python, extra: &Extra, config: &PyObject, field_name: Option<Py<PyString>>) -> Self {
         Self {
             config: config.clone_ref(py),
-            context: extra.context.map(Into::into),
+            context: extra.context.map(|ctx| ctx.clone().into()),
             field_name,
-            data: extra.data.map(Into::into),
+            data: extra.data.as_ref().map(|data| data.clone().into()),
             mode: extra.input_type,
         }
     }
@@ -498,16 +530,16 @@ impl ValidationInfo {
 impl ValidationInfo {
     fn __repr__(&self, py: Python) -> PyResult<String> {
         let context = match self.context {
-            Some(ref context) => safe_repr(context.as_ref(py)),
+            Some(ref context) => safe_repr(context.bind(py)).to_string(),
             None => "None".into(),
         };
-        let config = self.config.as_ref(py).repr()?;
+        let config = self.config.bind(py).repr()?;
         let data = match self.data {
-            Some(ref data) => safe_repr(data.as_ref(py)),
+            Some(ref data) => safe_repr(data.bind(py)).to_string(),
             None => "None".into(),
         };
         let field_name = match self.field_name {
-            Some(ref field_name) => safe_repr(field_name.as_ref(py)),
+            Some(ref field_name) => safe_repr(field_name.bind(py)).to_string(),
             None => "None".into(),
         };
         Ok(format!(
diff --git a/src/validators/generator.rs b/src/validators/generator.rs
index a366da431..1be9fcc8a 100644
--- a/src/validators/generator.rs
+++ b/src/validators/generator.rs
@@ -5,7 +5,7 @@ use pyo3::prelude::*;
 use pyo3::types::PyDict;
 
 use crate::errors::{ErrorType, LocItem, ValError, ValResult};
-use crate::input::{GenericIterator, Input};
+use crate::input::{BorrowInput, GenericIterator, Input};
 use crate::recursion_guard::RecursionState;
 use crate::tools::SchemaDict;
 use crate::ValidationError;
@@ -29,8 +29,8 @@ impl BuildValidator for GeneratorValidator {
     const EXPECTED_TYPE: &'static str = "generator";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let item_validator = get_items_schema(schema, config, definitions)?.map(Arc::new);
@@ -145,7 +145,9 @@ impl ValidatorIterator {
                                     ));
                                 }
                             }
-                            validator.validate(py, next, Some(index.into())).map(Some)
+                            validator
+                                .validate(py, next.borrow_input(), Some(index.into()))
+                                .map(Some)
                         }
                         None => Ok(Some(next.to_object(py))),
                     },
@@ -238,7 +240,7 @@ impl InternalValidator {
         Self {
             name: name.to_string(),
             validator,
-            data: extra.data.map(|d| d.into_py(py)),
+            data: extra.data.as_ref().map(|d| d.clone().into()),
             strict: extra.strict,
             from_attributes: extra.from_attributes,
             context: extra.context.map(|d| d.into_py(py)),
@@ -254,18 +256,18 @@ impl InternalValidator {
     pub fn validate_assignment<'data>(
         &mut self,
         py: Python<'data>,
-        model: &'data PyAny,
-        field_name: &'data str,
-        field_value: &'data PyAny,
+        model: &Bound<'data, PyAny>,
+        field_name: &str,
+        field_value: &Bound<'data, PyAny>,
         outer_location: Option<LocItem>,
     ) -> PyResult<PyObject> {
         let extra = Extra {
             input_type: self.validation_mode,
-            data: self.data.as_ref().map(|data| data.as_ref(py)),
+            data: self.data.as_ref().map(|data| data.bind(py).clone()),
             strict: self.strict,
             from_attributes: self.from_attributes,
-            context: self.context.as_ref().map(|data| data.as_ref(py)),
-            self_instance: self.self_instance.as_ref().map(|data| data.as_ref(py)),
+            context: self.context.as_ref().map(|data| data.bind(py)),
+            self_instance: self.self_instance.as_ref().map(|data| data.bind(py)),
         };
         let mut state = ValidationState::new(extra, &mut self.recursion_guard);
         state.exactness = self.exactness;
@@ -295,11 +297,11 @@ impl InternalValidator {
     ) -> PyResult<PyObject> {
         let extra = Extra {
             input_type: self.validation_mode,
-            data: self.data.as_ref().map(|data| data.as_ref(py)),
+            data: self.data.as_ref().map(|data| data.bind(py).clone()),
             strict: self.strict,
             from_attributes: self.from_attributes,
-            context: self.context.as_ref().map(|data| data.as_ref(py)),
-            self_instance: self.self_instance.as_ref().map(|data| data.as_ref(py)),
+            context: self.context.as_ref().map(|data| data.bind(py)),
+            self_instance: self.self_instance.as_ref().map(|data| data.bind(py)),
         };
         let mut state = ValidationState::new(extra, &mut self.recursion_guard);
         state.exactness = self.exactness;
diff --git a/src/validators/int.rs b/src/validators/int.rs
index a72afcb0e..5bb19fefb 100644
--- a/src/validators/int.rs
+++ b/src/validators/int.rs
@@ -19,8 +19,8 @@ impl BuildValidator for IntValidator {
     const EXPECTED_TYPE: &'static str = "int";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
@@ -145,7 +145,7 @@ impl Validator for ConstrainedIntValidator {
 }
 
 impl ConstrainedIntValidator {
-    fn build(schema: &PyDict, config: Option<&PyDict>) -> PyResult<CombinedValidator> {
+    fn build(schema: &Bound<'_, PyDict>, config: Option<&Bound<'_, PyDict>>) -> PyResult<CombinedValidator> {
         let py = schema.py();
         Ok(Self {
             strict: is_strict(schema, config)?,
diff --git a/src/validators/is_instance.rs b/src/validators/is_instance.rs
index 8355710d9..9f0fc1a13 100644
--- a/src/validators/is_instance.rs
+++ b/src/validators/is_instance.rs
@@ -21,25 +21,24 @@ impl BuildValidator for IsInstanceValidator {
     const EXPECTED_TYPE: &'static str = "is-instance";
 
     fn build(
-        schema: &PyDict,
-        _config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
         let cls_key = intern!(py, "cls");
-        let class: &PyAny = schema.get_as_req(cls_key)?;
+        let class = schema.get_as_req(cls_key)?;
 
         // test that class works with isinstance to avoid errors at call time, reuse cls_key since it doesn't
         // matter what object is being checked
-        let test_value: &PyAny = cls_key.as_ref();
-        if test_value.is_instance(class).is_err() {
+        if cls_key.is_instance(&class).is_err() {
             return py_schema_err!("'cls' must be valid as the first argument to 'isinstance'");
         }
 
         let class_repr = match schema.get_as(intern!(py, "cls_repr"))? {
             Some(s) => s,
             None => match class.extract::<&PyType>() {
-                Ok(t) => t.name()?.to_string(),
+                Ok(t) => t.qualname()?.to_string(),
                 Err(_) => class.repr()?.extract()?,
             },
         };
@@ -69,8 +68,8 @@ impl Validator for IsInstanceValidator {
             )));
         }
 
-        let ob = input.to_object(py);
-        match ob.as_ref(py).is_instance(self.class.as_ref(py))? {
+        let ob: Py<PyAny> = input.to_object(py);
+        match ob.bind(py).is_instance(self.class.bind(py))? {
             true => Ok(ob),
             false => Err(ValError::new(
                 ErrorType::IsInstanceOf {
diff --git a/src/validators/is_subclass.rs b/src/validators/is_subclass.rs
index e20a5c291..d7fbd238f 100644
--- a/src/validators/is_subclass.rs
+++ b/src/validators/is_subclass.rs
@@ -19,8 +19,8 @@ impl BuildValidator for IsSubclassValidator {
     const EXPECTED_TYPE: &'static str = "is-subclass";
 
     fn build(
-        schema: &PyDict,
-        _config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
@@ -28,7 +28,7 @@ impl BuildValidator for IsSubclassValidator {
 
         let class_repr = match schema.get_as(intern!(py, "cls_repr"))? {
             Some(s) => s,
-            None => class.name()?.to_string(),
+            None => class.qualname()?.to_string(),
         };
         let name = format!("{}[{class_repr}]", Self::EXPECTED_TYPE);
         Ok(Self {
@@ -49,7 +49,7 @@ impl Validator for IsSubclassValidator {
         input: &'data impl Input<'data>,
         _state: &mut ValidationState,
     ) -> ValResult<PyObject> {
-        match input.input_is_subclass(self.class.as_ref(py))? {
+        match input.input_is_subclass(self.class.bind(py))? {
             true => Ok(input.to_object(py)),
             false => Err(ValError::new(
                 ErrorType::IsSubclassOf {
diff --git a/src/validators/json.rs b/src/validators/json.rs
index 641892364..4543a41d0 100644
--- a/src/validators/json.rs
+++ b/src/validators/json.rs
@@ -20,13 +20,13 @@ impl BuildValidator for JsonValidator {
     const EXPECTED_TYPE: &'static str = "json";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let validator = match schema.get_as(intern!(schema.py(), "schema"))? {
             Some(schema) => {
-                let validator = build_validator(schema, config, definitions)?;
+                let validator = build_validator(&schema, config, definitions)?;
                 match validator {
                     CombinedValidator::Any(_) => None,
                     _ => Some(Box::new(validator)),
@@ -66,7 +66,7 @@ impl Validator for JsonValidator {
             None => {
                 let obj =
                     jiter::python_parse(py, json_bytes, true, true).map_err(|e| map_json_err(input, e, json_bytes))?;
-                Ok(obj)
+                Ok(obj.unbind())
             }
         }
     }
diff --git a/src/validators/json_or_python.rs b/src/validators/json_or_python.rs
index 7cdb10adf..ddbc53900 100644
--- a/src/validators/json_or_python.rs
+++ b/src/validators/json_or_python.rs
@@ -20,16 +20,16 @@ impl BuildValidator for JsonOrPython {
     const EXPECTED_TYPE: &'static str = "json-or-python";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
-        let json_schema: &PyDict = schema.get_as_req(intern!(py, "json_schema"))?;
-        let python_schema: &PyDict = schema.get_as_req(intern!(py, "python_schema"))?;
+        let json_schema = schema.get_as_req(intern!(py, "json_schema"))?;
+        let python_schema = schema.get_as_req(intern!(py, "python_schema"))?;
 
-        let json = build_validator(json_schema, config, definitions)?;
-        let python = build_validator(python_schema, config, definitions)?;
+        let json = build_validator(&json_schema, config, definitions)?;
+        let python = build_validator(&python_schema, config, definitions)?;
 
         let name = format!(
             "{}[json={},python={}]",
diff --git a/src/validators/lax_or_strict.rs b/src/validators/lax_or_strict.rs
index c130cc83a..654e38ed8 100644
--- a/src/validators/lax_or_strict.rs
+++ b/src/validators/lax_or_strict.rs
@@ -23,16 +23,16 @@ impl BuildValidator for LaxOrStrictValidator {
     const EXPECTED_TYPE: &'static str = "lax-or-strict";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
         let lax_schema = schema.get_as_req(intern!(py, "lax_schema"))?;
-        let lax_validator = Box::new(build_validator(lax_schema, config, definitions)?);
+        let lax_validator = Box::new(build_validator(&lax_schema, config, definitions)?);
 
         let strict_schema = schema.get_as_req(intern!(py, "strict_schema"))?;
-        let strict_validator = Box::new(build_validator(strict_schema, config, definitions)?);
+        let strict_validator = Box::new(build_validator(&strict_schema, config, definitions)?);
 
         let name = format!(
             "{}[lax={},strict={}]",
diff --git a/src/validators/list.rs b/src/validators/list.rs
index 1a8ecb134..a0ab11c29 100644
--- a/src/validators/list.rs
+++ b/src/validators/list.rs
@@ -20,13 +20,13 @@ pub struct ListValidator {
 }
 
 pub fn get_items_schema(
-    schema: &PyDict,
-    config: Option<&PyDict>,
+    schema: &Bound<'_, PyDict>,
+    config: Option<&Bound<'_, PyDict>>,
     definitions: &mut DefinitionsBuilder<CombinedValidator>,
 ) -> PyResult<Option<CombinedValidator>> {
     match schema.get_item(pyo3::intern!(schema.py(), "items_schema"))? {
         Some(d) => {
-            let validator = build_validator(d, config, definitions)?;
+            let validator = build_validator(&d, config, definitions)?;
             match validator {
                 CombinedValidator::Any(_) => Ok(None),
                 _ => Ok(Some(validator)),
@@ -96,8 +96,8 @@ impl BuildValidator for ListValidator {
     const EXPECTED_TYPE: &'static str = "list";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
diff --git a/src/validators/literal.rs b/src/validators/literal.rs
index 9f8c25e0f..35d37ef17 100644
--- a/src/validators/literal.rs
+++ b/src/validators/literal.rs
@@ -36,14 +36,14 @@ pub struct LiteralLookup<T: Debug> {
 }
 
 impl<T: Debug> LiteralLookup<T> {
-    pub fn new<'py>(py: Python<'py>, expected: impl Iterator<Item = (&'py PyAny, T)>) -> PyResult<Self> {
+    pub fn new<'py>(py: Python<'py>, expected: impl Iterator<Item = (Bound<'py, PyAny>, T)>) -> PyResult<Self> {
         let mut expected_int = AHashMap::new();
         let mut expected_str: AHashMap<String, usize> = AHashMap::new();
         let mut expected_bool = BoolLiteral {
             true_id: None,
             false_id: None,
         };
-        let expected_py = PyDict::new(py);
+        let expected_py = PyDict::new_bound(py);
         let mut values = Vec::new();
         for (k, v) in expected {
             let id = values.len();
@@ -66,7 +66,7 @@ impl<T: Debug> LiteralLookup<T> {
                     .map_err(|_| py_schema_error_type!("error extracting str {:?}", k))?;
                 expected_str.insert(str.to_string(), id);
             } else {
-                expected_py.set_item(k, id)?;
+                expected_py.set_item(&k, id)?;
             }
         }
 
@@ -139,7 +139,7 @@ impl<T: Debug> LiteralLookup<T> {
             // We don't use ? to unpack the result of `get_item` in the next line because unhashable
             // inputs will produce a TypeError, which in this case we just want to treat equivalently
             // to a failed lookup
-            if let Ok(Some(v)) = expected_py.as_ref(py).get_item(input) {
+            if let Ok(Some(v)) = expected_py.bind(py).get_item(input) {
                 let id: usize = v.extract().unwrap();
                 return Ok(Some((input, &self.values[id])));
             }
@@ -167,21 +167,21 @@ impl BuildValidator for LiteralValidator {
     const EXPECTED_TYPE: &'static str = "literal";
 
     fn build(
-        schema: &PyDict,
-        _config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
-        let expected: &PyList = schema.get_as_req(intern!(schema.py(), "expected"))?;
+        let expected: Bound<PyList> = schema.get_as_req(intern!(schema.py(), "expected"))?;
         if expected.is_empty() {
             return py_schema_err!("`expected` should have length > 0");
         }
         let py = expected.py();
         let mut repr_args: Vec<String> = Vec::new();
-        for item in expected {
+        for item in expected.iter() {
             repr_args.push(item.repr()?.extract()?);
         }
         let (expected_repr, name) = expected_repr_name(repr_args, "literal");
-        let lookup = LiteralLookup::new(py, expected.iter().map(|v| (v, v.to_object(py))))?;
+        let lookup = LiteralLookup::new(py, expected.into_iter().map(|v| (v.clone(), v.into())))?;
         Ok(CombinedValidator::Literal(Self {
             lookup,
             expected_repr,
diff --git a/src/validators/mod.rs b/src/validators/mod.rs
index 496da5c73..d7eb496ef 100644
--- a/src/validators/mod.rs
+++ b/src/validators/mod.rs
@@ -3,9 +3,9 @@ use std::fmt::Debug;
 use enum_dispatch::enum_dispatch;
 
 use pyo3::exceptions::PyTypeError;
-use pyo3::once_cell::GILOnceCell;
 use pyo3::prelude::*;
-use pyo3::types::{PyAny, PyDict, PyTuple, PyType};
+use pyo3::sync::GILOnceCell;
+use pyo3::types::{PyAny, PyDict, PyString, PyTuple, PyType};
 use pyo3::{intern, PyTraverseError, PyVisit};
 
 use crate::build_tools::{py_schema_err, py_schema_error_type, SchemaError};
@@ -76,7 +76,7 @@ impl PySome {
 #[pymethods]
 impl PySome {
     pub fn __repr__(&self, py: Python) -> PyResult<String> {
-        Ok(format!("Some({})", self.value.as_ref(py).repr()?,))
+        Ok(format!("Some({})", self.value.bind(py).repr()?,))
     }
 
     #[new]
@@ -86,13 +86,13 @@ impl PySome {
 
     #[classmethod]
     #[pyo3(signature = (_item, /))]
-    pub fn __class_getitem__(cls: &PyType, _item: &PyAny) -> Py<PyType> {
-        cls.into_py(cls.py())
+    pub fn __class_getitem__(cls: Py<PyType>, _item: &Bound<'_, PyAny>) -> Py<PyType> {
+        cls
     }
 
     #[classattr]
-    fn __match_args__(py: Python) -> &PyTuple {
-        PyTuple::new(py, vec![intern!(py, "value")])
+    fn __match_args__(py: Python) -> Bound<'_, PyTuple> {
+        PyTuple::new_bound(py, vec![intern!(py, "value")])
     }
 }
 
@@ -114,14 +114,14 @@ pub struct SchemaValidator {
 #[pymethods]
 impl SchemaValidator {
     #[new]
-    pub fn py_new(py: Python, schema: &PyAny, config: Option<&PyDict>) -> PyResult<Self> {
+    pub fn py_new(py: Python, schema: &Bound<'_, PyAny>, config: Option<&Bound<'_, PyDict>>) -> PyResult<Self> {
         let mut definitions_builder = DefinitionsBuilder::new();
 
         let validator = build_validator(schema, config, &mut definitions_builder)?;
         let definitions = definitions_builder.finish()?;
         let py_schema = schema.into_py(py);
         let py_config = match config {
-            Some(c) if !c.is_empty() => Some(c.into_py(py)),
+            Some(c) if !c.is_empty() => Some(c.clone().into()),
             _ => None,
         };
         let config_title = match config {
@@ -145,7 +145,7 @@ impl SchemaValidator {
         })
     }
 
-    pub fn __reduce__(slf: &PyCell<Self>) -> PyResult<(PyObject, (PyObject, PyObject))> {
+    pub fn __reduce__(slf: &Bound<Self>) -> PyResult<(PyObject, (PyObject, PyObject))> {
         // Enables support for `pickle` serialization.
         let py = slf.py();
         let cls = slf.get_type().into();
@@ -157,11 +157,11 @@ impl SchemaValidator {
     pub fn validate_python(
         &self,
         py: Python,
-        input: &PyAny,
+        input: &Bound<'_, PyAny>,
         strict: Option<bool>,
         from_attributes: Option<bool>,
-        context: Option<&PyAny>,
-        self_instance: Option<&PyAny>,
+        context: Option<&Bound<'_, PyAny>>,
+        self_instance: Option<&Bound<'_, PyAny>>,
     ) -> PyResult<PyObject> {
         self._validate(
             py,
@@ -179,11 +179,11 @@ impl SchemaValidator {
     pub fn isinstance_python(
         &self,
         py: Python,
-        input: &PyAny,
+        input: &Bound<'_, PyAny>,
         strict: Option<bool>,
         from_attributes: Option<bool>,
-        context: Option<&PyAny>,
-        self_instance: Option<&PyAny>,
+        context: Option<&Bound<'_, PyAny>>,
+        self_instance: Option<&Bound<'_, PyAny>>,
     ) -> PyResult<bool> {
         match self._validate(
             py,
@@ -206,10 +206,10 @@ impl SchemaValidator {
     pub fn validate_json(
         &self,
         py: Python,
-        input: &PyAny,
+        input: &Bound<'_, PyAny>,
         strict: Option<bool>,
-        context: Option<&PyAny>,
-        self_instance: Option<&PyAny>,
+        context: Option<&Bound<'_, PyAny>>,
+        self_instance: Option<&Bound<'_, PyAny>>,
     ) -> PyResult<PyObject> {
         let r = match json::validate_json_bytes(input) {
             Ok(v_match) => self._validate_json(
@@ -229,12 +229,12 @@ impl SchemaValidator {
     pub fn validate_strings(
         &self,
         py: Python,
-        input: &PyAny,
+        input: Bound<'_, PyAny>,
         strict: Option<bool>,
-        context: Option<&PyAny>,
+        context: Option<&Bound<'_, PyAny>>,
     ) -> PyResult<PyObject> {
         let t = InputType::String;
-        let string_mapping = StringMapping::new_value(input).map_err(|e| self.prepare_validation_err(py, e, t))?;
+        let string_mapping = StringMapping::new_value(&input).map_err(|e| self.prepare_validation_err(py, e, t))?;
 
         match self._validate(py, &string_mapping, t, strict, None, context, None) {
             Ok(r) => Ok(r),
@@ -247,12 +247,12 @@ impl SchemaValidator {
     pub fn validate_assignment(
         &self,
         py: Python,
-        obj: &PyAny,
+        obj: Bound<'_, PyAny>,
         field_name: &str,
-        field_value: &PyAny,
+        field_value: Bound<'_, PyAny>,
         strict: Option<bool>,
         from_attributes: Option<bool>,
-        context: Option<&PyAny>,
+        context: Option<&Bound<'_, PyAny>>,
     ) -> PyResult<PyObject> {
         let extra = Extra {
             input_type: InputType::Python,
@@ -266,12 +266,17 @@ impl SchemaValidator {
         let guard = &mut RecursionState::default();
         let mut state = ValidationState::new(extra, guard);
         self.validator
-            .validate_assignment(py, obj, field_name, field_value, &mut state)
+            .validate_assignment(py, &obj, field_name, &field_value, &mut state)
             .map_err(|e| self.prepare_validation_err(py, e, InputType::Python))
     }
 
     #[pyo3(signature = (*, strict=None, context=None))]
-    pub fn get_default_value(&self, py: Python, strict: Option<bool>, context: Option<&PyAny>) -> PyResult<PyObject> {
+    pub fn get_default_value(
+        &self,
+        py: Python,
+        strict: Option<bool>,
+        context: Option<&Bound<'_, PyAny>>,
+    ) -> PyResult<PyObject> {
         let extra = Extra {
             input_type: InputType::Python,
             data: None,
@@ -320,8 +325,8 @@ impl SchemaValidator {
         input_type: InputType,
         strict: Option<bool>,
         from_attributes: Option<bool>,
-        context: Option<&'data PyAny>,
-        self_instance: Option<&PyAny>,
+        context: Option<&Bound<'data, PyAny>>,
+        self_instance: Option<&Bound<'_, PyAny>>,
     ) -> ValResult<PyObject>
     where
         's: 'data,
@@ -337,11 +342,11 @@ impl SchemaValidator {
     fn _validate_json(
         &self,
         py: Python,
-        input: &PyAny,
+        input: &Bound<'_, PyAny>,
         json_data: &[u8],
         strict: Option<bool>,
-        context: Option<&PyAny>,
-        self_instance: Option<&PyAny>,
+        context: Option<&Bound<'_, PyAny>>,
+        self_instance: Option<&Bound<'_, PyAny>>,
     ) -> ValResult<PyObject> {
         let json_value =
             jiter::JsonValue::parse(json_data, true).map_err(|e| json::map_json_err(input, e, json_data))?;
@@ -377,27 +382,28 @@ impl<'py> SelfValidator<'py> {
         Ok(Self { validator })
     }
 
-    pub fn validate_schema(&self, py: Python<'py>, schema: &'py PyAny, strict: Option<bool>) -> PyResult<&'py PyAny> {
+    pub fn validate_schema(&self, schema: &Bound<'py, PyAny>, strict: Option<bool>) -> PyResult<Bound<'py, PyAny>> {
+        let py = schema.py();
         let mut recursion_guard = RecursionState::default();
         let mut state = ValidationState::new(
             Extra::new(strict, None, None, None, InputType::Python),
             &mut recursion_guard,
         );
         match self.validator.validator.validate(py, schema, &mut state) {
-            Ok(schema_obj) => Ok(schema_obj.into_ref(py)),
+            Ok(schema_obj) => Ok(schema_obj.into_bound(py)),
             Err(e) => Err(SchemaError::from_val_error(py, e)),
         }
     }
 
     fn build(py: Python) -> PyResult<SchemaValidator> {
         let code = include_str!("../self_schema.py");
-        let locals = PyDict::new(py);
-        py.run(code, None, Some(locals))?;
-        let self_schema: &PyDict = locals.get_as_req(intern!(py, "self_schema"))?;
+        let locals = PyDict::new_bound(py);
+        py.run_bound(code, None, Some(&locals))?;
+        let self_schema = locals.get_as_req(intern!(py, "self_schema"))?;
 
         let mut definitions_builder = DefinitionsBuilder::new();
 
-        let validator = match build_validator(self_schema, None, &mut definitions_builder) {
+        let validator = match build_validator(&self_schema, None, &mut definitions_builder) {
             Ok(v) => v,
             Err(err) => return py_schema_err!("Error building self-schema:\n  {}", err),
         };
@@ -415,9 +421,9 @@ impl<'py> SelfValidator<'py> {
 }
 
 #[pyfunction(signature = (schema, *, strict = None))]
-pub fn validate_core_schema<'a>(py: Python<'a>, schema: &'a PyAny, strict: Option<bool>) -> PyResult<&'a PyAny> {
-    let self_validator = SelfValidator::new(py)?;
-    self_validator.validate_schema(py, schema, strict)
+pub fn validate_core_schema<'py>(schema: &Bound<'py, PyAny>, strict: Option<bool>) -> PyResult<Bound<'py, PyAny>> {
+    let self_validator = SelfValidator::new(schema.py())?;
+    self_validator.validate_schema(schema, strict)
 }
 
 pub trait BuildValidator: Sized {
@@ -426,17 +432,17 @@ pub trait BuildValidator: Sized {
     /// Build a new validator from the schema, the return type is a trait to provide a way for validators
     /// to return other validators, see `string.rs`, `int.rs`, `float.rs` and `function.rs` for examples
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator>;
 }
 
 /// Logic to create a particular validator, called in the `validator_match` macro, then in turn by `build_validator`
-fn build_specific_validator<'a, T: BuildValidator>(
+fn build_specific_validator<T: BuildValidator>(
     val_type: &str,
-    schema_dict: &'a PyDict,
-    config: Option<&'a PyDict>,
+    schema_dict: &Bound<'_, PyDict>,
+    config: Option<&Bound<'_, PyDict>>,
     definitions: &mut DefinitionsBuilder<CombinedValidator>,
 ) -> PyResult<CombinedValidator> {
     T::build(schema_dict, config, definitions)
@@ -455,13 +461,14 @@ macro_rules! validator_match {
     };
 }
 
-pub fn build_validator<'a>(
-    schema: &'a PyAny,
-    config: Option<&'a PyDict>,
+pub fn build_validator(
+    schema: &Bound<'_, PyAny>,
+    config: Option<&Bound<'_, PyDict>>,
     definitions: &mut DefinitionsBuilder<CombinedValidator>,
 ) -> PyResult<CombinedValidator> {
-    let dict: &PyDict = schema.downcast()?;
-    let type_: &str = dict.get_as_req(intern!(schema.py(), "type"))?;
+    let dict = schema.downcast::<PyDict>()?;
+    let type_: Bound<'_, PyString> = dict.get_as_req(intern!(schema.py(), "type"))?;
+    let type_ = type_.to_str()?;
     validator_match!(
         type_,
         dict,
@@ -561,23 +568,23 @@ pub struct Extra<'a> {
     /// Validation mode
     pub input_type: InputType,
     /// This is used as the `data` kwargs to validator functions
-    pub data: Option<&'a PyDict>,
+    pub data: Option<Bound<'a, PyDict>>,
     /// whether we're in strict or lax mode
     pub strict: Option<bool>,
     /// Validation time setting of `from_attributes`
     pub from_attributes: Option<bool>,
     /// context used in validator functions
-    pub context: Option<&'a PyAny>,
+    pub context: Option<&'a Bound<'a, PyAny>>,
     /// This is an instance of the model or dataclass being validated, when validation is performed from `__init__`
-    self_instance: Option<&'a PyAny>,
+    self_instance: Option<&'a Bound<'a, PyAny>>,
 }
 
 impl<'a> Extra<'a> {
     pub fn new(
         strict: Option<bool>,
         from_attributes: Option<bool>,
-        context: Option<&'a PyAny>,
-        self_instance: Option<&'a PyAny>,
+        context: Option<&'a Bound<'a, PyAny>>,
+        self_instance: Option<&'a Bound<'a, PyAny>>,
         input_type: InputType,
     ) -> Self {
         Extra {
@@ -595,7 +602,7 @@ impl<'a> Extra<'a> {
     pub fn as_strict(&self) -> Self {
         Self {
             input_type: self.input_type,
-            data: self.data,
+            data: self.data.clone(),
             strict: Some(true),
             from_attributes: self.from_attributes,
             context: self.context,
@@ -723,9 +730,9 @@ pub trait Validator: Send + Sync + Debug {
     fn validate_assignment<'data>(
         &self,
         _py: Python<'data>,
-        _obj: &'data PyAny,
-        _field_name: &'data str,
-        _field_value: &'data PyAny,
+        _obj: &Bound<'data, PyAny>,
+        _field_name: &str,
+        _field_value: &Bound<'data, PyAny>,
         _state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         let py_err = PyTypeError::new_err(format!("validate_assignment is not supported for {}", self.get_name()));
diff --git a/src/validators/model.rs b/src/validators/model.rs
index 0cc39b6a3..abe649e2c 100644
--- a/src/validators/model.rs
+++ b/src/validators/model.rs
@@ -1,10 +1,9 @@
 use std::ptr::null_mut;
 
-use pyo3::conversion::AsPyPointer;
 use pyo3::exceptions::PyTypeError;
-use pyo3::prelude::*;
+use pyo3::ffi;
 use pyo3::types::{PyDict, PySet, PyString, PyTuple, PyType};
-use pyo3::{ffi, intern};
+use pyo3::{intern, prelude::*};
 
 use super::function::convert_err;
 use super::validation_state::Exactness;
@@ -42,11 +41,11 @@ impl Revalidate {
         }
     }
 
-    pub fn should_revalidate(&self, input: &PyAny, class: &PyType) -> bool {
+    pub fn should_revalidate(&self, input: &Bound<'_, PyAny>, class: &Bound<'_, PyType>) -> bool {
         match self {
             Revalidate::Always => true,
             Revalidate::Never => false,
-            Revalidate::SubclassInstances => !input.get_type().is(class),
+            Revalidate::SubclassInstances => !input.is_exact_instance(class),
         }
     }
 }
@@ -68,36 +67,39 @@ impl BuildValidator for ModelValidator {
     const EXPECTED_TYPE: &'static str = "model";
 
     fn build(
-        schema: &PyDict,
-        _config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
         // models ignore the parent config and always use the config from this model
         let config = schema.get_as(intern!(py, "config"))?;
 
-        let class: &PyType = schema.get_as_req(intern!(py, "cls"))?;
-        let sub_schema: &PyAny = schema.get_as_req(intern!(py, "schema"))?;
-        let validator = build_validator(sub_schema, config, definitions)?;
+        let class: Bound<'_, PyType> = schema.get_as_req(intern!(py, "cls"))?;
+        let sub_schema = schema.get_as_req(intern!(py, "schema"))?;
+        let validator = build_validator(&sub_schema, config.as_ref(), definitions)?;
+        let name = class.getattr(intern!(py, "__name__"))?.extract()?;
 
         Ok(Self {
-            revalidate: Revalidate::from_str(schema_or_config_same(
-                schema,
-                config,
-                intern!(py, "revalidate_instances"),
-            )?)?,
+            revalidate: Revalidate::from_str(
+                schema_or_config_same::<Bound<'_, PyString>>(
+                    schema,
+                    config.as_ref(),
+                    intern!(py, "revalidate_instances"),
+                )?
+                .as_ref()
+                .map(|s| s.to_str())
+                .transpose()?,
+            )?,
             validator: Box::new(validator),
             class: class.into(),
-            post_init: schema
-                .get_as::<&str>(intern!(py, "post_init"))?
-                .map(|s| PyString::new(py, s).into_py(py)),
+            post_init: schema.get_as(intern!(py, "post_init"))?,
             frozen: schema.get_as(intern!(py, "frozen"))?.unwrap_or(false),
             custom_init: schema.get_as(intern!(py, "custom_init"))?.unwrap_or(false),
             root_model: schema.get_as(intern!(py, "root_model"))?.unwrap_or(false),
             undefined: PydanticUndefinedType::new(py).to_object(py),
-            // Get the class's `__name__`, not using `class.name()` since it uses `__qualname__`
-            // which is not what we want here
-            name: class.getattr(intern!(py, "__name__"))?.extract()?,
+            // Get the class's `__name__`, not using `class.qualname()`
+            name,
         }
         .into())
     }
@@ -121,26 +123,26 @@ impl Validator for ModelValidator {
         // if we're not in strict mode, instances subclasses are okay, as well as dicts, mappings, from attributes etc.
         // if the input is an instance of the class, we "revalidate" it - e.g. we extract and reuse `__pydantic_fields_set__`
         // but use from attributes to create a new instance of the model field type
-        let class = self.class.as_ref(py);
+        let class = self.class.bind(py);
         if let Some(py_input) = input.input_is_instance(class) {
             if self.revalidate.should_revalidate(py_input, class) {
                 let fields_set = py_input.getattr(intern!(py, DUNDER_FIELDS_SET_KEY))?;
                 if self.root_model {
                     let inner_input = py_input.getattr(intern!(py, ROOT_FIELD))?;
-                    self.validate_construct(py, inner_input, Some(fields_set), state)
+                    self.validate_construct(py, &inner_input, Some(&fields_set), state)
                 } else {
                     // get dict here so from_attributes logic doesn't apply
                     let dict = py_input.getattr(intern!(py, DUNDER_DICT))?;
                     let model_extra = py_input.getattr(intern!(py, DUNDER_MODEL_EXTRA_KEY))?;
 
-                    let inner_input: &PyAny = if model_extra.is_none() {
+                    let inner_input = if PyAnyMethods::is_none(&model_extra) {
                         dict
                     } else {
                         let full_model_dict = dict.downcast::<PyDict>()?.copy()?;
                         full_model_dict.update(model_extra.downcast()?)?;
-                        full_model_dict
+                        full_model_dict.into_any()
                     };
-                    self.validate_construct(py, inner_input, Some(fields_set), state)
+                    self.validate_construct(py, &inner_input, Some(&fields_set), state)
                 }
             } else {
                 Ok(input.to_object(py))
@@ -155,9 +157,9 @@ impl Validator for ModelValidator {
     fn validate_assignment<'data>(
         &self,
         py: Python<'data>,
-        model: &'data PyAny,
-        field_name: &'data str,
-        field_value: &'data PyAny,
+        model: &Bound<'data, PyAny>,
+        field_name: &str,
+        field_value: &Bound<'data, PyAny>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         if self.frozen {
@@ -179,23 +181,22 @@ impl Validator for ModelValidator {
                 Ok(model.into_py(py))
             };
         }
-        let old_dict: &PyDict = model.getattr(intern!(py, DUNDER_DICT))?.downcast()?;
+        let old_dict = model.getattr(intern!(py, DUNDER_DICT))?.downcast_into::<PyDict>()?;
 
         let input_dict = old_dict.copy()?;
-        let old_extra: Option<&PyDict> = model.getattr(intern!(py, DUNDER_MODEL_EXTRA_KEY))?.downcast().ok();
-        if let Some(old_extra) = old_extra {
+        if let Ok(old_extra) = model.getattr(intern!(py, DUNDER_MODEL_EXTRA_KEY))?.downcast::<PyDict>() {
             input_dict.update(old_extra.as_mapping())?;
         }
         input_dict.set_item(field_name, field_value)?;
 
         let output = self
             .validator
-            .validate_assignment(py, input_dict, field_name, field_value, state)?;
+            .validate_assignment(py, input_dict.as_any(), field_name, field_value, state)?;
 
         let (validated_dict, validated_extra, validated_fields_set): (&PyDict, &PyAny, &PySet) = output.extract(py)?;
 
         if let Ok(fields_set) = model.getattr(intern!(py, DUNDER_FIELDS_SET_KEY)) {
-            let fields_set: &PySet = fields_set.downcast()?;
+            let fields_set = fields_set.downcast::<PySet>()?;
             for field_name in validated_fields_set {
                 fields_set.add(field_name)?;
             }
@@ -221,7 +222,7 @@ impl ModelValidator {
     fn validate_init<'s, 'data>(
         &'s self,
         py: Python<'data>,
-        self_instance: &'s PyAny,
+        self_instance: &Bound<'s, PyAny>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
@@ -232,24 +233,24 @@ impl ModelValidator {
 
         if self.root_model {
             let fields_set = if input.to_object(py).is(&self.undefined) {
-                PySet::empty(py)?
+                PySet::empty_bound(py)?
             } else {
-                PySet::new(py, [&String::from(ROOT_FIELD)])?
+                PySet::new_bound(py, [&String::from(ROOT_FIELD)])?
             };
             force_setattr(py, self_instance, intern!(py, DUNDER_FIELDS_SET_KEY), fields_set)?;
-            force_setattr(py, self_instance, intern!(py, ROOT_FIELD), output.as_ref(py))?;
+            force_setattr(py, self_instance, intern!(py, ROOT_FIELD), &output)?;
         } else {
-            let (model_dict, model_extra, fields_set): (&PyAny, &PyAny, &PyAny) = output.extract(py)?;
-            set_model_attrs(self_instance, model_dict, model_extra, fields_set)?;
+            let (model_dict, model_extra, fields_set) = output.extract(py)?;
+            set_model_attrs(self_instance, &model_dict, &model_extra, &fields_set)?;
         }
-        self.call_post_init(py, self_instance.into_py(py), input, state.extra())
+        self.call_post_init(py, self_instance.clone(), input, state.extra())
     }
 
     fn validate_construct<'s, 'data>(
         &'s self,
         py: Python<'data>,
         input: &'data impl Input<'data>,
-        existing_fields_set: Option<&'data PyAny>,
+        existing_fields_set: Option<&Bound<'_, PyAny>>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         if self.custom_init {
@@ -261,28 +262,27 @@ impl ModelValidator {
             if let Some(kwargs) = input.as_kwargs(py) {
                 return self
                     .class
-                    .call(py, (), Some(kwargs))
+                    .call_bound(py, (), Some(&kwargs))
                     .map_err(|e| convert_err(py, e, input));
             }
         }
 
         let output = self.validator.validate(py, input, state)?;
 
-        let instance = create_class(self.class.as_ref(py))?;
-        let instance_ref = instance.as_ref(py);
+        let instance = create_class(self.class.bind(py))?;
 
         if self.root_model {
             let fields_set = if input.to_object(py).is(&self.undefined) {
-                PySet::empty(py)?
+                PySet::empty_bound(py)?
             } else {
-                PySet::new(py, [&String::from(ROOT_FIELD)])?
+                PySet::new_bound(py, [&String::from(ROOT_FIELD)])?
             };
-            force_setattr(py, instance_ref, intern!(py, DUNDER_FIELDS_SET_KEY), fields_set)?;
-            force_setattr(py, instance_ref, intern!(py, ROOT_FIELD), output)?;
+            force_setattr(py, &instance, intern!(py, DUNDER_FIELDS_SET_KEY), fields_set)?;
+            force_setattr(py, &instance, intern!(py, ROOT_FIELD), output)?;
         } else {
-            let (model_dict, model_extra, val_fields_set): (&PyAny, &PyAny, &PyAny) = output.extract(py)?;
-            let fields_set = existing_fields_set.unwrap_or(val_fields_set);
-            set_model_attrs(instance_ref, model_dict, model_extra, fields_set)?;
+            let (model_dict, model_extra, val_fields_set) = output.extract(py)?;
+            let fields_set = existing_fields_set.unwrap_or(&val_fields_set);
+            set_model_attrs(&instance, &model_dict, &model_extra, fields_set)?;
         }
         self.call_post_init(py, instance, input, state.extra())
     }
@@ -290,30 +290,30 @@ impl ModelValidator {
     fn call_post_init<'s, 'data>(
         &'s self,
         py: Python<'data>,
-        instance: PyObject,
+        instance: Bound<'_, PyAny>,
         input: &'data impl Input<'data>,
         extra: &Extra,
     ) -> ValResult<PyObject> {
         if let Some(ref post_init) = self.post_init {
             instance
-                .call_method1(py, post_init.as_ref(py), (extra.context,))
+                .call_method1(post_init.bind(py), (extra.context,))
                 .map_err(|e| convert_err(py, e, input))?;
         }
-        Ok(instance)
+        Ok(instance.into())
     }
 }
 
 /// based on the following but with the second argument of new_func set to an empty tuple as required
 /// https://github.com/PyO3/pyo3/blob/d2caa056e9aacc46374139ef491d112cb8af1a25/src/pyclass_init.rs#L35-L77
-pub(super) fn create_class(class: &PyType) -> PyResult<PyObject> {
+pub(super) fn create_class<'py>(class: &Bound<'py, PyType>) -> PyResult<Bound<'py, PyAny>> {
     let py = class.py();
-    let args = PyTuple::empty(py);
+    let args = PyTuple::empty_bound(py);
     let raw_type = class.as_type_ptr();
     unsafe {
         // Safety: raw_type is known to be a non-null type object pointer
         match (*raw_type).tp_new {
             // Safety: the result of new_func is guaranteed to be either an owned pointer or null on error returns.
-            Some(new_func) => PyObject::from_owned_ptr_or_err(
+            Some(new_func) => Bound::from_owned_ptr_or_err(
                 py,
                 // Safety: the non-null pointers are known to be valid, and it's allowed to call tp_new with a
                 // null kwargs dict.
@@ -324,7 +324,12 @@ pub(super) fn create_class(class: &PyType) -> PyResult<PyObject> {
     }
 }
 
-fn set_model_attrs(instance: &PyAny, model_dict: &PyAny, model_extra: &PyAny, fields_set: &PyAny) -> PyResult<()> {
+fn set_model_attrs(
+    instance: &Bound<'_, PyAny>,
+    model_dict: &Bound<'_, PyAny>,
+    model_extra: &Bound<'_, PyAny>,
+    fields_set: &Bound<'_, PyAny>,
+) -> PyResult<()> {
     let py = instance.py();
     force_setattr(py, instance, intern!(py, DUNDER_DICT), model_dict)?;
     force_setattr(py, instance, intern!(py, DUNDER_MODEL_EXTRA_KEY), model_extra)?;
@@ -333,7 +338,7 @@ fn set_model_attrs(instance: &PyAny, model_dict: &PyAny, model_extra: &PyAny, fi
     Ok(())
 }
 
-pub(super) fn force_setattr<N, V>(py: Python<'_>, obj: &PyAny, attr_name: N, value: V) -> PyResult<()>
+pub(super) fn force_setattr<N, V>(py: Python<'_>, obj: &Bound<'_, PyAny>, attr_name: N, value: V) -> PyResult<()>
 where
     N: ToPyObject,
     V: ToPyObject,
diff --git a/src/validators/model_fields.rs b/src/validators/model_fields.rs
index 192d1ba8f..cbdacd1d7 100644
--- a/src/validators/model_fields.rs
+++ b/src/validators/model_fields.rs
@@ -47,8 +47,8 @@ impl BuildValidator for ModelFieldsValidator {
     const EXPECTED_TYPE: &'static str = "model-fields";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
@@ -60,7 +60,7 @@ impl BuildValidator for ModelFieldsValidator {
         let extra_behavior = ExtraBehavior::from_schema_or_config(py, schema, config, ExtraBehavior::Ignore)?;
 
         let extras_validator = match (schema.get_item(intern!(py, "extras_schema"))?, &extra_behavior) {
-            (Some(v), ExtraBehavior::Allow) => Some(Box::new(build_validator(v, config, definitions)?)),
+            (Some(v), ExtraBehavior::Allow) => Some(Box::new(build_validator(&v, config, definitions)?)),
             (Some(_), _) => return py_schema_err!("extras_schema can only be used if extra_behavior=allow"),
             (_, _) => None,
         };
@@ -68,16 +68,17 @@ impl BuildValidator for ModelFieldsValidator {
             .get_as(intern!(py, "model_name"))?
             .unwrap_or_else(|| "Model".to_string());
 
-        let fields_dict: &PyDict = schema.get_as_req(intern!(py, "fields"))?;
+        let fields_dict: Bound<'_, PyDict> = schema.get_as_req(intern!(py, "fields"))?;
         let mut fields: Vec<Field> = Vec::with_capacity(fields_dict.len());
 
         for (key, value) in fields_dict {
-            let field_info: &PyDict = value.downcast()?;
-            let field_name: &str = key.extract()?;
+            let field_info = value.downcast::<PyDict>()?;
+            let field_name_py: Bound<'_, PyString> = key.extract()?;
+            let field_name = field_name_py.to_str()?;
 
             let schema = field_info.get_as_req(intern!(py, "schema"))?;
 
-            let validator = match build_validator(schema, config, definitions) {
+            let validator = match build_validator(&schema, config, definitions) {
                 Ok(v) => v,
                 Err(err) => return py_schema_err!("Field \"{}\":\n  {}", field_name, err),
             };
@@ -85,7 +86,7 @@ impl BuildValidator for ModelFieldsValidator {
             let lookup_key = match field_info.get_item(intern!(py, "validation_alias"))? {
                 Some(alias) => {
                     let alt_alias = if populate_by_name { Some(field_name) } else { None };
-                    LookupKey::from_py(py, alias, alt_alias)?
+                    LookupKey::from_py(py, &alias, alt_alias)?
                 }
                 None => LookupKey::from_string(py, field_name),
             };
@@ -93,7 +94,7 @@ impl BuildValidator for ModelFieldsValidator {
             fields.push(Field {
                 name: field_name.to_string(),
                 lookup_key,
-                name_py: PyString::new(py, field_name).into(),
+                name_py: field_name_py.into(),
                 validator,
                 frozen: field_info.get_as::<bool>(intern!(py, "frozen"))?.unwrap_or(false),
             });
@@ -150,8 +151,8 @@ impl Validator for ModelFieldsValidator {
             Err(err) => return Err(err),
         };
 
-        let model_dict = PyDict::new(py);
-        let mut model_extra_dict_op: Option<&PyDict> = None;
+        let model_dict = PyDict::new_bound(py);
+        let mut model_extra_dict_op: Option<Bound<PyDict>> = None;
         let mut errors: Vec<ValLineError> = Vec::with_capacity(self.fields.len());
         let mut fields_set_vec: Vec<Py<PyString>> = Vec::with_capacity(self.fields.len());
 
@@ -173,9 +174,9 @@ impl Validator for ModelFieldsValidator {
         }
 
         macro_rules! process {
-            ($dict:ident, $get_method:ident, $iter:ty $(,$kwargs:ident)?) => {{
+            ($dict:expr, $get_method:ident, $iter:ty $(,$kwargs:expr)?) => {{
                 match state.with_new_extra(Extra {
-                    data: Some(model_dict),
+                    data: Some(model_dict.clone()),
                     ..*state.extra()
                 }, |state| {
                     for field in &self.fields {
@@ -248,7 +249,7 @@ impl Validator for ModelFieldsValidator {
                 }
 
                 if let Some(ref mut used_keys) = used_keys {
-                    let model_extra_dict = PyDict::new(py);
+                    let model_extra_dict = PyDict::new_bound(py);
                     for item_result in <$iter>::new($dict)? {
                         let (raw_key, value) = item_result?;
                         let either_str = match raw_key.validate_str(true, false).map(ValidationMatch::into_inner) {
@@ -278,7 +279,7 @@ impl Validator for ModelFieldsValidator {
                                     ValLineError::new_with_loc(
                                         ErrorTypeDefaults::ExtraForbidden,
                                         value,
-                                        raw_key,
+                                        raw_key.clone(),
                                     )
 
                                 );
@@ -289,8 +290,8 @@ impl Validator for ModelFieldsValidator {
                                 if let Some(ref validator) = self.extras_validator {
                                     match validator.validate(py, value, state) {
                                         Ok(value) => {
-                                            model_extra_dict.set_item(py_key, value)?;
-                                            fields_set_vec.push(py_key.into_py(py));
+                                            model_extra_dict.set_item(&py_key, value)?;
+                                            fields_set_vec.push(py_key.into());
                                         }
                                         Err(ValError::LineErrors(line_errors)) => {
                                             for err in line_errors {
@@ -300,8 +301,8 @@ impl Validator for ModelFieldsValidator {
                                         Err(err) => return Err(err),
                                     }
                                 } else {
-                                    model_extra_dict.set_item(py_key, value.to_object(py))?;
-                                    fields_set_vec.push(py_key.into_py(py));
+                                    model_extra_dict.set_item(&py_key, value.to_object(py))?;
+                                    fields_set_vec.push(py_key.into());
                                 };
                             }
                         }
@@ -313,22 +314,26 @@ impl Validator for ModelFieldsValidator {
             }};
         }
         match dict {
-            GenericMapping::PyDict(d) => process!(d, py_get_dict_item, DictGenericIterator),
-            GenericMapping::PyMapping(d) => process!(d, py_get_mapping_item, MappingGenericIterator),
-            GenericMapping::StringMapping(d) => process!(d, py_get_string_mapping_item, StringMappingGenericIterator),
-            GenericMapping::PyGetAttr(d, kwargs) => process!(d, py_get_attr, AttributesGenericIterator, kwargs),
+            GenericMapping::PyDict(d) => {
+                process!(&d, py_get_dict_item, DictGenericIterator);
+            }
+            GenericMapping::PyMapping(d) => process!(&d, py_get_mapping_item, MappingGenericIterator),
+            GenericMapping::StringMapping(d) => process!(&d, py_get_string_mapping_item, StringMappingGenericIterator),
+            GenericMapping::PyGetAttr(d, kwargs) => {
+                process!(&d, py_get_attr, AttributesGenericIterator, kwargs.as_ref());
+            }
             GenericMapping::JsonObject(d) => process!(d, json_get, JsonObjectGenericIterator),
         }
 
         if !errors.is_empty() {
             Err(ValError::LineErrors(errors))
         } else {
-            let fields_set = PySet::new(py, &fields_set_vec)?;
+            let fields_set = PySet::new_bound(py, &fields_set_vec)?;
 
             // if we have extra=allow, but we didn't create a dict because we were validating
             // from attributes, set it now so __pydantic_extra__ is always a dict if extra=allow
             if matches!(self.extra_behavior, ExtraBehavior::Allow) && model_extra_dict_op.is_none() {
-                model_extra_dict_op = Some(PyDict::new(py));
+                model_extra_dict_op = Some(PyDict::new_bound(py));
             };
 
             Ok((model_dict, model_extra_dict_op, fields_set).to_object(py))
@@ -338,12 +343,12 @@ impl Validator for ModelFieldsValidator {
     fn validate_assignment<'data>(
         &self,
         py: Python<'data>,
-        obj: &'data PyAny,
-        field_name: &'data str,
-        field_value: &'data PyAny,
+        obj: &Bound<'data, PyAny>,
+        field_name: &str,
+        field_value: &Bound<'data, PyAny>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
-        let dict: &PyDict = obj.downcast()?;
+        let dict = obj.downcast::<PyDict>()?;
 
         let get_updated_dict = |output: PyObject| {
             dict.set_item(field_name, output)?;
@@ -366,7 +371,7 @@ impl Validator for ModelFieldsValidator {
         let data_dict = dict.copy()?;
         if let Err(err) = data_dict.del_item(field_name) {
             // KeyError is fine here as the field might not be in the dict
-            if !err.get_type(py).is(PyType::new::<PyKeyError>(py)) {
+            if !err.get_type_bound(py).is(&PyType::new_bound::<PyKeyError>(py)) {
                 return Err(err.into());
             }
         }
@@ -416,9 +421,9 @@ impl Validator for ModelFieldsValidator {
 
         let new_extra = match &self.extra_behavior {
             ExtraBehavior::Allow => {
-                let non_extra_data = PyDict::new(py);
+                let non_extra_data = PyDict::new_bound(py);
                 self.fields.iter().for_each(|f| {
-                    let popped_value = PyAny::get_item(new_data, &f.name).unwrap();
+                    let popped_value = PyAnyMethods::get_item(&**new_data, &f.name).unwrap();
                     new_data.del_item(&f.name).unwrap();
                     non_extra_data.set_item(&f.name, popped_value).unwrap();
                 });
@@ -430,7 +435,7 @@ impl Validator for ModelFieldsValidator {
             _ => py.None(),
         };
 
-        let fields_set: &PySet = PySet::new(py, &[field_name.to_string()])?;
+        let fields_set = PySet::new_bound(py, &[field_name.to_string()])?;
         Ok((new_data.to_object(py), new_extra, fields_set.to_object(py)).to_object(py))
     }
 
diff --git a/src/validators/none.rs b/src/validators/none.rs
index c014c1218..36f19c2bd 100644
--- a/src/validators/none.rs
+++ b/src/validators/none.rs
@@ -13,8 +13,8 @@ impl BuildValidator for NoneValidator {
     const EXPECTED_TYPE: &'static str = "none";
 
     fn build(
-        _schema: &PyDict,
-        _config: Option<&PyDict>,
+        _schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         Ok(Self.into())
diff --git a/src/validators/nullable.rs b/src/validators/nullable.rs
index 7e5c68d03..872eb3d7f 100644
--- a/src/validators/nullable.rs
+++ b/src/validators/nullable.rs
@@ -19,12 +19,12 @@ impl BuildValidator for NullableValidator {
     const EXPECTED_TYPE: &'static str = "nullable";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
-        let schema: &PyAny = schema.get_as_req(intern!(schema.py(), "schema"))?;
-        let validator = Box::new(build_validator(schema, config, definitions)?);
+        let schema = schema.get_as_req(intern!(schema.py(), "schema"))?;
+        let validator = Box::new(build_validator(&schema, config, definitions)?);
         let name = format!("{}[{}]", Self::EXPECTED_TYPE, validator.get_name());
         Ok(Self { validator, name }.into())
     }
diff --git a/src/validators/set.rs b/src/validators/set.rs
index 38f21a026..4854f6ba8 100644
--- a/src/validators/set.rs
+++ b/src/validators/set.rs
@@ -21,13 +21,13 @@ pub struct SetValidator {
 macro_rules! set_build {
     () => {
         fn build(
-            schema: &PyDict,
-            config: Option<&PyDict>,
+            schema: &Bound<'_, PyDict>,
+            config: Option<&Bound<'_, PyDict>>,
             definitions: &mut DefinitionsBuilder<CombinedValidator>,
         ) -> PyResult<CombinedValidator> {
             let py = schema.py();
             let item_validator = match schema.get_item(pyo3::intern!(schema.py(), "items_schema"))? {
-                Some(d) => Box::new(crate::validators::build_validator(d, config, definitions)?),
+                Some(d) => Box::new(crate::validators::build_validator(&d, config, definitions)?),
                 None => Box::new(crate::validators::any::AnyValidator::build(
                     schema,
                     config,
@@ -71,8 +71,8 @@ impl Validator for SetValidator {
             _ => Exactness::Lax,
         };
         state.floor_exactness(exactness);
-        let set = PySet::empty(py)?;
-        collection.validate_to_set(py, set, input, self.max_length, "Set", &self.item_validator, state)?;
+        let set = PySet::empty_bound(py)?;
+        collection.validate_to_set(py, &set, input, self.max_length, "Set", &self.item_validator, state)?;
         min_length_check!(input, "Set", self.min_length, set);
         Ok(set.into_py(py))
     }
diff --git a/src/validators/string.rs b/src/validators/string.rs
index a8d66a42e..0dffec9c2 100644
--- a/src/validators/string.rs
+++ b/src/validators/string.rs
@@ -20,8 +20,8 @@ impl BuildValidator for StrValidator {
     const EXPECTED_TYPE: &'static str = "str";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let con_str_validator = StrConstrainedValidator::build(schema, config)?;
@@ -129,11 +129,11 @@ impl Validator for StrConstrainedValidator {
         }
 
         let py_string = if self.to_lower {
-            PyString::new(py, &str.to_lowercase())
+            PyString::new_bound(py, &str.to_lowercase())
         } else if self.to_upper {
-            PyString::new(py, &str.to_uppercase())
+            PyString::new_bound(py, &str.to_uppercase())
         } else if self.strip_whitespace {
-            PyString::new(py, str)
+            PyString::new_bound(py, str)
         } else {
             // we haven't modified the string, return the original as it might be a PyString
             either_str.as_py_string(py)
@@ -147,15 +147,23 @@ impl Validator for StrConstrainedValidator {
 }
 
 impl StrConstrainedValidator {
-    fn build(schema: &PyDict, config: Option<&PyDict>) -> PyResult<Self> {
+    fn build(schema: &Bound<'_, PyDict>, config: Option<&Bound<'_, PyDict>>) -> PyResult<Self> {
         let py = schema.py();
 
         let pattern = schema
             .get_as(intern!(py, "pattern"))?
             .map(|s| {
-                let regex_engine =
-                    schema_or_config(schema, config, intern!(py, "regex_engine"), intern!(py, "regex_engine"))?
-                        .unwrap_or(RegexEngine::RUST_REGEX);
+                let regex_engine = schema_or_config::<Bound<'_, PyString>>(
+                    schema,
+                    config,
+                    intern!(py, "regex_engine"),
+                    intern!(py, "regex_engine"),
+                )?;
+                let regex_engine = regex_engine
+                    .as_ref()
+                    .map(|s| s.to_str())
+                    .transpose()?
+                    .unwrap_or(RegexEngine::RUST_REGEX);
                 Pattern::compile(py, s, regex_engine)
             })
             .transpose()?;
@@ -177,7 +185,9 @@ impl StrConstrainedValidator {
             schema_or_config(schema, config, intern!(py, "to_upper"), intern!(py, "str_to_upper"))?.unwrap_or(false);
 
         let coerce_numbers_to_str = match config {
-            Some(c) => c.get_item("coerce_numbers_to_str")?.map_or(Ok(false), PyAny::is_true)?,
+            Some(c) => c
+                .get_item("coerce_numbers_to_str")?
+                .map_or(Ok(false), |any| any.is_truthy())?,
             None => false,
         };
 
@@ -229,7 +239,7 @@ impl Pattern {
                 RegexEngine::RustRegex(Regex::new(&pattern).map_err(|e| py_schema_error_type!("{}", e))?)
             }
             RegexEngine::PYTHON_RE => {
-                let re_compile = py.import(intern!(py, "re"))?.getattr(intern!(py, "compile"))?;
+                let re_compile = py.import_bound(intern!(py, "re"))?.getattr(intern!(py, "compile"))?;
                 RegexEngine::PythonRe(re_compile.call1((&pattern,))?.into())
             }
             _ => return Err(py_schema_error_type!("Invalid regex engine: {}", engine)),
diff --git a/src/validators/time.rs b/src/validators/time.rs
index 687e01eaf..9aa68955d 100644
--- a/src/validators/time.rs
+++ b/src/validators/time.rs
@@ -1,6 +1,6 @@
 use pyo3::intern;
 use pyo3::prelude::*;
-use pyo3::types::{PyDict, PyString, PyTime};
+use pyo3::types::{PyDict, PyString};
 
 use speedate::Time;
 
@@ -24,8 +24,8 @@ impl BuildValidator for TimeValidator {
     const EXPECTED_TYPE: &'static str = "time";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let s = Self {
@@ -85,8 +85,8 @@ impl Validator for TimeValidator {
     }
 }
 
-fn convert_pytime(schema: &PyDict, field: &PyString) -> PyResult<Option<Time>> {
-    match schema.get_as::<&PyTime>(field)? {
+fn convert_pytime(schema: &Bound<'_, PyDict>, field: &Bound<'_, PyString>) -> PyResult<Option<Time>> {
+    match schema.get_as(field)? {
         Some(date) => Ok(Some(EitherTime::Py(date).as_raw()?)),
         None => Ok(None),
     }
@@ -102,7 +102,7 @@ struct TimeConstraints {
 }
 
 impl TimeConstraints {
-    fn from_py(schema: &PyDict) -> PyResult<Option<Self>> {
+    fn from_py(schema: &Bound<'_, PyDict>) -> PyResult<Option<Self>> {
         let py = schema.py();
         let c = Self {
             le: convert_pytime(schema, intern!(py, "le"))?,
diff --git a/src/validators/timedelta.rs b/src/validators/timedelta.rs
index 326a279e8..f516818ef 100644
--- a/src/validators/timedelta.rs
+++ b/src/validators/timedelta.rs
@@ -24,10 +24,10 @@ struct TimedeltaConstraints {
     gt: Option<Duration>,
 }
 
-fn get_constraint(schema: &PyDict, key: &str) -> PyResult<Option<Duration>> {
+fn get_constraint(schema: &Bound<'_, PyDict>, key: &str) -> PyResult<Option<Duration>> {
     match schema.get_item(key)? {
         Some(value) => {
-            let either_timedelta = EitherTimedelta::try_from(value)?;
+            let either_timedelta = EitherTimedelta::try_from(&value)?;
             Ok(Some(either_timedelta.to_duration()?))
         }
         None => Ok(None),
@@ -38,8 +38,8 @@ impl BuildValidator for TimeDeltaValidator {
     const EXPECTED_TYPE: &'static str = "timedelta";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let constraints = TimedeltaConstraints {
@@ -88,7 +88,7 @@ impl Validator for TimeDeltaValidator {
                                     $constraint: pydelta_to_human_readable(duration_as_pytimedelta(py, constraint)?)
                                         .into(),
                                 },
-                                py_timedelta.as_ref(),
+                                py_timedelta.as_any(),
                             ));
                         }
                     }
@@ -107,7 +107,7 @@ impl Validator for TimeDeltaValidator {
         Self::EXPECTED_TYPE
     }
 }
-fn pydelta_to_human_readable(py_delta: &PyDelta) -> String {
+fn pydelta_to_human_readable(py_delta: Bound<'_, PyDelta>) -> String {
     let total_seconds = py_delta.get_seconds();
     let hours = total_seconds / 3600;
     let minutes = (total_seconds % 3600) / 60;
diff --git a/src/validators/tuple.rs b/src/validators/tuple.rs
index 6cad26073..d9311e4fe 100644
--- a/src/validators/tuple.rs
+++ b/src/validators/tuple.rs
@@ -5,6 +5,7 @@ use std::collections::VecDeque;
 
 use crate::build_tools::is_strict;
 use crate::errors::{py_err_string, ErrorType, ErrorTypeDefaults, ValError, ValLineError, ValResult};
+use crate::input::BorrowInput;
 use crate::input::{GenericIterable, Input};
 use crate::tools::SchemaDict;
 use crate::validators::Exactness;
@@ -24,15 +25,15 @@ pub struct TupleValidator {
 impl BuildValidator for TupleValidator {
     const EXPECTED_TYPE: &'static str = "tuple";
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
-        let items: &PyList = schema.get_as_req(intern!(py, "items_schema"))?;
+        let items: Bound<'_, PyList> = schema.get_as_req(intern!(py, "items_schema"))?;
         let validators: Vec<CombinedValidator> = items
             .iter()
-            .map(|item| build_validator(item, config, definitions))
+            .map(|item| build_validator(&item, config, definitions))
             .collect::<PyResult<_>>()?;
 
         let mut validator_names = validators.iter().map(Validator::get_name).collect::<Vec<_>>();
@@ -59,7 +60,7 @@ impl_py_gc_traverse!(TupleValidator { validators });
 
 impl TupleValidator {
     #[allow(clippy::too_many_arguments)]
-    fn validate_tuple_items<'s, 'data, I: Input<'data> + 'data>(
+    fn validate_tuple_items<'s, 'data, I: BorrowInput + 'data>(
         &self,
         py: Python<'data>,
         input: &'data impl Input<'data>,
@@ -67,13 +68,13 @@ impl TupleValidator {
         output: &mut Vec<PyObject>,
         errors: &mut Vec<ValLineError>,
         item_validators: &[CombinedValidator],
-        collection_iter: &mut NextCountingIterator<impl Iterator<Item = &'data I>>,
+        collection_iter: &mut NextCountingIterator<impl Iterator<Item = I>>,
         actual_length: Option<usize>,
     ) -> ValResult<()> {
         // Validate the head:
         for validator in item_validators {
             match collection_iter.next() {
-                Some((index, input_item)) => match validator.validate(py, input_item, state) {
+                Some((index, input_item)) => match validator.validate(py, input_item.borrow_input(), state) {
                     Ok(item) => self.push_output_item(input, output, item, actual_length)?,
                     Err(ValError::LineErrors(line_errors)) => {
                         errors.extend(line_errors.into_iter().map(|err| err.with_outer_location(index)));
@@ -96,13 +97,13 @@ impl TupleValidator {
     }
 
     #[allow(clippy::too_many_arguments)]
-    fn validate_tuple_variable<'data, I: Input<'data> + 'data, InputT: Input<'data> + 'data>(
+    fn validate_tuple_variable<'data, I: BorrowInput + 'data, InputT: Input<'data> + 'data>(
         &self,
         py: Python<'data>,
         input: &'data InputT,
         state: &mut ValidationState,
         errors: &mut Vec<ValLineError>,
-        collection_iter: &mut NextCountingIterator<impl Iterator<Item = &'data I>>,
+        collection_iter: &mut NextCountingIterator<impl Iterator<Item = I>>,
         actual_length: Option<usize>,
     ) -> ValResult<Vec<PyObject>> {
         let expected_length = if self.variadic_item_index.is_some() {
@@ -133,7 +134,7 @@ impl TupleValidator {
             let n_tail_validators = tail_validators.len();
             if n_tail_validators == 0 {
                 for (index, input_item) in collection_iter {
-                    match variable_validator.validate(py, input_item, state) {
+                    match variable_validator.validate(py, input_item.borrow_input(), state) {
                         Ok(item) => self.push_output_item(input, &mut output, item, actual_length)?,
                         Err(ValError::LineErrors(line_errors)) => {
                             errors.extend(line_errors.into_iter().map(|err| err.with_outer_location(index)));
@@ -147,8 +148,7 @@ impl TupleValidator {
                 // NB: We take from collection_iter.inner to avoid increasing the next calls count
                 // while populating the buffer. This means the index in the following loop is the
                 // right one for user errors.
-                let mut tail_buffer: VecDeque<&'data I> =
-                    collection_iter.inner.by_ref().take(n_tail_validators).collect();
+                let mut tail_buffer: VecDeque<I> = collection_iter.inner.by_ref().take(n_tail_validators).collect();
 
                 // Save the current index for the tail validation below when we recreate a new NextCountingIterator
                 let mut index = collection_iter.next_calls();
@@ -161,7 +161,7 @@ impl TupleValidator {
                     let buffered_item = tail_buffer.pop_front().unwrap();
                     tail_buffer.push_back(input_item);
 
-                    match variable_validator.validate(py, buffered_item, state) {
+                    match variable_validator.validate(py, buffered_item.borrow_input(), state) {
                         Ok(item) => self.push_output_item(input, &mut output, item, actual_length)?,
                         Err(ValError::LineErrors(line_errors)) => {
                             errors.extend(
@@ -326,7 +326,7 @@ impl Validator for TupleValidator {
         }
 
         if errors.is_empty() {
-            Ok(PyTuple::new(py, &output).into_py(py))
+            Ok(PyTuple::new_bound(py, output).into_py(py))
         } else {
             Err(ValError::LineErrors(errors))
         }
diff --git a/src/validators/typed_dict.rs b/src/validators/typed_dict.rs
index ec0cc07cf..7299cfff9 100644
--- a/src/validators/typed_dict.rs
+++ b/src/validators/typed_dict.rs
@@ -44,14 +44,15 @@ impl BuildValidator for TypedDictValidator {
     const EXPECTED_TYPE: &'static str = "typed-dict";
 
     fn build(
-        schema: &PyDict,
-        _config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
 
         // typed dicts ignore the parent config and always use the config from this TypedDict
         let config = schema.get_as(intern!(py, "config"))?;
+        let config = config.as_ref();
 
         let strict = is_strict(schema, config)?;
 
@@ -62,21 +63,22 @@ impl BuildValidator for TypedDictValidator {
         let extra_behavior = ExtraBehavior::from_schema_or_config(py, schema, config, ExtraBehavior::Ignore)?;
 
         let extras_validator = match (schema.get_item(intern!(py, "extras_schema"))?, &extra_behavior) {
-            (Some(v), ExtraBehavior::Allow) => Some(Box::new(build_validator(v, config, definitions)?)),
+            (Some(v), ExtraBehavior::Allow) => Some(Box::new(build_validator(&v, config, definitions)?)),
             (Some(_), _) => return py_schema_err!("extras_schema can only be used if extra_behavior=allow"),
             (_, _) => None,
         };
 
-        let fields_dict: &PyDict = schema.get_as_req(intern!(py, "fields"))?;
+        let fields_dict: Bound<'_, PyDict> = schema.get_as_req(intern!(py, "fields"))?;
         let mut fields: Vec<TypedDictField> = Vec::with_capacity(fields_dict.len());
 
         for (key, value) in fields_dict {
-            let field_info: &PyDict = value.downcast()?;
-            let field_name: &str = key.extract()?;
+            let field_info = value.downcast::<PyDict>()?;
+            let field_name_py = key.downcast_into::<PyString>()?;
+            let field_name = field_name_py.to_str()?;
 
             let schema = field_info.get_as_req(intern!(py, "schema"))?;
 
-            let validator = match build_validator(schema, config, definitions) {
+            let validator = match build_validator(&schema, config, definitions) {
                 Ok(v) => v,
                 Err(err) => return py_schema_err!("Field \"{}\":\n  {}", field_name, err),
             };
@@ -112,7 +114,7 @@ impl BuildValidator for TypedDictValidator {
             let lookup_key = match field_info.get_item(intern!(py, "validation_alias"))? {
                 Some(alias) => {
                     let alt_alias = if populate_by_name { Some(field_name) } else { None };
-                    LookupKey::from_py(py, alias, alt_alias)?
+                    LookupKey::from_py(py, &alias, alt_alias)?
                 }
                 None => LookupKey::from_string(py, field_name),
             };
@@ -120,7 +122,7 @@ impl BuildValidator for TypedDictValidator {
             fields.push(TypedDictField {
                 name: field_name.to_string(),
                 lookup_key,
-                name_py: PyString::new(py, field_name).into(),
+                name_py: field_name_py.into(),
                 validator,
                 required,
             });
@@ -152,7 +154,7 @@ impl Validator for TypedDictValidator {
         let strict = state.strict_or(self.strict);
         let dict = input.validate_dict(strict)?;
 
-        let output_dict = PyDict::new(py);
+        let output_dict = PyDict::new_bound(py);
         let mut errors: Vec<ValLineError> = Vec::with_capacity(self.fields.len());
 
         // we only care about which keys have been used if we're iterating over the object for extra after
@@ -173,9 +175,9 @@ impl Validator for TypedDictValidator {
         }
 
         macro_rules! process {
-            ($dict:ident, $get_method:ident, $iter:ty $(,$kwargs:ident)?) => {{
+            ($dict:expr, $get_method:ident, $iter:ty $(,$kwargs:expr)?) => {{
                 match state.with_new_extra(Extra {
-                    data: Some(output_dict),
+                    data: Some(output_dict.clone()),
                     ..*state.extra()
                 }, |state| {
                     for field in &self.fields {
@@ -278,7 +280,7 @@ impl Validator for TypedDictValidator {
                                     ValLineError::new_with_loc(
                                         ErrorTypeDefaults::ExtraForbidden,
                                         value,
-                                        raw_key,
+                                        raw_key.clone(),
                                     )
 
                                 );
@@ -310,10 +312,14 @@ impl Validator for TypedDictValidator {
             }};
         }
         match dict {
-            GenericMapping::PyDict(d) => process!(d, py_get_dict_item, DictGenericIterator),
-            GenericMapping::PyMapping(d) => process!(d, py_get_mapping_item, MappingGenericIterator),
-            GenericMapping::StringMapping(d) => process!(d, py_get_string_mapping_item, StringMappingGenericIterator),
-            GenericMapping::PyGetAttr(d, kwargs) => process!(d, py_get_attr, AttributesGenericIterator, kwargs),
+            GenericMapping::PyDict(d) => {
+                process!(&d, py_get_dict_item, DictGenericIterator);
+            }
+            GenericMapping::PyMapping(d) => process!(&d, py_get_mapping_item, MappingGenericIterator),
+            GenericMapping::StringMapping(d) => process!(&d, py_get_string_mapping_item, StringMappingGenericIterator),
+            GenericMapping::PyGetAttr(d, kwargs) => {
+                process!(&d, py_get_attr, AttributesGenericIterator, kwargs.as_ref());
+            }
             GenericMapping::JsonObject(d) => process!(d, json_get, JsonObjectGenericIterator),
         }
 
diff --git a/src/validators/union.rs b/src/validators/union.rs
index 0a5bd0c65..8b64ecbf6 100644
--- a/src/validators/union.rs
+++ b/src/validators/union.rs
@@ -51,17 +51,17 @@ impl BuildValidator for UnionValidator {
     const EXPECTED_TYPE: &'static str = "union";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
         let choices: Vec<(CombinedValidator, Option<String>)> = schema
-            .get_as_req::<&PyList>(intern!(py, "choices"))?
+            .get_as_req::<Bound<'_, PyList>>(intern!(py, "choices"))?
             .iter()
             .map(|choice| {
                 let mut label: Option<String> = None;
-                let choice: &PyAny = match choice.downcast::<PyTuple>() {
+                let choice = match choice.downcast::<PyTuple>() {
                     Ok(py_tuple) => {
                         let choice = py_tuple.get_item(0)?;
                         label = Some(py_tuple.get_item(1)?.to_string());
@@ -69,14 +69,14 @@ impl BuildValidator for UnionValidator {
                     }
                     Err(_) => choice,
                 };
-                Ok((build_validator(choice, config, definitions)?, label))
+                Ok((build_validator(&choice, config, definitions)?, label))
             })
             .collect::<PyResult<Vec<(CombinedValidator, Option<String>)>>>()?;
 
         let auto_collapse = || schema.get_as_req(intern!(py, "auto_collapse")).unwrap_or(true);
         let mode = schema
-            .get_as::<&str>(intern!(py, "mode"))?
-            .map_or(Ok(UnionMode::Smart), UnionMode::from_str)?;
+            .get_as::<Bound<'_, PyString>>(intern!(py, "mode"))?
+            .map_or(Ok(UnionMode::Smart), |mode| mode.to_str().and_then(UnionMode::from_str))?;
         match choices.len() {
             0 => py_schema_err!("One or more union choices required"),
             1 if auto_collapse() => Ok(choices.into_iter().next().unwrap().0),
@@ -284,7 +284,7 @@ enum Discriminator {
 }
 
 impl Discriminator {
-    fn new(py: Python, raw: &PyAny) -> PyResult<Self> {
+    fn new(py: Python, raw: &Bound<'_, PyAny>) -> PyResult<Self> {
         if raw.is_callable() {
             return Ok(Self::Function(raw.to_object(py)));
         } else if let Ok(py_str) = raw.downcast::<PyString>() {
@@ -332,24 +332,24 @@ impl BuildValidator for TaggedUnionValidator {
     const EXPECTED_TYPE: &'static str = "tagged-union";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
-        let discriminator = Discriminator::new(py, schema.get_as_req(intern!(py, "discriminator"))?)?;
+        let discriminator = Discriminator::new(py, &schema.get_as_req(intern!(py, "discriminator"))?)?;
         let discriminator_repr = discriminator.to_string_py(py)?;
 
-        let choices = PyDict::new(py);
+        let choices = PyDict::new_bound(py);
         let mut tags_repr = String::with_capacity(50);
         let mut descr = String::with_capacity(50);
         let mut first = true;
         let mut discriminators = Vec::with_capacity(choices.len());
-        let schema_choices: &PyDict = schema.get_as_req(intern!(py, "choices"))?;
+        let schema_choices: Bound<PyDict> = schema.get_as_req(intern!(py, "choices"))?;
         let mut lookup_map = Vec::with_capacity(choices.len());
         for (choice_key, choice_schema) in schema_choices {
-            discriminators.push(choice_key);
-            let validator = build_validator(choice_schema, config, definitions)?;
+            discriminators.push(choice_key.clone());
+            let validator = build_validator(&choice_schema, config, definitions)?;
             let tag_repr = choice_key.repr()?.to_string();
             if first {
                 first = false;
@@ -399,13 +399,11 @@ impl Validator for TaggedUnionValidator {
         match self.discriminator {
             Discriminator::LookupKey(ref lookup_key) => {
                 macro_rules! find_validator {
-                    ($get_method:ident, $($dict:ident),+) => {{
+                    ($get_method:ident, $($dict:expr),+) => {{
                         // note all these methods return PyResult<Option<(data, data)>>, the outer Err is just for
                         // errors when getting attributes which should be "raised"
                         match lookup_key.$get_method($( $dict ),+)? {
-                            Some((_, value)) => {
-                                Ok(value.to_object(py).into_ref(py))
-                            }
+                            Some((_, value)) => Ok(value.to_object(py)),
                             None => Err(self.tag_not_found(input)),
                         }
                     }};
@@ -413,24 +411,32 @@ impl Validator for TaggedUnionValidator {
                 let from_attributes = state.extra().from_attributes.unwrap_or(self.from_attributes);
                 let dict = input.validate_model_fields(self.strict, from_attributes)?;
                 let tag = match dict {
-                    GenericMapping::PyDict(dict) => find_validator!(py_get_dict_item, dict),
-                    GenericMapping::PyMapping(mapping) => find_validator!(py_get_mapping_item, mapping),
-                    GenericMapping::StringMapping(d) => find_validator!(py_get_dict_item, d),
-                    GenericMapping::PyGetAttr(obj, kwargs) => find_validator!(py_get_attr, obj, kwargs),
+                    GenericMapping::PyDict(dict) => {
+                        find_validator!(py_get_dict_item, &dict)
+                    }
+                    GenericMapping::PyMapping(mapping) => {
+                        find_validator!(py_get_mapping_item, &mapping)
+                    }
+                    GenericMapping::StringMapping(d) => {
+                        find_validator!(py_get_dict_item, &d)
+                    }
+                    GenericMapping::PyGetAttr(obj, kwargs) => {
+                        find_validator!(py_get_attr, &obj, kwargs.as_ref())
+                    }
                     GenericMapping::JsonObject(mapping) => find_validator!(json_get, mapping),
                 }?;
-                self.find_call_validator(py, tag, input, state)
+                self.find_call_validator(py, tag.bind(py), input, state)
             }
             Discriminator::Function(ref func) => {
-                let tag = func.call1(py, (input.to_object(py),))?;
+                let tag: Py<PyAny> = func.call1(py, (input.to_object(py),))?;
                 if tag.is_none(py) {
                     Err(self.tag_not_found(input))
                 } else {
-                    self.find_call_validator(py, tag.into_ref(py), input, state)
+                    self.find_call_validator(py, tag.bind(py), input, state)
                 }
             }
             Discriminator::SelfSchema => {
-                self.find_call_validator(py, self.self_schema_tag(py, input)?.as_ref(), input, state)
+                self.find_call_validator(py, self.self_schema_tag(py, input)?.as_any(), input, state)
             }
         }
     }
@@ -441,45 +447,43 @@ impl Validator for TaggedUnionValidator {
 }
 
 impl TaggedUnionValidator {
-    fn self_schema_tag<'s, 'data>(
-        &'s self,
+    fn self_schema_tag<'data>(
+        &self,
         py: Python<'data>,
         input: &'data impl Input<'data>,
-    ) -> ValResult<&'data PyString> {
+    ) -> ValResult<Bound<'data, PyString>> {
         let dict = input.strict_dict()?;
-        let either_tag = match dict {
+        let tag = match &dict {
             GenericMapping::PyDict(dict) => match dict.get_item(intern!(py, "type"))? {
-                Some(t) => t.validate_str(true, false)?.into_inner(),
+                Some(t) => t.downcast_into::<PyString>()?,
                 None => return Err(self.tag_not_found(input)),
             },
             _ => unreachable!(),
         };
-        let tag_cow = either_tag.as_cow()?;
-        let tag = tag_cow.as_ref();
+        let tag = tag.to_str()?;
         // custom logic to distinguish between different function and tuple schemas
         if tag == "function" {
-            let mode = match dict {
-                GenericMapping::PyDict(dict) => match dict.get_item(intern!(py, "mode"))? {
-                    Some(m) => Some(m.validate_str(true, false)?.into_inner()),
-                    None => None,
-                },
-                _ => unreachable!(),
+            let GenericMapping::PyDict(dict) = dict else {
+                unreachable!()
             };
-            let mode = mode.ok_or_else(|| self.tag_not_found(input))?;
-            match mode.as_cow()?.as_ref() {
-                "plain" => Ok(intern!(py, "function-plain")),
-                "wrap" => Ok(intern!(py, "function-wrap")),
-                _ => Ok(intern!(py, "function")),
-            }
+            let Some(mode) = dict.get_item(intern!(py, "mode"))? else {
+                return Err(self.tag_not_found(input));
+            };
+            let tag = match mode.validate_str(true, false)?.into_inner().as_cow()?.as_ref() {
+                "plain" => Ok(intern!(py, "function-plain").to_owned()),
+                "wrap" => Ok(intern!(py, "function-wrap").to_owned()),
+                _ => Ok(intern!(py, "function").to_owned()),
+            };
+            tag
         } else {
-            Ok(PyString::new(py, tag))
+            Ok(PyString::new_bound(py, tag))
         }
     }
 
     fn find_call_validator<'s, 'data>(
         &'s self,
         py: Python<'data>,
-        tag: &'data PyAny,
+        tag: &Bound<'data, PyAny>,
         input: &'data impl Input<'data>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
diff --git a/src/validators/url.rs b/src/validators/url.rs
index ba0d4cd4d..5529c2667 100644
--- a/src/validators/url.rs
+++ b/src/validators/url.rs
@@ -37,8 +37,8 @@ impl BuildValidator for UrlValidator {
     const EXPECTED_TYPE: &'static str = "url";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let (allowed_schemes, name) = get_allowed_schemas(schema, Self::EXPECTED_TYPE)?;
@@ -165,8 +165,8 @@ impl BuildValidator for MultiHostUrlValidator {
     const EXPECTED_TYPE: &'static str = "multi-host-url";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let (allowed_schemes, name) = get_allowed_schemas(schema, Self::EXPECTED_TYPE)?;
@@ -501,7 +501,7 @@ fn check_sub_defaults(
     Ok(())
 }
 
-fn get_allowed_schemas(schema: &PyDict, name: &'static str) -> PyResult<(AllowedSchemas, String)> {
+fn get_allowed_schemas(schema: &Bound<'_, PyDict>, name: &'static str) -> PyResult<(AllowedSchemas, String)> {
     match schema.get_as::<&PyList>(intern!(schema.py(), "allowed_schemes"))? {
         Some(list) => {
             if list.is_empty() {
diff --git a/src/validators/uuid.rs b/src/validators/uuid.rs
index c0854c10f..a567d3f6b 100644
--- a/src/validators/uuid.rs
+++ b/src/validators/uuid.rs
@@ -23,13 +23,13 @@ const UUID_IS_SAFE: &str = "is_safe";
 static UUID_TYPE: GILOnceCell<Py<PyType>> = GILOnceCell::new();
 
 fn import_type(py: Python, module: &str, attr: &str) -> PyResult<Py<PyType>> {
-    py.import(module)?.getattr(attr)?.extract()
+    py.import_bound(module)?.getattr(attr)?.extract()
 }
 
-fn get_uuid_type(py: Python) -> PyResult<&PyType> {
+fn get_uuid_type(py: Python) -> PyResult<&Bound<'_, PyType>> {
     Ok(UUID_TYPE
         .get_or_init(py, || import_type(py, "uuid", "UUID").unwrap())
-        .as_ref(py))
+        .bind(py))
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -68,8 +68,8 @@ impl BuildValidator for UuidValidator {
     const EXPECTED_TYPE: &'static str = "uuid";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
@@ -113,7 +113,7 @@ impl Validator for UuidValidator {
         } else if state.strict_or(self.strict) && state.extra().input_type == InputType::Python {
             Err(ValError::new(
                 ErrorType::IsInstanceOf {
-                    class: class.name().unwrap_or("UUID").to_string(),
+                    class: class.qualname().unwrap_or_else(|_| "UUID".to_owned()),
                     context: None,
                 },
                 input,
@@ -140,7 +140,7 @@ impl Validator for UuidValidator {
                     ));
                 }
             }
-            self.create_py_uuid(py, class, &uuid)
+            self.create_py_uuid(class, &uuid)
         }
     }
 
@@ -213,16 +213,16 @@ impl UuidValidator {
     ///
     /// This implementation does not use the Python `__init__` function to speed up the process,
     /// as the `__init__` function in the Python `uuid` module performs extensive checks.
-    fn create_py_uuid(&self, py: Python<'_>, py_type: &PyType, uuid: &Uuid) -> ValResult<Py<PyAny>> {
-        let class = create_class(py_type)?;
-        let dc = class.as_ref(py);
+    fn create_py_uuid(&self, py_type: &Bound<'_, PyType>, uuid: &Uuid) -> ValResult<PyObject> {
+        let py = py_type.py();
+        let dc = create_class(py_type)?;
         let int = uuid.as_u128();
         let safe = py
-            .import(intern!(py, "uuid"))?
+            .import_bound(intern!(py, "uuid"))?
             .getattr(intern!(py, "SafeUUID"))?
             .get_item("safe")?;
-        force_setattr(py, dc, intern!(py, UUID_INT), int)?;
-        force_setattr(py, dc, intern!(py, UUID_IS_SAFE), safe)?;
-        Ok(dc.to_object(py))
+        force_setattr(py, &dc, intern!(py, UUID_INT), int)?;
+        force_setattr(py, &dc, intern!(py, UUID_IS_SAFE), safe)?;
+        Ok(dc.into())
     }
 }
diff --git a/src/validators/validation_state.rs b/src/validators/validation_state.rs
index 4f241d768..61de64fd6 100644
--- a/src/validators/validation_state.rs
+++ b/src/validators/validation_state.rs
@@ -38,7 +38,9 @@ impl<'a> ValidationState<'a> {
             extra,
         };
         let result = f(&mut new_state);
-        match new_state.exactness {
+        let exactness = new_state.exactness;
+        drop(new_state);
+        match exactness {
             Some(exactness) => self.floor_exactness(exactness),
             None => self.exactness = None,
         }
@@ -53,7 +55,10 @@ impl<'a> ValidationState<'a> {
         f: impl FnOnce(&mut Extra<'a>),
     ) -> ValidationStateWithReboundExtra<'state, 'a> {
         #[allow(clippy::unnecessary_struct_initialization)]
-        let old_extra = Extra { ..self.extra };
+        let old_extra = Extra {
+            data: self.extra.data.clone(),
+            ..self.extra
+        };
         f(&mut self.extra);
         ValidationStateWithReboundExtra { state: self, old_extra }
     }
diff --git a/src/validators/with_default.rs b/src/validators/with_default.rs
index f520eaf38..b1ee12ca9 100644
--- a/src/validators/with_default.rs
+++ b/src/validators/with_default.rs
@@ -1,7 +1,8 @@
 use pyo3::intern;
-use pyo3::once_cell::GILOnceCell;
 use pyo3::prelude::*;
+use pyo3::sync::GILOnceCell;
 use pyo3::types::PyDict;
+use pyo3::types::PyString;
 use pyo3::PyTraverseError;
 use pyo3::PyVisit;
 
@@ -17,7 +18,7 @@ use crate::PydanticUndefinedType;
 static COPY_DEEPCOPY: GILOnceCell<PyObject> = GILOnceCell::new();
 
 fn get_deepcopy(py: Python) -> PyResult<PyObject> {
-    Ok(py.import("copy")?.getattr("deepcopy")?.into_py(py))
+    Ok(py.import_bound("copy")?.getattr("deepcopy")?.into_py(py))
 }
 
 #[derive(Debug, Clone)]
@@ -28,7 +29,7 @@ pub enum DefaultType {
 }
 
 impl DefaultType {
-    pub fn new(schema: &PyDict) -> PyResult<Self> {
+    pub fn new(schema: &Bound<'_, PyDict>) -> PyResult<Self> {
         let py = schema.py();
         match (
             schema.get_as(intern!(py, "default"))?,
@@ -81,13 +82,18 @@ impl BuildValidator for WithDefaultValidator {
     const EXPECTED_TYPE: &'static str = "default";
 
     fn build(
-        schema: &PyDict,
-        config: Option<&PyDict>,
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
         let default = DefaultType::new(schema)?;
-        let on_error = match schema.get_as::<&str>(intern!(py, "on_error"))? {
+        let on_error = match schema
+            .get_as::<Bound<'_, PyString>>(intern!(py, "on_error"))?
+            .as_ref()
+            .map(|s| s.to_str())
+            .transpose()?
+        {
             Some("raise") => OnError::Raise,
             Some("omit") => OnError::Omit,
             Some("default") => {
@@ -101,11 +107,11 @@ impl BuildValidator for WithDefaultValidator {
             _ => unreachable!(),
         };
 
-        let sub_schema: &PyAny = schema.get_as_req(intern!(schema.py(), "schema"))?;
-        let validator = Box::new(build_validator(sub_schema, config, definitions)?);
+        let sub_schema = schema.get_as_req(intern!(schema.py(), "schema"))?;
+        let validator = Box::new(build_validator(&sub_schema, config, definitions)?);
 
         let copy_default = if let DefaultType::Default(default_obj) = &default {
-            default_obj.as_ref(py).hash().is_err()
+            default_obj.bind(py).hash().is_err()
         } else {
             false
         };
@@ -166,7 +172,7 @@ impl Validator for WithDefaultValidator {
                     stored_dft
                 };
                 if self.validate_default {
-                    match self.validate(py, dft.into_ref(py), state) {
+                    match self.validate(py, dft.bind(py), state) {
                         Ok(v) => Ok(Some(v)),
                         Err(e) => {
                             if let Some(outer_loc) = outer_loc {
diff --git a/tests/test.rs b/tests/test.rs
index 597084b3b..46d0ede8d 100644
--- a/tests/test.rs
+++ b/tests/test.rs
@@ -45,8 +45,8 @@ mod tests {
                     },
                 ]
             }";
-            let schema: &PyDict = py.eval(code, None, None).unwrap().extract().unwrap();
-            SchemaSerializer::py_new(py, schema, None).unwrap();
+            let schema: Bound<'_, PyDict> = py.eval_bound(code, None, None).unwrap().extract().unwrap();
+            SchemaSerializer::py_new(schema, None).unwrap();
         });
     }
 
@@ -73,18 +73,22 @@ schema = {
 }
 a = A()
             "#;
-            let locals = PyDict::new(py);
-            py.run(code, None, Some(locals)).unwrap();
-            let a: &PyAny = locals.get_item("a").unwrap().unwrap().extract().unwrap();
-            let schema: &PyDict = locals.get_item("schema").unwrap().unwrap().extract().unwrap();
-            let serialized: Vec<u8> = SchemaSerializer::py_new(py, schema, None)
+            let locals = PyDict::new_bound(py);
+            py.run_bound(code, None, Some(&locals)).unwrap();
+            let a = locals.get_item("a").unwrap().unwrap();
+            let schema = locals
+                .get_item("schema")
+                .unwrap()
+                .unwrap()
+                .downcast_into::<PyDict>()
+                .unwrap();
+            let serialized = SchemaSerializer::py_new(schema, None)
                 .unwrap()
                 .to_json(
-                    py, a, None, None, None, true, false, false, false, false, true, None, None,
+                    py, &a, None, None, None, true, false, false, false, false, true, None, None,
                 )
-                .unwrap()
-                .extract(py)
                 .unwrap();
+            let serialized: &[u8] = serialized.extract(py).unwrap();
             assert_eq!(serialized, b"{\"b\":\"b\"}");
         });
     }
@@ -106,13 +110,13 @@ schema = {
 }
 json_input = '{"a": "something"}'
             "#;
-            let locals = PyDict::new(py);
-            py.run(code, None, Some(locals)).unwrap();
-            let schema: &PyDict = locals.get_item("schema").unwrap().unwrap().extract().unwrap();
-            let json_input: &PyAny = locals.get_item("json_input").unwrap().unwrap().extract().unwrap();
-            let binding = SchemaValidator::py_new(py, schema, None)
+            let locals = PyDict::new_bound(py);
+            py.run_bound(code, None, Some(&locals)).unwrap();
+            let schema = locals.get_item("schema").unwrap().unwrap();
+            let json_input = locals.get_item("json_input").unwrap().unwrap();
+            let binding = SchemaValidator::py_new(py, &schema, None)
                 .unwrap()
-                .validate_json(py, json_input, None, None, None)
+                .validate_json(py, &json_input, None, None, None)
                 .unwrap();
             let validation_result: &PyAny = binding.extract(py).unwrap();
             let repr = format!("{}", validation_result.repr().unwrap());
@@ -159,26 +163,21 @@ schema = {
 dump_json_input_1 = 1
 dump_json_input_2 = {'a': 'something'}
             ";
-            let locals = PyDict::new(py);
-            py.run(code, None, Some(locals)).unwrap();
-            let schema: &PyDict = locals.get_item("schema").unwrap().unwrap().extract().unwrap();
-            let dump_json_input_1: &PyAny = locals
-                .get_item("dump_json_input_1")
+            let locals = PyDict::new_bound(py);
+            py.run_bound(code, None, Some(&locals)).unwrap();
+            let schema = locals
+                .get_item("schema")
                 .unwrap()
                 .unwrap()
-                .extract()
+                .downcast_into::<PyDict>()
                 .unwrap();
-            let dump_json_input_2: &PyAny = locals
-                .get_item("dump_json_input_2")
-                .unwrap()
-                .unwrap()
-                .extract()
-                .unwrap();
-            let binding = SchemaSerializer::py_new(py, schema, None)
-                .unwrap()
+            let dump_json_input_1 = locals.get_item("dump_json_input_1").unwrap().unwrap();
+            let dump_json_input_2 = locals.get_item("dump_json_input_2").unwrap().unwrap();
+            let serializer = SchemaSerializer::py_new(schema, None).unwrap();
+            let serialization_result = serializer
                 .to_json(
                     py,
-                    dump_json_input_1,
+                    &dump_json_input_1,
                     None,
                     None,
                     None,
@@ -192,15 +191,13 @@ dump_json_input_2 = {'a': 'something'}
                     None,
                 )
                 .unwrap();
-            let serialization_result: &PyAny = binding.extract(py).unwrap();
-            let repr = format!("{}", serialization_result.repr().unwrap());
+            let repr = format!("{}", serialization_result.bind(py).repr().unwrap());
             assert_eq!(repr, "b'1'");
 
-            let binding = SchemaSerializer::py_new(py, schema, None)
-                .unwrap()
+            let serialization_result = serializer
                 .to_json(
                     py,
-                    dump_json_input_2,
+                    &dump_json_input_2,
                     None,
                     None,
                     None,
@@ -214,8 +211,7 @@ dump_json_input_2 = {'a': 'something'}
                     None,
                 )
                 .unwrap();
-            let serialization_result: &PyAny = binding.extract(py).unwrap();
-            let repr = format!("{}", serialization_result.repr().unwrap());
+            let repr = format!("{}", serialization_result.bind(py).repr().unwrap());
             assert_eq!(repr, "b'{\"a\":\"something\"}'");
         });
     }

From 10095b5fba25d33e4a71ab6765818dda8d617dbb Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Wed, 13 Mar 2024 08:56:43 +0000
Subject: [PATCH 229/550] tidy up some remaining PyO3 GIL Refs (#1225)

---
 benches/main.rs                    | 68 +++++++++++++++---------------
 src/argument_markers.rs            |  6 +--
 src/errors/types.rs                | 10 ++---
 src/errors/validation_exception.rs |  2 +-
 src/errors/value_exception.rs      |  6 +--
 src/input/datetime.rs              |  6 +--
 src/serializers/filter.rs          |  6 +--
 src/url.rs                         |  4 +-
 src/validators/custom_error.rs     |  3 +-
 src/validators/dataclass.rs        |  2 +-
 src/validators/model.rs            |  6 ++-
 tests/test.rs                      |  2 +-
 12 files changed, 62 insertions(+), 59 deletions(-)

diff --git a/benches/main.rs b/benches/main.rs
index d1ef27a93..5ef9b6898 100644
--- a/benches/main.rs
+++ b/benches/main.rs
@@ -9,8 +9,8 @@ use pyo3::types::{PyDict, PyString};
 
 use _pydantic_core::{validate_core_schema, SchemaValidator};
 
-fn build_schema_validator_with_globals(py: Python, code: &str, globals: Option<&PyDict>) -> SchemaValidator {
-    let mut schema = py.eval(code, globals, None).unwrap().extract().unwrap();
+fn build_schema_validator_with_globals(py: Python, code: &str, globals: Option<&Bound<'_, PyDict>>) -> SchemaValidator {
+    let mut schema = py.eval_bound(code, globals, None).unwrap().extract().unwrap();
     schema = validate_core_schema(&schema, None).unwrap().extract().unwrap();
     SchemaValidator::py_new(py, &schema, None).unwrap()
 }
@@ -71,7 +71,7 @@ fn list_int_input(py: Python<'_>) -> (SchemaValidator, PyObject) {
         (0..100).map(|x| x.to_string()).collect::<Vec<String>>().join(",")
     );
 
-    let input = py.eval(&code, None, None).unwrap();
+    let input = py.eval_bound(&code, None, None).unwrap();
     (validator, input.to_object(py))
 }
 
@@ -117,7 +117,7 @@ fn list_error_json(bench: &mut Bencher) {
         match validator.validate_json(py, &json(py, &code), None, None, None) {
             Ok(_) => panic!("unexpectedly valid"),
             Err(e) => {
-                let v = e.value(py);
+                let v = e.value_bound(py);
                 // println!("error: {}", v.to_string());
                 assert_eq!(v.getattr("title").unwrap().to_string(), "list[int]");
                 let error_count: i64 = v.call_method0("error_count").unwrap().extract().unwrap();
@@ -144,12 +144,12 @@ fn list_error_python_input(py: Python<'_>) -> (SchemaValidator, PyObject) {
             .join(", ")
     );
 
-    let input = py.eval(&code, None, None).unwrap().extract().unwrap();
+    let input = py.eval_bound(&code, None, None).unwrap().extract().unwrap();
 
     match validator.validate_python(py, &input, None, None, None, None) {
         Ok(_) => panic!("unexpectedly valid"),
         Err(e) => {
-            let v = e.value(py);
+            let v = e.value_bound(py);
             // println!("error: {}", v.to_string());
             assert_eq!(v.getattr("title").unwrap().to_string(), "list[int]");
             let error_count: i64 = v.call_method0("error_count").unwrap().extract().unwrap();
@@ -211,7 +211,7 @@ fn list_any_python(bench: &mut Bencher) {
             "[{}]",
             (0..100).map(|x| x.to_string()).collect::<Vec<String>>().join(",")
         );
-        let input = py.eval(&code, None, None).unwrap().to_object(py);
+        let input = py.eval_bound(&code, None, None).unwrap().to_object(py);
         let input = black_box(input.bind(py));
         bench.iter(|| {
             let v = validator.validate_python(py, &input, None, None, None, None).unwrap();
@@ -263,7 +263,7 @@ fn dict_python(bench: &mut Bencher) {
                 .collect::<Vec<String>>()
                 .join(", ")
         );
-        let input = py.eval(&code, None, None).unwrap().to_object(py);
+        let input = py.eval_bound(&code, None, None).unwrap().to_object(py);
         let input = black_box(input.bind(py));
         bench.iter(|| {
             let v = validator.validate_python(py, &input, None, None, None, None).unwrap();
@@ -292,12 +292,12 @@ fn dict_value_error(bench: &mut Bencher) {
                 .join(", ")
         );
 
-        let input = py.eval(&code, None, None).unwrap().to_object(py).into_bound(py);
+        let input = py.eval_bound(&code, None, None).unwrap().to_object(py).into_bound(py);
 
         match validator.validate_python(py, &input, None, None, None, None) {
             Ok(_) => panic!("unexpectedly valid"),
             Err(e) => {
-                let v = e.value(py);
+                let v = e.value_bound(py);
                 // println!("error: {}", v.to_string());
                 assert_eq!(v.getattr("title").unwrap().to_string(), "dict[str,constrained-int]");
                 let error_count: i64 = v.call_method0("error_count").unwrap().extract().unwrap();
@@ -370,7 +370,7 @@ fn typed_dict_python(bench: &mut Bencher) {
         );
 
         let code = r#"{"a": 1, "b": 2, "c": 3, "d": 4, "e": 5, "f": 6, "g": 7, "h": 8, "i": 9, "j": 0}"#.to_string();
-        let input = py.eval(&code, None, None).unwrap().to_object(py);
+        let input = py.eval_bound(&code, None, None).unwrap().to_object(py);
         let input = black_box(input.bind(py));
         bench.iter(|| {
             let v = validator.validate_python(py, &input, None, None, None, None).unwrap();
@@ -410,13 +410,13 @@ fn typed_dict_deep_error(bench: &mut Bencher) {
 
         let code = "{'field_a': '1', 'field_b': {'field_c': '2', 'field_d': {'field_e': '4', 'field_f': 'xx'}}}";
 
-        let input = py.eval(code, None, None).unwrap().to_object(py);
+        let input = py.eval_bound(code, None, None).unwrap().to_object(py);
         let input = black_box(input.bind(py));
 
         match validator.validate_python(py, &input, None, None, None, None) {
             Ok(_) => panic!("unexpectedly valid"),
             Err(e) => {
-                let v = e.value(py);
+                let v = e.value_bound(py);
                 // println!("error: {}", v.to_string());
                 assert_eq!(v.getattr("title").unwrap().to_string(), "typed-dict");
                 let error_count: i64 = v.call_method0("error_count").unwrap().extract().unwrap();
@@ -438,7 +438,7 @@ fn typed_dict_deep_error(bench: &mut Bencher) {
 #[bench]
 fn complete_model(bench: &mut Bencher) {
     Python::with_gil(|py| {
-        let sys_path = py.import("sys").unwrap().getattr("path").unwrap();
+        let sys_path = py.import_bound("sys").unwrap().getattr("path").unwrap();
         sys_path.call_method1("append", ("./tests/benchmarks/",)).unwrap();
 
         let complete_schema = py.import_bound("complete_schema").unwrap();
@@ -458,7 +458,7 @@ fn complete_model(bench: &mut Bencher) {
 #[bench]
 fn nested_model_using_definitions(bench: &mut Bencher) {
     Python::with_gil(|py| {
-        let sys_path = py.import("sys").unwrap().getattr("path").unwrap();
+        let sys_path = py.import_bound("sys").unwrap().getattr("path").unwrap();
         sys_path.call_method1("append", ("./tests/benchmarks/",)).unwrap();
 
         let complete_schema = py.import_bound("nested_schema").unwrap();
@@ -480,7 +480,7 @@ fn nested_model_using_definitions(bench: &mut Bencher) {
 #[bench]
 fn nested_model_inlined(bench: &mut Bencher) {
     Python::with_gil(|py| {
-        let sys_path = py.import("sys").unwrap().getattr("path").unwrap();
+        let sys_path = py.import_bound("sys").unwrap().getattr("path").unwrap();
         sys_path.call_method1("append", ("./tests/benchmarks/",)).unwrap();
 
         let complete_schema = py.import_bound("nested_schema").unwrap();
@@ -520,7 +520,7 @@ fn literal_strings_few_small_python(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let validator = build_schema_validator(py, "{'type': 'literal', 'expected': [f'{idx}' for idx in range(5)]}");
 
-        let input = py.eval("'4'", None, None).unwrap();
+        let input = py.eval_bound("'4'", None, None).unwrap();
         let input = input.to_object(py).into_bound(py);
         let input_str: String = input.extract().unwrap();
         let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
@@ -540,7 +540,7 @@ fn literal_strings_few_large_python(bench: &mut Bencher) {
             "{'type': 'literal', 'expected': ['a' * 25 + f'{idx}' for idx in range(5)]}",
         );
 
-        let input = py.eval("'a' * 25 + '4'", None, None).unwrap();
+        let input = py.eval_bound("'a' * 25 + '4'", None, None).unwrap();
         let input = input.to_object(py).into_bound(py);
         let input_str: String = input.extract().unwrap();
         let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
@@ -556,7 +556,7 @@ fn literal_strings_few_large_python(bench: &mut Bencher) {
 fn literal_enums_few_python(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let globals = PyDict::new_bound(py);
-        py.run(
+        py.run_bound(
             r#"
 from enum import Enum
 
@@ -566,7 +566,7 @@ class Foo(Enum):
     v3 = object()
     v4 = object()
 "#,
-            Some(globals.as_gil_ref()),
+            Some(&globals),
             None,
         )
         .unwrap();
@@ -574,10 +574,10 @@ class Foo(Enum):
         let validator = build_schema_validator_with_globals(
             py,
             "{'type': 'literal', 'expected': [Foo.v1, Foo.v2, Foo.v3, Foo.v4]}",
-            Some(globals.as_gil_ref()),
+            Some(&globals),
         );
 
-        let input = py.eval("Foo.v4", Some(globals.as_gil_ref()), None).unwrap();
+        let input = py.eval_bound("Foo.v4", Some(&globals), None).unwrap();
         let input = input.to_object(py).into_bound(py);
         let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
         assert!(input.eq(result).unwrap());
@@ -607,7 +607,7 @@ fn literal_strings_many_small_python(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let validator = build_schema_validator(py, "{'type': 'literal', 'expected': [f'{idx}' for idx in range(100)]}");
 
-        let input = py.eval("'99'", None, None).unwrap();
+        let input = py.eval_bound("'99'", None, None).unwrap();
         let input = input.to_object(py).into_bound(py);
         let input_str: String = input.extract().unwrap();
         let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
@@ -627,7 +627,7 @@ fn literal_strings_many_large_python(bench: &mut Bencher) {
             "{'type': 'literal', 'expected': ['a' * 25 + f'{idx}' for idx in range(100)]}",
         );
 
-        let input = py.eval("'a' * 25 + '99'", None, None).unwrap();
+        let input = py.eval_bound("'a' * 25 + '99'", None, None).unwrap();
         let input = input.to_object(py).into_bound(py);
         let input_str: String = input.extract().unwrap();
         let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
@@ -644,7 +644,7 @@ fn literal_ints_many_json(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let validator = build_schema_validator(py, "{'type': 'literal', 'expected': list(range(100))}");
 
-        let input_json = py.eval("'99'", None, None).unwrap();
+        let input_json = py.eval_bound("'99'", None, None).unwrap();
         let input_json = input_json.to_object(py).into_bound(py);
         let result = validator.validate_json(py, &input_json, None, None, None).unwrap();
         let result_int: i64 = result.extract(py).unwrap();
@@ -663,9 +663,9 @@ fn literal_strings_many_large_json(bench: &mut Bencher) {
             "{'type': 'literal', 'expected': ['a' * 25 + f'{idx}' for idx in range(100)]}",
         );
 
-        let input = py.eval("'a' * 25 + '99'", None, None).unwrap();
+        let input = py.eval_bound("'a' * 25 + '99'", None, None).unwrap();
         let input = input.to_object(py).into_bound(py);
-        let input_json = py.eval("'\"' + 'a' * 25 + '99' + '\"'", None, None).unwrap();
+        let input_json = py.eval_bound("'\"' + 'a' * 25 + '99' + '\"'", None, None).unwrap();
         let input_json = input_json.to_object(py).into_bound(py);
         let input_str: String = input.extract().unwrap();
         let result = validator.validate_json(py, &input_json, None, None, None).unwrap();
@@ -681,7 +681,7 @@ fn literal_strings_many_large_json(bench: &mut Bencher) {
 fn literal_mixed_few_python(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let globals = PyDict::new_bound(py);
-        py.run(
+        py.run_bound(
             r#"
 from enum import Enum
 
@@ -691,19 +691,19 @@ class Foo(Enum):
     v3 = object()
     v4 = object()
 "#,
-            Some(globals.as_gil_ref()),
+            Some(&globals),
             None,
         )
         .unwrap();
         let validator = build_schema_validator_with_globals(
             py,
             "{'type': 'literal', 'expected': [None, 'null', -1, Foo.v4]}",
-            Some(globals.as_gil_ref()),
+            Some(&globals),
         );
 
         // String
         {
-            let input = py.eval("'null'", None, None).unwrap();
+            let input = py.eval_bound("'null'", None, None).unwrap();
             let input = input.to_object(py).into_bound(py);
             let input_str: String = input.extract().unwrap();
             let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
@@ -716,7 +716,7 @@ class Foo(Enum):
 
         // Int
         {
-            let input = py.eval("-1", None, None).unwrap();
+            let input = py.eval_bound("-1", None, None).unwrap();
             let input = input.to_object(py).into_bound(py);
             let input_int: i64 = input.extract().unwrap();
             let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
@@ -729,7 +729,7 @@ class Foo(Enum):
 
         // None
         {
-            let input = py.eval("None", None, None).unwrap();
+            let input = py.eval_bound("None", None, None).unwrap();
             let input = input.to_object(py).into_bound(py);
             let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
             assert!(input.eq(result).unwrap());
@@ -740,7 +740,7 @@ class Foo(Enum):
 
         // Enum
         {
-            let input = py.eval("Foo.v4", Some(globals.as_gil_ref()), None).unwrap();
+            let input = py.eval_bound("Foo.v4", Some(&globals), None).unwrap();
             let input = input.to_object(py).into_bound(py);
             let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
             assert!(input.eq(result).unwrap());
diff --git a/src/argument_markers.rs b/src/argument_markers.rs
index 748dd0ae2..b3ca97c8d 100644
--- a/src/argument_markers.rs
+++ b/src/argument_markers.rs
@@ -30,11 +30,11 @@ impl ArgsKwargs {
 #[pymethods]
 impl ArgsKwargs {
     #[new]
-    fn py_new(py: Python, args: &PyTuple, kwargs: Option<&PyDict>) -> Self {
+    fn py_new(py: Python, args: &PyTuple, kwargs: Option<&Bound<'_, PyDict>>) -> Self {
         Self {
             args: args.into_py(py),
             kwargs: match kwargs {
-                Some(d) if !d.is_empty() => Some(d.into_py(py)),
+                Some(d) if !d.is_empty() => Some(d.to_owned().unbind()),
                 _ => None,
             },
         }
@@ -94,7 +94,7 @@ impl PydanticUndefinedType {
     }
 
     #[pyo3(signature = (_memo, /))]
-    fn __deepcopy__(&self, py: Python, _memo: &PyAny) -> Py<Self> {
+    fn __deepcopy__(&self, py: Python, _memo: &Bound<'_, PyAny>) -> Py<Self> {
         self.__copy__(py)
     }
 
diff --git a/src/errors/types.rs b/src/errors/types.rs
index a77ed6a8e..d3a6cdebb 100644
--- a/src/errors/types.rs
+++ b/src/errors/types.rs
@@ -43,7 +43,7 @@ pub fn list_all_errors(py: Python) -> PyResult<Bound<'_, PyList>> {
 }
 
 fn field_from_context<'py, T: FromPyObject<'py>>(
-    context: Option<&'py PyDict>,
+    context: Option<&Bound<'py, PyDict>>,
     field_name: &str,
     enum_name: &str,
     type_name_fn: fn() -> &'static str,
@@ -57,7 +57,7 @@ fn field_from_context<'py, T: FromPyObject<'py>>(
 }
 
 fn cow_field_from_context<'py, T: FromPyObject<'py>, B: ?Sized + 'static>(
-    context: Option<&'py PyDict>,
+    context: Option<&Bound<'py, PyDict>>,
     field_name: &str,
     enum_name: &str,
     _type_name_fn: fn() -> &'static str,
@@ -101,7 +101,7 @@ macro_rules! error_types {
             ),+,
         }
         impl ErrorType {
-            pub fn new(py: Python, value: &str, context: Option<&PyDict>) -> PyResult<Self> {
+            pub fn new(py: Python, value: &str, context: Option<Bound<'_, PyDict>>) -> PyResult<Self> {
                 let lookup = ERROR_TYPE_LOOKUP.get_or_init(py, Self::build_lookup);
                 let error_type = match lookup.get(value) {
                     Some(error_type) => error_type.clone(),
@@ -111,10 +111,10 @@ macro_rules! error_types {
                     $(
                         Self::$item { .. } => {
                             Ok(Self::$item {
-                                context: context.map(|c| c.into_py(py)),
                                 $(
-                                    $key: $ctx_fn(context, stringify!($key), stringify!($item), || stringify!($ctx_type))?,
+                                    $key: $ctx_fn(context.as_ref(), stringify!($key), stringify!($item), || stringify!($ctx_type))?,
                                 )*
+                                context: context.map(|c| c.unbind()),
                             })
                         },
                     )+
diff --git a/src/errors/validation_exception.rs b/src/errors/validation_exception.rs
index 059763a21..8960c8ff2 100644
--- a/src/errors/validation_exception.rs
+++ b/src/errors/validation_exception.rs
@@ -478,7 +478,7 @@ impl TryFrom<&Bound<'_, PyAny>> for PyLineError {
             .ok_or_else(|| PyKeyError::new_err("type"))?;
 
         let error_type = if let Ok(type_str) = type_raw.downcast::<PyString>() {
-            let context: Option<&PyDict> = dict.get_as(intern!(py, "ctx"))?;
+            let context: Option<Bound<'_, PyDict>> = dict.get_as(intern!(py, "ctx"))?;
             ErrorType::new(py, type_str.to_str()?, context)?
         } else if let Ok(custom_error) = type_raw.extract::<PydanticCustomError>() {
             ErrorType::new_custom_error(py, custom_error)
diff --git a/src/errors/value_exception.rs b/src/errors/value_exception.rs
index e69fc0a9c..b8b484d89 100644
--- a/src/errors/value_exception.rs
+++ b/src/errors/value_exception.rs
@@ -65,11 +65,11 @@ pub struct PydanticCustomError {
 #[pymethods]
 impl PydanticCustomError {
     #[new]
-    pub fn py_new(py: Python, error_type: String, message_template: String, context: Option<&PyDict>) -> Self {
+    pub fn py_new(error_type: String, message_template: String, context: Option<Bound<'_, PyDict>>) -> Self {
         Self {
             error_type,
             message_template,
-            context: context.map(|c| c.into_py(py)),
+            context: context.map(Bound::unbind),
         }
     }
 
@@ -143,7 +143,7 @@ pub struct PydanticKnownError {
 #[pymethods]
 impl PydanticKnownError {
     #[new]
-    pub fn py_new(py: Python, error_type: &str, context: Option<&PyDict>) -> PyResult<Self> {
+    pub fn py_new(py: Python, error_type: &str, context: Option<Bound<'_, PyDict>>) -> PyResult<Self> {
         let error_type = ErrorType::new(py, error_type, context)?;
         Ok(Self { error_type })
     }
diff --git a/src/input/datetime.rs b/src/input/datetime.rs
index 9dcf9006e..a567bd3d2 100644
--- a/src/input/datetime.rs
+++ b/src/input/datetime.rs
@@ -562,11 +562,11 @@ impl TzInfo {
         hasher.finish()
     }
 
-    fn __richcmp__(&self, other: &PyAny, op: CompareOp) -> PyResult<Py<PyAny>> {
+    fn __richcmp__(&self, other: &Bound<'_, PyAny>, op: CompareOp) -> PyResult<Py<PyAny>> {
         let py = other.py();
         if other.is_instance_of::<PyTzInfo>() {
             let offset_delta = other.call_method1(intern!(py, "utcoffset"), (py.None(),))?;
-            if offset_delta.is_none() {
+            if PyAnyMethods::is_none(&offset_delta) {
                 return Ok(py.NotImplemented());
             }
             let offset_seconds: f64 = offset_delta.call_method0(intern!(py, "total_seconds"))?.extract()?;
@@ -577,7 +577,7 @@ impl TzInfo {
         }
     }
 
-    fn __deepcopy__(&self, py: Python, _memo: &PyDict) -> PyResult<Py<Self>> {
+    fn __deepcopy__(&self, py: Python, _memo: &Bound<'_, PyDict>) -> PyResult<Py<Self>> {
         Py::new(py, self.clone())
     }
 
diff --git a/src/serializers/filter.rs b/src/serializers/filter.rs
index 4af04bb6c..8ba4a3bc2 100644
--- a/src/serializers/filter.rs
+++ b/src/serializers/filter.rs
@@ -63,7 +63,7 @@ type NextFilters<'py> = Option<(Option<Bound<'py, PyAny>>, Option<Bound<'py, PyA
 impl SchemaFilter<usize> {
     pub fn from_schema(schema: &Bound<'_, PyDict>) -> PyResult<Self> {
         let py = schema.py();
-        match schema.get_as::<&PyDict>(intern!(py, "serialization"))? {
+        match schema.get_as::<Bound<'_, PyDict>>(intern!(py, "serialization"))? {
             Some(ser) => {
                 let include = Self::build_set_ints(ser.get_item(intern!(py, "include"))?)?;
                 let exclude = Self::build_set_ints(ser.get_item(intern!(py, "exclude"))?)?;
@@ -73,13 +73,13 @@ impl SchemaFilter<usize> {
         }
     }
 
-    fn build_set_ints(v: Option<&PyAny>) -> PyResult<Option<AHashSet<usize>>> {
+    fn build_set_ints(v: Option<Bound<'_, PyAny>>) -> PyResult<Option<AHashSet<usize>>> {
         match v {
             Some(value) => {
                 if value.is_none() {
                     Ok(None)
                 } else {
-                    let py_set: &PySet = value.downcast()?;
+                    let py_set = value.downcast::<PySet>()?;
                     let mut set: AHashSet<usize> = AHashSet::with_capacity(py_set.len());
 
                     for item in py_set {
diff --git a/src/url.rs b/src/url.rs
index 6a6a921fe..4f02f36d9 100644
--- a/src/url.rs
+++ b/src/url.rs
@@ -147,7 +147,7 @@ impl PyUrl {
     }
 
     #[pyo3(signature = (_memo, /))]
-    pub fn __deepcopy__(&self, py: Python, _memo: &PyDict) -> Py<PyAny> {
+    pub fn __deepcopy__(&self, py: Python, _memo: Bound<'_, PyAny>) -> Py<PyAny> {
         self.clone().into_py(py)
     }
 
@@ -347,7 +347,7 @@ impl PyMultiHostUrl {
         true // an empty string is not a valid URL
     }
 
-    pub fn __deepcopy__(&self, py: Python, _memo: &PyDict) -> Py<PyAny> {
+    pub fn __deepcopy__(&self, py: Python, _memo: &Bound<'_, PyDict>) -> Py<PyAny> {
         self.clone().into_py(py)
     }
 
diff --git a/src/validators/custom_error.rs b/src/validators/custom_error.rs
index 0febcdca3..c605a59f1 100644
--- a/src/validators/custom_error.rs
+++ b/src/validators/custom_error.rs
@@ -28,7 +28,7 @@ impl CustomError {
             Some(error_type) => error_type,
             None => return Ok(None),
         };
-        let context: Option<&PyDict> = schema.get_as(intern!(py, "custom_error_context"))?;
+        let context: Option<Bound<'_, PyDict>> = schema.get_as(intern!(py, "custom_error_context"))?;
 
         if ErrorType::valid_type(py, &error_type) {
             if schema.contains(intern!(py, "custom_error_message"))? {
@@ -41,7 +41,6 @@ impl CustomError {
             }
         } else {
             let error = PydanticCustomError::py_new(
-                py,
                 error_type,
                 schema.get_as_req::<String>(intern!(py, "custom_error_message"))?,
                 context,
diff --git a/src/validators/dataclass.rs b/src/validators/dataclass.rs
index 648f53fdb..b2da5a048 100644
--- a/src/validators/dataclass.rs
+++ b/src/validators/dataclass.rs
@@ -589,7 +589,7 @@ impl Validator for DataclassValidator {
             self.validator
                 .validate_assignment(py, new_dict.as_any(), field_name, field_value, state)?;
 
-        let (dc_dict, _): (&PyDict, PyObject) = val_assignment_result.extract(py)?;
+        let (dc_dict, _): (Bound<'_, PyDict>, Bound<'_, PyAny>) = val_assignment_result.extract(py)?;
 
         if self.slots {
             let value = dc_dict
diff --git a/src/validators/model.rs b/src/validators/model.rs
index abe649e2c..8c63fa6f2 100644
--- a/src/validators/model.rs
+++ b/src/validators/model.rs
@@ -193,7 +193,11 @@ impl Validator for ModelValidator {
             .validator
             .validate_assignment(py, input_dict.as_any(), field_name, field_value, state)?;
 
-        let (validated_dict, validated_extra, validated_fields_set): (&PyDict, &PyAny, &PySet) = output.extract(py)?;
+        let (validated_dict, validated_extra, validated_fields_set): (
+            Bound<'_, PyDict>,
+            Bound<'_, PyAny>,
+            Bound<'_, PySet>,
+        ) = output.extract(py)?;
 
         if let Ok(fields_set) = model.getattr(intern!(py, DUNDER_FIELDS_SET_KEY)) {
             let fields_set = fields_set.downcast::<PySet>()?;
diff --git a/tests/test.rs b/tests/test.rs
index 46d0ede8d..2609316ad 100644
--- a/tests/test.rs
+++ b/tests/test.rs
@@ -118,7 +118,7 @@ json_input = '{"a": "something"}'
                 .unwrap()
                 .validate_json(py, &json_input, None, None, None)
                 .unwrap();
-            let validation_result: &PyAny = binding.extract(py).unwrap();
+            let validation_result: Bound<'_, PyAny> = binding.extract(py).unwrap();
             let repr = format!("{}", validation_result.repr().unwrap());
             assert_eq!(repr, "{'a': 'something'}");
         });

From 9efbc163a7b1e99c9240959946df504a72dd67f0 Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Wed, 13 Mar 2024 15:22:28 +0100
Subject: [PATCH 230/550] Use new typing syntax for `_pydantic_core.pyi`
 (#1217)

Co-authored-by: David Hewitt <mail@davidhewitt.dev>
---
 python/pydantic_core/_pydantic_core.pyi | 52 ++++++++++---------------
 1 file changed, 20 insertions(+), 32 deletions(-)

diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index 347589fd4..7679d9c74 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -1,24 +1,12 @@
-from __future__ import annotations
-
 import datetime
-import sys
-from typing import Any, Callable, Generic, Optional, Type, TypeVar
+from typing import Any, Callable, Generic, Literal, TypeVar, final
+
+from _typeshed import SupportsAllComparisons
+from typing_extensions import LiteralString, Self, TypeAlias
 
 from pydantic_core import ErrorDetails, ErrorTypeInfo, InitErrorDetails, MultiHostHost
 from pydantic_core.core_schema import CoreConfig, CoreSchema, ErrorType
 
-if sys.version_info < (3, 8):
-    from typing_extensions import final
-else:
-    from typing import final
-
-if sys.version_info < (3, 11):
-    from typing_extensions import Literal, LiteralString, Self, TypeAlias
-else:
-    from typing import Literal, LiteralString, Self, TypeAlias
-
-from _typeshed import SupportsAllComparisons
-
 __all__ = [
     '__version__',
     'build_profile',
@@ -73,7 +61,7 @@ class Some(Generic[_T]):
         Returns the value wrapped by `Some`.
         """
     @classmethod
-    def __class_getitem__(cls, item: Any, /) -> Type[Self]: ...
+    def __class_getitem__(cls, item: Any, /) -> type[Self]: ...
 
 @final
 class SchemaValidator:
@@ -569,13 +557,13 @@ class Url(SupportsAllComparisons):
         cls,
         *,
         scheme: str,
-        username: Optional[str] = None,
-        password: Optional[str] = None,
+        username: str | None = None,
+        password: str | None = None,
         host: str,
-        port: Optional[int] = None,
-        path: Optional[str] = None,
-        query: Optional[str] = None,
-        fragment: Optional[str] = None,
+        port: int | None = None,
+        path: str | None = None,
+        query: str | None = None,
+        fragment: str | None = None,
     ) -> Self:
         """
         Build a new `Url` instance from its component parts.
@@ -683,14 +671,14 @@ class MultiHostUrl(SupportsAllComparisons):
         cls,
         *,
         scheme: str,
-        hosts: Optional[list[MultiHostHost]] = None,
-        username: Optional[str] = None,
-        password: Optional[str] = None,
-        host: Optional[str] = None,
-        port: Optional[int] = None,
-        path: Optional[str] = None,
-        query: Optional[str] = None,
-        fragment: Optional[str] = None,
+        hosts: list[MultiHostHost] | None = None,
+        username: str | None = None,
+        password: str | None = None,
+        host: str | None = None,
+        port: int | None = None,
+        path: str | None = None,
+        query: str | None = None,
+        fragment: str | None = None,
     ) -> Self:
         """
         Build a new `MultiHostUrl` instance from its component parts.
@@ -883,7 +871,7 @@ class TzInfo(datetime.tzinfo):
     def utcoffset(self, _dt: datetime.datetime | None) -> datetime.timedelta: ...
     def dst(self, _dt: datetime.datetime | None) -> datetime.timedelta: ...
     def fromutc(self, dt: datetime.datetime) -> datetime.datetime: ...
-    def __deepcopy__(self, _memo: dict[Any, Any]) -> 'TzInfo': ...
+    def __deepcopy__(self, _memo: dict[Any, Any]) -> TzInfo: ...
 
 def validate_core_schema(schema: CoreSchema, *, strict: bool | None = None) -> CoreSchema:
     """Validate a CoreSchema

From 8db3a6f45b4af2e977a56af1f34099b8f5ff01eb Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Thu, 14 Mar 2024 20:46:47 +0000
Subject: [PATCH 231/550] separate `Input` trait `'a` and `'py` lifetimes
 (#1227)

---
 benches/main.rs                  |  24 +++---
 src/input/input_abstract.rs      |  74 ++++++++----------
 src/input/input_json.rs          |  96 +++++++++++------------
 src/input/input_python.rs        | 106 +++++++++++++------------
 src/input/input_string.rs        |  40 +++++-----
 src/input/return_enums.rs        | 129 ++++++++++++++++---------------
 src/input/shared.rs              |  10 +--
 src/lookup_key.rs                |   2 +-
 src/validators/any.rs            |   6 +-
 src/validators/arguments.rs      |   6 +-
 src/validators/bool.rs           |   6 +-
 src/validators/bytes.rs          |  12 +--
 src/validators/call.rs           |   6 +-
 src/validators/callable.rs       |   6 +-
 src/validators/chain.rs          |   6 +-
 src/validators/custom_error.rs   |   6 +-
 src/validators/dataclass.rs      |  16 ++--
 src/validators/date.rs           |   8 +-
 src/validators/datetime.rs       |  10 +--
 src/validators/decimal.rs        |   8 +-
 src/validators/definitions.rs    |   6 +-
 src/validators/dict.rs           |  23 +++---
 src/validators/float.rs          |  12 +--
 src/validators/frozenset.rs      |   6 +-
 src/validators/function.rs       |  33 ++++----
 src/validators/generator.rs      |   8 +-
 src/validators/int.rs            |  12 +--
 src/validators/is_instance.rs    |   2 +-
 src/validators/is_subclass.rs    |   2 +-
 src/validators/json.rs           |  10 +--
 src/validators/json_or_python.rs |   6 +-
 src/validators/lax_or_strict.rs  |   6 +-
 src/validators/list.rs           |   6 +-
 src/validators/literal.rs        |   8 +-
 src/validators/mod.rs            |   8 +-
 src/validators/model.rs          |  12 +--
 src/validators/model_fields.rs   |   6 +-
 src/validators/none.rs           |   2 +-
 src/validators/nullable.rs       |   6 +-
 src/validators/set.rs            |   6 +-
 src/validators/string.rs         |  12 +--
 src/validators/time.rs           |   6 +-
 src/validators/timedelta.rs      |   6 +-
 src/validators/tuple.rs          |  18 ++---
 src/validators/typed_dict.rs     |   6 +-
 src/validators/union.rs          |  22 +++---
 src/validators/url.rs            |  24 +++---
 src/validators/uuid.rs           |   8 +-
 src/validators/with_default.rs   |   6 +-
 49 files changed, 424 insertions(+), 441 deletions(-)

diff --git a/benches/main.rs b/benches/main.rs
index 5ef9b6898..86812edb2 100644
--- a/benches/main.rs
+++ b/benches/main.rs
@@ -277,11 +277,11 @@ fn dict_value_error(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let validator = build_schema_validator(
             py,
-            r#"{
+            r"{
                 'type': 'dict',
                 'keys_schema': {'type': 'str'},
                 'values_schema': {'type': 'int', 'lt': 0},
-            }"#,
+            }",
         );
 
         let code = format!(
@@ -322,7 +322,7 @@ fn typed_dict_json(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let validator = build_schema_validator(
             py,
-            r#"{
+            r"{
           'type': 'typed-dict',
           'extra_behavior': 'ignore',
           'fields': {
@@ -337,7 +337,7 @@ fn typed_dict_json(bench: &mut Bencher) {
             'i': {'type': 'typed-dict-field', 'schema': {'type': 'int'}},
             'j': {'type': 'typed-dict-field', 'schema': {'type': 'int'}},
           },
-        }"#,
+        }",
         );
 
         let code = r#"{"a": 1, "b": 2, "c": 3, "d": 4, "e": 5, "f": 6, "g": 7, "h": 8, "i": 9, "j": 0}"#.to_string();
@@ -351,7 +351,7 @@ fn typed_dict_python(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let validator = build_schema_validator(
             py,
-            r#"{
+            r"{
           'type': 'typed-dict',
           'extra_behavior': 'ignore',
           'fields': {
@@ -366,7 +366,7 @@ fn typed_dict_python(bench: &mut Bencher) {
             'i': {'type': 'typed-dict-field', 'schema': {'type': 'int'}},
             'j': {'type': 'typed-dict-field', 'schema': {'type': 'int'}},
           },
-        }"#,
+        }",
         );
 
         let code = r#"{"a": 1, "b": 2, "c": 3, "d": 4, "e": 5, "f": 6, "g": 7, "h": 8, "i": 9, "j": 0}"#.to_string();
@@ -384,7 +384,7 @@ fn typed_dict_deep_error(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let validator = build_schema_validator(
             py,
-            r#"{
+            r"{
             'type': 'typed-dict',
             'fields': {
                 'field_a': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
@@ -405,7 +405,7 @@ fn typed_dict_deep_error(bench: &mut Bencher) {
                     }
                 },
             },
-        }"#,
+        }",
         );
 
         let code = "{'field_a': '1', 'field_b': {'field_c': '2', 'field_d': {'field_e': '4', 'field_f': 'xx'}}}";
@@ -557,7 +557,7 @@ fn literal_enums_few_python(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let globals = PyDict::new_bound(py);
         py.run_bound(
-            r#"
+            r"
 from enum import Enum
 
 class Foo(Enum):
@@ -565,7 +565,7 @@ class Foo(Enum):
     v2 = object()
     v3 = object()
     v4 = object()
-"#,
+",
             Some(&globals),
             None,
         )
@@ -682,7 +682,7 @@ fn literal_mixed_few_python(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let globals = PyDict::new_bound(py);
         py.run_bound(
-            r#"
+            r"
 from enum import Enum
 
 class Foo(Enum):
@@ -690,7 +690,7 @@ class Foo(Enum):
     v2 = object()
     v3 = object()
     v4 = object()
-"#,
+",
             Some(&globals),
             None,
         )
diff --git a/src/input/input_abstract.rs b/src/input/input_abstract.rs
index 249161343..4198e7202 100644
--- a/src/input/input_abstract.rs
+++ b/src/input/input_abstract.rs
@@ -46,7 +46,7 @@ impl TryFrom<&str> for InputType {
 /// the convention is to either implement:
 /// * `strict_*` & `lax_*` if they have different behavior
 /// * or, `validate_*` and `strict_*` to just call `validate_*` if the behavior for strict and lax is the same
-pub trait Input<'a>: fmt::Debug + ToPyObject + Into<LocItem> + Sized {
+pub trait Input<'py>: fmt::Debug + ToPyObject + Into<LocItem> + Sized {
     fn as_error_value(&self) -> InputValue;
 
     fn identity(&self) -> Option<usize> {
@@ -57,7 +57,7 @@ pub trait Input<'a>: fmt::Debug + ToPyObject + Into<LocItem> + Sized {
         false
     }
 
-    fn input_is_instance(&self, _class: &Bound<'_, PyType>) -> Option<&Bound<'a, PyAny>> {
+    fn input_is_instance(&self, _class: &Bound<'py, PyType>) -> Option<&Bound<'py, PyAny>> {
         None
     }
 
@@ -65,7 +65,7 @@ pub trait Input<'a>: fmt::Debug + ToPyObject + Into<LocItem> + Sized {
         false
     }
 
-    fn as_kwargs(&self, py: Python<'a>) -> Option<Bound<'a, PyDict>>;
+    fn as_kwargs(&self, py: Python<'py>) -> Option<Bound<'py, PyDict>>;
 
     fn input_is_subclass(&self, _class: &Bound<'_, PyType>) -> PyResult<bool> {
         Ok(false)
@@ -83,23 +83,19 @@ pub trait Input<'a>: fmt::Debug + ToPyObject + Into<LocItem> + Sized {
         false
     }
 
-    fn validate_args(&'a self) -> ValResult<GenericArguments<'a>>;
+    fn validate_args(&self) -> ValResult<GenericArguments<'_>>;
 
-    fn validate_dataclass_args(&'a self, dataclass_name: &str) -> ValResult<GenericArguments<'a>>;
+    fn validate_dataclass_args<'a>(&'a self, dataclass_name: &str) -> ValResult<GenericArguments<'a>>;
 
-    fn validate_str(
-        &'a self,
-        strict: bool,
-        coerce_numbers_to_str: bool,
-    ) -> ValResult<ValidationMatch<EitherString<'a>>>;
+    fn validate_str(&self, strict: bool, coerce_numbers_to_str: bool) -> ValResult<ValidationMatch<EitherString<'_>>>;
 
-    fn validate_bytes(&'a self, strict: bool) -> ValResult<ValidationMatch<EitherBytes<'a>>>;
+    fn validate_bytes<'a>(&'a self, strict: bool) -> ValResult<ValidationMatch<EitherBytes<'a, 'py>>>;
 
     fn validate_bool(&self, strict: bool) -> ValResult<ValidationMatch<bool>>;
 
-    fn validate_int(&'a self, strict: bool) -> ValResult<ValidationMatch<EitherInt<'a>>>;
+    fn validate_int(&self, strict: bool) -> ValResult<ValidationMatch<EitherInt<'_>>>;
 
-    fn exact_int(&'a self) -> ValResult<EitherInt<'a>> {
+    fn exact_int(&self) -> ValResult<EitherInt<'_>> {
         self.validate_int(true).and_then(|val_match| {
             val_match
                 .require_exact()
@@ -109,7 +105,7 @@ pub trait Input<'a>: fmt::Debug + ToPyObject + Into<LocItem> + Sized {
 
     /// Extract a String from the input, only allowing exact
     /// matches for a String (no subclasses)
-    fn exact_str(&'a self) -> ValResult<EitherString<'a>> {
+    fn exact_str(&self) -> ValResult<EitherString<'_>> {
         self.validate_str(true, false).and_then(|val_match| {
             val_match
                 .require_exact()
@@ -117,91 +113,91 @@ pub trait Input<'a>: fmt::Debug + ToPyObject + Into<LocItem> + Sized {
         })
     }
 
-    fn validate_float(&'a self, strict: bool) -> ValResult<ValidationMatch<EitherFloat<'a>>>;
+    fn validate_float(&self, strict: bool) -> ValResult<ValidationMatch<EitherFloat<'_>>>;
 
-    fn validate_decimal(&'a self, strict: bool, py: Python<'a>) -> ValResult<Bound<'a, PyAny>> {
+    fn validate_decimal(&self, strict: bool, py: Python<'py>) -> ValResult<Bound<'py, PyAny>> {
         if strict {
             self.strict_decimal(py)
         } else {
             self.lax_decimal(py)
         }
     }
-    fn strict_decimal(&'a self, py: Python<'a>) -> ValResult<Bound<'a, PyAny>>;
+    fn strict_decimal(&self, py: Python<'py>) -> ValResult<Bound<'py, PyAny>>;
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn lax_decimal(&'a self, py: Python<'a>) -> ValResult<Bound<'a, PyAny>> {
+    fn lax_decimal(&self, py: Python<'py>) -> ValResult<Bound<'py, PyAny>> {
         self.strict_decimal(py)
     }
 
-    fn validate_dict(&'a self, strict: bool) -> ValResult<GenericMapping<'a>> {
+    fn validate_dict<'a>(&'a self, strict: bool) -> ValResult<GenericMapping<'a, 'py>> {
         if strict {
             self.strict_dict()
         } else {
             self.lax_dict()
         }
     }
-    fn strict_dict(&'a self) -> ValResult<GenericMapping<'a>>;
+    fn strict_dict<'a>(&'a self) -> ValResult<GenericMapping<'a, 'py>>;
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn lax_dict(&'a self) -> ValResult<GenericMapping<'a>> {
+    fn lax_dict<'a>(&'a self) -> ValResult<GenericMapping<'a, 'py>> {
         self.strict_dict()
     }
 
-    fn validate_model_fields(&'a self, strict: bool, _from_attributes: bool) -> ValResult<GenericMapping<'a>> {
+    fn validate_model_fields<'a>(&'a self, strict: bool, _from_attributes: bool) -> ValResult<GenericMapping<'a, 'py>> {
         self.validate_dict(strict)
     }
 
-    fn validate_list(&'a self, strict: bool) -> ValResult<GenericIterable<'a>> {
+    fn validate_list<'a>(&'a self, strict: bool) -> ValResult<GenericIterable<'a, 'py>> {
         if strict {
             self.strict_list()
         } else {
             self.lax_list()
         }
     }
-    fn strict_list(&'a self) -> ValResult<GenericIterable<'a>>;
+    fn strict_list<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>>;
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn lax_list(&'a self) -> ValResult<GenericIterable<'a>> {
+    fn lax_list<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
         self.strict_list()
     }
 
-    fn validate_tuple(&'a self, strict: bool) -> ValResult<GenericIterable<'a>> {
+    fn validate_tuple<'a>(&'a self, strict: bool) -> ValResult<GenericIterable<'a, 'py>> {
         if strict {
             self.strict_tuple()
         } else {
             self.lax_tuple()
         }
     }
-    fn strict_tuple(&'a self) -> ValResult<GenericIterable<'a>>;
+    fn strict_tuple<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>>;
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn lax_tuple(&'a self) -> ValResult<GenericIterable<'a>> {
+    fn lax_tuple<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
         self.strict_tuple()
     }
 
-    fn validate_set(&'a self, strict: bool) -> ValResult<GenericIterable<'a>> {
+    fn validate_set<'a>(&'a self, strict: bool) -> ValResult<GenericIterable<'a, 'py>> {
         if strict {
             self.strict_set()
         } else {
             self.lax_set()
         }
     }
-    fn strict_set(&'a self) -> ValResult<GenericIterable<'a>>;
+    fn strict_set<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>>;
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn lax_set(&'a self) -> ValResult<GenericIterable<'a>> {
+    fn lax_set<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
         self.strict_set()
     }
 
-    fn validate_frozenset(&'a self, strict: bool) -> ValResult<GenericIterable<'a>> {
+    fn validate_frozenset<'a>(&'a self, strict: bool) -> ValResult<GenericIterable<'a, 'py>> {
         if strict {
             self.strict_frozenset()
         } else {
             self.lax_frozenset()
         }
     }
-    fn strict_frozenset(&'a self) -> ValResult<GenericIterable<'a>>;
+    fn strict_frozenset<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>>;
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn lax_frozenset(&'a self) -> ValResult<GenericIterable<'a>> {
+    fn lax_frozenset<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
         self.strict_frozenset()
     }
 
-    fn extract_generic_iterable(&'a self) -> ValResult<GenericIterable<'a>>;
+    fn extract_generic_iterable<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>>;
 
     fn validate_iter(&self) -> ValResult<GenericIterator>;
 
@@ -231,9 +227,7 @@ pub trait Input<'a>: fmt::Debug + ToPyObject + Into<LocItem> + Sized {
 /// this trait we abstract over whether the return value from the iterator is owned
 /// or borrowed; all we care about is that we can borrow it again with `borrow_input`
 /// for some lifetime 'a.
-pub trait BorrowInput {
-    type Input<'a>: Input<'a>
-    where
-        Self: 'a;
-    fn borrow_input(&self) -> &Self::Input<'_>;
+pub trait BorrowInput<'py> {
+    type Input: Input<'py>;
+    fn borrow_input(&self) -> &Self::Input;
 }
diff --git a/src/input/input_json.rs b/src/input/input_json.rs
index 6cc21f98c..86cfe69e4 100644
--- a/src/input/input_json.rs
+++ b/src/input/input_json.rs
@@ -37,7 +37,7 @@ impl From<JsonValue> for LocItem {
     }
 }
 
-impl<'a> Input<'a> for JsonValue {
+impl<'py> Input<'py> for JsonValue {
     fn as_error_value(&self) -> InputValue {
         // cloning JsonValue is cheap due to use of Arc
         InputValue::Json(self.clone())
@@ -47,7 +47,7 @@ impl<'a> Input<'a> for JsonValue {
         matches!(self, JsonValue::Null)
     }
 
-    fn as_kwargs(&self, py: Python<'a>) -> Option<Bound<'a, PyDict>> {
+    fn as_kwargs(&self, py: Python<'py>) -> Option<Bound<'py, PyDict>> {
         match self {
             JsonValue::Object(object) => {
                 let dict = PyDict::new_bound(py);
@@ -60,7 +60,7 @@ impl<'a> Input<'a> for JsonValue {
         }
     }
 
-    fn validate_args(&'a self) -> ValResult<GenericArguments<'a>> {
+    fn validate_args(&self) -> ValResult<GenericArguments<'_>> {
         match self {
             JsonValue::Object(object) => Ok(JsonArgs::new(None, Some(object)).into()),
             JsonValue::Array(array) => Ok(JsonArgs::new(Some(array), None).into()),
@@ -68,7 +68,7 @@ impl<'a> Input<'a> for JsonValue {
         }
     }
 
-    fn validate_dataclass_args(&'a self, class_name: &str) -> ValResult<GenericArguments<'a>> {
+    fn validate_dataclass_args<'a>(&'a self, class_name: &str) -> ValResult<GenericArguments<'a>> {
         match self {
             JsonValue::Object(object) => Ok(JsonArgs::new(None, Some(object)).into()),
             _ => {
@@ -84,11 +84,7 @@ impl<'a> Input<'a> for JsonValue {
         }
     }
 
-    fn validate_str(
-        &'a self,
-        strict: bool,
-        coerce_numbers_to_str: bool,
-    ) -> ValResult<ValidationMatch<EitherString<'a>>> {
+    fn validate_str(&self, strict: bool, coerce_numbers_to_str: bool) -> ValResult<ValidationMatch<EitherString<'_>>> {
         // 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
@@ -103,7 +99,7 @@ impl<'a> Input<'a> for JsonValue {
         }
     }
 
-    fn validate_bytes(&'a self, _strict: bool) -> ValResult<ValidationMatch<EitherBytes<'a>>> {
+    fn validate_bytes<'a>(&'a self, _strict: bool) -> ValResult<ValidationMatch<EitherBytes<'a, 'py>>> {
         match self {
             JsonValue::Str(s) => Ok(ValidationMatch::strict(s.as_bytes().into())),
             _ => Err(ValError::new(ErrorTypeDefaults::BytesType, self)),
@@ -126,7 +122,7 @@ impl<'a> Input<'a> for JsonValue {
         }
     }
 
-    fn validate_int(&'a self, strict: bool) -> ValResult<ValidationMatch<EitherInt<'a>>> {
+    fn validate_int(&self, strict: bool) -> ValResult<ValidationMatch<EitherInt<'_>>> {
         match self {
             JsonValue::Int(i) => Ok(ValidationMatch::exact(EitherInt::I64(*i))),
             JsonValue::BigInt(b) => Ok(ValidationMatch::exact(EitherInt::BigInt(b.clone()))),
@@ -137,14 +133,14 @@ impl<'a> Input<'a> for JsonValue {
         }
     }
 
-    fn exact_str(&'a self) -> ValResult<EitherString<'a>> {
+    fn exact_str(&self) -> ValResult<EitherString<'_>> {
         match self {
             JsonValue::Str(s) => Ok(s.as_str().into()),
             _ => Err(ValError::new(ErrorTypeDefaults::StringType, self)),
         }
     }
 
-    fn validate_float(&'a self, strict: bool) -> ValResult<ValidationMatch<EitherFloat<'a>>> {
+    fn validate_float(&self, strict: bool) -> ValResult<ValidationMatch<EitherFloat<'_>>> {
         match self {
             JsonValue::Float(f) => Ok(ValidationMatch::exact(EitherFloat::F64(*f))),
             JsonValue::Int(i) => Ok(ValidationMatch::strict(EitherFloat::F64(*i as f64))),
@@ -154,7 +150,7 @@ impl<'a> Input<'a> for JsonValue {
         }
     }
 
-    fn strict_decimal(&'a self, py: Python<'a>) -> ValResult<Bound<'a, PyAny>> {
+    fn strict_decimal(&self, py: Python<'py>) -> ValResult<Bound<'py, PyAny>> {
         match self {
             JsonValue::Float(f) => create_decimal(&PyString::new_bound(py, &f.to_string()), self),
 
@@ -165,29 +161,29 @@ impl<'a> Input<'a> for JsonValue {
         }
     }
 
-    fn validate_dict(&'a self, _strict: bool) -> ValResult<GenericMapping<'a>> {
+    fn validate_dict<'a>(&'a self, _strict: bool) -> ValResult<GenericMapping<'a, 'py>> {
         match self {
             JsonValue::Object(dict) => Ok(dict.into()),
             _ => Err(ValError::new(ErrorTypeDefaults::DictType, self)),
         }
     }
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn strict_dict(&'a self) -> ValResult<GenericMapping<'a>> {
+    fn strict_dict<'a>(&'a self) -> ValResult<GenericMapping<'a, 'py>> {
         self.validate_dict(false)
     }
 
-    fn validate_list(&'a self, _strict: bool) -> ValResult<GenericIterable<'a>> {
+    fn validate_list<'a>(&'a self, _strict: bool) -> ValResult<GenericIterable<'a, 'py>> {
         match self {
             JsonValue::Array(a) => Ok(GenericIterable::JsonArray(a)),
             _ => Err(ValError::new(ErrorTypeDefaults::ListType, self)),
         }
     }
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn strict_list(&'a self) -> ValResult<GenericIterable<'a>> {
+    fn strict_list<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
         self.validate_list(false)
     }
 
-    fn validate_tuple(&'a self, _strict: bool) -> ValResult<GenericIterable<'a>> {
+    fn validate_tuple<'a>(&'a self, _strict: bool) -> ValResult<GenericIterable<'a, 'py>> {
         // just as in set's case, List has to be allowed
         match self {
             JsonValue::Array(a) => Ok(GenericIterable::JsonArray(a)),
@@ -195,11 +191,11 @@ impl<'a> Input<'a> for JsonValue {
         }
     }
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn strict_tuple(&'a self) -> ValResult<GenericIterable<'a>> {
+    fn strict_tuple<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
         self.validate_tuple(false)
     }
 
-    fn validate_set(&'a self, _strict: bool) -> ValResult<GenericIterable<'a>> {
+    fn validate_set<'a>(&'a self, _strict: bool) -> ValResult<GenericIterable<'a, 'py>> {
         // we allow a list here since otherwise it would be impossible to create a set from JSON
         match self {
             JsonValue::Array(a) => Ok(GenericIterable::JsonArray(a)),
@@ -207,11 +203,11 @@ impl<'a> Input<'a> for JsonValue {
         }
     }
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn strict_set(&'a self) -> ValResult<GenericIterable<'a>> {
+    fn strict_set<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
         self.validate_set(false)
     }
 
-    fn validate_frozenset(&'a self, _strict: bool) -> ValResult<GenericIterable<'a>> {
+    fn validate_frozenset<'a>(&'a self, _strict: bool) -> ValResult<GenericIterable<'a, 'py>> {
         // we allow a list here since otherwise it would be impossible to create a frozenset from JSON
         match self {
             JsonValue::Array(a) => Ok(GenericIterable::JsonArray(a)),
@@ -219,11 +215,11 @@ impl<'a> Input<'a> for JsonValue {
         }
     }
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn strict_frozenset(&'a self) -> ValResult<GenericIterable<'a>> {
+    fn strict_frozenset<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
         self.validate_frozenset(false)
     }
 
-    fn extract_generic_iterable(&self) -> ValResult<GenericIterable> {
+    fn extract_generic_iterable(&self) -> ValResult<GenericIterable<'_, 'py>> {
         match self {
             JsonValue::Array(a) => Ok(GenericIterable::JsonArray(a)),
             JsonValue::Str(s) => Ok(GenericIterable::JsonString(s)),
@@ -312,32 +308,32 @@ impl<'a> Input<'a> for JsonValue {
     }
 }
 
-impl BorrowInput for &'_ JsonValue {
-    type Input<'a> = JsonValue where Self: 'a;
-    fn borrow_input(&self) -> &Self::Input<'_> {
+impl BorrowInput<'_> for &'_ JsonValue {
+    type Input = JsonValue;
+    fn borrow_input(&self) -> &Self::Input {
         self
     }
 }
 
 /// Required for JSON Object keys so the string can behave like an Input
-impl<'a> Input<'a> for String {
+impl<'py> Input<'py> for String {
     fn as_error_value(&self) -> InputValue {
         // Justification for the clone: this is on the error pathway and we are generally ok
         // with errors having a performance penalty
         InputValue::Json(JsonValue::Str(self.clone()))
     }
 
-    fn as_kwargs(&self, _py: Python<'a>) -> Option<Bound<'a, PyDict>> {
+    fn as_kwargs(&self, _py: Python<'py>) -> Option<Bound<'py, PyDict>> {
         None
     }
 
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn validate_args(&'a self) -> ValResult<GenericArguments<'a>> {
+    fn validate_args(&self) -> ValResult<GenericArguments<'_>> {
         Err(ValError::new(ErrorTypeDefaults::ArgumentsType, self))
     }
 
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn validate_dataclass_args(&'a self, class_name: &str) -> ValResult<GenericArguments<'a>> {
+    fn validate_dataclass_args<'a>(&'a self, class_name: &str) -> ValResult<GenericArguments<'a>> {
         let class_name = class_name.to_string();
         Err(ValError::new(
             ErrorType::DataclassType {
@@ -349,10 +345,10 @@ impl<'a> Input<'a> for String {
     }
 
     fn validate_str(
-        &'a self,
+        &self,
         _strict: bool,
         _coerce_numbers_to_str: bool,
-    ) -> ValResult<ValidationMatch<EitherString<'a>>> {
+    ) -> ValResult<ValidationMatch<EitherString<'_>>> {
         // 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
@@ -361,7 +357,7 @@ impl<'a> Input<'a> for String {
         Ok(ValidationMatch::strict(self.as_str().into()))
     }
 
-    fn validate_bytes(&'a self, _strict: bool) -> ValResult<ValidationMatch<EitherBytes<'a>>> {
+    fn validate_bytes<'a>(&'a self, _strict: bool) -> ValResult<ValidationMatch<EitherBytes<'a, 'py>>> {
         Ok(ValidationMatch::strict(self.as_bytes().into()))
     }
 
@@ -369,44 +365,44 @@ impl<'a> Input<'a> for String {
         str_as_bool(self, self).map(ValidationMatch::lax)
     }
 
-    fn validate_int(&'a self, _strict: bool) -> ValResult<ValidationMatch<EitherInt<'a>>> {
+    fn validate_int(&self, _strict: bool) -> ValResult<ValidationMatch<EitherInt<'_>>> {
         str_as_int(self, self).map(ValidationMatch::lax)
     }
 
-    fn validate_float(&'a self, _strict: bool) -> ValResult<ValidationMatch<EitherFloat<'a>>> {
+    fn validate_float(&self, _strict: bool) -> ValResult<ValidationMatch<EitherFloat<'_>>> {
         str_as_float(self, self).map(ValidationMatch::lax)
     }
 
-    fn strict_decimal(&'a self, py: Python<'a>) -> ValResult<Bound<'a, PyAny>> {
+    fn strict_decimal(&self, py: Python<'py>) -> ValResult<Bound<'py, PyAny>> {
         create_decimal(self.to_object(py).bind(py), self)
     }
 
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn strict_dict(&'a self) -> ValResult<GenericMapping<'a>> {
+    fn strict_dict<'a>(&'a self) -> ValResult<GenericMapping<'a, 'py>> {
         Err(ValError::new(ErrorTypeDefaults::DictType, self))
     }
 
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn strict_list(&'a self) -> ValResult<GenericIterable<'a>> {
+    fn strict_list<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
         Err(ValError::new(ErrorTypeDefaults::ListType, self))
     }
 
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn strict_tuple(&'a self) -> ValResult<GenericIterable<'a>> {
+    fn strict_tuple<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
         Err(ValError::new(ErrorTypeDefaults::TupleType, self))
     }
 
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn strict_set(&'a self) -> ValResult<GenericIterable<'a>> {
+    fn strict_set<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
         Err(ValError::new(ErrorTypeDefaults::SetType, self))
     }
 
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn strict_frozenset(&'a self) -> ValResult<GenericIterable<'a>> {
+    fn strict_frozenset<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
         Err(ValError::new(ErrorTypeDefaults::FrozenSetType, self))
     }
 
-    fn extract_generic_iterable(&'a self) -> ValResult<GenericIterable<'a>> {
+    fn extract_generic_iterable<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
         Ok(GenericIterable::JsonString(self))
     }
 
@@ -443,16 +439,16 @@ impl<'a> Input<'a> for String {
     }
 }
 
-impl BorrowInput for &'_ String {
-    type Input<'a> = String where Self: 'a;
-    fn borrow_input(&self) -> &Self::Input<'_> {
+impl BorrowInput<'_> for &'_ String {
+    type Input = String;
+    fn borrow_input(&self) -> &Self::Input {
         self
     }
 }
 
-impl BorrowInput for String {
-    type Input<'a> = String where Self: 'a;
-    fn borrow_input(&self) -> &Self::Input<'_> {
+impl BorrowInput<'_> for String {
+    type Input = String;
+    fn borrow_input(&self) -> &Self::Input {
         self
     }
 }
diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index 471eb8de7..c74942cae 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -110,7 +110,7 @@ impl From<Bound<'_, PyAny>> for LocItem {
     }
 }
 
-impl<'a> Input<'a> for Bound<'a, PyAny> {
+impl<'py> Input<'py> for Bound<'py, PyAny> {
     fn as_error_value(&self) -> InputValue {
         InputValue::Python(self.clone().into())
     }
@@ -123,7 +123,7 @@ impl<'a> Input<'a> for Bound<'a, PyAny> {
         PyAnyMethods::is_none(self)
     }
 
-    fn input_is_instance(&self, class: &Bound<'_, PyType>) -> Option<&Bound<'a, PyAny>> {
+    fn input_is_instance(&self, class: &Bound<'py, PyType>) -> Option<&Bound<'py, PyAny>> {
         if self.is_instance(class).unwrap_or(false) {
             Some(self)
         } else {
@@ -135,8 +135,10 @@ impl<'a> Input<'a> for Bound<'a, PyAny> {
         true
     }
 
-    fn as_kwargs(&self, _py: Python<'a>) -> Option<Bound<'a, PyDict>> {
-        self.downcast::<PyDict>().ok().map(Clone::clone)
+    fn as_kwargs(&self, py: Python<'py>) -> Option<Bound<'py, PyDict>> {
+        self.downcast::<PyDict>()
+            .ok()
+            .map(|dict| dict.to_owned().unbind().into_bound(py))
     }
 
     fn input_is_subclass(&self, class: &Bound<'_, PyType>) -> PyResult<bool> {
@@ -158,7 +160,7 @@ impl<'a> Input<'a> for Bound<'a, PyAny> {
         self.is_callable()
     }
 
-    fn validate_args(&'a self) -> ValResult<GenericArguments<'a>> {
+    fn validate_args(&self) -> ValResult<GenericArguments<'_>> {
         if let Ok(dict) = self.downcast::<PyDict>() {
             Ok(PyArgs::new(None, Some(dict.clone())).into())
         } else if let Ok(args_kwargs) = self.extract::<ArgsKwargs>() {
@@ -174,7 +176,7 @@ impl<'a> Input<'a> for Bound<'a, PyAny> {
         }
     }
 
-    fn validate_dataclass_args(&'a self, class_name: &str) -> ValResult<GenericArguments<'a>> {
+    fn validate_dataclass_args<'a>(&'a self, class_name: &str) -> ValResult<GenericArguments<'a>> {
         if let Ok(dict) = self.downcast::<PyDict>() {
             Ok(PyArgs::new(None, Some(dict.clone())).into())
         } else if let Ok(args_kwargs) = self.extract::<ArgsKwargs>() {
@@ -193,11 +195,7 @@ impl<'a> Input<'a> for Bound<'a, PyAny> {
         }
     }
 
-    fn validate_str(
-        &'a self,
-        strict: bool,
-        coerce_numbers_to_str: bool,
-    ) -> ValResult<ValidationMatch<EitherString<'a>>> {
+    fn validate_str(&self, strict: bool, coerce_numbers_to_str: bool) -> ValResult<ValidationMatch<EitherString<'_>>> {
         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>() {
@@ -244,7 +242,7 @@ impl<'a> Input<'a> for Bound<'a, PyAny> {
         Err(ValError::new(ErrorTypeDefaults::StringType, self))
     }
 
-    fn validate_bytes(&'a self, strict: bool) -> ValResult<ValidationMatch<EitherBytes<'a>>> {
+    fn validate_bytes<'a>(&'a self, strict: bool) -> ValResult<ValidationMatch<EitherBytes<'a, 'py>>> {
         if let Ok(py_bytes) = self.downcast_exact::<PyBytes>() {
             return Ok(ValidationMatch::exact(py_bytes.into()));
         } else if let Ok(py_bytes) = self.downcast::<PyBytes>() {
@@ -291,7 +289,7 @@ impl<'a> Input<'a> for Bound<'a, PyAny> {
         Err(ValError::new(ErrorTypeDefaults::BoolType, self))
     }
 
-    fn validate_int(&'a self, strict: bool) -> ValResult<ValidationMatch<EitherInt<'a>>> {
+    fn validate_int(&self, strict: bool) -> ValResult<ValidationMatch<EitherInt<'_>>> {
         if self.is_exact_instance_of::<PyInt>() {
             return Ok(ValidationMatch::exact(EitherInt::Py(self.clone())));
         } else if self.is_instance_of::<PyInt>() {
@@ -331,7 +329,7 @@ impl<'a> Input<'a> for Bound<'a, PyAny> {
         Err(ValError::new(ErrorTypeDefaults::IntType, self))
     }
 
-    fn exact_int(&'a self) -> ValResult<EitherInt<'a>> {
+    fn exact_int(&self) -> ValResult<EitherInt<'_>> {
         if self.is_exact_instance_of::<PyInt>() {
             Ok(EitherInt::Py(self.clone()))
         } else {
@@ -339,7 +337,7 @@ impl<'a> Input<'a> for Bound<'a, PyAny> {
         }
     }
 
-    fn exact_str(&'a self) -> ValResult<EitherString<'a>> {
+    fn exact_str(&self) -> ValResult<EitherString<'_>> {
         if let Ok(py_str) = self.downcast_exact() {
             Ok(EitherString::Py(py_str.clone()))
         } else {
@@ -347,7 +345,7 @@ impl<'a> Input<'a> for Bound<'a, PyAny> {
         }
     }
 
-    fn validate_float(&'a self, strict: bool) -> ValResult<ValidationMatch<EitherFloat<'a>>> {
+    fn validate_float(&self, strict: bool) -> ValResult<ValidationMatch<EitherFloat<'_>>> {
         if let Ok(float) = self.downcast_exact::<PyFloat>() {
             return Ok(ValidationMatch::exact(EitherFloat::Py(float.clone())));
         }
@@ -374,11 +372,11 @@ impl<'a> Input<'a> for Bound<'a, PyAny> {
         Err(ValError::new(ErrorTypeDefaults::FloatType, self))
     }
 
-    fn strict_decimal(&'a self, py: Python<'a>) -> ValResult<Bound<'a, PyAny>> {
+    fn strict_decimal(&self, py: Python<'py>) -> ValResult<Bound<'py, PyAny>> {
         let decimal_type = get_decimal_type(py);
         // Fast path for existing decimal objects
         if self.is_exact_instance(decimal_type) {
-            return Ok(self.clone());
+            return Ok(self.to_owned());
         }
 
         // Try subclasses of decimals, they will be upcast to Decimal
@@ -395,11 +393,11 @@ impl<'a> Input<'a> for Bound<'a, PyAny> {
         ))
     }
 
-    fn lax_decimal(&'a self, py: Python<'a>) -> ValResult<Bound<'a, PyAny>> {
+    fn lax_decimal(&self, py: Python<'py>) -> ValResult<Bound<'py, PyAny>> {
         let decimal_type = get_decimal_type(py);
         // Fast path for existing decimal objects
         if self.is_exact_instance(decimal_type) {
-            return Ok(self.clone());
+            return Ok(self.to_owned().clone());
         }
 
         if self.is_instance_of::<PyString>() || (self.is_instance_of::<PyInt>() && !self.is_instance_of::<PyBool>()) {
@@ -415,37 +413,37 @@ impl<'a> Input<'a> for Bound<'a, PyAny> {
         }
     }
 
-    fn strict_dict(&'a self) -> ValResult<GenericMapping<'a>> {
+    fn strict_dict<'a>(&'a self) -> ValResult<GenericMapping<'a, 'py>> {
         if let Ok(dict) = self.downcast::<PyDict>() {
-            Ok(dict.clone().into())
+            Ok(dict.into())
         } else {
             Err(ValError::new(ErrorTypeDefaults::DictType, self))
         }
     }
 
-    fn lax_dict(&'a self) -> ValResult<GenericMapping<'a>> {
+    fn lax_dict<'a>(&'a self) -> ValResult<GenericMapping<'a, 'py>> {
         if let Ok(dict) = self.downcast::<PyDict>() {
-            Ok(dict.clone().into())
+            Ok(dict.into())
         } else if let Ok(mapping) = self.downcast::<PyMapping>() {
-            Ok(mapping.clone().into())
+            Ok(mapping.into())
         } else {
             Err(ValError::new(ErrorTypeDefaults::DictType, self))
         }
     }
 
-    fn validate_model_fields(&'a self, strict: bool, from_attributes: bool) -> ValResult<GenericMapping<'a>> {
+    fn validate_model_fields<'a>(&'a self, strict: bool, from_attributes: bool) -> ValResult<GenericMapping<'a, 'py>> {
         if from_attributes {
             // if from_attributes, first try a dict, then mapping then from_attributes
             if let Ok(dict) = self.downcast::<PyDict>() {
-                return Ok(dict.clone().into());
+                return Ok(dict.into());
             } else if !strict {
                 if let Ok(mapping) = self.downcast::<PyMapping>() {
-                    return Ok(mapping.clone().into());
+                    return Ok(mapping.into());
                 }
             }
 
             if from_attributes_applicable(self) {
-                Ok(self.clone().into())
+                Ok(GenericMapping::PyGetAttr(self.to_owned(), None))
             } else if let Ok((obj, kwargs)) = self.extract() {
                 if from_attributes_applicable(&obj) {
                     Ok(GenericMapping::PyGetAttr(obj, Some(kwargs)))
@@ -463,14 +461,14 @@ impl<'a> Input<'a> for Bound<'a, PyAny> {
         }
     }
 
-    fn strict_list(&'a self) -> ValResult<GenericIterable<'a>> {
+    fn strict_list<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
         match self.lax_list()? {
             GenericIterable::List(iter) => Ok(GenericIterable::List(iter)),
             _ => Err(ValError::new(ErrorTypeDefaults::ListType, self)),
         }
     }
 
-    fn lax_list(&'a self) -> ValResult<GenericIterable<'a>> {
+    fn lax_list<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
         match self
             .extract_generic_iterable()
             .map_err(|_| ValError::new(ErrorTypeDefaults::ListType, self))?
@@ -483,14 +481,14 @@ impl<'a> Input<'a> for Bound<'a, PyAny> {
         }
     }
 
-    fn strict_tuple(&'a self) -> ValResult<GenericIterable<'a>> {
+    fn strict_tuple<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
         match self.lax_tuple()? {
             GenericIterable::Tuple(iter) => Ok(GenericIterable::Tuple(iter)),
             _ => Err(ValError::new(ErrorTypeDefaults::TupleType, self)),
         }
     }
 
-    fn lax_tuple(&'a self) -> ValResult<GenericIterable<'a>> {
+    fn lax_tuple<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
         match self
             .extract_generic_iterable()
             .map_err(|_| ValError::new(ErrorTypeDefaults::TupleType, self))?
@@ -503,14 +501,14 @@ impl<'a> Input<'a> for Bound<'a, PyAny> {
         }
     }
 
-    fn strict_set(&'a self) -> ValResult<GenericIterable<'a>> {
+    fn strict_set<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
         match self.lax_set()? {
             GenericIterable::Set(iter) => Ok(GenericIterable::Set(iter)),
             _ => Err(ValError::new(ErrorTypeDefaults::SetType, self)),
         }
     }
 
-    fn lax_set(&'a self) -> ValResult<GenericIterable<'a>> {
+    fn lax_set<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
         match self
             .extract_generic_iterable()
             .map_err(|_| ValError::new(ErrorTypeDefaults::SetType, self))?
@@ -523,14 +521,14 @@ impl<'a> Input<'a> for Bound<'a, PyAny> {
         }
     }
 
-    fn strict_frozenset(&'a self) -> ValResult<GenericIterable<'a>> {
+    fn strict_frozenset<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
         match self.lax_frozenset()? {
             GenericIterable::FrozenSet(iter) => Ok(GenericIterable::FrozenSet(iter)),
             _ => Err(ValError::new(ErrorTypeDefaults::FrozenSetType, self)),
         }
     }
 
-    fn lax_frozenset(&'a self) -> ValResult<GenericIterable<'a>> {
+    fn lax_frozenset<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
         match self
             .extract_generic_iterable()
             .map_err(|_| ValError::new(ErrorTypeDefaults::FrozenSetType, self))?
@@ -543,18 +541,18 @@ impl<'a> Input<'a> for Bound<'a, PyAny> {
         }
     }
 
-    fn extract_generic_iterable(&'a self) -> ValResult<GenericIterable<'a>> {
+    fn extract_generic_iterable<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
         // Handle concrete non-overlapping types first, then abstract types
         if let Ok(iterable) = self.downcast::<PyList>() {
-            Ok(GenericIterable::List(iterable.clone()))
+            Ok(GenericIterable::List(iterable))
         } else if let Ok(iterable) = self.downcast::<PyTuple>() {
-            Ok(GenericIterable::Tuple(iterable.clone()))
+            Ok(GenericIterable::Tuple(iterable))
         } else if let Ok(iterable) = self.downcast::<PySet>() {
-            Ok(GenericIterable::Set(iterable.clone()))
+            Ok(GenericIterable::Set(iterable))
         } else if let Ok(iterable) = self.downcast::<PyFrozenSet>() {
-            Ok(GenericIterable::FrozenSet(iterable.clone()))
+            Ok(GenericIterable::FrozenSet(iterable))
         } else if let Ok(iterable) = self.downcast::<PyDict>() {
-            Ok(GenericIterable::Dict(iterable.clone()))
+            Ok(GenericIterable::Dict(iterable))
         } else if let Some(iterable) = extract_dict_keys!(self.py(), self) {
             Ok(GenericIterable::DictKeys(iterable))
         } else if let Some(iterable) = extract_dict_values!(self.py(), self) {
@@ -562,15 +560,15 @@ impl<'a> Input<'a> for Bound<'a, PyAny> {
         } else if let Some(iterable) = extract_dict_items!(self.py(), self) {
             Ok(GenericIterable::DictItems(iterable))
         } else if let Ok(iterable) = self.downcast::<PyMapping>() {
-            Ok(GenericIterable::Mapping(iterable.clone()))
+            Ok(GenericIterable::Mapping(iterable))
         } else if let Ok(iterable) = self.downcast::<PyString>() {
-            Ok(GenericIterable::PyString(iterable.clone()))
+            Ok(GenericIterable::PyString(iterable))
         } else if let Ok(iterable) = self.downcast::<PyBytes>() {
-            Ok(GenericIterable::Bytes(iterable.clone()))
+            Ok(GenericIterable::Bytes(iterable))
         } else if let Ok(iterable) = self.downcast::<PyByteArray>() {
-            Ok(GenericIterable::PyByteArray(iterable.clone()))
+            Ok(GenericIterable::PyByteArray(iterable))
         } else if let Ok(iterable) = self.downcast::<PySequence>() {
-            Ok(GenericIterable::Sequence(iterable.clone()))
+            Ok(GenericIterable::Sequence(iterable))
         } else if let Ok(iterable) = self.iter() {
             Ok(GenericIterable::Iterator(iterable))
         } else {
@@ -719,16 +717,16 @@ impl<'a> Input<'a> for Bound<'a, PyAny> {
     }
 }
 
-impl BorrowInput for Bound<'_, PyAny> {
-    type Input<'a> = Bound<'a, PyAny> where Self: 'a;
-    fn borrow_input(&self) -> &Self::Input<'_> {
+impl<'py> BorrowInput<'py> for Bound<'py, PyAny> {
+    type Input = Bound<'py, PyAny>;
+    fn borrow_input(&self) -> &Self::Input {
         self
     }
 }
 
-impl BorrowInput for Borrowed<'_, '_, PyAny> {
-    type Input<'a> = Bound<'a, PyAny> where Self: 'a;
-    fn borrow_input(&self) -> &Self::Input<'_> {
+impl<'py> BorrowInput<'py> for Borrowed<'_, 'py, PyAny> {
+    type Input = Bound<'py, PyAny>;
+    fn borrow_input(&self) -> &Self::Input {
         self
     }
 }
diff --git a/src/input/input_string.rs b/src/input/input_string.rs
index 6cc0226ac..61a41cd34 100644
--- a/src/input/input_string.rs
+++ b/src/input/input_string.rs
@@ -61,7 +61,7 @@ impl From<StringMapping<'_>> for LocItem {
     }
 }
 
-impl<'a> Input<'a> for StringMapping<'a> {
+impl<'py> Input<'py> for StringMapping<'py> {
     fn as_error_value(&self) -> InputValue {
         match self {
             Self::String(s) => s.as_error_value(),
@@ -69,16 +69,16 @@ impl<'a> Input<'a> for StringMapping<'a> {
         }
     }
 
-    fn as_kwargs(&self, _py: Python<'a>) -> Option<Bound<'a, PyDict>> {
+    fn as_kwargs(&self, _py: Python<'py>) -> Option<Bound<'py, PyDict>> {
         None
     }
 
-    fn validate_args(&'a self) -> ValResult<GenericArguments<'a>> {
+    fn validate_args(&self) -> ValResult<GenericArguments<'_>> {
         // do we want to support this?
         Err(ValError::new(ErrorTypeDefaults::ArgumentsType, self))
     }
 
-    fn validate_dataclass_args(&'a self, _dataclass_name: &str) -> ValResult<GenericArguments<'a>> {
+    fn validate_dataclass_args<'a>(&'a self, _dataclass_name: &str) -> ValResult<GenericArguments<'a>> {
         match self {
             StringMapping::String(_) => Err(ValError::new(ErrorTypeDefaults::ArgumentsType, self)),
             StringMapping::Mapping(m) => Ok(GenericArguments::StringMapping(m.clone())),
@@ -86,17 +86,17 @@ impl<'a> Input<'a> for StringMapping<'a> {
     }
 
     fn validate_str(
-        &'a self,
+        &self,
         _strict: bool,
         _coerce_numbers_to_str: bool,
-    ) -> ValResult<ValidationMatch<EitherString<'a>>> {
+    ) -> ValResult<ValidationMatch<EitherString<'_>>> {
         match self {
             Self::String(s) => Ok(ValidationMatch::strict(s.clone().into())),
             Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::StringType, self)),
         }
     }
 
-    fn validate_bytes(&'a self, _strict: bool) -> ValResult<ValidationMatch<EitherBytes<'a>>> {
+    fn validate_bytes<'a>(&'a self, _strict: bool) -> ValResult<ValidationMatch<EitherBytes<'a, 'py>>> {
         match self {
             Self::String(s) => py_string_str(s).map(|b| ValidationMatch::strict(b.as_bytes().into())),
             Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::BytesType, self)),
@@ -110,51 +110,51 @@ impl<'a> Input<'a> for StringMapping<'a> {
         }
     }
 
-    fn validate_int(&'a self, _strict: bool) -> ValResult<ValidationMatch<EitherInt<'a>>> {
+    fn validate_int(&self, _strict: bool) -> ValResult<ValidationMatch<EitherInt<'_>>> {
         match self {
             Self::String(s) => str_as_int(self, py_string_str(s)?).map(ValidationMatch::strict),
             Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::IntType, self)),
         }
     }
 
-    fn validate_float(&'a self, _strict: bool) -> ValResult<ValidationMatch<EitherFloat<'a>>> {
+    fn validate_float(&self, _strict: bool) -> ValResult<ValidationMatch<EitherFloat<'_>>> {
         match self {
             Self::String(s) => str_as_float(self, py_string_str(s)?).map(ValidationMatch::strict),
             Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::FloatType, self)),
         }
     }
 
-    fn strict_decimal(&'a self, _py: Python<'a>) -> ValResult<Bound<'a, PyAny>> {
+    fn strict_decimal(&self, _py: Python<'py>) -> ValResult<Bound<'py, PyAny>> {
         match self {
             Self::String(s) => create_decimal(s, self),
             Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::DecimalType, self)),
         }
     }
 
-    fn strict_dict(&'a self) -> ValResult<GenericMapping<'a>> {
+    fn strict_dict<'a>(&'a self) -> ValResult<GenericMapping<'a, 'py>> {
         match self {
             Self::String(_) => Err(ValError::new(ErrorTypeDefaults::DictType, self)),
-            Self::Mapping(d) => Ok(GenericMapping::StringMapping(d.clone())),
+            Self::Mapping(d) => Ok(GenericMapping::StringMapping(d)),
         }
     }
 
-    fn strict_list(&'a self) -> ValResult<GenericIterable<'a>> {
+    fn strict_list<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
         Err(ValError::new(ErrorTypeDefaults::ListType, self))
     }
 
-    fn strict_tuple(&'a self) -> ValResult<GenericIterable<'a>> {
+    fn strict_tuple<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
         Err(ValError::new(ErrorTypeDefaults::TupleType, self))
     }
 
-    fn strict_set(&'a self) -> ValResult<GenericIterable<'a>> {
+    fn strict_set<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
         Err(ValError::new(ErrorTypeDefaults::SetType, self))
     }
 
-    fn strict_frozenset(&'a self) -> ValResult<GenericIterable<'a>> {
+    fn strict_frozenset<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
         Err(ValError::new(ErrorTypeDefaults::FrozenSetType, self))
     }
 
-    fn extract_generic_iterable(&'a self) -> ValResult<GenericIterable<'a>> {
+    fn extract_generic_iterable<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
         Err(ValError::new(ErrorTypeDefaults::IterableType, self))
     }
 
@@ -206,9 +206,9 @@ impl<'a> Input<'a> for StringMapping<'a> {
     }
 }
 
-impl BorrowInput for StringMapping<'_> {
-    type Input<'a> = StringMapping<'a> where Self: 'a;
-    fn borrow_input(&self) -> &Self::Input<'_> {
+impl<'py> BorrowInput<'py> for StringMapping<'py> {
+    type Input = Self;
+    fn borrow_input(&self) -> &Self::Input {
         self
     }
 }
diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index 9e881c10d..b365500e0 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -64,36 +64,36 @@ impl<T> ValidationMatch<T> {
 /// can mostly be converted to each other in lax mode.
 /// This mostly matches python's definition of `Collection`.
 #[cfg_attr(debug_assertions, derive(Debug))]
-pub enum GenericIterable<'a> {
-    List(Bound<'a, PyList>),
-    Tuple(Bound<'a, PyTuple>),
-    Set(Bound<'a, PySet>),
-    FrozenSet(Bound<'a, PyFrozenSet>),
-    Dict(Bound<'a, PyDict>),
+pub enum GenericIterable<'a, 'py> {
+    List(&'a Bound<'py, PyList>),
+    Tuple(&'a Bound<'py, PyTuple>),
+    Set(&'a Bound<'py, PySet>),
+    FrozenSet(&'a Bound<'py, PyFrozenSet>),
+    Dict(&'a Bound<'py, PyDict>),
     // Treat dict values / keys / items as generic iterators
     // since PyPy doesn't export the concrete types
-    DictKeys(Bound<'a, PyIterator>),
-    DictValues(Bound<'a, PyIterator>),
-    DictItems(Bound<'a, PyIterator>),
-    Mapping(Bound<'a, PyMapping>),
-    PyString(Bound<'a, PyString>),
-    Bytes(Bound<'a, PyBytes>),
-    PyByteArray(Bound<'a, PyByteArray>),
-    Sequence(Bound<'a, PySequence>),
-    Iterator(Bound<'a, PyIterator>),
+    DictKeys(Bound<'py, PyIterator>),
+    DictValues(Bound<'py, PyIterator>),
+    DictItems(Bound<'py, PyIterator>),
+    Mapping(&'a Bound<'py, PyMapping>),
+    PyString(&'a Bound<'py, PyString>),
+    Bytes(&'a Bound<'py, PyBytes>),
+    PyByteArray(&'a Bound<'py, PyByteArray>),
+    Sequence(&'a Bound<'py, PySequence>),
+    Iterator(Bound<'py, PyIterator>),
     JsonArray(&'a [JsonValue]),
     JsonObject(&'a JsonObject),
     JsonString(&'a String),
 }
 
-impl<'a, 'py: 'a> GenericIterable<'a> {
+impl<'py> GenericIterable<'_, 'py> {
     pub fn as_sequence_iterator(
         &self,
         py: Python<'py>,
-    ) -> PyResult<Box<dyn Iterator<Item = PyResult<Bound<'a, PyAny>>> + 'a>> {
+    ) -> PyResult<Box<dyn Iterator<Item = PyResult<Bound<'py, PyAny>>> + '_>> {
         match self {
-            GenericIterable::List(iter) => Ok(Box::new(iter.clone().into_iter().map(Ok))),
-            GenericIterable::Tuple(iter) => Ok(Box::new(iter.clone().into_iter().map(Ok))),
+            GenericIterable::List(iter) => Ok(Box::new(iter.iter().map(Ok))),
+            GenericIterable::Tuple(iter) => Ok(Box::new(iter.iter().map(Ok))),
             GenericIterable::Set(iter) => Ok(Box::new(iter.iter().map(Ok))),
             GenericIterable::FrozenSet(iter) => Ok(Box::new(iter.iter().map(Ok))),
             // Note that this iterates over only the keys, just like doing iter({}) in Python
@@ -130,7 +130,7 @@ struct MaxLengthCheck<'a, INPUT> {
     actual_length: Option<usize>,
 }
 
-impl<'a, INPUT: Input<'a>> MaxLengthCheck<'a, INPUT> {
+impl<'a, INPUT> MaxLengthCheck<'a, INPUT> {
     fn new(max_length: Option<usize>, field_type: &'a str, input: &'a INPUT, actual_length: Option<usize>) -> Self {
         Self {
             current_length: 0,
@@ -140,7 +140,9 @@ impl<'a, INPUT: Input<'a>> MaxLengthCheck<'a, INPUT> {
             actual_length,
         }
     }
+}
 
+impl<'a, INPUT: Input<'a>> MaxLengthCheck<'_, INPUT> {
     fn incr(&mut self) -> ValResult<()> {
         if let Some(max_length) = self.max_length {
             self.current_length += 1;
@@ -176,9 +178,9 @@ macro_rules! any_next_error {
 #[allow(clippy::too_many_arguments)]
 fn validate_iter_to_vec<'a, 's>(
     py: Python<'a>,
-    iter: impl Iterator<Item = PyResult<impl BorrowInput>>,
+    iter: impl Iterator<Item = PyResult<impl BorrowInput<'a>>>,
     capacity: usize,
-    mut max_length_check: MaxLengthCheck<'a, impl Input<'a>>,
+    mut max_length_check: MaxLengthCheck<'_, impl Input<'a>>,
     validator: &'s CombinedValidator,
     state: &mut ValidationState,
 ) -> ValResult<Vec<PyObject>> {
@@ -241,8 +243,8 @@ impl BuildSet for Bound<'_, PyFrozenSet> {
 fn validate_iter_to_set<'a, 's>(
     py: Python<'a>,
     set: &impl BuildSet,
-    iter: impl Iterator<Item = PyResult<impl BorrowInput>>,
-    input: &'a (impl Input<'a> + 'a),
+    iter: impl Iterator<Item = PyResult<impl BorrowInput<'a>>>,
+    input: &impl Input<'a>,
     field_type: &'static str,
     max_length: Option<usize>,
     validator: &'s CombinedValidator,
@@ -286,11 +288,11 @@ fn validate_iter_to_set<'a, 's>(
     }
 }
 
-fn no_validator_iter_to_vec<'a, 's>(
-    py: Python<'a>,
-    input: &'a (impl Input<'a> + 'a),
-    iter: impl Iterator<Item = PyResult<impl BorrowInput>>,
-    mut max_length_check: MaxLengthCheck<'a, impl Input<'a>>,
+fn no_validator_iter_to_vec<'py>(
+    py: Python<'py>,
+    input: &impl Input<'py>,
+    iter: impl Iterator<Item = PyResult<impl BorrowInput<'py>>>,
+    mut max_length_check: MaxLengthCheck<'_, impl Input<'py>>,
 ) -> ValResult<Vec<PyObject>> {
     iter.enumerate()
         .map(|(index, result)| {
@@ -304,7 +306,7 @@ fn no_validator_iter_to_vec<'a, 's>(
 // pretty arbitrary default capacity when creating vecs from iteration
 static DEFAULT_CAPACITY: usize = 10;
 
-impl<'a> GenericIterable<'a> {
+impl<'py> GenericIterable<'_, 'py> {
     pub fn generic_len(&self) -> Option<usize> {
         match &self {
             GenericIterable::List(iter) => Some(iter.len()),
@@ -328,13 +330,13 @@ impl<'a> GenericIterable<'a> {
     }
 
     #[allow(clippy::too_many_arguments)]
-    pub fn validate_to_vec<'s>(
-        &'s self,
-        py: Python<'a>,
-        input: &'a impl Input<'a>,
+    pub fn validate_to_vec(
+        &self,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         max_length: Option<usize>,
         field_type: &'static str,
-        validator: &'s CombinedValidator,
+        validator: &CombinedValidator,
         state: &mut ValidationState,
     ) -> ValResult<Vec<PyObject>> {
         let actual_length = self.generic_len();
@@ -360,14 +362,14 @@ impl<'a> GenericIterable<'a> {
     }
 
     #[allow(clippy::too_many_arguments)]
-    pub fn validate_to_set<'s>(
-        &'s self,
-        py: Python<'a>,
+    pub fn validate_to_set(
+        &self,
+        py: Python<'py>,
         set: &impl BuildSet,
-        input: &'a impl Input<'a>,
+        input: &impl Input<'py>,
         max_length: Option<usize>,
         field_type: &'static str,
-        validator: &'s CombinedValidator,
+        validator: &CombinedValidator,
         state: &mut ValidationState,
     ) -> ValResult<()> {
         macro_rules! validate_set {
@@ -388,10 +390,10 @@ impl<'a> GenericIterable<'a> {
         }
     }
 
-    pub fn to_vec<'s>(
-        &'s self,
-        py: Python<'a>,
-        input: &'a impl Input<'a>,
+    pub fn to_vec(
+        &self,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         field_type: &'static str,
         max_length: Option<usize>,
     ) -> ValResult<Vec<PyObject>> {
@@ -426,18 +428,18 @@ impl<'a> GenericIterable<'a> {
 }
 
 #[cfg_attr(debug_assertions, derive(Debug))]
-pub enum GenericMapping<'a> {
-    PyDict(Bound<'a, PyDict>),
-    PyMapping(Bound<'a, PyMapping>),
-    StringMapping(Bound<'a, PyDict>),
-    PyGetAttr(Bound<'a, PyAny>, Option<Bound<'a, PyDict>>),
+pub enum GenericMapping<'a, 'py> {
+    PyDict(&'a Bound<'py, PyDict>),
+    PyMapping(&'a Bound<'py, PyMapping>),
+    StringMapping(&'a Bound<'py, PyDict>),
+    PyGetAttr(Bound<'py, PyAny>, Option<Bound<'py, PyDict>>),
     JsonObject(&'a JsonObject),
 }
 
 macro_rules! derive_from {
     ($enum:ident, $key:ident, $type:ty $(, $extra_types:ident )*) => {
-        impl<'a> From<Bound<'a, $type>> for $enum<'a> {
-            fn from(s: Bound<'a, $type>) -> $enum<'a> {
+        impl<'a, 'py> From<&'a Bound<'py, $type>> for $enum<'a, 'py> {
+            fn from(s: &'a Bound<'py, $type>) -> Self {
                 Self::$key(s $(, $extra_types )*)
             }
         }
@@ -446,10 +448,9 @@ macro_rules! derive_from {
 
 derive_from!(GenericMapping, PyDict, PyDict);
 derive_from!(GenericMapping, PyMapping, PyMapping);
-derive_from!(GenericMapping, PyGetAttr, PyAny, None);
 
-impl<'a> From<&'a JsonObject> for GenericMapping<'a> {
-    fn from(s: &'a JsonObject) -> GenericMapping<'a> {
+impl<'a> From<&'a JsonObject> for GenericMapping<'a, '_> {
+    fn from(s: &'a JsonObject) -> Self {
         Self::JsonObject(s)
     }
 }
@@ -815,38 +816,38 @@ pub fn py_string_str<'a>(py_str: &'a Bound<'_, PyString>) -> ValResult<&'a str>
 }
 
 #[cfg_attr(debug_assertions, derive(Debug))]
-pub enum EitherBytes<'a> {
+pub enum EitherBytes<'a, 'py> {
     Cow(Cow<'a, [u8]>),
-    Py(Bound<'a, PyBytes>),
+    Py(Bound<'py, PyBytes>),
 }
 
-impl<'a> From<Vec<u8>> for EitherBytes<'a> {
+impl<'a> From<Vec<u8>> for EitherBytes<'a, '_> {
     fn from(bytes: Vec<u8>) -> Self {
         Self::Cow(Cow::Owned(bytes))
     }
 }
 
-impl<'a> From<&'a [u8]> for EitherBytes<'a> {
+impl<'a> From<&'a [u8]> for EitherBytes<'a, '_> {
     fn from(bytes: &'a [u8]) -> Self {
         Self::Cow(Cow::Borrowed(bytes))
     }
 }
 
-impl<'a> From<&'_ Bound<'a, PyBytes>> for EitherBytes<'a> {
-    fn from(bytes: &'_ Bound<'a, PyBytes>) -> Self {
+impl<'a, 'py> From<&'a Bound<'py, PyBytes>> for EitherBytes<'a, 'py> {
+    fn from(bytes: &'a Bound<'py, PyBytes>) -> Self {
         Self::Py(bytes.clone())
     }
 }
 
-impl<'a> EitherBytes<'a> {
-    pub fn as_slice(&'a self) -> &[u8] {
+impl EitherBytes<'_, '_> {
+    pub fn as_slice(&self) -> &[u8] {
         match self {
             EitherBytes::Cow(bytes) => bytes,
             EitherBytes::Py(py_bytes) => py_bytes.as_bytes(),
         }
     }
 
-    pub fn len(&'a self) -> PyResult<usize> {
+    pub fn len(&self) -> PyResult<usize> {
         match self {
             EitherBytes::Cow(bytes) => Ok(bytes.len()),
             EitherBytes::Py(py_bytes) => py_bytes.len(),
@@ -854,7 +855,7 @@ impl<'a> EitherBytes<'a> {
     }
 }
 
-impl<'a> IntoPy<PyObject> for EitherBytes<'a> {
+impl IntoPy<PyObject> for EitherBytes<'_, '_> {
     fn into_py(self, py: Python<'_>) -> PyObject {
         match self {
             EitherBytes::Cow(bytes) => PyBytes::new_bound(py, &bytes).into_py(py),
diff --git a/src/input/shared.rs b/src/input/shared.rs
index 8771d4c01..2f8edf6ad 100644
--- a/src/input/shared.rs
+++ b/src/input/shared.rs
@@ -20,7 +20,7 @@ pub fn get_enum_meta_object(py: Python) -> &Bound<'_, PyAny> {
         .bind(py)
 }
 
-pub fn str_as_bool<'a>(input: &'a impl Input<'a>, str: &str) -> ValResult<bool> {
+pub fn str_as_bool<'py>(input: &impl Input<'py>, str: &str) -> ValResult<bool> {
     if str == "0"
         || str.eq_ignore_ascii_case("f")
         || str.eq_ignore_ascii_case("n")
@@ -42,7 +42,7 @@ pub fn str_as_bool<'a>(input: &'a impl Input<'a>, str: &str) -> ValResult<bool>
     }
 }
 
-pub fn int_as_bool<'a>(input: &'a impl Input<'a>, int: i64) -> ValResult<bool> {
+pub fn int_as_bool<'py>(input: &impl Input<'py>, int: i64) -> ValResult<bool> {
     if int == 0 {
         Ok(false)
     } else if int == 1 {
@@ -72,7 +72,7 @@ fn strip_underscores(s: &str) -> Option<String> {
 /// max length of the input is 4300, see
 /// https://docs.python.org/3/whatsnew/3.11.html#other-cpython-implementation-changes and
 /// https://github.com/python/cpython/issues/95778 for more info in that length bound
-pub fn str_as_int<'s, 'l>(input: &'s impl Input<'s>, str: &'l str) -> ValResult<EitherInt<'s>> {
+pub fn str_as_int<'s>(input: &'s impl Input<'s>, str: &str) -> ValResult<EitherInt<'s>> {
     let str = str.trim();
     let len = str.len();
     if len > 4300 {
@@ -97,7 +97,7 @@ pub fn str_as_int<'s, 'l>(input: &'s impl Input<'s>, str: &'l str) -> ValResult<
 }
 
 /// parse a float as a float
-pub fn str_as_float<'s, 'l>(input: &'s impl Input<'s>, str: &'l str) -> ValResult<EitherFloat<'s>> {
+pub fn str_as_float<'s>(input: &'s impl Input<'s>, str: &str) -> ValResult<EitherFloat<'s>> {
     match str.trim().parse() {
         Ok(float) => Ok(EitherFloat::F64(float)),
         Err(_) => match strip_underscores(str).and_then(|stripped| stripped.parse().ok()) {
@@ -109,7 +109,7 @@ pub fn str_as_float<'s, 'l>(input: &'s impl Input<'s>, str: &'l str) -> ValResul
 
 /// parse a string as an int, `input` is required here to get lifetimes to match up
 ///
-fn _parse_str<'s, 'l>(_input: &'s impl Input<'s>, str: &'l str, len: usize) -> Option<EitherInt<'s>> {
+fn _parse_str<'s>(_input: &'s impl Input<'s>, str: &str, len: usize) -> Option<EitherInt<'s>> {
     if len < 19 {
         if let Ok(i) = str.parse::<i64>() {
             return Some(EitherInt::I64(i));
diff --git a/src/lookup_key.rs b/src/lookup_key.rs
index 3a92a447c..d8f8aac61 100644
--- a/src/lookup_key.rs
+++ b/src/lookup_key.rs
@@ -310,7 +310,7 @@ impl LookupKey {
     pub fn error<'d>(
         &self,
         error_type: ErrorType,
-        input: &'d impl Input<'d>,
+        input: &impl Input<'d>,
         loc_by_alias: bool,
         field_name: &str,
     ) -> ValLineError {
diff --git a/src/validators/any.rs b/src/validators/any.rs
index 61a58a09c..a274ff642 100644
--- a/src/validators/any.rs
+++ b/src/validators/any.rs
@@ -27,10 +27,10 @@ impl BuildValidator for AnyValidator {
 impl_py_gc_traverse!(AnyValidator {});
 
 impl Validator for AnyValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         // in a union, Any should be preferred to doing lax coercions
diff --git a/src/validators/arguments.rs b/src/validators/arguments.rs
index 57c6e1fb7..33a9e504a 100644
--- a/src/validators/arguments.rs
+++ b/src/validators/arguments.rs
@@ -166,10 +166,10 @@ impl_py_gc_traverse!(ArgumentsValidator {
 });
 
 impl Validator for ArgumentsValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         let args = input.validate_args()?;
diff --git a/src/validators/bool.rs b/src/validators/bool.rs
index 97729ed60..81f7d51df 100644
--- a/src/validators/bool.rs
+++ b/src/validators/bool.rs
@@ -30,10 +30,10 @@ impl BuildValidator for BoolValidator {
 impl_py_gc_traverse!(BoolValidator {});
 
 impl Validator for BoolValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         // TODO in theory this could be quicker if we used PyBool rather than going to a bool
diff --git a/src/validators/bytes.rs b/src/validators/bytes.rs
index 16b41a05c..ded9da112 100644
--- a/src/validators/bytes.rs
+++ b/src/validators/bytes.rs
@@ -40,10 +40,10 @@ impl BuildValidator for BytesValidator {
 impl_py_gc_traverse!(BytesValidator {});
 
 impl Validator for BytesValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         input
@@ -66,10 +66,10 @@ pub struct BytesConstrainedValidator {
 impl_py_gc_traverse!(BytesConstrainedValidator {});
 
 impl Validator for BytesConstrainedValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         let either_bytes = input.validate_bytes(state.strict_or(self.strict))?.unpack(state);
diff --git a/src/validators/call.rs b/src/validators/call.rs
index b0d966811..09f0fa771 100644
--- a/src/validators/call.rs
+++ b/src/validators/call.rs
@@ -75,10 +75,10 @@ impl_py_gc_traverse!(CallValidator {
 });
 
 impl Validator for CallValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         let args = self.arguments_validator.validate(py, input, state)?.into_bound(py);
diff --git a/src/validators/callable.rs b/src/validators/callable.rs
index 90bc04957..15c3c3c6b 100644
--- a/src/validators/callable.rs
+++ b/src/validators/callable.rs
@@ -25,10 +25,10 @@ impl BuildValidator for CallableValidator {
 impl_py_gc_traverse!(CallableValidator {});
 
 impl Validator for CallableValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         state.floor_exactness(Exactness::Lax);
diff --git a/src/validators/chain.rs b/src/validators/chain.rs
index 0f368f477..0b20b142e 100644
--- a/src/validators/chain.rs
+++ b/src/validators/chain.rs
@@ -70,10 +70,10 @@ fn build_validator_steps(
 impl_py_gc_traverse!(ChainValidator { steps });
 
 impl Validator for ChainValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         let mut steps_iter = self.steps.iter();
diff --git a/src/validators/custom_error.rs b/src/validators/custom_error.rs
index c605a59f1..44dffbdb5 100644
--- a/src/validators/custom_error.rs
+++ b/src/validators/custom_error.rs
@@ -88,10 +88,10 @@ impl BuildValidator for CustomErrorValidator {
 impl_py_gc_traverse!(CustomErrorValidator { validator });
 
 impl Validator for CustomErrorValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         self.validator
diff --git a/src/validators/dataclass.rs b/src/validators/dataclass.rs
index b2da5a048..68067ef78 100644
--- a/src/validators/dataclass.rs
+++ b/src/validators/dataclass.rs
@@ -141,10 +141,10 @@ impl_py_gc_traverse!(Field { validator });
 impl_py_gc_traverse!(DataclassArgsValidator { fields });
 
 impl Validator for DataclassArgsValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         let args = input.validate_dataclass_args(&self.dataclass_name)?;
@@ -529,10 +529,10 @@ impl BuildValidator for DataclassValidator {
 impl_py_gc_traverse!(DataclassValidator { class, validator });
 
 impl Validator for DataclassValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         if let Some(self_instance) = state.extra().self_instance {
@@ -614,7 +614,7 @@ impl DataclassValidator {
         &'s self,
         py: Python<'data>,
         self_instance: &Bound<'_, PyAny>,
-        input: &'data impl Input<'data>,
+        input: &impl Input<'data>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         // we need to set `self_instance` to None for nested validators as we don't want to operate on the self_instance
@@ -642,7 +642,7 @@ impl DataclassValidator {
         py: Python<'data>,
         dc: &Bound<'_, PyAny>,
         val_output: PyObject,
-        input: &'data impl Input<'data>,
+        input: &impl Input<'data>,
     ) -> ValResult<()> {
         let (dc_dict, post_init_kwargs): (Bound<'_, PyAny>, Bound<'_, PyAny>) = val_output.extract(py)?;
         if self.slots {
diff --git a/src/validators/date.rs b/src/validators/date.rs
index 009878a62..c34d9eeaf 100644
--- a/src/validators/date.rs
+++ b/src/validators/date.rs
@@ -39,10 +39,10 @@ impl BuildValidator for DateValidator {
 impl_py_gc_traverse!(DateValidator {});
 
 impl Validator for DateValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         let strict = state.strict_or(self.strict);
@@ -109,7 +109,7 @@ impl Validator for DateValidator {
 /// "exact date", e.g. has a zero time component.
 ///
 /// Ok(None) means that this is not relevant to dates (the input was not a datetime nor a string)
-fn date_from_datetime<'data>(input: &'data impl Input<'data>) -> Result<Option<EitherDate<'data>>, ValError> {
+fn date_from_datetime<'data>(input: &impl Input<'data>) -> Result<Option<EitherDate<'data>>, ValError> {
     let either_dt = match input.validate_datetime(false, speedate::MicrosecondsPrecisionOverflowBehavior::Truncate) {
         Ok(val_match) => val_match.into_inner(),
         // if the error was a parsing error, update the error type from DatetimeParsing to DateFromDatetimeParsing
diff --git a/src/validators/datetime.rs b/src/validators/datetime.rs
index bd8944fb4..d31f53bec 100644
--- a/src/validators/datetime.rs
+++ b/src/validators/datetime.rs
@@ -59,10 +59,10 @@ impl BuildValidator for DateTimeValidator {
 impl_py_gc_traverse!(DateTimeValidator {});
 
 impl Validator for DateTimeValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         let strict = state.strict_or(self.strict);
@@ -141,7 +141,7 @@ impl Validator for DateTimeValidator {
 
 /// In lax mode, if the input is not a datetime, we try parsing the input as a date and add the "00:00:00" time.
 /// Ok(None) means that this is not relevant to datetimes (the input was not a date nor a string)
-fn datetime_from_date<'data>(input: &'data impl Input<'data>) -> Result<Option<EitherDateTime<'data>>, ValError> {
+fn datetime_from_date<'data>(input: &impl Input<'data>) -> Result<Option<EitherDateTime<'data>>, ValError> {
     let either_date = match input.validate_date(false) {
         Ok(val_match) => val_match.into_inner(),
         // if the error was a parsing error, update the error type from DateParsing to DatetimeFromDateParsing
@@ -307,7 +307,7 @@ impl TZConstraint {
         }
     }
 
-    pub(super) fn tz_check<'d>(&self, tz_offset: Option<i32>, input: &'d impl Input<'d>) -> ValResult<()> {
+    pub(super) fn tz_check<'d>(&self, tz_offset: Option<i32>, input: &impl Input<'d>) -> ValResult<()> {
         match (self, tz_offset) {
             (TZConstraint::Aware(_), None) => return Err(ValError::new(ErrorTypeDefaults::TimezoneAware, input)),
             (TZConstraint::Aware(Some(tz_expected)), Some(tz_actual)) => {
diff --git a/src/validators/decimal.rs b/src/validators/decimal.rs
index f4f292d76..183647656 100644
--- a/src/validators/decimal.rs
+++ b/src/validators/decimal.rs
@@ -117,10 +117,10 @@ fn extract_decimal_digits_info(decimal: &Bound<'_, PyAny>, normalized: bool) ->
 }
 
 impl Validator for DecimalValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         let decimal = input.validate_decimal(state.strict_or(self.strict), py)?;
@@ -264,7 +264,7 @@ impl Validator for DecimalValidator {
     }
 }
 
-pub(crate) fn create_decimal<'a>(arg: &Bound<'a, PyAny>, input: &'a impl Input<'a>) -> ValResult<Bound<'a, PyAny>> {
+pub(crate) fn create_decimal<'a>(arg: &Bound<'a, PyAny>, input: &impl Input<'a>) -> ValResult<Bound<'a, PyAny>> {
     let py = arg.py();
     get_decimal_type(py).call1((arg,)).map_err(|e| {
         let decimal_exception = match py
diff --git a/src/validators/definitions.rs b/src/validators/definitions.rs
index 6e9b05a6b..a6599c847 100644
--- a/src/validators/definitions.rs
+++ b/src/validators/definitions.rs
@@ -69,10 +69,10 @@ impl BuildValidator for DefinitionRefValidator {
 impl_py_gc_traverse!(DefinitionRefValidator {});
 
 impl Validator for DefinitionRefValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         self.definition.read(|validator| {
diff --git a/src/validators/dict.rs b/src/validators/dict.rs
index 7f5337f9e..425ea606e 100644
--- a/src/validators/dict.rs
+++ b/src/validators/dict.rs
@@ -67,24 +67,24 @@ impl_py_gc_traverse!(DictValidator {
 });
 
 impl Validator for DictValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         let strict = state.strict_or(self.strict);
         let dict = input.validate_dict(strict)?;
         match dict {
             GenericMapping::PyDict(py_dict) => {
-                self.validate_generic_mapping(py, input, DictGenericIterator::new(&py_dict)?, state)
+                self.validate_generic_mapping(py, input, DictGenericIterator::new(py_dict)?, state)
             }
             GenericMapping::PyMapping(mapping) => {
                 state.floor_exactness(super::Exactness::Lax);
-                self.validate_generic_mapping(py, input, MappingGenericIterator::new(&mapping)?, state)
+                self.validate_generic_mapping(py, input, MappingGenericIterator::new(mapping)?, state)
             }
             GenericMapping::StringMapping(dict) => {
-                self.validate_generic_mapping(py, input, StringMappingGenericIterator::new(&dict)?, state)
+                self.validate_generic_mapping(py, input, StringMappingGenericIterator::new(dict)?, state)
             }
             GenericMapping::PyGetAttr(_, _) => unreachable!(),
             GenericMapping::JsonObject(json_object) => {
@@ -99,15 +99,12 @@ impl Validator for DictValidator {
 }
 
 impl DictValidator {
-    fn validate_generic_mapping<'s, 'data>(
-        &'s self,
+    fn validate_generic_mapping<'data>(
+        &self,
         py: Python<'data>,
-        input: &'data impl Input<'data>,
+        input: &impl Input<'data>,
         mapping_iter: impl Iterator<
-            Item = ValResult<(
-                impl BorrowInput + Clone + Into<LocItem> + 'data,
-                impl BorrowInput + 'data,
-            )>,
+            Item = ValResult<(impl BorrowInput<'data> + Clone + Into<LocItem>, impl BorrowInput<'data>)>,
         >,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
diff --git a/src/validators/float.rs b/src/validators/float.rs
index a1d1f485f..3d8a9a9a8 100644
--- a/src/validators/float.rs
+++ b/src/validators/float.rs
@@ -64,10 +64,10 @@ impl BuildValidator for FloatValidator {
 impl_py_gc_traverse!(FloatValidator {});
 
 impl Validator for FloatValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         let either_float = input.validate_float(state.strict_or(self.strict))?.unpack(state);
@@ -96,10 +96,10 @@ pub struct ConstrainedFloatValidator {
 impl_py_gc_traverse!(ConstrainedFloatValidator {});
 
 impl Validator for ConstrainedFloatValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         let either_float = input.validate_float(state.strict_or(self.strict))?.unpack(state);
diff --git a/src/validators/frozenset.rs b/src/validators/frozenset.rs
index 1d3b602e0..b5f705627 100644
--- a/src/validators/frozenset.rs
+++ b/src/validators/frozenset.rs
@@ -28,10 +28,10 @@ impl BuildValidator for FrozenSetValidator {
 impl_py_gc_traverse!(FrozenSetValidator { item_validator });
 
 impl Validator for FrozenSetValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         let collection = input.validate_frozenset(state.strict_or(self.strict))?;
diff --git a/src/validators/function.rs b/src/validators/function.rs
index 3cf298af2..6f54e5a16 100644
--- a/src/validators/function.rs
+++ b/src/validators/function.rs
@@ -97,7 +97,7 @@ impl FunctionBeforeValidator {
         &'s self,
         call: impl FnOnce(Bound<'data, PyAny>, &mut ValidationState<'_>) -> ValResult<PyObject>,
         py: Python<'data>,
-        input: &'data impl Input<'data>,
+        input: &impl Input<'data>,
         state: &'s mut ValidationState<'_>,
     ) -> ValResult<PyObject> {
         let r = if self.info_arg {
@@ -121,7 +121,7 @@ impl Validator for FunctionBeforeValidator {
     fn validate<'data>(
         &self,
         py: Python<'data>,
-        input: &'data impl Input<'data>,
+        input: &impl Input<'data>,
         state: &mut ValidationState<'_>,
     ) -> ValResult<PyObject> {
         let validate = |v, s: &mut ValidationState<'_>| self.validator.validate(py, &v, s);
@@ -161,9 +161,9 @@ impl_build!(FunctionAfterValidator, "function-after");
 impl FunctionAfterValidator {
     fn _validate<'s, 'data, I: Input<'data>>(
         &'s self,
-        call: impl FnOnce(&'data I, &mut ValidationState<'_>) -> ValResult<PyObject>,
+        call: impl FnOnce(&I, &mut ValidationState<'_>) -> ValResult<PyObject>,
         py: Python<'data>,
-        input: &'data I,
+        input: &I,
         state: &mut ValidationState<'_>,
     ) -> ValResult<PyObject> {
         let v = call(input, state)?;
@@ -187,10 +187,10 @@ impl Validator for FunctionAfterValidator {
     fn validate<'data>(
         &self,
         py: Python<'data>,
-        input: &'data impl Input<'data>,
+        input: &impl Input<'data>,
         state: &mut ValidationState<'_>,
     ) -> ValResult<PyObject> {
-        let validate = |v, s: &mut ValidationState<'_>| self.validator.validate(py, v, s);
+        let validate = |v: &_, s: &mut ValidationState<'_>| self.validator.validate(py, v, s);
         self._validate(validate, py, input, state)
     }
     fn validate_assignment<'data>(
@@ -201,8 +201,9 @@ impl Validator for FunctionAfterValidator {
         field_value: &Bound<'data, PyAny>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
-        let validate =
-            move |v, s: &mut ValidationState<'_>| self.validator.validate_assignment(py, v, field_name, field_value, s);
+        let validate = move |v: &Bound<'data, PyAny>, s: &mut ValidationState<'_>| {
+            self.validator.validate_assignment(py, v, field_name, field_value, s)
+        };
         self._validate(validate, py, obj, state)
     }
 
@@ -247,10 +248,10 @@ impl BuildValidator for FunctionPlainValidator {
 impl_py_gc_traverse!(FunctionPlainValidator { func, config });
 
 impl Validator for FunctionPlainValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         let r = if self.info_arg {
@@ -314,7 +315,7 @@ impl FunctionWrapValidator {
         &'s self,
         handler: &Bound<'_, PyAny>,
         py: Python<'data>,
-        input: &'data impl Input<'data>,
+        input: &impl Input<'data>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         let r = if self.info_arg {
@@ -334,10 +335,10 @@ impl_py_gc_traverse!(FunctionWrapValidator {
 });
 
 impl Validator for FunctionWrapValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         let handler = ValidatorCallable {
@@ -470,7 +471,7 @@ macro_rules! py_err_string {
 
 /// Only `ValueError` (including `PydanticCustomError` and `ValidationError`) and `AssertionError` are considered
 /// as validation errors, `TypeError` is now considered as a runtime error to catch errors in function signatures
-pub fn convert_err<'a>(py: Python<'a>, err: PyErr, input: &'a impl Input<'a>) -> ValError {
+pub fn convert_err<'a>(py: Python<'a>, err: PyErr, input: &impl Input<'a>) -> ValError {
     if err.is_instance_of::<PyValueError>(py) {
         let error_value = err.value_bound(py);
         if let Ok(pydantic_value_error) = error_value.extract::<PydanticCustomError>() {
diff --git a/src/validators/generator.rs b/src/validators/generator.rs
index 1be9fcc8a..d4326cf47 100644
--- a/src/validators/generator.rs
+++ b/src/validators/generator.rs
@@ -59,10 +59,10 @@ impl BuildValidator for GeneratorValidator {
 impl_py_gc_traverse!(GeneratorValidator { item_validator });
 
 impl Validator for GeneratorValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         let iterator = input.validate_iter()?;
@@ -292,7 +292,7 @@ impl InternalValidator {
     pub fn validate<'data>(
         &mut self,
         py: Python<'data>,
-        input: &'data impl Input<'data>,
+        input: &impl Input<'data>,
         outer_location: Option<LocItem>,
     ) -> PyResult<PyObject> {
         let extra = Extra {
diff --git a/src/validators/int.rs b/src/validators/int.rs
index 5bb19fefb..580c677d6 100644
--- a/src/validators/int.rs
+++ b/src/validators/int.rs
@@ -43,10 +43,10 @@ impl BuildValidator for IntValidator {
 impl_py_gc_traverse!(IntValidator {});
 
 impl Validator for IntValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         input
@@ -72,10 +72,10 @@ pub struct ConstrainedIntValidator {
 impl_py_gc_traverse!(ConstrainedIntValidator {});
 
 impl Validator for ConstrainedIntValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         let either_int = input.validate_int(state.strict_or(self.strict))?.unpack(state);
diff --git a/src/validators/is_instance.rs b/src/validators/is_instance.rs
index 9f0fc1a13..0261beae5 100644
--- a/src/validators/is_instance.rs
+++ b/src/validators/is_instance.rs
@@ -58,7 +58,7 @@ impl Validator for IsInstanceValidator {
     fn validate<'data>(
         &self,
         py: Python<'data>,
-        input: &'data impl Input<'data>,
+        input: &impl Input<'data>,
         _state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         if !input.is_python() {
diff --git a/src/validators/is_subclass.rs b/src/validators/is_subclass.rs
index d7fbd238f..54b343aae 100644
--- a/src/validators/is_subclass.rs
+++ b/src/validators/is_subclass.rs
@@ -46,7 +46,7 @@ impl Validator for IsSubclassValidator {
     fn validate<'data>(
         &self,
         py: Python<'data>,
-        input: &'data impl Input<'data>,
+        input: &impl Input<'data>,
         _state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         match input.input_is_subclass(self.class.bind(py))? {
diff --git a/src/validators/json.rs b/src/validators/json.rs
index 4543a41d0..bcae2b3ec 100644
--- a/src/validators/json.rs
+++ b/src/validators/json.rs
@@ -46,10 +46,10 @@ impl BuildValidator for JsonValidator {
 impl_py_gc_traverse!(JsonValidator { validator });
 
 impl Validator for JsonValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         let v_match = validate_json_bytes(input)?;
@@ -76,7 +76,7 @@ impl Validator for JsonValidator {
     }
 }
 
-pub fn validate_json_bytes<'data>(input: &'data impl Input<'data>) -> ValResult<ValidationMatch<EitherBytes<'data>>> {
+pub fn validate_json_bytes<'a, 'py>(input: &'a impl Input<'py>) -> ValResult<ValidationMatch<EitherBytes<'a, 'py>>> {
     match input.validate_bytes(false) {
         Ok(v_match) => Ok(v_match),
         Err(ValError::LineErrors(e)) => Err(ValError::LineErrors(
@@ -95,7 +95,7 @@ fn map_bytes_error(line_error: ValLineError) -> ValLineError {
     }
 }
 
-pub fn map_json_err<'a>(input: &'a impl Input<'a>, error: jiter::JsonError, json_bytes: &[u8]) -> ValError {
+pub fn map_json_err<'py>(input: &impl Input<'py>, error: jiter::JsonError, json_bytes: &[u8]) -> ValError {
     ValError::new(
         ErrorType::JsonInvalid {
             error: error.description(json_bytes),
diff --git a/src/validators/json_or_python.rs b/src/validators/json_or_python.rs
index ddbc53900..373f1e0f6 100644
--- a/src/validators/json_or_python.rs
+++ b/src/validators/json_or_python.rs
@@ -49,10 +49,10 @@ impl BuildValidator for JsonOrPython {
 impl_py_gc_traverse!(JsonOrPython { json, python });
 
 impl Validator for JsonOrPython {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         match state.extra().input_type {
diff --git a/src/validators/lax_or_strict.rs b/src/validators/lax_or_strict.rs
index 654e38ed8..38c7d6893 100644
--- a/src/validators/lax_or_strict.rs
+++ b/src/validators/lax_or_strict.rs
@@ -56,10 +56,10 @@ impl_py_gc_traverse!(LaxOrStrictValidator {
 });
 
 impl Validator for LaxOrStrictValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         if state.strict_or(self.strict) {
diff --git a/src/validators/list.rs b/src/validators/list.rs
index a0ab11c29..fed237213 100644
--- a/src/validators/list.rs
+++ b/src/validators/list.rs
@@ -116,10 +116,10 @@ impl BuildValidator for ListValidator {
 impl_py_gc_traverse!(ListValidator { item_validator });
 
 impl Validator for ListValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         let seq = input.validate_list(state.strict_or(self.strict))?;
diff --git a/src/validators/literal.rs b/src/validators/literal.rs
index 35d37ef17..43ffdd5d4 100644
--- a/src/validators/literal.rs
+++ b/src/validators/literal.rs
@@ -91,11 +91,7 @@ impl<T: Debug> LiteralLookup<T> {
         })
     }
 
-    pub fn validate<'data, I: Input<'data>>(
-        &self,
-        py: Python<'data>,
-        input: &'data I,
-    ) -> ValResult<Option<(&'data I, &T)>> {
+    pub fn validate<'a, 'py, I: Input<'py>>(&self, py: Python<'py>, input: &'a I) -> ValResult<Option<(&'a I, &T)>> {
         if let Some(expected_bool) = &self.expected_bool {
             if let Ok(bool_value) = input.validate_bool(true) {
                 if bool_value.into_inner() {
@@ -196,7 +192,7 @@ impl Validator for LiteralValidator {
     fn validate<'data>(
         &self,
         py: Python<'data>,
-        input: &'data impl Input<'data>,
+        input: &impl Input<'data>,
         _state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         match self.lookup.validate(py, input)? {
diff --git a/src/validators/mod.rs b/src/validators/mod.rs
index d7eb496ef..4f791ac7e 100644
--- a/src/validators/mod.rs
+++ b/src/validators/mod.rs
@@ -321,7 +321,7 @@ impl SchemaValidator {
     fn _validate<'s, 'data>(
         &'data self,
         py: Python<'data>,
-        input: &'data impl Input<'data>,
+        input: &impl Input<'data>,
         input_type: InputType,
         strict: Option<bool>,
         from_attributes: Option<bool>,
@@ -708,10 +708,10 @@ pub enum CombinedValidator {
 #[enum_dispatch(CombinedValidator)]
 pub trait Validator: Send + Sync + Debug {
     /// Do the actual validation for this schema/type
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject>;
 
diff --git a/src/validators/model.rs b/src/validators/model.rs
index 8c63fa6f2..182f64432 100644
--- a/src/validators/model.rs
+++ b/src/validators/model.rs
@@ -108,10 +108,10 @@ impl BuildValidator for ModelValidator {
 impl_py_gc_traverse!(ModelValidator { class, validator });
 
 impl Validator for ModelValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         if let Some(self_instance) = state.extra().self_instance {
@@ -227,7 +227,7 @@ impl ModelValidator {
         &'s self,
         py: Python<'data>,
         self_instance: &Bound<'s, PyAny>,
-        input: &'data impl Input<'data>,
+        input: &impl Input<'data>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         // we need to set `self_instance` to None for nested validators as we don't want to operate on self_instance
@@ -253,7 +253,7 @@ impl ModelValidator {
     fn validate_construct<'s, 'data>(
         &'s self,
         py: Python<'data>,
-        input: &'data impl Input<'data>,
+        input: &impl Input<'data>,
         existing_fields_set: Option<&Bound<'_, PyAny>>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
@@ -295,7 +295,7 @@ impl ModelValidator {
         &'s self,
         py: Python<'data>,
         instance: Bound<'_, PyAny>,
-        input: &'data impl Input<'data>,
+        input: &impl Input<'data>,
         extra: &Extra,
     ) -> ValResult<PyObject> {
         if let Some(ref post_init) = self.post_init {
diff --git a/src/validators/model_fields.rs b/src/validators/model_fields.rs
index cbdacd1d7..2f01d09df 100644
--- a/src/validators/model_fields.rs
+++ b/src/validators/model_fields.rs
@@ -119,10 +119,10 @@ impl_py_gc_traverse!(ModelFieldsValidator {
 });
 
 impl Validator for ModelFieldsValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         let strict = state.strict_or(self.strict);
diff --git a/src/validators/none.rs b/src/validators/none.rs
index 36f19c2bd..1ae1a3b14 100644
--- a/src/validators/none.rs
+++ b/src/validators/none.rs
@@ -27,7 +27,7 @@ impl Validator for NoneValidator {
     fn validate<'data>(
         &self,
         py: Python<'data>,
-        input: &'data impl Input<'data>,
+        input: &impl Input<'data>,
         _state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         match input.is_none() {
diff --git a/src/validators/nullable.rs b/src/validators/nullable.rs
index 872eb3d7f..20c1d7926 100644
--- a/src/validators/nullable.rs
+++ b/src/validators/nullable.rs
@@ -33,10 +33,10 @@ impl BuildValidator for NullableValidator {
 impl_py_gc_traverse!(NullableValidator { validator });
 
 impl Validator for NullableValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         match input.is_none() {
diff --git a/src/validators/set.rs b/src/validators/set.rs
index 4854f6ba8..92f58e8d2 100644
--- a/src/validators/set.rs
+++ b/src/validators/set.rs
@@ -58,10 +58,10 @@ impl BuildValidator for SetValidator {
 impl_py_gc_traverse!(SetValidator { item_validator });
 
 impl Validator for SetValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         let collection = input.validate_set(state.strict_or(self.strict))?;
diff --git a/src/validators/string.rs b/src/validators/string.rs
index 0dffec9c2..b72b6efb4 100644
--- a/src/validators/string.rs
+++ b/src/validators/string.rs
@@ -41,10 +41,10 @@ impl BuildValidator for StrValidator {
 impl_py_gc_traverse!(StrValidator {});
 
 impl Validator for StrValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         input
@@ -73,10 +73,10 @@ pub struct StrConstrainedValidator {
 impl_py_gc_traverse!(StrConstrainedValidator {});
 
 impl Validator for StrConstrainedValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         let either_str = input
diff --git a/src/validators/time.rs b/src/validators/time.rs
index 9aa68955d..524050f89 100644
--- a/src/validators/time.rs
+++ b/src/validators/time.rs
@@ -40,10 +40,10 @@ impl BuildValidator for TimeValidator {
 impl_py_gc_traverse!(TimeValidator {});
 
 impl Validator for TimeValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         let time = input
diff --git a/src/validators/timedelta.rs b/src/validators/timedelta.rs
index f516818ef..17ebc0936 100644
--- a/src/validators/timedelta.rs
+++ b/src/validators/timedelta.rs
@@ -65,10 +65,10 @@ impl BuildValidator for TimeDeltaValidator {
 impl_py_gc_traverse!(TimeDeltaValidator {});
 
 impl Validator for TimeDeltaValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         let timedelta = input
diff --git a/src/validators/tuple.rs b/src/validators/tuple.rs
index d9311e4fe..a3968f85c 100644
--- a/src/validators/tuple.rs
+++ b/src/validators/tuple.rs
@@ -60,10 +60,10 @@ impl_py_gc_traverse!(TupleValidator { validators });
 
 impl TupleValidator {
     #[allow(clippy::too_many_arguments)]
-    fn validate_tuple_items<'s, 'data, I: BorrowInput + 'data>(
+    fn validate_tuple_items<'data, I: BorrowInput<'data>>(
         &self,
         py: Python<'data>,
-        input: &'data impl Input<'data>,
+        input: &impl Input<'data>,
         state: &mut ValidationState,
         output: &mut Vec<PyObject>,
         errors: &mut Vec<ValLineError>,
@@ -97,10 +97,10 @@ impl TupleValidator {
     }
 
     #[allow(clippy::too_many_arguments)]
-    fn validate_tuple_variable<'data, I: BorrowInput + 'data, InputT: Input<'data> + 'data>(
+    fn validate_tuple_variable<'data, I: BorrowInput<'data>, InputT: Input<'data>>(
         &self,
         py: Python<'data>,
-        input: &'data InputT,
+        input: &InputT,
         state: &mut ValidationState,
         errors: &mut Vec<ValLineError>,
         collection_iter: &mut NextCountingIterator<impl Iterator<Item = I>>,
@@ -218,7 +218,7 @@ impl TupleValidator {
 
     fn push_output_item<'data>(
         &self,
-        input: &'data impl Input<'data>,
+        input: &impl Input<'data>,
         output: &mut Vec<PyObject>,
         item: PyObject,
         actual_length: Option<usize>,
@@ -242,13 +242,13 @@ impl TupleValidator {
 }
 
 impl Validator for TupleValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
-        let collection: GenericIterable<'_> = input.validate_tuple(state.strict_or(self.strict))?;
+        let collection = input.validate_tuple(state.strict_or(self.strict))?;
         let exactness = match &collection {
             GenericIterable::Tuple(_) | GenericIterable::JsonArray(_) => Exactness::Exact,
             GenericIterable::List(_) => Exactness::Strict,
diff --git a/src/validators/typed_dict.rs b/src/validators/typed_dict.rs
index 7299cfff9..b85d2df60 100644
--- a/src/validators/typed_dict.rs
+++ b/src/validators/typed_dict.rs
@@ -145,10 +145,10 @@ impl_py_gc_traverse!(TypedDictValidator {
 });
 
 impl Validator for TypedDictValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         let strict = state.strict_or(self.strict);
diff --git a/src/validators/union.rs b/src/validators/union.rs
index 8b64ecbf6..f3c1174a0 100644
--- a/src/validators/union.rs
+++ b/src/validators/union.rs
@@ -104,7 +104,7 @@ impl UnionValidator {
     fn validate_smart<'data>(
         &self,
         py: Python<'data>,
-        input: &'data impl Input<'data>,
+        input: &impl Input<'data>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         let old_exactness = state.exactness;
@@ -170,7 +170,7 @@ impl UnionValidator {
     fn validate_left_to_right<'data>(
         &self,
         py: Python<'data>,
-        input: &'data impl Input<'data>,
+        input: &impl Input<'data>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         let mut errors = MaybeErrors::new(self.custom_error.as_ref());
@@ -202,10 +202,10 @@ impl PyGcTraverse for UnionValidator {
 }
 
 impl Validator for UnionValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         match self.mode {
@@ -390,10 +390,10 @@ impl BuildValidator for TaggedUnionValidator {
 impl_py_gc_traverse!(TaggedUnionValidator { discriminator, lookup });
 
 impl Validator for TaggedUnionValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         match self.discriminator {
@@ -450,7 +450,7 @@ impl TaggedUnionValidator {
     fn self_schema_tag<'data>(
         &self,
         py: Python<'data>,
-        input: &'data impl Input<'data>,
+        input: &impl Input<'data>,
     ) -> ValResult<Bound<'data, PyString>> {
         let dict = input.strict_dict()?;
         let tag = match &dict {
@@ -484,7 +484,7 @@ impl TaggedUnionValidator {
         &'s self,
         py: Python<'data>,
         tag: &Bound<'data, PyAny>,
-        input: &'data impl Input<'data>,
+        input: &impl Input<'data>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         if let Ok(Some((tag, validator))) = self.lookup.validate(py, tag) {
@@ -507,7 +507,7 @@ impl TaggedUnionValidator {
         }
     }
 
-    fn tag_not_found<'s, 'data>(&'s self, input: &'data impl Input<'data>) -> ValError {
+    fn tag_not_found<'s, 'data>(&'s self, input: &impl Input<'data>) -> ValError {
         match self.custom_error {
             Some(ref custom_error) => custom_error.as_val_error(input),
             None => ValError::new(
diff --git a/src/validators/url.rs b/src/validators/url.rs
index 5529c2667..29eb2daa6 100644
--- a/src/validators/url.rs
+++ b/src/validators/url.rs
@@ -60,10 +60,10 @@ impl BuildValidator for UrlValidator {
 impl_py_gc_traverse!(UrlValidator {});
 
 impl Validator for UrlValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         let mut lib_url = self.get_url(input, state.strict_or(self.strict))?;
@@ -103,7 +103,7 @@ impl Validator for UrlValidator {
 }
 
 impl UrlValidator {
-    fn get_url<'s, 'data>(&'s self, input: &'data impl Input<'data>, strict: bool) -> ValResult<Url> {
+    fn get_url<'s, 'data>(&'s self, input: &impl Input<'data>, strict: bool) -> ValResult<Url> {
         match input.validate_str(strict, false) {
             Ok(val_match) => {
                 let either_str = val_match.into_inner();
@@ -133,7 +133,7 @@ impl UrlValidator {
         }
     }
 
-    fn check_length<'s, 'data>(&self, input: &'data impl Input<'data>, url_str: &str) -> ValResult<()> {
+    fn check_length<'s, 'data>(&self, input: &impl Input<'data>, url_str: &str) -> ValResult<()> {
         if let Some(max_length) = self.max_length {
             if url_str.len() > max_length {
                 return Err(ValError::new(
@@ -194,10 +194,10 @@ impl BuildValidator for MultiHostUrlValidator {
 impl_py_gc_traverse!(MultiHostUrlValidator {});
 
 impl Validator for MultiHostUrlValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         let mut multi_url = self.get_url(input, state.strict_or(self.strict))?;
@@ -236,7 +236,7 @@ impl Validator for MultiHostUrlValidator {
 }
 
 impl MultiHostUrlValidator {
-    fn get_url<'s, 'data>(&'s self, input: &'data impl Input<'data>, strict: bool) -> ValResult<PyMultiHostUrl> {
+    fn get_url<'s, 'data>(&'s self, input: &impl Input<'data>, strict: bool) -> ValResult<PyMultiHostUrl> {
         match input.validate_str(strict, false) {
             Ok(val_match) => {
                 let either_str = val_match.into_inner();
@@ -264,7 +264,7 @@ impl MultiHostUrlValidator {
         }
     }
 
-    fn check_length<'s, 'data, F>(&self, input: &'data impl Input<'data>, func: F) -> ValResult<()>
+    fn check_length<'s, 'data, F>(&self, input: &impl Input<'data>, func: F) -> ValResult<()>
     where
         F: FnOnce() -> usize,
     {
@@ -285,7 +285,7 @@ impl MultiHostUrlValidator {
 
 fn parse_multihost_url<'url, 'input>(
     url_str: &'url str,
-    input: &'input impl Input<'input>,
+    input: &impl Input<'input>,
     strict: bool,
 ) -> ValResult<PyMultiHostUrl> {
     macro_rules! parsing_err {
@@ -402,7 +402,7 @@ fn parse_multihost_url<'url, 'input>(
     }
 }
 
-fn parse_url<'url, 'input>(url_str: &'url str, input: &'input impl Input<'input>, strict: bool) -> ValResult<Url> {
+fn parse_url<'url, 'input>(url_str: &'url str, input: &impl Input<'input>, strict: bool) -> ValResult<Url> {
     if url_str.is_empty() {
         return Err(ValError::new(
             ErrorType::UrlParsing {
diff --git a/src/validators/uuid.rs b/src/validators/uuid.rs
index a567d3f6b..ab452a21f 100644
--- a/src/validators/uuid.rs
+++ b/src/validators/uuid.rs
@@ -86,10 +86,10 @@ impl BuildValidator for UuidValidator {
 impl_py_gc_traverse!(UuidValidator {});
 
 impl Validator for UuidValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         let class = get_uuid_type(py)?;
@@ -150,7 +150,7 @@ impl Validator for UuidValidator {
 }
 
 impl UuidValidator {
-    fn get_uuid<'s, 'data>(&'s self, input: &'data impl Input<'data>) -> ValResult<Uuid> {
+    fn get_uuid<'s, 'data>(&'s self, input: &impl Input<'data>) -> ValResult<Uuid> {
         let uuid = match input.exact_str().ok() {
             Some(either_string) => {
                 let cow = either_string.as_cow()?;
diff --git a/src/validators/with_default.rs b/src/validators/with_default.rs
index b1ee12ca9..06ab2159a 100644
--- a/src/validators/with_default.rs
+++ b/src/validators/with_default.rs
@@ -134,10 +134,10 @@ impl BuildValidator for WithDefaultValidator {
 impl_py_gc_traverse!(WithDefaultValidator { default, validator });
 
 impl Validator for WithDefaultValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &'data impl Input<'data>,
+        py: Python<'py>,
+        input: &impl Input<'py>,
         state: &mut ValidationState,
     ) -> ValResult<PyObject> {
         if input.to_object(py).is(&self.undefined) {

From b92a69b057bbabeaf61c355a7e9b7d3059e26e15 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Mon, 18 Mar 2024 10:15:56 -0500
Subject: [PATCH 232/550] Fix json serialization when computed field is
 excluded (#1228)

---
 src/serializers/computed_fields.rs | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/src/serializers/computed_fields.rs b/src/serializers/computed_fields.rs
index 25c5d32e8..009f947dd 100644
--- a/src/serializers/computed_fields.rs
+++ b/src/serializers/computed_fields.rs
@@ -71,16 +71,18 @@ impl ComputedFields {
             // Do not serialize computed fields
             return Ok(());
         }
+
         for computed_field in &self.0 {
             let property_name_py = computed_field.property_name_py.bind(model.py());
-            let value = model.getattr(property_name_py).map_err(py_err_se_err)?;
-            if extra.exclude_none && value.is_none() {
-                continue;
-            }
+
             if let Some((next_include, next_exclude)) = filter
                 .key_filter(property_name_py, include, exclude)
                 .map_err(py_err_se_err)?
             {
+                let value = model.getattr(property_name_py).map_err(py_err_se_err)?;
+                if extra.exclude_none && value.is_none() {
+                    continue;
+                }
                 let cfs = ComputedFieldSerializer {
                     model,
                     computed_field,

From 352d40f6928498856ab119f1df57cbb2b5df1cb7 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Mon, 18 Mar 2024 16:39:03 +0000
Subject: [PATCH 233/550] implement `Input` for `str` (#1229)

---
 src/errors/line_error.rs           | 33 ++++++----
 src/errors/mod.rs                  |  2 +-
 src/errors/value_exception.rs      |  6 +-
 src/input/datetime.rs              | 47 ++++++++-------
 src/input/input_abstract.rs        | 25 +++++---
 src/input/input_json.rs            | 41 ++++++-------
 src/input/input_python.rs          | 12 ++--
 src/input/input_string.rs          | 12 ++--
 src/input/return_enums.rs          | 71 +++++++++++-----------
 src/input/shared.rs                | 17 +++---
 src/lookup_key.rs                  |  8 +--
 src/validators/any.rs              |  4 +-
 src/validators/arguments.rs        |  4 +-
 src/validators/bool.rs             |  4 +-
 src/validators/bytes.rs            |  8 +--
 src/validators/call.rs             |  4 +-
 src/validators/callable.rs         |  4 +-
 src/validators/chain.rs            |  4 +-
 src/validators/custom_error.rs     |  8 +--
 src/validators/dataclass.rs        | 46 +++++++-------
 src/validators/date.rs             |  6 +-
 src/validators/datetime.rs         |  9 +--
 src/validators/decimal.rs          | 18 +++---
 src/validators/definitions.rs      | 14 ++---
 src/validators/dict.rs             | 14 ++---
 src/validators/float.rs            |  8 +--
 src/validators/frozenset.rs        |  4 +-
 src/validators/function.rs         | 97 +++++++++++++++---------------
 src/validators/generator.rs        | 18 +++---
 src/validators/int.rs              |  8 +--
 src/validators/is_instance.rs      |  8 +--
 src/validators/is_subclass.rs      |  8 +--
 src/validators/json.rs             | 10 +--
 src/validators/json_or_python.rs   |  4 +-
 src/validators/lax_or_strict.rs    |  4 +-
 src/validators/list.rs             |  4 +-
 src/validators/literal.rs          | 14 +++--
 src/validators/mod.rs              | 53 ++++++++--------
 src/validators/model.rs            | 44 +++++++-------
 src/validators/model_fields.rs     | 14 ++---
 src/validators/none.rs             |  8 +--
 src/validators/nullable.rs         |  4 +-
 src/validators/set.rs              |  4 +-
 src/validators/string.rs           |  8 +--
 src/validators/time.rs             |  4 +-
 src/validators/timedelta.rs        |  4 +-
 src/validators/tuple.rs            | 24 ++++----
 src/validators/typed_dict.rs       |  4 +-
 src/validators/union.rs            | 50 +++++++--------
 src/validators/url.rs              | 25 ++++----
 src/validators/uuid.rs             |  6 +-
 src/validators/validation_state.rs | 34 +++++------
 src/validators/with_default.rs     | 10 +--
 53 files changed, 461 insertions(+), 443 deletions(-)

diff --git a/src/errors/line_error.rs b/src/errors/line_error.rs
index ecd429409..9a9d6ef6f 100644
--- a/src/errors/line_error.rs
+++ b/src/errors/line_error.rs
@@ -5,6 +5,7 @@ use pyo3::DowncastIntoError;
 
 use jiter::JsonValue;
 
+use crate::input::BorrowInput;
 use crate::input::Input;
 
 use super::location::{LocItem, Location};
@@ -12,13 +13,19 @@ use super::types::ErrorType;
 
 pub type ValResult<T> = Result<T, ValError>;
 
-pub trait AsErrorValue {
-    fn as_error_value(&self) -> InputValue;
+pub trait ToErrorValue {
+    fn to_error_value(&self) -> InputValue;
 }
 
-impl<'a, T: Input<'a>> AsErrorValue for T {
-    fn as_error_value(&self) -> InputValue {
-        Input::as_error_value(self)
+impl<'a, T: BorrowInput<'a>> ToErrorValue for T {
+    fn to_error_value(&self) -> InputValue {
+        Input::as_error_value(self.borrow_input())
+    }
+}
+
+impl ToErrorValue for &'_ dyn ToErrorValue {
+    fn to_error_value(&self) -> InputValue {
+        (**self).to_error_value()
     }
 }
 
@@ -55,11 +62,11 @@ impl From<Vec<ValLineError>> for ValError {
 }
 
 impl ValError {
-    pub fn new(error_type: ErrorType, input: &impl AsErrorValue) -> ValError {
+    pub fn new(error_type: ErrorType, input: impl ToErrorValue) -> ValError {
         Self::LineErrors(vec![ValLineError::new(error_type, input)])
     }
 
-    pub fn new_with_loc(error_type: ErrorType, input: &impl AsErrorValue, loc: impl Into<LocItem>) -> ValError {
+    pub fn new_with_loc(error_type: ErrorType, input: impl ToErrorValue, loc: impl Into<LocItem>) -> ValError {
         Self::LineErrors(vec![ValLineError::new_with_loc(error_type, input, loc)])
     }
 
@@ -94,26 +101,26 @@ pub struct ValLineError {
 }
 
 impl ValLineError {
-    pub fn new(error_type: ErrorType, input: &impl AsErrorValue) -> ValLineError {
+    pub fn new(error_type: ErrorType, input: impl ToErrorValue) -> ValLineError {
         Self {
             error_type,
-            input_value: input.as_error_value(),
+            input_value: input.to_error_value(),
             location: Location::default(),
         }
     }
 
-    pub fn new_with_loc(error_type: ErrorType, input: &impl AsErrorValue, loc: impl Into<LocItem>) -> ValLineError {
+    pub fn new_with_loc(error_type: ErrorType, input: impl ToErrorValue, loc: impl Into<LocItem>) -> ValLineError {
         Self {
             error_type,
-            input_value: input.as_error_value(),
+            input_value: input.to_error_value(),
             location: Location::new_some(loc.into()),
         }
     }
 
-    pub fn new_with_full_loc(error_type: ErrorType, input: &impl AsErrorValue, location: Location) -> ValLineError {
+    pub fn new_with_full_loc(error_type: ErrorType, input: impl ToErrorValue, location: Location) -> ValLineError {
         Self {
             error_type,
-            input_value: input.as_error_value(),
+            input_value: input.to_error_value(),
             location,
         }
     }
diff --git a/src/errors/mod.rs b/src/errors/mod.rs
index bee5f7225..ffdda90e3 100644
--- a/src/errors/mod.rs
+++ b/src/errors/mod.rs
@@ -6,7 +6,7 @@ mod types;
 mod validation_exception;
 mod value_exception;
 
-pub use self::line_error::{AsErrorValue, InputValue, ValError, ValLineError, ValResult};
+pub use self::line_error::{InputValue, ToErrorValue, ValError, ValLineError, ValResult};
 pub use self::location::LocItem;
 pub use self::types::{list_all_errors, ErrorType, ErrorTypeDefaults, Number};
 pub use self::validation_exception::ValidationError;
diff --git a/src/errors/value_exception.rs b/src/errors/value_exception.rs
index b8b484d89..20ad6174a 100644
--- a/src/errors/value_exception.rs
+++ b/src/errors/value_exception.rs
@@ -5,7 +5,7 @@ use pyo3::types::{PyDict, PyString};
 use crate::input::InputType;
 use crate::tools::extract_i64;
 
-use super::line_error::AsErrorValue;
+use super::line_error::ToErrorValue;
 use super::{ErrorType, ValError};
 
 #[pyclass(extends=PyException, module="pydantic_core._pydantic_core")]
@@ -106,7 +106,7 @@ impl PydanticCustomError {
 }
 
 impl PydanticCustomError {
-    pub fn into_val_error(self, input: &impl AsErrorValue) -> ValError {
+    pub fn into_val_error(self, input: impl ToErrorValue) -> ValError {
         let error_type = ErrorType::CustomError {
             error_type: self.error_type,
             message_template: self.message_template,
@@ -181,7 +181,7 @@ impl PydanticKnownError {
 }
 
 impl PydanticKnownError {
-    pub fn into_val_error(self, input: &impl AsErrorValue) -> ValError {
+    pub fn into_val_error(self, input: impl ToErrorValue) -> ValError {
         ValError::new(self.error_type, input)
     }
 }
diff --git a/src/input/datetime.rs b/src/input/datetime.rs
index a567bd3d2..f8ae6929e 100644
--- a/src/input/datetime.rs
+++ b/src/input/datetime.rs
@@ -14,6 +14,7 @@ use std::hash::Hasher;
 use strum::EnumMessage;
 
 use super::Input;
+use crate::errors::ToErrorValue;
 use crate::errors::{ErrorType, ValError, ValResult};
 use crate::tools::py_err;
 
@@ -285,7 +286,7 @@ impl<'a> EitherDateTime<'a> {
     }
 }
 
-pub fn bytes_as_date<'a>(input: &'a impl Input<'a>, bytes: &[u8]) -> ValResult<EitherDate<'a>> {
+pub fn bytes_as_date<'py>(input: &(impl Input<'py> + ?Sized), bytes: &[u8]) -> ValResult<EitherDate<'py>> {
     match Date::parse_bytes(bytes) {
         Ok(date) => Ok(date.into()),
         Err(err) => Err(ValError::new(
@@ -298,11 +299,11 @@ pub fn bytes_as_date<'a>(input: &'a impl Input<'a>, bytes: &[u8]) -> ValResult<E
     }
 }
 
-pub fn bytes_as_time<'a>(
-    input: &'a impl Input<'a>,
+pub fn bytes_as_time<'py>(
+    input: &(impl Input<'py> + ?Sized),
     bytes: &[u8],
     microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
-) -> ValResult<EitherTime<'a>> {
+) -> ValResult<EitherTime<'py>> {
     match Time::parse_bytes_with_config(
         bytes,
         &TimeConfig {
@@ -321,11 +322,11 @@ pub fn bytes_as_time<'a>(
     }
 }
 
-pub fn bytes_as_datetime<'a, 'b>(
-    input: &'a impl Input<'a>,
-    bytes: &'b [u8],
+pub fn bytes_as_datetime<'py>(
+    input: &(impl Input<'py> + ?Sized),
+    bytes: &[u8],
     microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
-) -> ValResult<EitherDateTime<'a>> {
+) -> ValResult<EitherDateTime<'py>> {
     match DateTime::parse_bytes_with_config(
         bytes,
         &TimeConfig {
@@ -344,11 +345,11 @@ pub fn bytes_as_datetime<'a, 'b>(
     }
 }
 
-pub fn int_as_datetime<'a>(
-    input: &'a impl Input<'a>,
+pub fn int_as_datetime<'py>(
+    input: &(impl Input<'py> + ?Sized),
     timestamp: i64,
     timestamp_microseconds: u32,
-) -> ValResult<EitherDateTime> {
+) -> ValResult<EitherDateTime<'py>> {
     match DateTime::from_timestamp_with_config(
         timestamp,
         timestamp_microseconds,
@@ -382,7 +383,7 @@ macro_rules! nan_check {
     };
 }
 
-pub fn float_as_datetime<'a>(input: &'a impl Input<'a>, timestamp: f64) -> ValResult<EitherDateTime> {
+pub fn float_as_datetime<'py>(input: &(impl Input<'py> + ?Sized), timestamp: f64) -> ValResult<EitherDateTime<'py>> {
     nan_check!(input, timestamp, DatetimeParsing);
     let microseconds = timestamp.fract().abs() * 1_000_000.0;
     // checking for extra digits in microseconds is unreliable with large floats,
@@ -408,11 +409,11 @@ pub fn date_as_datetime<'py>(date: &Bound<'py, PyDate>) -> PyResult<EitherDateTi
 
 const MAX_U32: i64 = u32::MAX as i64;
 
-pub fn int_as_time<'a>(
-    input: &'a impl Input<'a>,
+pub fn int_as_time<'py>(
+    input: &(impl Input<'py> + ?Sized),
     timestamp: i64,
     timestamp_microseconds: u32,
-) -> ValResult<EitherTime> {
+) -> ValResult<EitherTime<'py>> {
     let time_timestamp: u32 = match timestamp {
         t if t < 0_i64 => {
             return Err(ValError::new(
@@ -447,14 +448,14 @@ pub fn int_as_time<'a>(
     }
 }
 
-pub fn float_as_time<'a>(input: &'a impl Input<'a>, timestamp: f64) -> ValResult<EitherTime> {
+pub fn float_as_time<'py>(input: &(impl Input<'py> + ?Sized), timestamp: f64) -> ValResult<EitherTime<'py>> {
     nan_check!(input, timestamp, TimeParsing);
     let microseconds = timestamp.fract().abs() * 1_000_000.0;
     // round for same reason as above
     int_as_time(input, timestamp.floor() as i64, microseconds.round() as u32)
 }
 
-fn map_timedelta_err<'a>(input: &'a impl Input<'a>, err: ParseError) -> ValError {
+fn map_timedelta_err(input: impl ToErrorValue, err: ParseError) -> ValError {
     ValError::new(
         ErrorType::TimeDeltaParsing {
             error: Cow::Borrowed(err.get_documentation().unwrap_or_default()),
@@ -464,11 +465,11 @@ fn map_timedelta_err<'a>(input: &'a impl Input<'a>, err: ParseError) -> ValError
     )
 }
 
-pub fn bytes_as_timedelta<'a, 'b>(
-    input: &'a impl Input<'a>,
-    bytes: &'b [u8],
+pub fn bytes_as_timedelta<'py>(
+    input: &(impl Input<'py> + ?Sized),
+    bytes: &[u8],
     microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
-) -> ValResult<EitherTimedelta<'a>> {
+) -> ValResult<EitherTimedelta<'py>> {
     match Duration::parse_bytes_with_config(
         bytes,
         &TimeConfig {
@@ -481,7 +482,7 @@ pub fn bytes_as_timedelta<'a, 'b>(
     }
 }
 
-pub fn int_as_duration<'a>(input: &'a impl Input<'a>, total_seconds: i64) -> ValResult<Duration> {
+pub fn int_as_duration(input: impl ToErrorValue, total_seconds: i64) -> ValResult<Duration> {
     let positive = total_seconds >= 0;
     let total_seconds = total_seconds.unsigned_abs();
     // we can safely unwrap here since we've guaranteed seconds and microseconds can't cause overflow
@@ -490,7 +491,7 @@ pub fn int_as_duration<'a>(input: &'a impl Input<'a>, total_seconds: i64) -> Val
     Duration::new(positive, days, seconds, 0).map_err(|err| map_timedelta_err(input, err))
 }
 
-pub fn float_as_duration<'a>(input: &'a impl Input<'a>, total_seconds: f64) -> ValResult<Duration> {
+pub fn float_as_duration(input: impl ToErrorValue, total_seconds: f64) -> ValResult<Duration> {
     nan_check!(input, total_seconds, TimeDeltaParsing);
     let positive = total_seconds >= 0_f64;
     let total_seconds = total_seconds.abs();
diff --git a/src/input/input_abstract.rs b/src/input/input_abstract.rs
index 4198e7202..553f0b33c 100644
--- a/src/input/input_abstract.rs
+++ b/src/input/input_abstract.rs
@@ -4,7 +4,7 @@ use pyo3::exceptions::PyValueError;
 use pyo3::types::{PyDict, PyType};
 use pyo3::{intern, prelude::*};
 
-use crate::errors::{ErrorTypeDefaults, InputValue, LocItem, ValError, ValResult};
+use crate::errors::{ErrorTypeDefaults, InputValue, ValError, ValResult};
 use crate::tools::py_err;
 use crate::{PyMultiHostUrl, PyUrl};
 
@@ -46,7 +46,7 @@ impl TryFrom<&str> for InputType {
 /// the convention is to either implement:
 /// * `strict_*` & `lax_*` if they have different behavior
 /// * or, `validate_*` and `strict_*` to just call `validate_*` if the behavior for strict and lax is the same
-pub trait Input<'py>: fmt::Debug + ToPyObject + Into<LocItem> + Sized {
+pub trait Input<'py>: fmt::Debug + ToPyObject {
     fn as_error_value(&self) -> InputValue;
 
     fn identity(&self) -> Option<usize> {
@@ -83,9 +83,9 @@ pub trait Input<'py>: fmt::Debug + ToPyObject + Into<LocItem> + Sized {
         false
     }
 
-    fn validate_args(&self) -> ValResult<GenericArguments<'_>>;
+    fn validate_args(&self) -> ValResult<GenericArguments<'_, 'py>>;
 
-    fn validate_dataclass_args<'a>(&'a self, dataclass_name: &str) -> ValResult<GenericArguments<'a>>;
+    fn validate_dataclass_args<'a>(&'a self, dataclass_name: &str) -> ValResult<GenericArguments<'a, 'py>>;
 
     fn validate_str(&self, strict: bool, coerce_numbers_to_str: bool) -> ValResult<ValidationMatch<EitherString<'_>>>;
 
@@ -201,25 +201,25 @@ pub trait Input<'py>: fmt::Debug + ToPyObject + Into<LocItem> + Sized {
 
     fn validate_iter(&self) -> ValResult<GenericIterator>;
 
-    fn validate_date(&self, strict: bool) -> ValResult<ValidationMatch<EitherDate>>;
+    fn validate_date(&self, strict: bool) -> ValResult<ValidationMatch<EitherDate<'py>>>;
 
     fn validate_time(
         &self,
         strict: bool,
         microseconds_overflow_behavior: speedate::MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<ValidationMatch<EitherTime>>;
+    ) -> ValResult<ValidationMatch<EitherTime<'py>>>;
 
     fn validate_datetime(
         &self,
         strict: bool,
         microseconds_overflow_behavior: speedate::MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<ValidationMatch<EitherDateTime>>;
+    ) -> ValResult<ValidationMatch<EitherDateTime<'py>>>;
 
     fn validate_timedelta(
         &self,
         strict: bool,
         microseconds_overflow_behavior: speedate::MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<ValidationMatch<EitherTimedelta>>;
+    ) -> ValResult<ValidationMatch<EitherTimedelta<'py>>>;
 }
 
 /// The problem to solve here is that iterating collections often returns owned
@@ -228,6 +228,13 @@ pub trait Input<'py>: fmt::Debug + ToPyObject + Into<LocItem> + Sized {
 /// or borrowed; all we care about is that we can borrow it again with `borrow_input`
 /// for some lifetime 'a.
 pub trait BorrowInput<'py> {
-    type Input: Input<'py>;
+    type Input: Input<'py> + ?Sized;
     fn borrow_input(&self) -> &Self::Input;
 }
+
+impl<'py, T: Input<'py> + ?Sized> BorrowInput<'py> for &'_ T {
+    type Input = T;
+    fn borrow_input(&self) -> &Self::Input {
+        self
+    }
+}
diff --git a/src/input/input_json.rs b/src/input/input_json.rs
index 86cfe69e4..53a261d81 100644
--- a/src/input/input_json.rs
+++ b/src/input/input_json.rs
@@ -60,7 +60,7 @@ impl<'py> Input<'py> for JsonValue {
         }
     }
 
-    fn validate_args(&self) -> ValResult<GenericArguments<'_>> {
+    fn validate_args(&self) -> ValResult<GenericArguments<'_, 'py>> {
         match self {
             JsonValue::Object(object) => Ok(JsonArgs::new(None, Some(object)).into()),
             JsonValue::Array(array) => Ok(JsonArgs::new(Some(array), None).into()),
@@ -68,7 +68,7 @@ impl<'py> Input<'py> for JsonValue {
         }
     }
 
-    fn validate_dataclass_args<'a>(&'a self, class_name: &str) -> ValResult<GenericArguments<'a>> {
+    fn validate_dataclass_args<'a>(&'a self, class_name: &str) -> ValResult<GenericArguments<'a, 'py>> {
         match self {
             JsonValue::Object(object) => Ok(JsonArgs::new(None, Some(object)).into()),
             _ => {
@@ -241,7 +241,7 @@ impl<'py> Input<'py> for JsonValue {
         }
     }
 
-    fn validate_date(&self, _strict: bool) -> ValResult<ValidationMatch<EitherDate>> {
+    fn validate_date(&self, _strict: bool) -> ValResult<ValidationMatch<EitherDate<'py>>> {
         match self {
             JsonValue::Str(v) => bytes_as_date(self, v.as_bytes()).map(ValidationMatch::strict),
             _ => Err(ValError::new(ErrorTypeDefaults::DateType, self)),
@@ -251,7 +251,7 @@ impl<'py> Input<'py> for JsonValue {
         &self,
         strict: bool,
         microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<ValidationMatch<EitherTime>> {
+    ) -> ValResult<ValidationMatch<EitherTime<'py>>> {
         match self {
             JsonValue::Str(v) => {
                 bytes_as_time(self, v.as_bytes(), microseconds_overflow_behavior).map(ValidationMatch::strict)
@@ -277,7 +277,7 @@ impl<'py> Input<'py> for JsonValue {
         &self,
         strict: bool,
         microseconds_overflow_behavior: speedate::MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<ValidationMatch<EitherDateTime>> {
+    ) -> ValResult<ValidationMatch<EitherDateTime<'py>>> {
         match self {
             JsonValue::Str(v) => {
                 bytes_as_datetime(self, v.as_bytes(), microseconds_overflow_behavior).map(ValidationMatch::strict)
@@ -292,7 +292,7 @@ impl<'py> Input<'py> for JsonValue {
         &self,
         strict: bool,
         microseconds_overflow_behavior: speedate::MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<ValidationMatch<EitherTimedelta>> {
+    ) -> ValResult<ValidationMatch<EitherTimedelta<'py>>> {
         match self {
             JsonValue::Str(v) => {
                 bytes_as_timedelta(self, v.as_bytes(), microseconds_overflow_behavior).map(ValidationMatch::strict)
@@ -308,19 +308,12 @@ impl<'py> Input<'py> for JsonValue {
     }
 }
 
-impl BorrowInput<'_> for &'_ JsonValue {
-    type Input = JsonValue;
-    fn borrow_input(&self) -> &Self::Input {
-        self
-    }
-}
-
 /// Required for JSON Object keys so the string can behave like an Input
-impl<'py> Input<'py> for String {
+impl<'py> Input<'py> for str {
     fn as_error_value(&self) -> InputValue {
         // Justification for the clone: this is on the error pathway and we are generally ok
         // with errors having a performance penalty
-        InputValue::Json(JsonValue::Str(self.clone()))
+        InputValue::Json(JsonValue::Str(self.to_owned()))
     }
 
     fn as_kwargs(&self, _py: Python<'py>) -> Option<Bound<'py, PyDict>> {
@@ -328,12 +321,12 @@ impl<'py> Input<'py> for String {
     }
 
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn validate_args(&self) -> ValResult<GenericArguments<'_>> {
+    fn validate_args(&self) -> ValResult<GenericArguments<'_, 'py>> {
         Err(ValError::new(ErrorTypeDefaults::ArgumentsType, self))
     }
 
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn validate_dataclass_args<'a>(&'a self, class_name: &str) -> ValResult<GenericArguments<'a>> {
+    fn validate_dataclass_args<'a>(&'a self, class_name: &str) -> ValResult<GenericArguments<'a, 'py>> {
         let class_name = class_name.to_string();
         Err(ValError::new(
             ErrorType::DataclassType {
@@ -354,7 +347,7 @@ impl<'py> Input<'py> for String {
         // converting input
         // TODO: in V3 we may want to make JSON str always win if in union, for consistency,
         // see https://github.com/pydantic/pydantic-core/pull/867#discussion_r1386582501
-        Ok(ValidationMatch::strict(self.as_str().into()))
+        Ok(ValidationMatch::strict(self.into()))
     }
 
     fn validate_bytes<'a>(&'a self, _strict: bool) -> ValResult<ValidationMatch<EitherBytes<'a, 'py>>> {
@@ -410,7 +403,7 @@ impl<'py> Input<'py> for String {
         Ok(string_to_vec(self).into())
     }
 
-    fn validate_date(&self, _strict: bool) -> ValResult<ValidationMatch<EitherDate>> {
+    fn validate_date(&self, _strict: bool) -> ValResult<ValidationMatch<EitherDate<'py>>> {
         bytes_as_date(self, self.as_bytes()).map(ValidationMatch::lax)
     }
 
@@ -418,7 +411,7 @@ impl<'py> Input<'py> for String {
         &self,
         _strict: bool,
         microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<ValidationMatch<EitherTime>> {
+    ) -> ValResult<ValidationMatch<EitherTime<'py>>> {
         bytes_as_time(self, self.as_bytes(), microseconds_overflow_behavior).map(ValidationMatch::lax)
     }
 
@@ -426,7 +419,7 @@ impl<'py> Input<'py> for String {
         &self,
         _strict: bool,
         microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<ValidationMatch<EitherDateTime>> {
+    ) -> ValResult<ValidationMatch<EitherDateTime<'py>>> {
         bytes_as_datetime(self, self.as_bytes(), microseconds_overflow_behavior).map(ValidationMatch::lax)
     }
 
@@ -434,20 +427,20 @@ impl<'py> Input<'py> for String {
         &self,
         _strict: bool,
         microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<ValidationMatch<EitherTimedelta>> {
+    ) -> ValResult<ValidationMatch<EitherTimedelta<'py>>> {
         bytes_as_timedelta(self, self.as_bytes(), microseconds_overflow_behavior).map(ValidationMatch::lax)
     }
 }
 
 impl BorrowInput<'_> for &'_ String {
-    type Input = String;
+    type Input = str;
     fn borrow_input(&self) -> &Self::Input {
         self
     }
 }
 
 impl BorrowInput<'_> for String {
-    type Input = String;
+    type Input = str;
     fn borrow_input(&self) -> &Self::Input {
         self
     }
diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index c74942cae..edc9aec04 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -160,7 +160,7 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
         self.is_callable()
     }
 
-    fn validate_args(&self) -> ValResult<GenericArguments<'_>> {
+    fn validate_args(&self) -> ValResult<GenericArguments<'_, 'py>> {
         if let Ok(dict) = self.downcast::<PyDict>() {
             Ok(PyArgs::new(None, Some(dict.clone())).into())
         } else if let Ok(args_kwargs) = self.extract::<ArgsKwargs>() {
@@ -176,7 +176,7 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
         }
     }
 
-    fn validate_dataclass_args<'a>(&'a self, class_name: &str) -> ValResult<GenericArguments<'a>> {
+    fn validate_dataclass_args<'a>(&'a self, class_name: &str) -> ValResult<GenericArguments<'a, 'py>> {
         if let Ok(dict) = self.downcast::<PyDict>() {
             Ok(PyArgs::new(None, Some(dict.clone())).into())
         } else if let Ok(args_kwargs) = self.extract::<ArgsKwargs>() {
@@ -584,7 +584,7 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
         }
     }
 
-    fn validate_date(&self, strict: bool) -> ValResult<ValidationMatch<EitherDate>> {
+    fn validate_date(&self, strict: bool) -> ValResult<ValidationMatch<EitherDate<'py>>> {
         if let Ok(date) = self.downcast_exact::<PyDate>() {
             Ok(ValidationMatch::exact(date.clone().into()))
         } else if self.is_instance_of::<PyDateTime>() {
@@ -615,7 +615,7 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
         &self,
         strict: bool,
         microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<ValidationMatch<EitherTime>> {
+    ) -> ValResult<ValidationMatch<EitherTime<'py>>> {
         if let Ok(time) = self.downcast_exact::<PyTime>() {
             return Ok(ValidationMatch::exact(time.clone().into()));
         } else if let Ok(time) = self.downcast::<PyTime>() {
@@ -649,7 +649,7 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
         &self,
         strict: bool,
         microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<ValidationMatch<EitherDateTime>> {
+    ) -> ValResult<ValidationMatch<EitherDateTime<'py>>> {
         if let Ok(dt) = self.downcast_exact::<PyDateTime>() {
             return Ok(ValidationMatch::exact(dt.clone().into()));
         } else if let Ok(dt) = self.downcast::<PyDateTime>() {
@@ -685,7 +685,7 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
         &self,
         strict: bool,
         microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<ValidationMatch<EitherTimedelta>> {
+    ) -> ValResult<ValidationMatch<EitherTimedelta<'py>>> {
         if let Ok(either_dt) = EitherTimedelta::try_from(self) {
             let exactness = if matches!(either_dt, EitherTimedelta::PyExact(_)) {
                 Exactness::Exact
diff --git a/src/input/input_string.rs b/src/input/input_string.rs
index 61a41cd34..486dff5ff 100644
--- a/src/input/input_string.rs
+++ b/src/input/input_string.rs
@@ -73,12 +73,12 @@ impl<'py> Input<'py> for StringMapping<'py> {
         None
     }
 
-    fn validate_args(&self) -> ValResult<GenericArguments<'_>> {
+    fn validate_args(&self) -> ValResult<GenericArguments<'_, 'py>> {
         // do we want to support this?
         Err(ValError::new(ErrorTypeDefaults::ArgumentsType, self))
     }
 
-    fn validate_dataclass_args<'a>(&'a self, _dataclass_name: &str) -> ValResult<GenericArguments<'a>> {
+    fn validate_dataclass_args<'a>(&'a self, _dataclass_name: &str) -> ValResult<GenericArguments<'a, 'py>> {
         match self {
             StringMapping::String(_) => Err(ValError::new(ErrorTypeDefaults::ArgumentsType, self)),
             StringMapping::Mapping(m) => Ok(GenericArguments::StringMapping(m.clone())),
@@ -162,7 +162,7 @@ impl<'py> Input<'py> for StringMapping<'py> {
         Err(ValError::new(ErrorTypeDefaults::IterableType, self))
     }
 
-    fn validate_date(&self, _strict: bool) -> ValResult<ValidationMatch<EitherDate>> {
+    fn validate_date(&self, _strict: bool) -> ValResult<ValidationMatch<EitherDate<'py>>> {
         match self {
             Self::String(s) => bytes_as_date(self, py_string_str(s)?.as_bytes()).map(ValidationMatch::strict),
             Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::DateType, self)),
@@ -173,7 +173,7 @@ impl<'py> Input<'py> for StringMapping<'py> {
         &self,
         _strict: bool,
         microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<ValidationMatch<EitherTime>> {
+    ) -> ValResult<ValidationMatch<EitherTime<'py>>> {
         match self {
             Self::String(s) => bytes_as_time(self, py_string_str(s)?.as_bytes(), microseconds_overflow_behavior)
                 .map(ValidationMatch::strict),
@@ -185,7 +185,7 @@ impl<'py> Input<'py> for StringMapping<'py> {
         &self,
         _strict: bool,
         microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<ValidationMatch<EitherDateTime>> {
+    ) -> ValResult<ValidationMatch<EitherDateTime<'py>>> {
         match self {
             Self::String(s) => bytes_as_datetime(self, py_string_str(s)?.as_bytes(), microseconds_overflow_behavior)
                 .map(ValidationMatch::strict),
@@ -197,7 +197,7 @@ impl<'py> Input<'py> for StringMapping<'py> {
         &self,
         _strict: bool,
         microseconds_overflow_behavior: MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<ValidationMatch<EitherTimedelta>> {
+    ) -> ValResult<ValidationMatch<EitherTimedelta<'py>>> {
         match self {
             Self::String(s) => bytes_as_timedelta(self, py_string_str(s)?.as_bytes(), microseconds_overflow_behavior)
                 .map(ValidationMatch::strict),
diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index b365500e0..a6db98710 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -20,7 +20,9 @@ use pyo3::{ffi, intern};
 use pyo3::types::PyFunction;
 use serde::{ser::Error, Serialize, Serializer};
 
-use crate::errors::{py_err_string, ErrorType, ErrorTypeDefaults, InputValue, ValError, ValLineError, ValResult};
+use crate::errors::{
+    py_err_string, ErrorType, ErrorTypeDefaults, InputValue, ToErrorValue, ValError, ValLineError, ValResult,
+};
 use crate::tools::{extract_i64, py_err};
 use crate::validators::{CombinedValidator, Exactness, ValidationState, Validator};
 
@@ -83,7 +85,7 @@ pub enum GenericIterable<'a, 'py> {
     Iterator(Bound<'py, PyIterator>),
     JsonArray(&'a [JsonValue]),
     JsonObject(&'a JsonObject),
-    JsonString(&'a String),
+    JsonString(&'a str),
 }
 
 impl<'py> GenericIterable<'_, 'py> {
@@ -121,8 +123,7 @@ impl<'py> GenericIterable<'_, 'py> {
     }
 }
 
-#[derive(Debug)]
-struct MaxLengthCheck<'a, INPUT> {
+struct MaxLengthCheck<'a, INPUT: ?Sized> {
     current_length: usize,
     max_length: Option<usize>,
     field_type: &'a str,
@@ -130,7 +131,7 @@ struct MaxLengthCheck<'a, INPUT> {
     actual_length: Option<usize>,
 }
 
-impl<'a, INPUT> MaxLengthCheck<'a, INPUT> {
+impl<'a, INPUT: ?Sized> MaxLengthCheck<'a, INPUT> {
     fn new(max_length: Option<usize>, field_type: &'a str, input: &'a INPUT, actual_length: Option<usize>) -> Self {
         Self {
             current_length: 0,
@@ -142,19 +143,19 @@ impl<'a, INPUT> MaxLengthCheck<'a, INPUT> {
     }
 }
 
-impl<'a, INPUT: Input<'a>> MaxLengthCheck<'_, INPUT> {
+impl<'py, INPUT: Input<'py> + ?Sized> MaxLengthCheck<'_, INPUT> {
     fn incr(&mut self) -> ValResult<()> {
         if let Some(max_length) = self.max_length {
             self.current_length += 1;
             if self.current_length > max_length {
-                return Err(ValError::new(
+                return Err(ValError::new_custom_input(
                     ErrorType::TooLong {
                         field_type: self.field_type.to_string(),
                         max_length,
                         actual_length: self.actual_length,
                         context: None,
                     },
-                    self.input,
+                    self.input.to_error_value(),
                 ));
             }
         }
@@ -176,13 +177,13 @@ macro_rules! any_next_error {
 }
 
 #[allow(clippy::too_many_arguments)]
-fn validate_iter_to_vec<'a, 's>(
-    py: Python<'a>,
-    iter: impl Iterator<Item = PyResult<impl BorrowInput<'a>>>,
+fn validate_iter_to_vec<'py>(
+    py: Python<'py>,
+    iter: impl Iterator<Item = PyResult<impl BorrowInput<'py>>>,
     capacity: usize,
-    mut max_length_check: MaxLengthCheck<'_, impl Input<'a>>,
-    validator: &'s CombinedValidator,
-    state: &mut ValidationState,
+    mut max_length_check: MaxLengthCheck<'_, impl Input<'py> + ?Sized>,
+    validator: &CombinedValidator,
+    state: &mut ValidationState<'_, 'py>,
 ) -> ValResult<Vec<PyObject>> {
     let mut output: Vec<PyObject> = Vec::with_capacity(capacity);
     let mut errors: Vec<ValLineError> = Vec::new();
@@ -240,15 +241,15 @@ impl BuildSet for Bound<'_, PyFrozenSet> {
 }
 
 #[allow(clippy::too_many_arguments)]
-fn validate_iter_to_set<'a, 's>(
-    py: Python<'a>,
+fn validate_iter_to_set<'py>(
+    py: Python<'py>,
     set: &impl BuildSet,
-    iter: impl Iterator<Item = PyResult<impl BorrowInput<'a>>>,
-    input: &impl Input<'a>,
+    iter: impl Iterator<Item = PyResult<impl BorrowInput<'py>>>,
+    input: &(impl Input<'py> + ?Sized),
     field_type: &'static str,
     max_length: Option<usize>,
-    validator: &'s CombinedValidator,
-    state: &mut ValidationState,
+    validator: &CombinedValidator,
+    state: &mut ValidationState<'_, 'py>,
 ) -> ValResult<()> {
     let mut errors: Vec<ValLineError> = Vec::new();
     for (index, item_result) in iter.enumerate() {
@@ -290,9 +291,9 @@ fn validate_iter_to_set<'a, 's>(
 
 fn no_validator_iter_to_vec<'py>(
     py: Python<'py>,
-    input: &impl Input<'py>,
+    input: &(impl Input<'py> + ?Sized),
     iter: impl Iterator<Item = PyResult<impl BorrowInput<'py>>>,
-    mut max_length_check: MaxLengthCheck<'_, impl Input<'py>>,
+    mut max_length_check: MaxLengthCheck<'_, impl Input<'py> + ?Sized>,
 ) -> ValResult<Vec<PyObject>> {
     iter.enumerate()
         .map(|(index, result)| {
@@ -333,11 +334,11 @@ impl<'py> GenericIterable<'_, 'py> {
     pub fn validate_to_vec(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
+        input: &(impl Input<'py> + ?Sized),
         max_length: Option<usize>,
         field_type: &'static str,
         validator: &CombinedValidator,
-        state: &mut ValidationState,
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<Vec<PyObject>> {
         let actual_length = self.generic_len();
         let capacity = actual_length.unwrap_or(DEFAULT_CAPACITY);
@@ -366,11 +367,11 @@ impl<'py> GenericIterable<'_, 'py> {
         &self,
         py: Python<'py>,
         set: &impl BuildSet,
-        input: &impl Input<'py>,
+        input: &(impl Input<'py> + ?Sized),
         max_length: Option<usize>,
         field_type: &'static str,
         validator: &CombinedValidator,
-        state: &mut ValidationState,
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<()> {
         macro_rules! validate_set {
             ($iter:expr) => {
@@ -393,7 +394,7 @@ impl<'py> GenericIterable<'_, 'py> {
     pub fn to_vec(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
+        input: &(impl Input<'py> + ?Sized),
         field_type: &'static str,
         max_length: Option<usize>,
     ) -> ValResult<Vec<PyObject>> {
@@ -479,7 +480,7 @@ pub struct MappingGenericIterator<'py> {
     iter: Bound<'py, PyIterator>,
 }
 
-fn mapping_err<'py>(err: PyErr, py: Python<'py>, input: &'py impl Input<'py>) -> ValError {
+fn mapping_err<'py>(err: PyErr, py: Python<'py>, input: &'py (impl Input<'py> + ?Sized)) -> ValError {
     ValError::new(
         ErrorType::MappingType {
             error: py_err_string(py, err).into(),
@@ -742,20 +743,20 @@ impl<'a> JsonArgs<'a> {
 }
 
 #[cfg_attr(debug_assertions, derive(Debug))]
-pub enum GenericArguments<'a> {
-    Py(PyArgs<'a>),
+pub enum GenericArguments<'a, 'py> {
+    Py(PyArgs<'py>),
     Json(JsonArgs<'a>),
-    StringMapping(Bound<'a, PyDict>),
+    StringMapping(Bound<'py, PyDict>),
 }
 
-impl<'a> From<PyArgs<'a>> for GenericArguments<'a> {
-    fn from(s: PyArgs<'a>) -> GenericArguments<'a> {
+impl<'py> From<PyArgs<'py>> for GenericArguments<'_, 'py> {
+    fn from(s: PyArgs<'py>) -> Self {
         Self::Py(s)
     }
 }
 
-impl<'a> From<JsonArgs<'a>> for GenericArguments<'a> {
-    fn from(s: JsonArgs<'a>) -> GenericArguments<'a> {
+impl<'a> From<JsonArgs<'a>> for GenericArguments<'a, '_> {
+    fn from(s: JsonArgs<'a>) -> Self {
         Self::Json(s)
     }
 }
diff --git a/src/input/shared.rs b/src/input/shared.rs
index 2f8edf6ad..5f0040e3e 100644
--- a/src/input/shared.rs
+++ b/src/input/shared.rs
@@ -20,7 +20,7 @@ pub fn get_enum_meta_object(py: Python) -> &Bound<'_, PyAny> {
         .bind(py)
 }
 
-pub fn str_as_bool<'py>(input: &impl Input<'py>, str: &str) -> ValResult<bool> {
+pub fn str_as_bool<'py>(input: &(impl Input<'py> + ?Sized), str: &str) -> ValResult<bool> {
     if str == "0"
         || str.eq_ignore_ascii_case("f")
         || str.eq_ignore_ascii_case("n")
@@ -42,7 +42,7 @@ pub fn str_as_bool<'py>(input: &impl Input<'py>, str: &str) -> ValResult<bool> {
     }
 }
 
-pub fn int_as_bool<'py>(input: &impl Input<'py>, int: i64) -> ValResult<bool> {
+pub fn int_as_bool<'py>(input: &(impl Input<'py> + ?Sized), int: i64) -> ValResult<bool> {
     if int == 0 {
         Ok(false)
     } else if int == 1 {
@@ -72,7 +72,7 @@ fn strip_underscores(s: &str) -> Option<String> {
 /// max length of the input is 4300, see
 /// https://docs.python.org/3/whatsnew/3.11.html#other-cpython-implementation-changes and
 /// https://github.com/python/cpython/issues/95778 for more info in that length bound
-pub fn str_as_int<'s>(input: &'s impl Input<'s>, str: &str) -> ValResult<EitherInt<'s>> {
+pub fn str_as_int<'py>(input: &(impl Input<'py> + ?Sized), str: &str) -> ValResult<EitherInt<'py>> {
     let str = str.trim();
     let len = str.len();
     if len > 4300 {
@@ -97,7 +97,7 @@ pub fn str_as_int<'s>(input: &'s impl Input<'s>, str: &str) -> ValResult<EitherI
 }
 
 /// parse a float as a float
-pub fn str_as_float<'s>(input: &'s impl Input<'s>, str: &str) -> ValResult<EitherFloat<'s>> {
+pub fn str_as_float<'py>(input: &(impl Input<'py> + ?Sized), str: &str) -> ValResult<EitherFloat<'py>> {
     match str.trim().parse() {
         Ok(float) => Ok(EitherFloat::F64(float)),
         Err(_) => match strip_underscores(str).and_then(|stripped| stripped.parse().ok()) {
@@ -109,7 +109,7 @@ pub fn str_as_float<'s>(input: &'s impl Input<'s>, str: &str) -> ValResult<Eithe
 
 /// parse a string as an int, `input` is required here to get lifetimes to match up
 ///
-fn _parse_str<'s>(_input: &'s impl Input<'s>, str: &str, len: usize) -> Option<EitherInt<'s>> {
+fn _parse_str<'py>(_input: &(impl Input<'py> + ?Sized), str: &str, len: usize) -> Option<EitherInt<'py>> {
     if len < 19 {
         if let Ok(i) = str.parse::<i64>() {
             return Some(EitherInt::I64(i));
@@ -131,7 +131,7 @@ fn strip_decimal_zeros(s: &str) -> Option<&str> {
     None
 }
 
-pub fn float_as_int<'a>(input: &'a impl Input<'a>, float: f64) -> ValResult<EitherInt<'a>> {
+pub fn float_as_int<'py>(input: &(impl Input<'py> + ?Sized), float: f64) -> ValResult<EitherInt<'py>> {
     if float.is_infinite() || float.is_nan() {
         Err(ValError::new(ErrorTypeDefaults::FiniteNumber, input))
     } else if float % 1.0 != 0.0 {
@@ -143,7 +143,10 @@ pub fn float_as_int<'a>(input: &'a impl Input<'a>, float: f64) -> ValResult<Eith
     }
 }
 
-pub fn decimal_as_int<'a>(input: &'a impl Input<'a>, decimal: &Bound<'a, PyAny>) -> ValResult<EitherInt<'a>> {
+pub fn decimal_as_int<'py>(
+    input: &(impl Input<'py> + ?Sized),
+    decimal: &Bound<'py, PyAny>,
+) -> ValResult<EitherInt<'py>> {
     let py = decimal.py();
     if !decimal.call_method0(intern!(py, "is_finite"))?.extract::<bool>()? {
         return Err(ValError::new(ErrorTypeDefaults::FiniteNumber, input));
diff --git a/src/lookup_key.rs b/src/lookup_key.rs
index d8f8aac61..a7772a184 100644
--- a/src/lookup_key.rs
+++ b/src/lookup_key.rs
@@ -8,8 +8,8 @@ use pyo3::types::{PyDict, PyList, PyMapping, PyString};
 use jiter::{JsonObject, JsonValue};
 
 use crate::build_tools::py_schema_err;
-use crate::errors::{py_err_string, ErrorType, ValError, ValLineError, ValResult};
-use crate::input::{Input, StringMapping};
+use crate::errors::{py_err_string, ErrorType, ToErrorValue, ValError, ValLineError, ValResult};
+use crate::input::StringMapping;
 use crate::tools::{extract_i64, py_err};
 
 /// Used for getting items from python dicts, python objects, or JSON objects, in different ways
@@ -307,10 +307,10 @@ impl LookupKey {
         }
     }
 
-    pub fn error<'d>(
+    pub fn error(
         &self,
         error_type: ErrorType,
-        input: &impl Input<'d>,
+        input: impl ToErrorValue,
         loc_by_alias: bool,
         field_name: &str,
     ) -> ValLineError {
diff --git a/src/validators/any.rs b/src/validators/any.rs
index a274ff642..d254cb31b 100644
--- a/src/validators/any.rs
+++ b/src/validators/any.rs
@@ -30,8 +30,8 @@ impl Validator for AnyValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         // in a union, Any should be preferred to doing lax coercions
         state.floor_exactness(Exactness::Strict);
diff --git a/src/validators/arguments.rs b/src/validators/arguments.rs
index 33a9e504a..e2e2d13de 100644
--- a/src/validators/arguments.rs
+++ b/src/validators/arguments.rs
@@ -169,8 +169,8 @@ impl Validator for ArgumentsValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let args = input.validate_args()?;
 
diff --git a/src/validators/bool.rs b/src/validators/bool.rs
index 81f7d51df..d09fbd5f0 100644
--- a/src/validators/bool.rs
+++ b/src/validators/bool.rs
@@ -33,8 +33,8 @@ impl Validator for BoolValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         // TODO in theory this could be quicker if we used PyBool rather than going to a bool
         // and back again, might be worth profiling?
diff --git a/src/validators/bytes.rs b/src/validators/bytes.rs
index ded9da112..eb9d9441d 100644
--- a/src/validators/bytes.rs
+++ b/src/validators/bytes.rs
@@ -43,8 +43,8 @@ impl Validator for BytesValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         input
             .validate_bytes(state.strict_or(self.strict))
@@ -69,8 +69,8 @@ impl Validator for BytesConstrainedValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let either_bytes = input.validate_bytes(state.strict_or(self.strict))?.unpack(state);
         let len = either_bytes.len()?;
diff --git a/src/validators/call.rs b/src/validators/call.rs
index 09f0fa771..6783a5eda 100644
--- a/src/validators/call.rs
+++ b/src/validators/call.rs
@@ -78,8 +78,8 @@ impl Validator for CallValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let args = self.arguments_validator.validate(py, input, state)?.into_bound(py);
 
diff --git a/src/validators/callable.rs b/src/validators/callable.rs
index 15c3c3c6b..235dc6dd0 100644
--- a/src/validators/callable.rs
+++ b/src/validators/callable.rs
@@ -28,8 +28,8 @@ impl Validator for CallableValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         state.floor_exactness(Exactness::Lax);
         match input.callable() {
diff --git a/src/validators/chain.rs b/src/validators/chain.rs
index 0b20b142e..f7137d398 100644
--- a/src/validators/chain.rs
+++ b/src/validators/chain.rs
@@ -73,8 +73,8 @@ impl Validator for ChainValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let mut steps_iter = self.steps.iter();
         let first_step = steps_iter.next().unwrap();
diff --git a/src/validators/custom_error.rs b/src/validators/custom_error.rs
index 44dffbdb5..6759f7795 100644
--- a/src/validators/custom_error.rs
+++ b/src/validators/custom_error.rs
@@ -3,7 +3,7 @@ use pyo3::prelude::*;
 use pyo3::types::PyDict;
 
 use crate::build_tools::py_schema_err;
-use crate::errors::AsErrorValue;
+use crate::errors::ToErrorValue;
 use crate::errors::{ErrorType, PydanticCustomError, PydanticKnownError, ValError, ValResult};
 use crate::input::Input;
 use crate::tools::SchemaDict;
@@ -49,7 +49,7 @@ impl CustomError {
         }
     }
 
-    pub fn as_val_error(&self, input: &impl AsErrorValue) -> ValError {
+    pub fn as_val_error(&self, input: impl ToErrorValue) -> ValError {
         match self {
             CustomError::KnownError(ref known_error) => known_error.clone().into_val_error(input),
             CustomError::Custom(ref custom_error) => custom_error.clone().into_val_error(input),
@@ -91,8 +91,8 @@ impl Validator for CustomErrorValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         self.validator
             .validate(py, input, state)
diff --git a/src/validators/dataclass.rs b/src/validators/dataclass.rs
index 68067ef78..e2b479fbd 100644
--- a/src/validators/dataclass.rs
+++ b/src/validators/dataclass.rs
@@ -144,8 +144,8 @@ impl Validator for DataclassArgsValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let args = input.validate_dataclass_args(&self.dataclass_name)?;
 
@@ -382,13 +382,13 @@ impl Validator for DataclassArgsValidator {
         }
     }
 
-    fn validate_assignment<'data>(
+    fn validate_assignment<'py>(
         &self,
-        py: Python<'data>,
-        obj: &Bound<'data, PyAny>,
+        py: Python<'py>,
+        obj: &Bound<'py, PyAny>,
         field_name: &str,
-        field_value: &Bound<'data, PyAny>,
-        state: &mut ValidationState,
+        field_value: &Bound<'py, PyAny>,
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let dict = obj.downcast::<PyDict>()?;
 
@@ -532,8 +532,8 @@ impl Validator for DataclassValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         if let Some(self_instance) = state.extra().self_instance {
             // in the case that self_instance is Some, we're calling validation from within `BaseModel.__init__`
@@ -569,13 +569,13 @@ impl Validator for DataclassValidator {
         }
     }
 
-    fn validate_assignment<'data>(
+    fn validate_assignment<'py>(
         &self,
-        py: Python<'data>,
-        obj: &Bound<'data, PyAny>,
+        py: Python<'py>,
+        obj: &Bound<'py, PyAny>,
         field_name: &str,
-        field_value: &Bound<'data, PyAny>,
-        state: &mut ValidationState,
+        field_value: &Bound<'py, PyAny>,
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         if self.frozen {
             return Err(ValError::new(ErrorTypeDefaults::FrozenInstance, field_value));
@@ -610,12 +610,12 @@ impl Validator for DataclassValidator {
 
 impl DataclassValidator {
     /// here we just call the inner validator, then set attributes on `self_instance`
-    fn validate_init<'s, 'data>(
-        &'s self,
-        py: Python<'data>,
+    fn validate_init<'py>(
+        &self,
+        py: Python<'py>,
         self_instance: &Bound<'_, PyAny>,
-        input: &impl Input<'data>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         // we need to set `self_instance` to None for nested validators as we don't want to operate on the self_instance
         // instance anymore
@@ -637,12 +637,12 @@ impl DataclassValidator {
         Ok(dict)
     }
 
-    fn set_dict_call<'s, 'data>(
-        &'s self,
-        py: Python<'data>,
+    fn set_dict_call<'py>(
+        &self,
+        py: Python<'py>,
         dc: &Bound<'_, PyAny>,
         val_output: PyObject,
-        input: &impl Input<'data>,
+        input: &(impl Input<'py> + ?Sized),
     ) -> ValResult<()> {
         let (dc_dict, post_init_kwargs): (Bound<'_, PyAny>, Bound<'_, PyAny>) = val_output.extract(py)?;
         if self.slots {
diff --git a/src/validators/date.rs b/src/validators/date.rs
index c34d9eeaf..75aefa935 100644
--- a/src/validators/date.rs
+++ b/src/validators/date.rs
@@ -42,8 +42,8 @@ impl Validator for DateValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let strict = state.strict_or(self.strict);
         let date = match input.validate_date(strict) {
@@ -109,7 +109,7 @@ impl Validator for DateValidator {
 /// "exact date", e.g. has a zero time component.
 ///
 /// Ok(None) means that this is not relevant to dates (the input was not a datetime nor a string)
-fn date_from_datetime<'data>(input: &impl Input<'data>) -> Result<Option<EitherDate<'data>>, ValError> {
+fn date_from_datetime<'py>(input: &(impl Input<'py> + ?Sized)) -> Result<Option<EitherDate<'py>>, ValError> {
     let either_dt = match input.validate_datetime(false, speedate::MicrosecondsPrecisionOverflowBehavior::Truncate) {
         Ok(val_match) => val_match.into_inner(),
         // if the error was a parsing error, update the error type from DatetimeParsing to DateFromDatetimeParsing
diff --git a/src/validators/datetime.rs b/src/validators/datetime.rs
index d31f53bec..4874e78a3 100644
--- a/src/validators/datetime.rs
+++ b/src/validators/datetime.rs
@@ -8,6 +8,7 @@ use strum::EnumMessage;
 
 use crate::build_tools::{is_strict, py_schema_error_type};
 use crate::build_tools::{py_schema_err, schema_or_config_same};
+use crate::errors::ToErrorValue;
 use crate::errors::{py_err_string, ErrorType, ErrorTypeDefaults, ValError, ValResult};
 use crate::input::{EitherDateTime, Input};
 
@@ -62,8 +63,8 @@ impl Validator for DateTimeValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let strict = state.strict_or(self.strict);
         let datetime = match input.validate_datetime(strict, self.microseconds_precision) {
@@ -141,7 +142,7 @@ impl Validator for DateTimeValidator {
 
 /// In lax mode, if the input is not a datetime, we try parsing the input as a date and add the "00:00:00" time.
 /// Ok(None) means that this is not relevant to datetimes (the input was not a date nor a string)
-fn datetime_from_date<'data>(input: &impl Input<'data>) -> Result<Option<EitherDateTime<'data>>, ValError> {
+fn datetime_from_date<'py>(input: &(impl Input<'py> + ?Sized)) -> Result<Option<EitherDateTime<'py>>, ValError> {
     let either_date = match input.validate_date(false) {
         Ok(val_match) => val_match.into_inner(),
         // if the error was a parsing error, update the error type from DateParsing to DatetimeFromDateParsing
@@ -307,7 +308,7 @@ impl TZConstraint {
         }
     }
 
-    pub(super) fn tz_check<'d>(&self, tz_offset: Option<i32>, input: &impl Input<'d>) -> ValResult<()> {
+    pub(super) fn tz_check(&self, tz_offset: Option<i32>, input: impl ToErrorValue) -> ValResult<()> {
         match (self, tz_offset) {
             (TZConstraint::Aware(_), None) => return Err(ValError::new(ErrorTypeDefaults::TimezoneAware, input)),
             (TZConstraint::Aware(Some(tz_expected)), Some(tz_actual)) => {
diff --git a/src/validators/decimal.rs b/src/validators/decimal.rs
index 183647656..38409c9d4 100644
--- a/src/validators/decimal.rs
+++ b/src/validators/decimal.rs
@@ -5,10 +5,10 @@ use pyo3::types::{IntoPyDict, PyDict, PyTuple, PyType};
 use pyo3::{prelude::*, PyTypeInfo};
 
 use crate::build_tools::{is_strict, schema_or_config_same};
-use crate::errors::ValError;
+use crate::errors::ErrorType;
 use crate::errors::ValResult;
-use crate::errors::{ErrorType, InputValue};
 use crate::errors::{ErrorTypeDefaults, Number};
+use crate::errors::{ToErrorValue, ValError};
 use crate::input::Input;
 use crate::tools::SchemaDict;
 
@@ -120,8 +120,8 @@ impl Validator for DecimalValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let decimal = input.validate_decimal(state.strict_or(self.strict), py)?;
 
@@ -264,7 +264,7 @@ impl Validator for DecimalValidator {
     }
 }
 
-pub(crate) fn create_decimal<'a>(arg: &Bound<'a, PyAny>, input: &impl Input<'a>) -> ValResult<Bound<'a, PyAny>> {
+pub(crate) fn create_decimal<'py>(arg: &Bound<'py, PyAny>, input: impl ToErrorValue) -> ValResult<Bound<'py, PyAny>> {
     let py = arg.py();
     get_decimal_type(py).call1((arg,)).map_err(|e| {
         let decimal_exception = match py
@@ -274,16 +274,16 @@ pub(crate) fn create_decimal<'a>(arg: &Bound<'a, PyAny>, input: &impl Input<'a>)
             Ok(decimal_exception) => decimal_exception,
             Err(e) => return ValError::InternalErr(e),
         };
-        handle_decimal_new_error(input.as_error_value(), e, decimal_exception)
+        handle_decimal_new_error(input, e, decimal_exception)
     })
 }
 
-fn handle_decimal_new_error(input: InputValue, error: PyErr, decimal_exception: Bound<'_, PyAny>) -> ValError {
+fn handle_decimal_new_error(input: impl ToErrorValue, error: PyErr, decimal_exception: Bound<'_, PyAny>) -> ValError {
     let py = decimal_exception.py();
     if error.matches(py, decimal_exception) {
-        ValError::new_custom_input(ErrorTypeDefaults::DecimalParsing, input)
+        ValError::new(ErrorTypeDefaults::DecimalParsing, input)
     } else if error.matches(py, PyTypeError::type_object_bound(py)) {
-        ValError::new_custom_input(ErrorTypeDefaults::DecimalType, input)
+        ValError::new(ErrorTypeDefaults::DecimalType, input)
     } else {
         ValError::InternalErr(error)
     }
diff --git a/src/validators/definitions.rs b/src/validators/definitions.rs
index a6599c847..9cbb32271 100644
--- a/src/validators/definitions.rs
+++ b/src/validators/definitions.rs
@@ -72,8 +72,8 @@ impl Validator for DefinitionRefValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         self.definition.read(|validator| {
             let validator = validator.unwrap();
@@ -88,13 +88,13 @@ impl Validator for DefinitionRefValidator {
         })
     }
 
-    fn validate_assignment<'data>(
+    fn validate_assignment<'py>(
         &self,
-        py: Python<'data>,
-        obj: &Bound<'data, PyAny>,
+        py: Python<'py>,
+        obj: &Bound<'py, PyAny>,
         field_name: &str,
-        field_value: &Bound<'data, PyAny>,
-        state: &mut ValidationState,
+        field_value: &Bound<'py, PyAny>,
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         self.definition.read(|validator| {
             let validator = validator.unwrap();
diff --git a/src/validators/dict.rs b/src/validators/dict.rs
index 425ea606e..48a7c82b2 100644
--- a/src/validators/dict.rs
+++ b/src/validators/dict.rs
@@ -70,8 +70,8 @@ impl Validator for DictValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let strict = state.strict_or(self.strict);
         let dict = input.validate_dict(strict)?;
@@ -99,14 +99,14 @@ impl Validator for DictValidator {
 }
 
 impl DictValidator {
-    fn validate_generic_mapping<'data>(
+    fn validate_generic_mapping<'py>(
         &self,
-        py: Python<'data>,
-        input: &impl Input<'data>,
+        py: Python<'py>,
+        input: &(impl Input<'py> + ?Sized),
         mapping_iter: impl Iterator<
-            Item = ValResult<(impl BorrowInput<'data> + Clone + Into<LocItem>, impl BorrowInput<'data>)>,
+            Item = ValResult<(impl BorrowInput<'py> + Clone + Into<LocItem>, impl BorrowInput<'py>)>,
         >,
-        state: &mut ValidationState,
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let output = PyDict::new_bound(py);
         let mut errors: Vec<ValLineError> = Vec::new();
diff --git a/src/validators/float.rs b/src/validators/float.rs
index 3d8a9a9a8..3a79de9fe 100644
--- a/src/validators/float.rs
+++ b/src/validators/float.rs
@@ -67,8 +67,8 @@ impl Validator for FloatValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let either_float = input.validate_float(state.strict_or(self.strict))?.unpack(state);
         if !self.allow_inf_nan && !either_float.as_f64().is_finite() {
@@ -99,8 +99,8 @@ impl Validator for ConstrainedFloatValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let either_float = input.validate_float(state.strict_or(self.strict))?.unpack(state);
         let float: f64 = either_float.as_f64();
diff --git a/src/validators/frozenset.rs b/src/validators/frozenset.rs
index b5f705627..b6b395630 100644
--- a/src/validators/frozenset.rs
+++ b/src/validators/frozenset.rs
@@ -31,8 +31,8 @@ impl Validator for FrozenSetValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let collection = input.validate_frozenset(state.strict_or(self.strict))?;
         let exactness = match &collection {
diff --git a/src/validators/function.rs b/src/validators/function.rs
index 6f54e5a16..855337a01 100644
--- a/src/validators/function.rs
+++ b/src/validators/function.rs
@@ -6,7 +6,8 @@ use pyo3::types::{PyAny, PyDict, PyString};
 use pyo3::{intern, PyTraverseError, PyVisit};
 
 use crate::errors::{
-    ErrorType, PydanticCustomError, PydanticKnownError, PydanticOmit, ValError, ValResult, ValidationError,
+    ErrorType, PydanticCustomError, PydanticKnownError, PydanticOmit, ToErrorValue, ValError, ValResult,
+    ValidationError,
 };
 use crate::input::Input;
 use crate::py_gc::PyGcTraverse;
@@ -93,12 +94,12 @@ pub struct FunctionBeforeValidator {
 impl_build!(FunctionBeforeValidator, "function-before");
 
 impl FunctionBeforeValidator {
-    fn _validate<'s, 'data>(
+    fn _validate<'s, 'py>(
         &'s self,
-        call: impl FnOnce(Bound<'data, PyAny>, &mut ValidationState<'_>) -> ValResult<PyObject>,
-        py: Python<'data>,
-        input: &impl Input<'data>,
-        state: &'s mut ValidationState<'_>,
+        call: impl FnOnce(Bound<'py, PyAny>, &mut ValidationState<'_, 'py>) -> ValResult<PyObject>,
+        py: Python<'py>,
+        input: &(impl Input<'py> + ?Sized),
+        state: &'s mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let r = if self.info_arg {
             let info = ValidationInfo::new(py, state.extra(), &self.config, self.field_name.clone());
@@ -118,24 +119,24 @@ impl_py_gc_traverse!(FunctionBeforeValidator {
 });
 
 impl Validator for FunctionBeforeValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &impl Input<'data>,
-        state: &mut ValidationState<'_>,
+        py: Python<'py>,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
-        let validate = |v, s: &mut ValidationState<'_>| self.validator.validate(py, &v, s);
+        let validate = |v, s: &mut ValidationState<'_, 'py>| self.validator.validate(py, &v, s);
         self._validate(validate, py, input, state)
     }
-    fn validate_assignment<'data>(
+    fn validate_assignment<'py>(
         &self,
-        py: Python<'data>,
-        obj: &Bound<'data, PyAny>,
+        py: Python<'py>,
+        obj: &Bound<'py, PyAny>,
         field_name: &str,
-        field_value: &Bound<'data, PyAny>,
-        state: &mut ValidationState,
+        field_value: &Bound<'py, PyAny>,
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
-        let validate = move |v, s: &mut ValidationState<'_>| {
+        let validate = move |v, s: &mut ValidationState<'_, 'py>| {
             self.validator.validate_assignment(py, &v, field_name, field_value, s)
         };
         self._validate(validate, py, obj, state)
@@ -159,12 +160,12 @@ pub struct FunctionAfterValidator {
 impl_build!(FunctionAfterValidator, "function-after");
 
 impl FunctionAfterValidator {
-    fn _validate<'s, 'data, I: Input<'data>>(
-        &'s self,
-        call: impl FnOnce(&I, &mut ValidationState<'_>) -> ValResult<PyObject>,
-        py: Python<'data>,
+    fn _validate<'py, I: Input<'py> + ?Sized>(
+        &self,
+        call: impl FnOnce(&I, &mut ValidationState<'_, 'py>) -> ValResult<PyObject>,
+        py: Python<'py>,
         input: &I,
-        state: &mut ValidationState<'_>,
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let v = call(input, state)?;
         let r = if self.info_arg {
@@ -184,24 +185,24 @@ impl_py_gc_traverse!(FunctionAfterValidator {
 });
 
 impl Validator for FunctionAfterValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &impl Input<'data>,
-        state: &mut ValidationState<'_>,
+        py: Python<'py>,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
-        let validate = |v: &_, s: &mut ValidationState<'_>| self.validator.validate(py, v, s);
+        let validate = |v: &_, s: &mut ValidationState<'_, 'py>| self.validator.validate(py, v, s);
         self._validate(validate, py, input, state)
     }
-    fn validate_assignment<'data>(
+    fn validate_assignment<'py>(
         &self,
-        py: Python<'data>,
-        obj: &Bound<'data, PyAny>,
+        py: Python<'py>,
+        obj: &Bound<'py, PyAny>,
         field_name: &str,
-        field_value: &Bound<'data, PyAny>,
-        state: &mut ValidationState,
+        field_value: &Bound<'py, PyAny>,
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
-        let validate = move |v: &Bound<'data, PyAny>, s: &mut ValidationState<'_>| {
+        let validate = move |v: &Bound<'py, PyAny>, s: &mut ValidationState<'_, 'py>| {
             self.validator.validate_assignment(py, v, field_name, field_value, s)
         };
         self._validate(validate, py, obj, state)
@@ -251,8 +252,8 @@ impl Validator for FunctionPlainValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let r = if self.info_arg {
             let info = ValidationInfo::new(py, state.extra(), &self.config, self.field_name.clone());
@@ -311,12 +312,12 @@ impl BuildValidator for FunctionWrapValidator {
 }
 
 impl FunctionWrapValidator {
-    fn _validate<'s, 'data>(
-        &'s self,
+    fn _validate<'py>(
+        &self,
         handler: &Bound<'_, PyAny>,
-        py: Python<'data>,
-        input: &impl Input<'data>,
-        state: &mut ValidationState,
+        py: Python<'py>,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let r = if self.info_arg {
             let info = ValidationInfo::new(py, state.extra(), &self.config, self.field_name.clone());
@@ -338,8 +339,8 @@ impl Validator for FunctionWrapValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let handler = ValidatorCallable {
             validator: InternalValidator::new(
@@ -357,13 +358,13 @@ impl Validator for FunctionWrapValidator {
         result
     }
 
-    fn validate_assignment<'data>(
+    fn validate_assignment<'py>(
         &self,
-        py: Python<'data>,
-        obj: &Bound<'data, PyAny>,
+        py: Python<'py>,
+        obj: &Bound<'py, PyAny>,
         field_name: &str,
-        field_value: &Bound<'data, PyAny>,
-        state: &mut ValidationState,
+        field_value: &Bound<'py, PyAny>,
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let handler = AssignmentValidatorCallable {
             validator: InternalValidator::new(
@@ -471,7 +472,7 @@ macro_rules! py_err_string {
 
 /// Only `ValueError` (including `PydanticCustomError` and `ValidationError`) and `AssertionError` are considered
 /// as validation errors, `TypeError` is now considered as a runtime error to catch errors in function signatures
-pub fn convert_err<'a>(py: Python<'a>, err: PyErr, input: &impl Input<'a>) -> ValError {
+pub fn convert_err(py: Python<'_>, err: PyErr, input: impl ToErrorValue) -> ValError {
     if err.is_instance_of::<PyValueError>(py) {
         let error_value = err.value_bound(py);
         if let Ok(pydantic_value_error) = error_value.extract::<PydanticCustomError>() {
diff --git a/src/validators/generator.rs b/src/validators/generator.rs
index d4326cf47..f73532268 100644
--- a/src/validators/generator.rs
+++ b/src/validators/generator.rs
@@ -62,8 +62,8 @@ impl Validator for GeneratorValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let iterator = input.validate_iter()?;
         let validator = self.item_validator.as_ref().map(|v| {
@@ -253,12 +253,12 @@ impl InternalValidator {
         }
     }
 
-    pub fn validate_assignment<'data>(
+    pub fn validate_assignment<'py>(
         &mut self,
-        py: Python<'data>,
-        model: &Bound<'data, PyAny>,
+        py: Python<'py>,
+        model: &Bound<'py, PyAny>,
         field_name: &str,
-        field_value: &Bound<'data, PyAny>,
+        field_value: &Bound<'py, PyAny>,
         outer_location: Option<LocItem>,
     ) -> PyResult<PyObject> {
         let extra = Extra {
@@ -289,10 +289,10 @@ impl InternalValidator {
         result
     }
 
-    pub fn validate<'data>(
+    pub fn validate<'py>(
         &mut self,
-        py: Python<'data>,
-        input: &impl Input<'data>,
+        py: Python<'py>,
+        input: &(impl Input<'py> + ?Sized),
         outer_location: Option<LocItem>,
     ) -> PyResult<PyObject> {
         let extra = Extra {
diff --git a/src/validators/int.rs b/src/validators/int.rs
index 580c677d6..e5b233322 100644
--- a/src/validators/int.rs
+++ b/src/validators/int.rs
@@ -46,8 +46,8 @@ impl Validator for IntValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         input
             .validate_int(state.strict_or(self.strict))
@@ -75,8 +75,8 @@ impl Validator for ConstrainedIntValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let either_int = input.validate_int(state.strict_or(self.strict))?.unpack(state);
         let int_value = either_int.as_int()?;
diff --git a/src/validators/is_instance.rs b/src/validators/is_instance.rs
index 0261beae5..7eb7961d5 100644
--- a/src/validators/is_instance.rs
+++ b/src/validators/is_instance.rs
@@ -55,11 +55,11 @@ impl BuildValidator for IsInstanceValidator {
 impl_py_gc_traverse!(IsInstanceValidator { class });
 
 impl Validator for IsInstanceValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &impl Input<'data>,
-        _state: &mut ValidationState,
+        py: Python<'py>,
+        input: &(impl Input<'py> + ?Sized),
+        _state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         if !input.is_python() {
             return Err(ValError::InternalErr(PyNotImplementedError::new_err(
diff --git a/src/validators/is_subclass.rs b/src/validators/is_subclass.rs
index 54b343aae..da4599794 100644
--- a/src/validators/is_subclass.rs
+++ b/src/validators/is_subclass.rs
@@ -43,11 +43,11 @@ impl BuildValidator for IsSubclassValidator {
 impl_py_gc_traverse!(IsSubclassValidator { class });
 
 impl Validator for IsSubclassValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &impl Input<'data>,
-        _state: &mut ValidationState,
+        py: Python<'py>,
+        input: &(impl Input<'py> + ?Sized),
+        _state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         match input.input_is_subclass(self.class.bind(py))? {
             true => Ok(input.to_object(py)),
diff --git a/src/validators/json.rs b/src/validators/json.rs
index bcae2b3ec..62a23f0e6 100644
--- a/src/validators/json.rs
+++ b/src/validators/json.rs
@@ -49,8 +49,8 @@ impl Validator for JsonValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let v_match = validate_json_bytes(input)?;
         let json_either_bytes = v_match.unpack(state);
@@ -76,7 +76,9 @@ impl Validator for JsonValidator {
     }
 }
 
-pub fn validate_json_bytes<'a, 'py>(input: &'a impl Input<'py>) -> ValResult<ValidationMatch<EitherBytes<'a, 'py>>> {
+pub fn validate_json_bytes<'a, 'py>(
+    input: &'a (impl Input<'py> + ?Sized),
+) -> ValResult<ValidationMatch<EitherBytes<'a, 'py>>> {
     match input.validate_bytes(false) {
         Ok(v_match) => Ok(v_match),
         Err(ValError::LineErrors(e)) => Err(ValError::LineErrors(
@@ -95,7 +97,7 @@ fn map_bytes_error(line_error: ValLineError) -> ValLineError {
     }
 }
 
-pub fn map_json_err<'py>(input: &impl Input<'py>, error: jiter::JsonError, json_bytes: &[u8]) -> ValError {
+pub fn map_json_err<'py>(input: &(impl Input<'py> + ?Sized), error: jiter::JsonError, json_bytes: &[u8]) -> ValError {
     ValError::new(
         ErrorType::JsonInvalid {
             error: error.description(json_bytes),
diff --git a/src/validators/json_or_python.rs b/src/validators/json_or_python.rs
index 373f1e0f6..c76a29418 100644
--- a/src/validators/json_or_python.rs
+++ b/src/validators/json_or_python.rs
@@ -52,8 +52,8 @@ impl Validator for JsonOrPython {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         match state.extra().input_type {
             InputType::Python => self.python.validate(py, input, state),
diff --git a/src/validators/lax_or_strict.rs b/src/validators/lax_or_strict.rs
index 38c7d6893..bc354651a 100644
--- a/src/validators/lax_or_strict.rs
+++ b/src/validators/lax_or_strict.rs
@@ -59,8 +59,8 @@ impl Validator for LaxOrStrictValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         if state.strict_or(self.strict) {
             self.strict_validator.validate(py, input, state)
diff --git a/src/validators/list.rs b/src/validators/list.rs
index fed237213..6409d370b 100644
--- a/src/validators/list.rs
+++ b/src/validators/list.rs
@@ -119,8 +119,8 @@ impl Validator for ListValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let seq = input.validate_list(state.strict_or(self.strict))?;
         let exactness = match &seq {
diff --git a/src/validators/literal.rs b/src/validators/literal.rs
index 43ffdd5d4..69784efca 100644
--- a/src/validators/literal.rs
+++ b/src/validators/literal.rs
@@ -91,7 +91,11 @@ impl<T: Debug> LiteralLookup<T> {
         })
     }
 
-    pub fn validate<'a, 'py, I: Input<'py>>(&self, py: Python<'py>, input: &'a I) -> ValResult<Option<(&'a I, &T)>> {
+    pub fn validate<'a, 'py, I: Input<'py> + ?Sized>(
+        &self,
+        py: Python<'py>,
+        input: &'a I,
+    ) -> ValResult<Option<(&'a I, &T)>> {
         if let Some(expected_bool) = &self.expected_bool {
             if let Ok(bool_value) = input.validate_bool(true) {
                 if bool_value.into_inner() {
@@ -189,11 +193,11 @@ impl BuildValidator for LiteralValidator {
 impl_py_gc_traverse!(LiteralValidator { lookup });
 
 impl Validator for LiteralValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &impl Input<'data>,
-        _state: &mut ValidationState,
+        py: Python<'py>,
+        input: &(impl Input<'py> + ?Sized),
+        _state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         match self.lookup.validate(py, input)? {
             Some((_, v)) => Ok(v.clone()),
diff --git a/src/validators/mod.rs b/src/validators/mod.rs
index 4f791ac7e..8fbfb95eb 100644
--- a/src/validators/mod.rs
+++ b/src/validators/mod.rs
@@ -318,19 +318,16 @@ impl SchemaValidator {
 
 impl SchemaValidator {
     #[allow(clippy::too_many_arguments)]
-    fn _validate<'s, 'data>(
-        &'data self,
-        py: Python<'data>,
-        input: &impl Input<'data>,
+    fn _validate<'py>(
+        &self,
+        py: Python<'py>,
+        input: &(impl Input<'py> + ?Sized),
         input_type: InputType,
         strict: Option<bool>,
         from_attributes: Option<bool>,
-        context: Option<&Bound<'data, PyAny>>,
-        self_instance: Option<&Bound<'_, PyAny>>,
-    ) -> ValResult<PyObject>
-    where
-        's: 'data,
-    {
+        context: Option<&Bound<'py, PyAny>>,
+        self_instance: Option<&Bound<'py, PyAny>>,
+    ) -> ValResult<PyObject> {
         let mut recursion_guard = RecursionState::default();
         let mut state = ValidationState::new(
             Extra::new(strict, from_attributes, context, self_instance, input_type),
@@ -564,27 +561,27 @@ pub fn build_validator(
 /// More (mostly immutable) data to pass between validators, should probably be class `Context`,
 /// but that would confuse it with context as per pydantic/pydantic#1549
 #[derive(Debug)]
-pub struct Extra<'a> {
+pub struct Extra<'a, 'py> {
     /// Validation mode
     pub input_type: InputType,
     /// This is used as the `data` kwargs to validator functions
-    pub data: Option<Bound<'a, PyDict>>,
+    pub data: Option<Bound<'py, PyDict>>,
     /// whether we're in strict or lax mode
     pub strict: Option<bool>,
     /// Validation time setting of `from_attributes`
     pub from_attributes: Option<bool>,
     /// context used in validator functions
-    pub context: Option<&'a Bound<'a, PyAny>>,
+    pub context: Option<&'a Bound<'py, PyAny>>,
     /// This is an instance of the model or dataclass being validated, when validation is performed from `__init__`
-    self_instance: Option<&'a Bound<'a, PyAny>>,
+    self_instance: Option<&'a Bound<'py, PyAny>>,
 }
 
-impl<'a> Extra<'a> {
+impl<'a, 'py> Extra<'a, 'py> {
     pub fn new(
         strict: Option<bool>,
         from_attributes: Option<bool>,
-        context: Option<&'a Bound<'a, PyAny>>,
-        self_instance: Option<&'a Bound<'a, PyAny>>,
+        context: Option<&'a Bound<'py, PyAny>>,
+        self_instance: Option<&'a Bound<'py, PyAny>>,
         input_type: InputType,
     ) -> Self {
         Extra {
@@ -598,7 +595,7 @@ impl<'a> Extra<'a> {
     }
 }
 
-impl<'a> Extra<'a> {
+impl Extra<'_, '_> {
     pub fn as_strict(&self) -> Self {
         Self {
             input_type: self.input_type,
@@ -711,29 +708,29 @@ pub trait Validator: Send + Sync + Debug {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject>;
 
     /// Get a default value, currently only used by `WithDefaultValidator`
-    fn default_value(
+    fn default_value<'py>(
         &self,
-        _py: Python<'_>,
+        _py: Python<'py>,
         _outer_loc: Option<impl Into<LocItem>>,
-        _state: &mut ValidationState,
+        _state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<Option<PyObject>> {
         Ok(None)
     }
 
     /// Validate assignment to a field of a model
     #[allow(clippy::too_many_arguments)]
-    fn validate_assignment<'data>(
+    fn validate_assignment<'py>(
         &self,
-        _py: Python<'data>,
-        _obj: &Bound<'data, PyAny>,
+        _py: Python<'py>,
+        _obj: &Bound<'py, PyAny>,
         _field_name: &str,
-        _field_value: &Bound<'data, PyAny>,
-        _state: &mut ValidationState,
+        _field_value: &Bound<'py, PyAny>,
+        _state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let py_err = PyTypeError::new_err(format!("validate_assignment is not supported for {}", self.get_name()));
         Err(py_err.into())
diff --git a/src/validators/model.rs b/src/validators/model.rs
index 182f64432..db6f032f1 100644
--- a/src/validators/model.rs
+++ b/src/validators/model.rs
@@ -111,8 +111,8 @@ impl Validator for ModelValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         if let Some(self_instance) = state.extra().self_instance {
             // in the case that self_instance is Some, we're calling validation from within `BaseModel.__init__`
@@ -154,13 +154,13 @@ impl Validator for ModelValidator {
         }
     }
 
-    fn validate_assignment<'data>(
+    fn validate_assignment<'py>(
         &self,
-        py: Python<'data>,
-        model: &Bound<'data, PyAny>,
+        py: Python<'py>,
+        model: &Bound<'py, PyAny>,
         field_name: &str,
-        field_value: &Bound<'data, PyAny>,
-        state: &mut ValidationState,
+        field_value: &Bound<'py, PyAny>,
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         if self.frozen {
             return Err(ValError::new(ErrorTypeDefaults::FrozenInstance, field_value));
@@ -223,12 +223,12 @@ impl Validator for ModelValidator {
 
 impl ModelValidator {
     /// here we just call the inner validator, then set attributes on `self_instance`
-    fn validate_init<'s, 'data>(
-        &'s self,
-        py: Python<'data>,
-        self_instance: &Bound<'s, PyAny>,
-        input: &impl Input<'data>,
-        state: &mut ValidationState,
+    fn validate_init<'py>(
+        &self,
+        py: Python<'py>,
+        self_instance: &Bound<'py, PyAny>,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         // we need to set `self_instance` to None for nested validators as we don't want to operate on self_instance
         // anymore
@@ -250,12 +250,12 @@ impl ModelValidator {
         self.call_post_init(py, self_instance.clone(), input, state.extra())
     }
 
-    fn validate_construct<'s, 'data>(
-        &'s self,
-        py: Python<'data>,
-        input: &impl Input<'data>,
+    fn validate_construct<'py>(
+        &self,
+        py: Python<'py>,
+        input: &(impl Input<'py> + ?Sized),
         existing_fields_set: Option<&Bound<'_, PyAny>>,
-        state: &mut ValidationState,
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         if self.custom_init {
             // If we wanted, we could introspect the __init__ signature, and store the
@@ -291,11 +291,11 @@ impl ModelValidator {
         self.call_post_init(py, instance, input, state.extra())
     }
 
-    fn call_post_init<'s, 'data>(
-        &'s self,
-        py: Python<'data>,
+    fn call_post_init<'py>(
+        &self,
+        py: Python<'py>,
         instance: Bound<'_, PyAny>,
-        input: &impl Input<'data>,
+        input: &(impl Input<'py> + ?Sized),
         extra: &Extra,
     ) -> ValResult<PyObject> {
         if let Some(ref post_init) = self.post_init {
diff --git a/src/validators/model_fields.rs b/src/validators/model_fields.rs
index 2f01d09df..39042158f 100644
--- a/src/validators/model_fields.rs
+++ b/src/validators/model_fields.rs
@@ -122,8 +122,8 @@ impl Validator for ModelFieldsValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let strict = state.strict_or(self.strict);
         let from_attributes = state.extra().from_attributes.unwrap_or(self.from_attributes);
@@ -340,13 +340,13 @@ impl Validator for ModelFieldsValidator {
         }
     }
 
-    fn validate_assignment<'data>(
+    fn validate_assignment<'py>(
         &self,
-        py: Python<'data>,
-        obj: &Bound<'data, PyAny>,
+        py: Python<'py>,
+        obj: &Bound<'py, PyAny>,
         field_name: &str,
-        field_value: &Bound<'data, PyAny>,
-        state: &mut ValidationState,
+        field_value: &Bound<'py, PyAny>,
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let dict = obj.downcast::<PyDict>()?;
 
diff --git a/src/validators/none.rs b/src/validators/none.rs
index 1ae1a3b14..f3f04d078 100644
--- a/src/validators/none.rs
+++ b/src/validators/none.rs
@@ -24,11 +24,11 @@ impl BuildValidator for NoneValidator {
 impl_py_gc_traverse!(NoneValidator {});
 
 impl Validator for NoneValidator {
-    fn validate<'data>(
+    fn validate<'py>(
         &self,
-        py: Python<'data>,
-        input: &impl Input<'data>,
-        _state: &mut ValidationState,
+        py: Python<'py>,
+        input: &(impl Input<'py> + ?Sized),
+        _state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         match input.is_none() {
             true => Ok(py.None()),
diff --git a/src/validators/nullable.rs b/src/validators/nullable.rs
index 20c1d7926..de02179d5 100644
--- a/src/validators/nullable.rs
+++ b/src/validators/nullable.rs
@@ -36,8 +36,8 @@ impl Validator for NullableValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         match input.is_none() {
             true => Ok(py.None()),
diff --git a/src/validators/set.rs b/src/validators/set.rs
index 92f58e8d2..727d1a01f 100644
--- a/src/validators/set.rs
+++ b/src/validators/set.rs
@@ -61,8 +61,8 @@ impl Validator for SetValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let collection = input.validate_set(state.strict_or(self.strict))?;
         let exactness = match &collection {
diff --git a/src/validators/string.rs b/src/validators/string.rs
index b72b6efb4..645217edd 100644
--- a/src/validators/string.rs
+++ b/src/validators/string.rs
@@ -44,8 +44,8 @@ impl Validator for StrValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         input
             .validate_str(state.strict_or(self.strict), self.coerce_numbers_to_str)
@@ -76,8 +76,8 @@ impl Validator for StrConstrainedValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let either_str = input
             .validate_str(state.strict_or(self.strict), self.coerce_numbers_to_str)?
diff --git a/src/validators/time.rs b/src/validators/time.rs
index 524050f89..a9c6ae561 100644
--- a/src/validators/time.rs
+++ b/src/validators/time.rs
@@ -43,8 +43,8 @@ impl Validator for TimeValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let time = input
             .validate_time(state.strict_or(self.strict), self.microseconds_precision)?
diff --git a/src/validators/timedelta.rs b/src/validators/timedelta.rs
index 17ebc0936..47817662d 100644
--- a/src/validators/timedelta.rs
+++ b/src/validators/timedelta.rs
@@ -68,8 +68,8 @@ impl Validator for TimeDeltaValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let timedelta = input
             .validate_timedelta(state.strict_or(self.strict), self.microseconds_precision)?
diff --git a/src/validators/tuple.rs b/src/validators/tuple.rs
index a3968f85c..601e591b3 100644
--- a/src/validators/tuple.rs
+++ b/src/validators/tuple.rs
@@ -60,11 +60,11 @@ impl_py_gc_traverse!(TupleValidator { validators });
 
 impl TupleValidator {
     #[allow(clippy::too_many_arguments)]
-    fn validate_tuple_items<'data, I: BorrowInput<'data>>(
+    fn validate_tuple_items<'py, I: BorrowInput<'py>>(
         &self,
-        py: Python<'data>,
-        input: &impl Input<'data>,
-        state: &mut ValidationState,
+        py: Python<'py>,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
         output: &mut Vec<PyObject>,
         errors: &mut Vec<ValLineError>,
         item_validators: &[CombinedValidator],
@@ -97,11 +97,11 @@ impl TupleValidator {
     }
 
     #[allow(clippy::too_many_arguments)]
-    fn validate_tuple_variable<'data, I: BorrowInput<'data>, InputT: Input<'data>>(
+    fn validate_tuple_variable<'py, I: BorrowInput<'py>>(
         &self,
-        py: Python<'data>,
-        input: &InputT,
-        state: &mut ValidationState,
+        py: Python<'py>,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
         errors: &mut Vec<ValLineError>,
         collection_iter: &mut NextCountingIterator<impl Iterator<Item = I>>,
         actual_length: Option<usize>,
@@ -216,9 +216,9 @@ impl TupleValidator {
         Ok(output)
     }
 
-    fn push_output_item<'data>(
+    fn push_output_item<'py>(
         &self,
-        input: &impl Input<'data>,
+        input: &(impl Input<'py> + ?Sized),
         output: &mut Vec<PyObject>,
         item: PyObject,
         actual_length: Option<usize>,
@@ -245,8 +245,8 @@ impl Validator for TupleValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let collection = input.validate_tuple(state.strict_or(self.strict))?;
         let exactness = match &collection {
diff --git a/src/validators/typed_dict.rs b/src/validators/typed_dict.rs
index b85d2df60..998942f7f 100644
--- a/src/validators/typed_dict.rs
+++ b/src/validators/typed_dict.rs
@@ -148,8 +148,8 @@ impl Validator for TypedDictValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let strict = state.strict_or(self.strict);
         let dict = input.validate_dict(strict)?;
diff --git a/src/validators/union.rs b/src/validators/union.rs
index f3c1174a0..7001f9280 100644
--- a/src/validators/union.rs
+++ b/src/validators/union.rs
@@ -8,7 +8,7 @@ use smallvec::SmallVec;
 
 use crate::build_tools::py_schema_err;
 use crate::build_tools::{is_strict, schema_or_config};
-use crate::errors::{ErrorType, ValError, ValLineError, ValResult};
+use crate::errors::{ErrorType, ToErrorValue, ValError, ValLineError, ValResult};
 use crate::input::{GenericMapping, Input};
 use crate::lookup_key::LookupKey;
 use crate::py_gc::PyGcTraverse;
@@ -101,11 +101,11 @@ impl BuildValidator for UnionValidator {
 }
 
 impl UnionValidator {
-    fn validate_smart<'data>(
+    fn validate_smart<'py>(
         &self,
-        py: Python<'data>,
-        input: &impl Input<'data>,
-        state: &mut ValidationState,
+        py: Python<'py>,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let old_exactness = state.exactness;
         let strict = state.strict_or(self.strict);
@@ -167,11 +167,11 @@ impl UnionValidator {
         Err(errors.into_val_error(input))
     }
 
-    fn validate_left_to_right<'data>(
+    fn validate_left_to_right<'py>(
         &self,
-        py: Python<'data>,
-        input: &impl Input<'data>,
-        state: &mut ValidationState,
+        py: Python<'py>,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let mut errors = MaybeErrors::new(self.custom_error.as_ref());
 
@@ -205,8 +205,8 @@ impl Validator for UnionValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         match self.mode {
             UnionMode::Smart => self.validate_smart(py, input, state),
@@ -249,7 +249,7 @@ impl<'a> MaybeErrors<'a> {
         }
     }
 
-    fn into_val_error<'i>(self, input: &impl Input<'i>) -> ValError {
+    fn into_val_error(self, input: impl ToErrorValue) -> ValError {
         match self {
             Self::Custom(custom_error) => custom_error.as_val_error(input),
             Self::Errors(errors) => ValError::LineErrors(
@@ -393,8 +393,8 @@ impl Validator for TaggedUnionValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         match self.discriminator {
             Discriminator::LookupKey(ref lookup_key) => {
@@ -447,11 +447,11 @@ impl Validator for TaggedUnionValidator {
 }
 
 impl TaggedUnionValidator {
-    fn self_schema_tag<'data>(
+    fn self_schema_tag<'py>(
         &self,
-        py: Python<'data>,
-        input: &impl Input<'data>,
-    ) -> ValResult<Bound<'data, PyString>> {
+        py: Python<'py>,
+        input: &(impl Input<'py> + ?Sized),
+    ) -> ValResult<Bound<'py, PyString>> {
         let dict = input.strict_dict()?;
         let tag = match &dict {
             GenericMapping::PyDict(dict) => match dict.get_item(intern!(py, "type"))? {
@@ -480,12 +480,12 @@ impl TaggedUnionValidator {
         }
     }
 
-    fn find_call_validator<'s, 'data>(
-        &'s self,
-        py: Python<'data>,
-        tag: &Bound<'data, PyAny>,
-        input: &impl Input<'data>,
-        state: &mut ValidationState,
+    fn find_call_validator<'py>(
+        &self,
+        py: Python<'py>,
+        tag: &Bound<'py, PyAny>,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         if let Ok(Some((tag, validator))) = self.lookup.validate(py, tag) {
             return match validator.validate(py, input, state) {
@@ -507,7 +507,7 @@ impl TaggedUnionValidator {
         }
     }
 
-    fn tag_not_found<'s, 'data>(&'s self, input: &impl Input<'data>) -> ValError {
+    fn tag_not_found<'py>(&self, input: &(impl Input<'py> + ?Sized)) -> ValError {
         match self.custom_error {
             Some(ref custom_error) => custom_error.as_val_error(input),
             None => ValError::new(
diff --git a/src/validators/url.rs b/src/validators/url.rs
index 29eb2daa6..786b2d653 100644
--- a/src/validators/url.rs
+++ b/src/validators/url.rs
@@ -10,6 +10,7 @@ use ahash::AHashSet;
 use url::{ParseError, SyntaxViolation, Url};
 
 use crate::build_tools::{is_strict, py_schema_err};
+use crate::errors::ToErrorValue;
 use crate::errors::{ErrorType, ErrorTypeDefaults, ValError, ValResult};
 use crate::input::Input;
 use crate::tools::SchemaDict;
@@ -63,8 +64,8 @@ impl Validator for UrlValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let mut lib_url = self.get_url(input, state.strict_or(self.strict))?;
 
@@ -103,7 +104,7 @@ impl Validator for UrlValidator {
 }
 
 impl UrlValidator {
-    fn get_url<'s, 'data>(&'s self, input: &impl Input<'data>, strict: bool) -> ValResult<Url> {
+    fn get_url<'py>(&self, input: &(impl Input<'py> + ?Sized), strict: bool) -> ValResult<Url> {
         match input.validate_str(strict, false) {
             Ok(val_match) => {
                 let either_str = val_match.into_inner();
@@ -133,7 +134,7 @@ impl UrlValidator {
         }
     }
 
-    fn check_length<'s, 'data>(&self, input: &impl Input<'data>, url_str: &str) -> ValResult<()> {
+    fn check_length<'py>(&self, input: &(impl Input<'py> + ?Sized), url_str: &str) -> ValResult<()> {
         if let Some(max_length) = self.max_length {
             if url_str.len() > max_length {
                 return Err(ValError::new(
@@ -197,8 +198,8 @@ impl Validator for MultiHostUrlValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let mut multi_url = self.get_url(input, state.strict_or(self.strict))?;
 
@@ -236,7 +237,7 @@ impl Validator for MultiHostUrlValidator {
 }
 
 impl MultiHostUrlValidator {
-    fn get_url<'s, 'data>(&'s self, input: &impl Input<'data>, strict: bool) -> ValResult<PyMultiHostUrl> {
+    fn get_url<'py>(&self, input: &(impl Input<'py> + ?Sized), strict: bool) -> ValResult<PyMultiHostUrl> {
         match input.validate_str(strict, false) {
             Ok(val_match) => {
                 let either_str = val_match.into_inner();
@@ -264,7 +265,7 @@ impl MultiHostUrlValidator {
         }
     }
 
-    fn check_length<'s, 'data, F>(&self, input: &impl Input<'data>, func: F) -> ValResult<()>
+    fn check_length<'py, F>(&self, input: &(impl Input<'py> + ?Sized), func: F) -> ValResult<()>
     where
         F: FnOnce() -> usize,
     {
@@ -283,9 +284,9 @@ impl MultiHostUrlValidator {
     }
 }
 
-fn parse_multihost_url<'url, 'input>(
-    url_str: &'url str,
-    input: &impl Input<'input>,
+fn parse_multihost_url<'py>(
+    url_str: &str,
+    input: &(impl Input<'py> + ?Sized),
     strict: bool,
 ) -> ValResult<PyMultiHostUrl> {
     macro_rules! parsing_err {
@@ -402,7 +403,7 @@ fn parse_multihost_url<'url, 'input>(
     }
 }
 
-fn parse_url<'url, 'input>(url_str: &'url str, input: &impl Input<'input>, strict: bool) -> ValResult<Url> {
+fn parse_url(url_str: &str, input: impl ToErrorValue, strict: bool) -> ValResult<Url> {
     if url_str.is_empty() {
         return Err(ValError::new(
             ErrorType::UrlParsing {
diff --git a/src/validators/uuid.rs b/src/validators/uuid.rs
index ab452a21f..460a61834 100644
--- a/src/validators/uuid.rs
+++ b/src/validators/uuid.rs
@@ -89,8 +89,8 @@ impl Validator for UuidValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let class = get_uuid_type(py)?;
         if let Some(py_input) = input.input_is_instance(class) {
@@ -150,7 +150,7 @@ impl Validator for UuidValidator {
 }
 
 impl UuidValidator {
-    fn get_uuid<'s, 'data>(&'s self, input: &impl Input<'data>) -> ValResult<Uuid> {
+    fn get_uuid<'py>(&self, input: &(impl Input<'py> + ?Sized)) -> ValResult<Uuid> {
         let uuid = match input.exact_str().ok() {
             Some(either_string) => {
                 let cow = either_string.as_cow()?;
diff --git a/src/validators/validation_state.rs b/src/validators/validation_state.rs
index 61de64fd6..d7a831aee 100644
--- a/src/validators/validation_state.rs
+++ b/src/validators/validation_state.rs
@@ -9,15 +9,15 @@ pub enum Exactness {
     Exact,
 }
 
-pub struct ValidationState<'a> {
+pub struct ValidationState<'a, 'py> {
     pub recursion_guard: &'a mut RecursionState,
     pub exactness: Option<Exactness>,
     // deliberately make Extra readonly
-    extra: Extra<'a>,
+    extra: Extra<'a, 'py>,
 }
 
-impl<'a> ValidationState<'a> {
-    pub fn new(extra: Extra<'a>, recursion_guard: &'a mut RecursionState) -> Self {
+impl<'a, 'py> ValidationState<'a, 'py> {
+    pub fn new(extra: Extra<'a, 'py>, recursion_guard: &'a mut RecursionState) -> Self {
         Self {
             recursion_guard, // Don't care about exactness unless doing union validation
             exactness: None,
@@ -27,8 +27,8 @@ impl<'a> ValidationState<'a> {
 
     pub fn with_new_extra<'r, R: 'r>(
         &mut self,
-        extra: Extra<'_>,
-        f: impl for<'s> FnOnce(&'s mut ValidationState<'_>) -> R,
+        extra: Extra<'_, 'py>,
+        f: impl for<'s> FnOnce(&'s mut ValidationState<'_, 'py>) -> R,
     ) -> R {
         // TODO: It would be nice to implement this function with a drop guard instead of a closure,
         // but lifetimes get in a tangle. Maybe someone brave wants to have a go at unpicking lifetimes.
@@ -52,8 +52,8 @@ impl<'a> ValidationState<'a> {
     /// When `ValidationStateWithReboundExtra` drops, the extra field is restored to its original value.
     pub fn rebind_extra<'state>(
         &'state mut self,
-        f: impl FnOnce(&mut Extra<'a>),
-    ) -> ValidationStateWithReboundExtra<'state, 'a> {
+        f: impl FnOnce(&mut Extra<'a, 'py>),
+    ) -> ValidationStateWithReboundExtra<'state, 'a, 'py> {
         #[allow(clippy::unnecessary_struct_initialization)]
         let old_extra = Extra {
             data: self.extra.data.clone(),
@@ -63,7 +63,7 @@ impl<'a> ValidationState<'a> {
         ValidationStateWithReboundExtra { state: self, old_extra }
     }
 
-    pub fn extra(&self) -> &'_ Extra<'a> {
+    pub fn extra(&self) -> &'_ Extra<'a, 'py> {
         &self.extra
     }
 
@@ -89,32 +89,32 @@ impl<'a> ValidationState<'a> {
     }
 }
 
-impl ContainsRecursionState for ValidationState<'_> {
+impl ContainsRecursionState for ValidationState<'_, '_> {
     fn access_recursion_state<R>(&mut self, f: impl FnOnce(&mut RecursionState) -> R) -> R {
         f(self.recursion_guard)
     }
 }
 
-pub struct ValidationStateWithReboundExtra<'state, 'a> {
-    state: &'state mut ValidationState<'a>,
-    old_extra: Extra<'a>,
+pub struct ValidationStateWithReboundExtra<'state, 'a, 'py> {
+    state: &'state mut ValidationState<'a, 'py>,
+    old_extra: Extra<'a, 'py>,
 }
 
-impl<'a> std::ops::Deref for ValidationStateWithReboundExtra<'_, 'a> {
-    type Target = ValidationState<'a>;
+impl<'a, 'py> std::ops::Deref for ValidationStateWithReboundExtra<'_, 'a, 'py> {
+    type Target = ValidationState<'a, 'py>;
 
     fn deref(&self) -> &Self::Target {
         self.state
     }
 }
 
-impl<'a> std::ops::DerefMut for ValidationStateWithReboundExtra<'_, 'a> {
+impl std::ops::DerefMut for ValidationStateWithReboundExtra<'_, '_, '_> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         self.state
     }
 }
 
-impl Drop for ValidationStateWithReboundExtra<'_, '_> {
+impl Drop for ValidationStateWithReboundExtra<'_, '_, '_> {
     fn drop(&mut self) {
         std::mem::swap(&mut self.state.extra, &mut self.old_extra);
     }
diff --git a/src/validators/with_default.rs b/src/validators/with_default.rs
index 06ab2159a..e03830e77 100644
--- a/src/validators/with_default.rs
+++ b/src/validators/with_default.rs
@@ -137,8 +137,8 @@ impl Validator for WithDefaultValidator {
     fn validate<'py>(
         &self,
         py: Python<'py>,
-        input: &impl Input<'py>,
-        state: &mut ValidationState,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         if input.to_object(py).is(&self.undefined) {
             Ok(self.default_value(py, None::<usize>, state)?.unwrap())
@@ -157,11 +157,11 @@ impl Validator for WithDefaultValidator {
         }
     }
 
-    fn default_value(
+    fn default_value<'py>(
         &self,
-        py: Python<'_>,
+        py: Python<'py>,
         outer_loc: Option<impl Into<LocItem>>,
-        state: &mut ValidationState,
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<Option<PyObject>> {
         match self.default.default_value(py)? {
             Some(stored_dft) => {

From 89fc62fa2cf2edd6ab6cd5617eb907a29a4197c8 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Tue, 19 Mar 2024 10:14:10 +0000
Subject: [PATCH 234/550] move list validation to produce an associated type
 (#1230)

---
 src/input/input_abstract.rs | 78 +++++++++++++++++++++---------
 src/input/input_json.rs     | 36 ++++++++++----
 src/input/input_python.rs   | 34 ++++++-------
 src/input/input_string.rs   |  5 +-
 src/input/mod.rs            |  9 ++--
 src/input/return_enums.rs   | 73 ++++++++++++++++++++++++++--
 src/validators/list.rs      | 95 ++++++++++++++++++++++++++++++-------
 7 files changed, 258 insertions(+), 72 deletions(-)

diff --git a/src/input/input_abstract.rs b/src/input/input_abstract.rs
index 553f0b33c..db46f06fe 100644
--- a/src/input/input_abstract.rs
+++ b/src/input/input_abstract.rs
@@ -1,7 +1,7 @@
 use std::fmt;
 
 use pyo3::exceptions::PyValueError;
-use pyo3::types::{PyDict, PyType};
+use pyo3::types::{PyDict, PyList, PyType};
 use pyo3::{intern, prelude::*};
 
 use crate::errors::{ErrorTypeDefaults, InputValue, ValError, ValResult};
@@ -42,6 +42,8 @@ impl TryFrom<&str> for InputType {
     }
 }
 
+pub type ValMatch<T> = ValResult<ValidationMatch<T>>;
+
 /// all types have three methods: `validate_*`, `strict_*`, `lax_*`
 /// the convention is to either implement:
 /// * `strict_*` & `lax_*` if they have different behavior
@@ -87,13 +89,13 @@ pub trait Input<'py>: fmt::Debug + ToPyObject {
 
     fn validate_dataclass_args<'a>(&'a self, dataclass_name: &str) -> ValResult<GenericArguments<'a, 'py>>;
 
-    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) -> ValMatch<EitherString<'_>>;
 
-    fn validate_bytes<'a>(&'a self, strict: bool) -> ValResult<ValidationMatch<EitherBytes<'a, 'py>>>;
+    fn validate_bytes<'a>(&'a self, strict: bool) -> ValMatch<EitherBytes<'a, 'py>>;
 
-    fn validate_bool(&self, strict: bool) -> ValResult<ValidationMatch<bool>>;
+    fn validate_bool(&self, strict: bool) -> ValMatch<bool>;
 
-    fn validate_int(&self, strict: bool) -> ValResult<ValidationMatch<EitherInt<'_>>>;
+    fn validate_int(&self, strict: bool) -> ValMatch<EitherInt<'_>>;
 
     fn exact_int(&self) -> ValResult<EitherInt<'_>> {
         self.validate_int(true).and_then(|val_match| {
@@ -113,7 +115,7 @@ pub trait Input<'py>: fmt::Debug + ToPyObject {
         })
     }
 
-    fn validate_float(&self, strict: bool) -> ValResult<ValidationMatch<EitherFloat<'_>>>;
+    fn validate_float(&self, strict: bool) -> ValMatch<EitherFloat<'_>>;
 
     fn validate_decimal(&self, strict: bool, py: Python<'py>) -> ValResult<Bound<'py, PyAny>> {
         if strict {
@@ -145,18 +147,11 @@ pub trait Input<'py>: fmt::Debug + ToPyObject {
         self.validate_dict(strict)
     }
 
-    fn validate_list<'a>(&'a self, strict: bool) -> ValResult<GenericIterable<'a, 'py>> {
-        if strict {
-            self.strict_list()
-        } else {
-            self.lax_list()
-        }
-    }
-    fn strict_list<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>>;
-    #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn lax_list<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
-        self.strict_list()
-    }
+    type List<'a>: Iterable<'py> + AsPyList<'py>
+    where
+        Self: 'a;
+
+    fn validate_list(&self, strict: bool) -> ValMatch<Self::List<'_>>;
 
     fn validate_tuple<'a>(&'a self, strict: bool) -> ValResult<GenericIterable<'a, 'py>> {
         if strict {
@@ -201,25 +196,25 @@ pub trait Input<'py>: fmt::Debug + ToPyObject {
 
     fn validate_iter(&self) -> ValResult<GenericIterator>;
 
-    fn validate_date(&self, strict: bool) -> ValResult<ValidationMatch<EitherDate<'py>>>;
+    fn validate_date(&self, strict: bool) -> ValMatch<EitherDate<'py>>;
 
     fn validate_time(
         &self,
         strict: bool,
         microseconds_overflow_behavior: speedate::MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<ValidationMatch<EitherTime<'py>>>;
+    ) -> ValMatch<EitherTime<'py>>;
 
     fn validate_datetime(
         &self,
         strict: bool,
         microseconds_overflow_behavior: speedate::MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<ValidationMatch<EitherDateTime<'py>>>;
+    ) -> ValMatch<EitherDateTime<'py>>;
 
     fn validate_timedelta(
         &self,
         strict: bool,
         microseconds_overflow_behavior: speedate::MicrosecondsPrecisionOverflowBehavior,
-    ) -> ValResult<ValidationMatch<EitherTimedelta<'py>>>;
+    ) -> ValMatch<EitherTimedelta<'py>>;
 }
 
 /// The problem to solve here is that iterating collections often returns owned
@@ -238,3 +233,42 @@ impl<'py, T: Input<'py> + ?Sized> BorrowInput<'py> for &'_ T {
         self
     }
 }
+
+pub enum Never {}
+
+// Pairs with Iterable below
+pub trait ConsumeIterator<T> {
+    type Output;
+    fn consume_iterator(self, iterator: impl Iterator<Item = T>) -> Self::Output;
+}
+
+// This slightly awkward trait is used to define types which can be iterable. This formulation
+// arises because the Python enums have several different underlying iterator types, and we want to
+// be able to dispatch over each of them without overhead.
+pub trait Iterable<'py> {
+    type Input: BorrowInput<'py>;
+    fn len(&self) -> Option<usize>;
+    fn iterate<R>(self, consumer: impl ConsumeIterator<PyResult<Self::Input>, Output = R>) -> ValResult<R>;
+}
+
+// Necessary for inputs which don't support certain types, e.g. String -> list
+impl<'py> Iterable<'py> for Never {
+    type Input = Bound<'py, PyAny>; // Doesn't really matter what this is
+    fn len(&self) -> Option<usize> {
+        unreachable!()
+    }
+    fn iterate<R>(self, _consumer: impl ConsumeIterator<PyResult<Self::Input>, Output = R>) -> ValResult<R> {
+        unreachable!()
+    }
+}
+
+// Optimization pathway for inputs which are already python lists
+pub trait AsPyList<'py>: Iterable<'py> {
+    fn as_py_list(&self) -> Option<&Bound<'py, PyList>>;
+}
+
+impl<'py> AsPyList<'py> for Never {
+    fn as_py_list(&self) -> Option<&Bound<'py, PyList>> {
+        unreachable!()
+    }
+}
diff --git a/src/input/input_json.rs b/src/input/input_json.rs
index 53a261d81..e6727dc26 100644
--- a/src/input/input_json.rs
+++ b/src/input/input_json.rs
@@ -2,7 +2,8 @@ use std::borrow::Cow;
 
 use jiter::{JsonArray, JsonValue};
 use pyo3::prelude::*;
-use pyo3::types::{PyDict, PyString};
+use pyo3::types::{PyDict, PyList, PyString};
+use smallvec::SmallVec;
 use speedate::MicrosecondsPrecisionOverflowBehavior;
 use strum::EnumMessage;
 
@@ -13,6 +14,7 @@ use super::datetime::{
     bytes_as_date, bytes_as_datetime, bytes_as_time, bytes_as_timedelta, float_as_datetime, float_as_duration,
     float_as_time, int_as_datetime, int_as_duration, int_as_time, EitherDate, EitherDateTime, EitherTime,
 };
+use super::input_abstract::{AsPyList, ConsumeIterator, Iterable, Never, ValMatch};
 use super::return_enums::ValidationMatch;
 use super::shared::{float_as_int, int_as_bool, str_as_bool, str_as_float, str_as_int};
 use super::{
@@ -172,16 +174,14 @@ impl<'py> Input<'py> for JsonValue {
         self.validate_dict(false)
     }
 
-    fn validate_list<'a>(&'a self, _strict: bool) -> ValResult<GenericIterable<'a, 'py>> {
+    type List<'a> = &'a JsonArray;
+
+    fn validate_list(&self, _strict: bool) -> ValMatch<&JsonArray> {
         match self {
-            JsonValue::Array(a) => Ok(GenericIterable::JsonArray(a)),
+            JsonValue::Array(a) => Ok(ValidationMatch::strict(a)),
             _ => Err(ValError::new(ErrorTypeDefaults::ListType, self)),
         }
     }
-    #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn strict_list<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
-        self.validate_list(false)
-    }
 
     fn validate_tuple<'a>(&'a self, _strict: bool) -> ValResult<GenericIterable<'a, 'py>> {
         // just as in set's case, List has to be allowed
@@ -375,8 +375,9 @@ impl<'py> Input<'py> for str {
         Err(ValError::new(ErrorTypeDefaults::DictType, self))
     }
 
-    #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn strict_list<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
+    type List<'a> = Never;
+
+    fn validate_list(&self, _strict: bool) -> ValMatch<Never> {
         Err(ValError::new(ErrorTypeDefaults::ListType, self))
     }
 
@@ -449,3 +450,20 @@ impl BorrowInput<'_> for String {
 fn string_to_vec(s: &str) -> JsonArray {
     JsonArray::new(s.chars().map(|c| JsonValue::Str(c.to_string())).collect())
 }
+
+impl<'a> Iterable<'_> for &'a JsonArray {
+    type Input = &'a JsonValue;
+
+    fn len(&self) -> Option<usize> {
+        Some(SmallVec::len(self))
+    }
+    fn iterate<R>(self, consumer: impl ConsumeIterator<PyResult<Self::Input>, Output = R>) -> ValResult<R> {
+        Ok(consumer.consume_iterator(self.iter().map(Ok)))
+    }
+}
+
+impl<'py> AsPyList<'py> for &'_ JsonArray {
+    fn as_py_list(&self) -> Option<&Bound<'py, PyList>> {
+        None
+    }
+}
diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index edc9aec04..1c192c290 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -23,6 +23,7 @@ use super::datetime::{
     float_as_duration, float_as_time, int_as_datetime, int_as_duration, int_as_time, EitherDate, EitherDateTime,
     EitherTime,
 };
+use super::input_abstract::ValMatch;
 use super::return_enums::ValidationMatch;
 use super::shared::{
     decimal_as_int, float_as_int, get_enum_meta_object, int_as_bool, str_as_bool, str_as_float, str_as_int,
@@ -461,24 +462,25 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
         }
     }
 
-    fn strict_list<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
-        match self.lax_list()? {
-            GenericIterable::List(iter) => Ok(GenericIterable::List(iter)),
-            _ => Err(ValError::new(ErrorTypeDefaults::ListType, self)),
-        }
-    }
+    type List<'a> = GenericIterable<'a, 'py> where Self: 'a;
 
-    fn lax_list<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
-        match self
-            .extract_generic_iterable()
-            .map_err(|_| ValError::new(ErrorTypeDefaults::ListType, self))?
-        {
-            GenericIterable::PyString(_)
-            | GenericIterable::Bytes(_)
-            | GenericIterable::Dict(_)
-            | GenericIterable::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::ListType, self)),
-            other => Ok(other),
+    fn validate_list<'a>(&'a self, strict: bool) -> ValMatch<GenericIterable<'a, 'py>> {
+        if let Ok(list) = self.downcast::<PyList>() {
+            return Ok(ValidationMatch::exact(GenericIterable::List(list)));
+        } else if !strict {
+            match self.extract_generic_iterable() {
+                Ok(
+                    GenericIterable::PyString(_)
+                    | GenericIterable::Bytes(_)
+                    | GenericIterable::Dict(_)
+                    | GenericIterable::Mapping(_),
+                )
+                | Err(_) => {}
+                Ok(other) => return Ok(ValidationMatch::lax(other)),
+            }
         }
+
+        Err(ValError::new(ErrorTypeDefaults::ListType, self))
     }
 
     fn strict_tuple<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
diff --git a/src/input/input_string.rs b/src/input/input_string.rs
index 486dff5ff..76c1a9f39 100644
--- a/src/input/input_string.rs
+++ b/src/input/input_string.rs
@@ -11,6 +11,7 @@ use crate::validators::decimal::create_decimal;
 use super::datetime::{
     bytes_as_date, bytes_as_datetime, bytes_as_time, bytes_as_timedelta, EitherDate, EitherDateTime, EitherTime,
 };
+use super::input_abstract::{Never, ValMatch};
 use super::shared::{str_as_bool, str_as_float, str_as_int};
 use super::{
     BorrowInput, EitherBytes, EitherFloat, EitherInt, EitherString, EitherTimedelta, GenericArguments, GenericIterable,
@@ -138,7 +139,9 @@ impl<'py> Input<'py> for StringMapping<'py> {
         }
     }
 
-    fn strict_list<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
+    type List<'a> = Never where Self: 'a;
+
+    fn validate_list(&self, _strict: bool) -> ValMatch<Never> {
         Err(ValError::new(ErrorTypeDefaults::ListType, self))
     }
 
diff --git a/src/input/mod.rs b/src/input/mod.rs
index d7ca0a5bf..1d5047005 100644
--- a/src/input/mod.rs
+++ b/src/input/mod.rs
@@ -15,12 +15,13 @@ pub(crate) use datetime::{
     duration_as_pytimedelta, pydate_as_date, pydatetime_as_datetime, pytime_as_time, EitherDate, EitherDateTime,
     EitherTime, EitherTimedelta,
 };
-pub(crate) use input_abstract::{BorrowInput, Input, InputType};
+pub(crate) use input_abstract::{AsPyList, BorrowInput, ConsumeIterator, Input, InputType, Iterable};
 pub(crate) use input_string::StringMapping;
 pub(crate) use return_enums::{
-    py_string_str, AttributesGenericIterator, DictGenericIterator, EitherBytes, EitherFloat, EitherInt, EitherString,
-    GenericArguments, GenericIterable, GenericIterator, GenericMapping, Int, JsonArgs, JsonObjectGenericIterator,
-    MappingGenericIterator, PyArgs, StringMappingGenericIterator, ValidationMatch,
+    no_validator_iter_to_vec, py_string_str, validate_iter_to_vec, AttributesGenericIterator, DictGenericIterator,
+    EitherBytes, EitherFloat, EitherInt, EitherString, GenericArguments, GenericIterable, GenericIterator,
+    GenericMapping, Int, JsonArgs, JsonObjectGenericIterator, MappingGenericIterator, MaxLengthCheck, PyArgs,
+    StringMappingGenericIterator, ValidationMatch,
 };
 
 // Defined here as it's not exported by pyo3
diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index a6db98710..7c13a2972 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -26,6 +26,7 @@ use crate::errors::{
 use crate::tools::{extract_i64, py_err};
 use crate::validators::{CombinedValidator, Exactness, ValidationState, Validator};
 
+use super::input_abstract::{AsPyList, ConsumeIterator, Iterable};
 use super::input_string::StringMapping;
 use super::{py_error_on_minusone, BorrowInput, Input};
 
@@ -121,9 +122,31 @@ impl<'py> GenericIterable<'_, 'py> {
             GenericIterable::JsonString(s) => Ok(Box::new(PyString::new_bound(py, s).iter()?)),
         }
     }
+
+    pub fn as_sequence_iterator_py(&self) -> PyResult<Box<dyn Iterator<Item = PyResult<Bound<'py, PyAny>>> + '_>> {
+        match self {
+            GenericIterable::List(iter) => Ok(Box::new(iter.iter().map(Ok))),
+            GenericIterable::Tuple(iter) => Ok(Box::new(iter.iter().map(Ok))),
+            GenericIterable::Set(iter) => Ok(Box::new(iter.iter().map(Ok))),
+            GenericIterable::FrozenSet(iter) => Ok(Box::new(iter.iter().map(Ok))),
+            // Note that this iterates over only the keys, just like doing iter({}) in Python
+            GenericIterable::Dict(iter) => Ok(Box::new(iter.iter().map(|(k, _)| Ok(k)))),
+            GenericIterable::DictKeys(iter) => Ok(Box::new(iter.iter()?)),
+            GenericIterable::DictValues(iter) => Ok(Box::new(iter.iter()?)),
+            GenericIterable::DictItems(iter) => Ok(Box::new(iter.iter()?)),
+            // Note that this iterates over only the keys, just like doing iter({}) in Python
+            GenericIterable::Mapping(iter) => Ok(Box::new(iter.keys()?.iter()?)),
+            GenericIterable::PyString(iter) => Ok(Box::new(iter.iter()?)),
+            GenericIterable::Bytes(iter) => Ok(Box::new(iter.iter()?)),
+            GenericIterable::PyByteArray(iter) => Ok(Box::new(iter.iter()?)),
+            GenericIterable::Sequence(iter) => Ok(Box::new(iter.iter()?)),
+            GenericIterable::Iterator(iter) => Ok(Box::new(iter.iter()?)),
+            _ => unreachable!(),
+        }
+    }
 }
 
-struct MaxLengthCheck<'a, INPUT: ?Sized> {
+pub struct MaxLengthCheck<'a, INPUT: ?Sized> {
     current_length: usize,
     max_length: Option<usize>,
     field_type: &'a str,
@@ -132,7 +155,12 @@ struct MaxLengthCheck<'a, INPUT: ?Sized> {
 }
 
 impl<'a, INPUT: ?Sized> MaxLengthCheck<'a, INPUT> {
-    fn new(max_length: Option<usize>, field_type: &'a str, input: &'a INPUT, actual_length: Option<usize>) -> Self {
+    pub(crate) fn new(
+        max_length: Option<usize>,
+        field_type: &'a str,
+        input: &'a INPUT,
+        actual_length: Option<usize>,
+    ) -> Self {
         Self {
             current_length: 0,
             max_length,
@@ -177,7 +205,7 @@ macro_rules! any_next_error {
 }
 
 #[allow(clippy::too_many_arguments)]
-fn validate_iter_to_vec<'py>(
+pub(crate) fn validate_iter_to_vec<'py>(
     py: Python<'py>,
     iter: impl Iterator<Item = PyResult<impl BorrowInput<'py>>>,
     capacity: usize,
@@ -289,7 +317,7 @@ fn validate_iter_to_set<'py>(
     }
 }
 
-fn no_validator_iter_to_vec<'py>(
+pub(crate) fn no_validator_iter_to_vec<'py>(
     py: Python<'py>,
     input: &(impl Input<'py> + ?Sized),
     iter: impl Iterator<Item = PyResult<impl BorrowInput<'py>>>,
@@ -428,6 +456,43 @@ impl<'py> GenericIterable<'_, 'py> {
     }
 }
 
+impl<'py> Iterable<'py> for GenericIterable<'_, 'py> {
+    type Input = Bound<'py, PyAny>;
+    fn len(&self) -> Option<usize> {
+        self.generic_len()
+    }
+    fn iterate<R>(self, consumer: impl ConsumeIterator<PyResult<Self::Input>, Output = R>) -> ValResult<R> {
+        match self {
+            GenericIterable::List(iter) => Ok(consumer.consume_iterator(iter.iter().map(Ok))),
+            GenericIterable::Tuple(iter) => Ok(consumer.consume_iterator(iter.iter().map(Ok))),
+            GenericIterable::Set(iter) => Ok(consumer.consume_iterator(iter.iter().map(Ok))),
+            GenericIterable::FrozenSet(iter) => Ok(consumer.consume_iterator(iter.iter().map(Ok))),
+            // Note that this iterates over only the keys, just like doing iter({}) in Python
+            GenericIterable::Dict(iter) => Ok(consumer.consume_iterator(iter.iter().map(|(k, _)| Ok(k)))),
+            GenericIterable::DictKeys(iter) => Ok(consumer.consume_iterator(iter.iter()?)),
+            GenericIterable::DictValues(iter) => Ok(consumer.consume_iterator(iter.iter()?)),
+            GenericIterable::DictItems(iter) => Ok(consumer.consume_iterator(iter.iter()?)),
+            // Note that this iterates over only the keys, just like doing iter({}) in Python
+            GenericIterable::Mapping(iter) => Ok(consumer.consume_iterator(iter.keys()?.iter()?)),
+            GenericIterable::PyString(iter) => Ok(consumer.consume_iterator(iter.iter()?)),
+            GenericIterable::Bytes(iter) => Ok(consumer.consume_iterator(iter.iter()?)),
+            GenericIterable::PyByteArray(iter) => Ok(consumer.consume_iterator(iter.iter()?)),
+            GenericIterable::Sequence(iter) => Ok(consumer.consume_iterator(iter.iter()?)),
+            GenericIterable::Iterator(iter) => Ok(consumer.consume_iterator(iter.iter()?)),
+            _ => unreachable!(),
+        }
+    }
+}
+
+impl<'py> AsPyList<'py> for GenericIterable<'_, 'py> {
+    fn as_py_list(&self) -> Option<&Bound<'py, PyList>> {
+        match self {
+            GenericIterable::List(iter) => Some(iter),
+            _ => None,
+        }
+    }
+}
+
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub enum GenericMapping<'a, 'py> {
     PyDict(&'a Bound<'py, PyDict>),
diff --git a/src/validators/list.rs b/src/validators/list.rs
index 6409d370b..4d56e1160 100644
--- a/src/validators/list.rs
+++ b/src/validators/list.rs
@@ -4,9 +4,11 @@ use pyo3::prelude::*;
 use pyo3::types::PyDict;
 
 use crate::errors::ValResult;
-use crate::input::{GenericIterable, Input};
+use crate::input::{
+    no_validator_iter_to_vec, validate_iter_to_vec, AsPyList, BorrowInput, ConsumeIterator, Input, Iterable,
+    MaxLengthCheck,
+};
 use crate::tools::SchemaDict;
-use crate::validators::Exactness;
 
 use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
 
@@ -122,24 +124,34 @@ impl Validator for ListValidator {
         input: &(impl Input<'py> + ?Sized),
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
-        let seq = input.validate_list(state.strict_or(self.strict))?;
-        let exactness = match &seq {
-            GenericIterable::List(_) | GenericIterable::JsonArray(_) => Exactness::Exact,
-            GenericIterable::Tuple(_) => Exactness::Strict,
-            _ => Exactness::Lax,
-        };
-        state.floor_exactness(exactness);
+        let seq = input.validate_list(state.strict_or(self.strict))?.unpack(state);
 
+        let actual_length = seq.len();
         let output = match self.item_validator {
-            Some(ref v) => seq.validate_to_vec(py, input, self.max_length, "List", v, state)?,
-            None => match seq {
-                GenericIterable::List(list) => {
-                    length_check!(input, "List", self.min_length, self.max_length, list);
-                    let list_copy = list.get_slice(0, usize::MAX);
+            Some(ref v) => seq.iterate(ValidateToVec {
+                py,
+                input,
+                actual_length,
+                max_length: self.max_length,
+                field_type: "List",
+                item_validator: v,
+                state,
+            })??,
+            None => {
+                if let Some(py_list) = seq.as_py_list() {
+                    length_check!(input, "List", self.min_length, self.max_length, py_list);
+                    let list_copy = py_list.get_slice(0, usize::MAX);
                     return Ok(list_copy.into_py(py));
                 }
-                _ => seq.to_vec(py, input, "List", self.max_length)?,
-            },
+
+                seq.iterate(ToVec {
+                    py,
+                    input,
+                    actual_length,
+                    max_length: self.max_length,
+                    field_type: "List",
+                })??
+            }
         };
         min_length_check!(input, "List", self.min_length, output);
         Ok(output.into_py(py))
@@ -164,3 +176,54 @@ impl Validator for ListValidator {
         }
     }
 }
+
+struct ValidateToVec<'a, 's, 'py, I: Input<'py> + ?Sized> {
+    py: Python<'py>,
+    input: &'a I,
+    actual_length: Option<usize>,
+    max_length: Option<usize>,
+    field_type: &'static str,
+    item_validator: &'a CombinedValidator,
+    state: &'a mut ValidationState<'s, 'py>,
+}
+
+// pretty arbitrary default capacity when creating vecs from iteration
+const DEFAULT_CAPACITY: usize = 10;
+
+impl<'py, T, I: Input<'py> + ?Sized> ConsumeIterator<PyResult<T>> for ValidateToVec<'_, '_, 'py, I>
+where
+    T: BorrowInput<'py>,
+{
+    type Output = ValResult<Vec<PyObject>>;
+    fn consume_iterator(self, iterator: impl Iterator<Item = PyResult<T>>) -> ValResult<Vec<PyObject>> {
+        let capacity = self.actual_length.unwrap_or(DEFAULT_CAPACITY);
+        let max_length_check = MaxLengthCheck::new(self.max_length, self.field_type, self.input, self.actual_length);
+        validate_iter_to_vec(
+            self.py,
+            iterator,
+            capacity,
+            max_length_check,
+            self.item_validator,
+            self.state,
+        )
+    }
+}
+
+struct ToVec<'a, 'py, I: Input<'py> + ?Sized> {
+    py: Python<'py>,
+    input: &'a I,
+    actual_length: Option<usize>,
+    max_length: Option<usize>,
+    field_type: &'static str,
+}
+
+impl<'py, T, I: Input<'py> + ?Sized> ConsumeIterator<PyResult<T>> for ToVec<'_, 'py, I>
+where
+    T: BorrowInput<'py>,
+{
+    type Output = ValResult<Vec<PyObject>>;
+    fn consume_iterator(self, iterator: impl Iterator<Item = PyResult<T>>) -> ValResult<Vec<PyObject>> {
+        let max_length_check = MaxLengthCheck::new(self.max_length, self.field_type, self.input, self.actual_length);
+        no_validator_iter_to_vec(self.py, self.input, iterator, max_length_check)
+    }
+}

From 0587e152ed4fc0f83d9de87cbdbece9d1b797e1e Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Tue, 19 Mar 2024 12:19:41 +0000
Subject: [PATCH 235/550] remove `with_new_extra` (#1233)

---
 src/recursion_guard.rs             |  16 +-
 src/validators/dataclass.rs        | 386 ++++++++++++++---------------
 src/validators/mod.rs              |   2 +-
 src/validators/model_fields.rs     | 105 +++-----
 src/validators/typed_dict.rs       |  36 +--
 src/validators/validation_state.rs |  28 +--
 6 files changed, 250 insertions(+), 323 deletions(-)

diff --git a/src/recursion_guard.rs b/src/recursion_guard.rs
index d3302c0e9..b1f07ed2c 100644
--- a/src/recursion_guard.rs
+++ b/src/recursion_guard.rs
@@ -71,8 +71,11 @@ pub struct RecursionState {
     depth: u8,
 }
 
+// with debug_assertions enabled, function stacks are a bit bigger so need to be a bit more restricted
+const GUARD_OFFSET: u8 = if cfg!(debug_assertions) { 20 } else { 0 };
+
 // A hard limit to avoid stack overflows when rampant recursion occurs
-pub const RECURSION_GUARD_LIMIT: u8 = if cfg!(any(target_family = "wasm", all(windows, PyPy))) {
+pub const RECURSION_GUARD_LIMIT: u8 = (if cfg!(any(target_family = "wasm", all(windows, PyPy))) {
     // wasm and windows PyPy have very limited stack sizes
     49
 } else if cfg!(any(PyPy, windows)) {
@@ -80,7 +83,7 @@ pub const RECURSION_GUARD_LIMIT: u8 = if cfg!(any(target_family = "wasm", all(wi
     99
 } else {
     255
-};
+}) - GUARD_OFFSET;
 
 impl RecursionState {
     // insert a new value
@@ -92,17 +95,20 @@ impl RecursionState {
 
     // see #143 this is used as a backup in case the identity check recursion guard fails
     #[must_use]
-    #[cfg(any(target_family = "wasm", windows, PyPy))]
+    #[cfg(any(target_family = "wasm", windows, PyPy, debug_assertions))]
     pub fn incr_depth(&mut self) -> bool {
+        #[allow(clippy::assertions_on_constants)]
+        {
+            debug_assert!(RECURSION_GUARD_LIMIT < 255);
+        }
         // use saturating_add as it's faster (since there's no error path)
         // and the RECURSION_GUARD_LIMIT check will be hit before it overflows
-        debug_assert!(RECURSION_GUARD_LIMIT < 255);
         self.depth = self.depth.saturating_add(1);
         self.depth > RECURSION_GUARD_LIMIT
     }
 
     #[must_use]
-    #[cfg(not(any(target_family = "wasm", windows, PyPy)))]
+    #[cfg(not(any(target_family = "wasm", windows, PyPy, debug_assertions)))]
     pub fn incr_depth(&mut self) -> bool {
         debug_assert_eq!(RECURSION_GUARD_LIMIT, 255);
         // use checked_add to check if we've hit the limit
diff --git a/src/validators/dataclass.rs b/src/validators/dataclass.rs
index e2b479fbd..766691895 100644
--- a/src/validators/dataclass.rs
+++ b/src/validators/dataclass.rs
@@ -17,9 +17,7 @@ use crate::validators::function::convert_err;
 use super::arguments::{json_get, json_slice, py_get, py_slice};
 use super::model::{create_class, force_setattr, Revalidate};
 use super::validation_state::Exactness;
-use super::{
-    build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, Extra, ValidationState, Validator,
-};
+use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
 
 #[derive(Debug)]
 struct Field {
@@ -155,222 +153,213 @@ impl Validator for DataclassArgsValidator {
         let mut errors: Vec<ValLineError> = Vec::new();
         let mut used_keys: AHashSet<&str> = AHashSet::with_capacity(self.fields.len());
 
-        state.with_new_extra(
-            Extra {
-                data: Some(output_dict.clone()),
-                ..*state.extra()
-            },
-            |state| {
-                macro_rules! set_item {
-                    ($field:ident, $value:expr) => {{
-                        let py_name = $field.py_name.bind(py);
-                        if $field.init_only {
-                            if let Some(ref mut init_only_args) = init_only_args {
-                                init_only_args.push($value);
-                            }
-                        } else {
-                            output_dict.set_item(py_name, $value)?;
-                        }
-                    }};
+        let state = &mut state.rebind_extra(|extra| extra.data = Some(output_dict.clone()));
+
+        macro_rules! set_item {
+            ($field:ident, $value:expr) => {{
+                let py_name = $field.py_name.bind(py);
+                if $field.init_only {
+                    if let Some(ref mut init_only_args) = init_only_args {
+                        init_only_args.push($value);
+                    }
+                } else {
+                    output_dict.set_item(py_name, $value)?;
                 }
+            }};
+        }
 
-                macro_rules! process {
-                    ($args:ident, $get_method:ident, $get_macro:ident, $slice_macro:ident) => {{
-                        // go through fields getting the value from args or kwargs and validating it
-                        for (index, field) in self.fields.iter().enumerate() {
-                            if (!field.init) {
-                                match field.validator.default_value(py, Some(field.name.as_str()), state) {
-                                    Ok(Some(value)) => {
-                                        // Default value exists, and passed validation if required
-                                        set_item!(field, value);
-                                    },
-                                    Ok(None) | Err(ValError::Omit) => continue,
-                                    // Note: this will always use the field name even if there is an alias
-                                    // However, we don't mind so much because this error can only happen if the
-                                    // default value fails validation, which is arguably a developer error.
-                                    // We could try to "fix" this in the future if desired.
-                                    Err(ValError::LineErrors(line_errors)) => errors.extend(line_errors),
-                                    Err(err) => return Err(err),
-                                };
-                                continue;
-                            };
-
-                            let mut pos_value = None;
-                            if let Some(args) = &$args.args {
-                                if !field.kw_only {
-                                    pos_value = $get_macro!(args, index);
-                                }
+        macro_rules! process {
+            ($args:ident, $get_method:ident, $get_macro:ident, $slice_macro:ident) => {{
+                // go through fields getting the value from args or kwargs and validating it
+                for (index, field) in self.fields.iter().enumerate() {
+                    if (!field.init) {
+                        match field
+                            .validator
+                            .default_value(py, Some(field.name.as_str()), state)
+                        {
+                            Ok(Some(value)) => {
+                                // Default value exists, and passed validation if required
+                                set_item!(field, value);
                             }
+                            Ok(None) | Err(ValError::Omit) => continue,
+                            // Note: this will always use the field name even if there is an alias
+                            // However, we don't mind so much because this error can only happen if the
+                            // default value fails validation, which is arguably a developer error.
+                            // We could try to "fix" this in the future if desired.
+                            Err(ValError::LineErrors(line_errors)) => errors.extend(line_errors),
+                            Err(err) => return Err(err),
+                        };
+                        continue;
+                    };
 
-                            let mut kw_value = None;
-                            if let Some(kwargs) = &$args.kwargs {
-                                if let Some((lookup_path, value)) = field.lookup_key.$get_method(&kwargs)? {
-                                    used_keys.insert(lookup_path.first_key());
-                                    kw_value = Some((lookup_path, value));
+                    let mut pos_value = None;
+                    if let Some(args) = &$args.args {
+                        if !field.kw_only {
+                            pos_value = $get_macro!(args, index);
+                        }
+                    }
+
+                    let mut kw_value = None;
+                    if let Some(kwargs) = &$args.kwargs {
+                        if let Some((lookup_path, value)) = field.lookup_key.$get_method(&kwargs)? {
+                            used_keys.insert(lookup_path.first_key());
+                            kw_value = Some((lookup_path, value));
+                        }
+                    }
+                    let kw_value = kw_value
+                        .as_ref()
+                        .map(|(path, value)| (path, value.borrow_input()));
+
+                    match (pos_value, kw_value) {
+                        // found both positional and keyword arguments, error
+                        (Some(_), Some((_, kw_value))) => {
+                            errors.push(ValLineError::new_with_loc(
+                                ErrorTypeDefaults::MultipleArgumentValues,
+                                kw_value,
+                                field.name.clone(),
+                            ));
+                        }
+                        // found a positional argument, validate it
+                        (Some(pos_value), None) => {
+                            match field.validator.validate(py, pos_value.borrow_input(), state) {
+                                Ok(value) => set_item!(field, value),
+                                Err(ValError::LineErrors(line_errors)) => {
+                                    errors.extend(line_errors.into_iter().map(|err| err.with_outer_location(index)));
                                 }
+                                Err(err) => return Err(err),
                             }
-                            let kw_value = kw_value
-                                .as_ref()
-                                .map(|(path, value)| (path, value.borrow_input()));
-
-                            match (pos_value, kw_value) {
-                                // found both positional and keyword arguments, error
-                                (Some(_), Some((_, kw_value))) => {
-                                    errors.push(
-                                        ValLineError::new_with_loc(
-                                            ErrorTypeDefaults::MultipleArgumentValues,
-                                            kw_value,
-                                            field.name.clone(),
-                                        ),
-                                    );
+                        }
+                        // found a keyword argument, validate it
+                        (None, Some((lookup_path, kw_value))) => match field.validator.validate(py, kw_value, state) {
+                            Ok(value) => set_item!(field, value),
+                            Err(ValError::LineErrors(line_errors)) => {
+                                errors.extend(
+                                    line_errors
+                                        .into_iter()
+                                        .map(|err| lookup_path.apply_error_loc(err, self.loc_by_alias, &field.name)),
+                                );
+                            }
+                            Err(err) => return Err(err),
+                        },
+                        // found neither, check if there is a default value, otherwise error
+                        (None, None) => {
+                            match field
+                                .validator
+                                .default_value(py, Some(field.name.as_str()), state)
+                            {
+                                Ok(Some(value)) => {
+                                    // Default value exists, and passed validation if required
+                                    set_item!(field, value);
                                 }
-                                // found a positional argument, validate it
-                                (Some(pos_value), None) => match field.validator.validate(py, pos_value.borrow_input(), state) {
-                                    Ok(value) => set_item!(field, value),
-                                    Err(ValError::LineErrors(line_errors)) => {
-                                        errors.extend(
-                                            line_errors
-                                                .into_iter()
-                                                .map(|err| err.with_outer_location(index)),
-                                        );
-                                    }
-                                    Err(err) => return Err(err),
-                                },
-                                // found a keyword argument, validate it
-                                (None, Some((lookup_path, kw_value))) => {
-                                    match field.validator.validate(py, kw_value, state) {
-                                        Ok(value) => set_item!(field, value),
-                                        Err(ValError::LineErrors(line_errors)) => {
-                                            errors.extend(line_errors.into_iter().map(|err| {
-                                                lookup_path
-                                                    .apply_error_loc(err, self.loc_by_alias, &field.name)
-                                            }));
-                                        }
-                                        Err(err) => return Err(err),
-                                    }
+                                Ok(None) => {
+                                    // This means there was no default value
+                                    errors.push(field.lookup_key.error(
+                                        ErrorTypeDefaults::Missing,
+                                        input,
+                                        self.loc_by_alias,
+                                        &field.name,
+                                    ));
                                 }
-                                // found neither, check if there is a default value, otherwise error
-                                (None, None) => {
-                                    match field.validator.default_value(py, Some(field.name.as_str()), state) {
-                                        Ok(Some(value)) => {
-                                            // Default value exists, and passed validation if required
-                                            set_item!(field, value);
-                                        },
-                                        Ok(None) => {
-                                            // This means there was no default value
-                                            errors.push(field.lookup_key.error(
-                                                ErrorTypeDefaults::Missing,
-                                                input,
-                                                self.loc_by_alias,
-                                                &field.name
-                                            ));
-                                        },
-                                        Err(ValError::Omit) => continue,
-                                        Err(ValError::LineErrors(line_errors)) => {
-                                            for err in line_errors {
-                                                // Note: this will always use the field name even if there is an alias
-                                                // However, we don't mind so much because this error can only happen if the
-                                                // default value fails validation, which is arguably a developer error.
-                                                // We could try to "fix" this in the future if desired.
-                                                errors.push(err);
-                                            }
-                                        }
-                                        Err(err) => return Err(err),
+                                Err(ValError::Omit) => continue,
+                                Err(ValError::LineErrors(line_errors)) => {
+                                    for err in line_errors {
+                                        // Note: this will always use the field name even if there is an alias
+                                        // However, we don't mind so much because this error can only happen if the
+                                        // default value fails validation, which is arguably a developer error.
+                                        // We could try to "fix" this in the future if desired.
+                                        errors.push(err);
                                     }
                                 }
+                                Err(err) => return Err(err),
                             }
                         }
-                        // if there are more args than positional_count, add an error for each one
-                        if let Some(args) = $args.args {
-                            let len = args.len();
-                            if len > self.positional_count {
-                                for (index, item) in $slice_macro!(args, self.positional_count, len)
-                                    .iter()
-                                    .enumerate()
-                                {
-                                    errors.push(ValLineError::new_with_loc(
-                                        ErrorTypeDefaults::UnexpectedPositionalArgument,
-                                        item.borrow_input(),
-                                        index + self.positional_count,
-                                    ));
-                                }
-                            }
+                    }
+                }
+                // if there are more args than positional_count, add an error for each one
+                if let Some(args) = $args.args {
+                    let len = args.len();
+                    if len > self.positional_count {
+                        for (index, item) in $slice_macro!(args, self.positional_count, len).iter().enumerate() {
+                            errors.push(ValLineError::new_with_loc(
+                                ErrorTypeDefaults::UnexpectedPositionalArgument,
+                                item.borrow_input(),
+                                index + self.positional_count,
+                            ));
                         }
-                        // if there are kwargs check any that haven't been processed yet
-                        if let Some(kwargs) = $args.kwargs {
-                            if kwargs.len() != used_keys.len() {
-                                for (raw_key, value) in kwargs.iter() {
-                                    match raw_key.validate_str(true, false).map(ValidationMatch::into_inner) {
-                                        Ok(either_str) => {
-                                            if !used_keys.contains(either_str.as_cow()?.as_ref()) {
-                                                // Unknown / extra field
-                                                match self.extra_behavior {
-                                                    ExtraBehavior::Forbid => {
-                                                        errors.push(
-                                                            ValLineError::new_with_loc(
-                                                                ErrorTypeDefaults::UnexpectedKeywordArgument,
-                                                                value.borrow_input(),
-                                                                raw_key.clone(),
-                                                            ),
-                                                        );
-                                                    }
-                                                    ExtraBehavior::Ignore => {}
-                                                    ExtraBehavior::Allow => {
-                                                        if let Some(ref validator) = self.extras_validator {
-                                                            match validator.validate(py, value.borrow_input(), state) {
-                                                                Ok(value) => output_dict
-                                                                    .set_item(either_str.as_py_string(py), value)?,
-                                                                Err(ValError::LineErrors(line_errors)) => {
-                                                                    for err in line_errors {
-                                                                        errors.push(err.with_outer_location(raw_key.clone()));
-                                                                    }
-                                                                }
-                                                                Err(err) => return Err(err),
-                                                            }
-                                                        } else {
+                    }
+                }
+                // if there are kwargs check any that haven't been processed yet
+                if let Some(kwargs) = $args.kwargs {
+                    if kwargs.len() != used_keys.len() {
+                        for (raw_key, value) in kwargs.iter() {
+                            match raw_key.validate_str(true, false).map(ValidationMatch::into_inner) {
+                                Ok(either_str) => {
+                                    if !used_keys.contains(either_str.as_cow()?.as_ref()) {
+                                        // Unknown / extra field
+                                        match self.extra_behavior {
+                                            ExtraBehavior::Forbid => {
+                                                errors.push(ValLineError::new_with_loc(
+                                                    ErrorTypeDefaults::UnexpectedKeywordArgument,
+                                                    value.borrow_input(),
+                                                    raw_key.clone(),
+                                                ));
+                                            }
+                                            ExtraBehavior::Ignore => {}
+                                            ExtraBehavior::Allow => {
+                                                if let Some(ref validator) = self.extras_validator {
+                                                    match validator.validate(py, value.borrow_input(), state) {
+                                                        Ok(value) => {
                                                             output_dict.set_item(either_str.as_py_string(py), value)?
                                                         }
+                                                        Err(ValError::LineErrors(line_errors)) => {
+                                                            for err in line_errors {
+                                                                errors.push(err.with_outer_location(raw_key.clone()));
+                                                            }
+                                                        }
+                                                        Err(err) => return Err(err),
                                                     }
+                                                } else {
+                                                    output_dict.set_item(either_str.as_py_string(py), value)?
                                                 }
                                             }
                                         }
-                                        Err(ValError::LineErrors(line_errors)) => {
-                                            for err in line_errors {
-                                                errors.push(
-                                                    err.with_outer_location(raw_key.clone())
-                                                        .with_type(ErrorTypeDefaults::InvalidKey),
-                                                );
-                                            }
-                                        }
-                                        Err(err) => return Err(err),
                                     }
                                 }
+                                Err(ValError::LineErrors(line_errors)) => {
+                                    for err in line_errors {
+                                        errors.push(
+                                            err.with_outer_location(raw_key.clone())
+                                                .with_type(ErrorTypeDefaults::InvalidKey),
+                                        );
+                                    }
+                                }
+                                Err(err) => return Err(err),
                             }
                         }
-                    }};
+                    }
                 }
+            }};
+        }
 
-                match args {
-                    GenericArguments::Py(a) => process!(a, py_get_dict_item, py_get, py_slice),
-                    GenericArguments::Json(a) => process!(a, json_get, json_get, json_slice),
-                    GenericArguments::StringMapping(a) => {
-                        // StringMapping cannot pass positional args, so wrap the PyDict
-                        // in a type with guaranteed empty args array for sake of the process
-                        // macro
-                        struct StringMappingArgs<'py> {
-                            args: Option<Bound<'py, PyTuple>>,
-                            kwargs: Option<Bound<'py, PyDict>>,
-                        }
-                        let a = StringMappingArgs {
-                            args: None,
-                            kwargs: Some(a.clone()),
-                        };
-                        process!(a, py_get_string_mapping_item, py_get, py_slice);
-                    }
+        match args {
+            GenericArguments::Py(a) => process!(a, py_get_dict_item, py_get, py_slice),
+            GenericArguments::Json(a) => process!(a, json_get, json_get, json_slice),
+            GenericArguments::StringMapping(a) => {
+                // StringMapping cannot pass positional args, so wrap the PyDict
+                // in a type with guaranteed empty args array for sake of the process
+                // macro
+                struct StringMappingArgs<'py> {
+                    args: Option<Bound<'py, PyTuple>>,
+                    kwargs: Option<Bound<'py, PyDict>>,
                 }
-                Ok(())
-            },
-        )?;
+                let a = StringMappingArgs {
+                    args: None,
+                    kwargs: Some(a.clone()),
+                };
+                process!(a, py_get_string_mapping_item, py_get, py_slice);
+            }
+        }
+
         if errors.is_empty() {
             if let Some(init_only_args) = init_only_args {
                 Ok((output_dict, PyTuple::new_bound(py, init_only_args)).to_object(py))
@@ -417,12 +406,11 @@ impl Validator for DataclassArgsValidator {
                     return Err(err.into());
                 }
             }
-            match state.with_new_extra(
-                Extra {
-                    data: Some(data_dict.clone()),
-                    ..*state.extra()
-                },
-                |state| field.validator.validate(py, field_value, state),
+
+            match field.validator.validate(
+                py,
+                field_value,
+                &mut state.rebind_extra(|extra| extra.data = Some(data_dict.clone())),
             ) {
                 Ok(output) => ok(output),
                 Err(ValError::LineErrors(line_errors)) => {
diff --git a/src/validators/mod.rs b/src/validators/mod.rs
index 8fbfb95eb..4201ce422 100644
--- a/src/validators/mod.rs
+++ b/src/validators/mod.rs
@@ -560,7 +560,7 @@ pub fn build_validator(
 
 /// More (mostly immutable) data to pass between validators, should probably be class `Context`,
 /// but that would confuse it with context as per pydantic/pydantic#1549
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Extra<'a, 'py> {
     /// Validation mode
     pub input_type: InputType,
diff --git a/src/validators/model_fields.rs b/src/validators/model_fields.rs
index 39042158f..7ae4973fb 100644
--- a/src/validators/model_fields.rs
+++ b/src/validators/model_fields.rs
@@ -15,11 +15,7 @@ use crate::input::{
 use crate::lookup_key::LookupKey;
 use crate::tools::SchemaDict;
 
-use super::{
-    build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, Extra, ValidationState, Validator,
-};
-
-use std::ops::ControlFlow;
+use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
 
 #[derive(Debug)]
 struct Field {
@@ -164,21 +160,11 @@ impl Validator for ModelFieldsValidator {
             _ => None,
         };
 
-        macro_rules! control_flow {
-            ($e: expr) => {
-                match $e {
-                    Ok(v) => ControlFlow::Continue(v),
-                    Err(err) => ControlFlow::Break(ValError::from(err)),
-                }
-            };
-        }
-
         macro_rules! process {
             ($dict:expr, $get_method:ident, $iter:ty $(,$kwargs:expr)?) => {{
-                match state.with_new_extra(Extra {
-                    data: Some(model_dict.clone()),
-                    ..*state.extra()
-                }, |state| {
+                {
+                    let state = &mut state.rebind_extra(|extra| extra.data = Some(model_dict.clone()));
+
                     for field in &self.fields {
                         let op_key_value = match field.lookup_key.$get_method($dict $(, $kwargs )? ) {
                             Ok(v) => v,
@@ -188,7 +174,7 @@ impl Validator for ModelFieldsValidator {
                                 }
                                 continue;
                             }
-                            Err(err) => return ControlFlow::Break(err),
+                            Err(err) => return Err(err),
                         };
                         if let Some((lookup_path, value)) = op_key_value {
                             if let Some(ref mut used_keys) = used_keys {
@@ -198,7 +184,7 @@ impl Validator for ModelFieldsValidator {
                             }
                             match field.validator.validate(py, value.borrow_input(), state) {
                                 Ok(value) => {
-                                    control_flow!(model_dict.set_item(&field.name_py, value))?;
+                                    model_dict.set_item(&field.name_py, value)?;
                                     fields_set_vec.push(field.name_py.clone_ref(py));
                                 }
                                 Err(ValError::Omit) => continue,
@@ -210,7 +196,7 @@ impl Validator for ModelFieldsValidator {
                                         );
                                     }
                                 }
-                                Err(err) => return ControlFlow::Break(err),
+                                Err(err) => return Err(err),
                             }
                             continue;
                         }
@@ -218,7 +204,7 @@ impl Validator for ModelFieldsValidator {
                         match field.validator.default_value(py, Some(field.name.as_str()), state) {
                             Ok(Some(value)) => {
                                 // Default value exists, and passed validation if required
-                                control_flow!(model_dict.set_item(&field.name_py, value))?;
+                                model_dict.set_item(&field.name_py, value)?;
                             },
                             Ok(None) => {
                                 // This means there was no default value
@@ -239,13 +225,9 @@ impl Validator for ModelFieldsValidator {
                                     errors.push(err);
                                 }
                             }
-                            Err(err) => return ControlFlow::Break(err),
+                            Err(err) => return Err(err),
                         }
                     }
-                    ControlFlow::Continue(())
-                }) {
-                    ControlFlow::Continue(()) => {}
-                    ControlFlow::Break(err) => return Err(err),
                 }
 
                 if let Some(ref mut used_keys) = used_keys {
@@ -376,48 +358,43 @@ impl Validator for ModelFieldsValidator {
             }
         }
 
-        let new_extra = Extra {
-            data: Some(data_dict),
-            ..*state.extra()
-        };
+        let new_data = {
+            let state = &mut state.rebind_extra(move |extra| extra.data = Some(data_dict));
 
-        let new_data = if let Some(field) = self.fields.iter().find(|f| f.name == field_name) {
-            if field.frozen {
-                Err(ValError::new_with_loc(
-                    ErrorTypeDefaults::FrozenField,
-                    field_value,
-                    field.name.to_string(),
-                ))
-            } else {
-                prepare_result(
-                    state.with_new_extra(new_extra, |state| field.validator.validate(py, field_value, state)),
-                )
-            }
-        } else {
-            // Handle extra (unknown) field
-            // We partially use the extra_behavior for initialization / validation
-            // to determine how to handle assignment
-            // For models / typed dicts we forbid assigning extra attributes
-            // unless the user explicitly set extra_behavior to 'allow'
-            match self.extra_behavior {
-                ExtraBehavior::Allow => match self.extras_validator {
-                    Some(ref validator) => prepare_result(
-                        state.with_new_extra(new_extra, |state| validator.validate(py, field_value, state)),
-                    ),
-                    None => get_updated_dict(field_value.to_object(py)),
-                },
-                ExtraBehavior::Forbid | ExtraBehavior::Ignore => {
+            if let Some(field) = self.fields.iter().find(|f| f.name == field_name) {
+                if field.frozen {
                     return Err(ValError::new_with_loc(
-                        ErrorType::NoSuchAttribute {
-                            attribute: field_name.to_string(),
-                            context: None,
-                        },
+                        ErrorTypeDefaults::FrozenField,
                         field_value,
-                        field_name.to_string(),
-                    ))
+                        field.name.to_string(),
+                    ));
+                }
+
+                prepare_result(field.validator.validate(py, field_value, state))?
+            } else {
+                // Handle extra (unknown) field
+                // We partially use the extra_behavior for initialization / validation
+                // to determine how to handle assignment
+                // For models / typed dicts we forbid assigning extra attributes
+                // unless the user explicitly set extra_behavior to 'allow'
+                match self.extra_behavior {
+                    ExtraBehavior::Allow => match self.extras_validator {
+                        Some(ref validator) => prepare_result(validator.validate(py, field_value, state))?,
+                        None => get_updated_dict(field_value.to_object(py))?,
+                    },
+                    ExtraBehavior::Forbid | ExtraBehavior::Ignore => {
+                        return Err(ValError::new_with_loc(
+                            ErrorType::NoSuchAttribute {
+                                attribute: field_name.to_string(),
+                                context: None,
+                            },
+                            field_value,
+                            field_name.to_string(),
+                        ))
+                    }
                 }
             }
-        }?;
+        };
 
         let new_extra = match &self.extra_behavior {
             ExtraBehavior::Allow => {
diff --git a/src/validators/typed_dict.rs b/src/validators/typed_dict.rs
index 998942f7f..afde8868c 100644
--- a/src/validators/typed_dict.rs
+++ b/src/validators/typed_dict.rs
@@ -1,5 +1,3 @@
-use std::ops::ControlFlow;
-
 use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyString};
@@ -16,9 +14,7 @@ use crate::input::{
 use crate::lookup_key::LookupKey;
 use crate::tools::SchemaDict;
 
-use super::{
-    build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, Extra, ValidationState, Validator,
-};
+use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
 
 #[derive(Debug)]
 struct TypedDictField {
@@ -165,21 +161,11 @@ impl Validator for TypedDictValidator {
             _ => None,
         };
 
-        macro_rules! control_flow {
-            ($e: expr) => {
-                match $e {
-                    Ok(v) => ControlFlow::Continue(v),
-                    Err(err) => ControlFlow::Break(ValError::from(err)),
-                }
-            };
-        }
-
         macro_rules! process {
             ($dict:expr, $get_method:ident, $iter:ty $(,$kwargs:expr)?) => {{
-                match state.with_new_extra(Extra {
-                    data: Some(output_dict.clone()),
-                    ..*state.extra()
-                }, |state| {
+                {
+                    let state = &mut state.rebind_extra(|extra| extra.data = Some(output_dict.clone()));
+
                     for field in &self.fields {
                         let op_key_value = match field.lookup_key.$get_method($dict $(, $kwargs )? ) {
                             Ok(v) => v,
@@ -189,7 +175,7 @@ impl Validator for TypedDictValidator {
                                 }
                                 continue;
                             }
-                            Err(err) => return ControlFlow::Break(err),
+                            Err(err) => return Err(err),
                         };
                         if let Some((lookup_path, value)) = op_key_value {
                             if let Some(ref mut used_keys) = used_keys {
@@ -199,7 +185,7 @@ impl Validator for TypedDictValidator {
                             }
                             match field.validator.validate(py, value.borrow_input(), state) {
                                 Ok(value) => {
-                                    control_flow!(output_dict.set_item(&field.name_py, value))?;
+                                    output_dict.set_item(&field.name_py, value)?;
                                 }
                                 Err(ValError::Omit) => continue,
                                 Err(ValError::LineErrors(line_errors)) => {
@@ -210,7 +196,7 @@ impl Validator for TypedDictValidator {
                                         );
                                     }
                                 }
-                                Err(err) => return ControlFlow::Break(err),
+                                Err(err) => return Err(err),
                             }
                             continue;
                         }
@@ -218,7 +204,7 @@ impl Validator for TypedDictValidator {
                         match field.validator.default_value(py, Some(field.name.as_str()), state) {
                             Ok(Some(value)) => {
                                 // Default value exists, and passed validation if required
-                                control_flow!(output_dict.set_item(&field.name_py, value))?;
+                                output_dict.set_item(&field.name_py, value)?;
                             },
                             Ok(None) => {
                                 // This means there was no default value
@@ -241,13 +227,9 @@ impl Validator for TypedDictValidator {
                                     errors.push(err);
                                 }
                             }
-                            Err(err) => return ControlFlow::Break(err),
+                            Err(err) => return Err(err),
                         }
                     }
-                    ControlFlow::Continue(())
-                }) {
-                    ControlFlow::Continue(()) => {}
-                    ControlFlow::Break(err) => return Err(err),
                 }
 
                 if let Some(ref mut used_keys) = used_keys {
diff --git a/src/validators/validation_state.rs b/src/validators/validation_state.rs
index d7a831aee..1de2d75bd 100644
--- a/src/validators/validation_state.rs
+++ b/src/validators/validation_state.rs
@@ -25,28 +25,6 @@ impl<'a, 'py> ValidationState<'a, 'py> {
         }
     }
 
-    pub fn with_new_extra<'r, R: 'r>(
-        &mut self,
-        extra: Extra<'_, 'py>,
-        f: impl for<'s> FnOnce(&'s mut ValidationState<'_, 'py>) -> R,
-    ) -> R {
-        // TODO: It would be nice to implement this function with a drop guard instead of a closure,
-        // but lifetimes get in a tangle. Maybe someone brave wants to have a go at unpicking lifetimes.
-        let mut new_state = ValidationState {
-            recursion_guard: self.recursion_guard,
-            exactness: self.exactness,
-            extra,
-        };
-        let result = f(&mut new_state);
-        let exactness = new_state.exactness;
-        drop(new_state);
-        match exactness {
-            Some(exactness) => self.floor_exactness(exactness),
-            None => self.exactness = None,
-        }
-        result
-    }
-
     /// Temporarily rebinds the extra field by calling `f` to modify extra.
     ///
     /// When `ValidationStateWithReboundExtra` drops, the extra field is restored to its original value.
@@ -54,11 +32,7 @@ impl<'a, 'py> ValidationState<'a, 'py> {
         &'state mut self,
         f: impl FnOnce(&mut Extra<'a, 'py>),
     ) -> ValidationStateWithReboundExtra<'state, 'a, 'py> {
-        #[allow(clippy::unnecessary_struct_initialization)]
-        let old_extra = Extra {
-            data: self.extra.data.clone(),
-            ..self.extra
-        };
+        let old_extra = self.extra.clone();
         f(&mut self.extra);
         ValidationStateWithReboundExtra { state: self, old_extra }
     }

From abff9ba089a714496ee0d31f10697e6a77167f90 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Tue, 19 Mar 2024 15:13:35 +0000
Subject: [PATCH 236/550] associated types for arguments in Input (#1234)

---
 Cargo.toml                  |   2 +-
 src/input/input_abstract.rs |  96 +++++++++--
 src/input/input_json.rs     |  90 +++++++++--
 src/input/input_python.rs   |  99 ++++++++++--
 src/input/input_string.rs   |  54 ++++++-
 src/input/mod.rs            |   9 +-
 src/input/return_enums.rs   |  43 -----
 src/validators/arguments.rs | 290 +++++++++++++++------------------
 src/validators/dataclass.rs | 315 ++++++++++++++++--------------------
 9 files changed, 579 insertions(+), 419 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index f74976967..ff97d1dbf 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -24,7 +24,7 @@ include = [
     "!tests/.pytest_cache",
     "!*.so",
 ]
-rust-version = "1.70"
+rust-version = "1.76"
 
 [dependencies]
 pyo3 = { version = "0.21.0-beta.0", features = ["generate-import-lib", "num-bigint"] }
diff --git a/src/input/input_abstract.rs b/src/input/input_abstract.rs
index db46f06fe..a97b2b7de 100644
--- a/src/input/input_abstract.rs
+++ b/src/input/input_abstract.rs
@@ -4,13 +4,14 @@ use pyo3::exceptions::PyValueError;
 use pyo3::types::{PyDict, PyList, PyType};
 use pyo3::{intern, prelude::*};
 
-use crate::errors::{ErrorTypeDefaults, InputValue, ValError, ValResult};
+use crate::errors::{ErrorTypeDefaults, InputValue, LocItem, ValError, ValResult};
+use crate::lookup_key::{LookupKey, LookupPath};
 use crate::tools::py_err;
 use crate::{PyMultiHostUrl, PyUrl};
 
 use super::datetime::{EitherDate, EitherDateTime, EitherTime, EitherTimedelta};
 use super::return_enums::{EitherBytes, EitherInt, EitherString};
-use super::{EitherFloat, GenericArguments, GenericIterable, GenericIterator, GenericMapping, ValidationMatch};
+use super::{EitherFloat, GenericIterable, GenericIterator, GenericMapping, ValidationMatch};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum InputType {
@@ -85,9 +86,13 @@ pub trait Input<'py>: fmt::Debug + ToPyObject {
         false
     }
 
-    fn validate_args(&self) -> ValResult<GenericArguments<'_, 'py>>;
+    type Arguments<'a>: Arguments<'py>
+    where
+        Self: 'a;
 
-    fn validate_dataclass_args<'a>(&'a self, dataclass_name: &str) -> ValResult<GenericArguments<'a, 'py>>;
+    fn validate_args(&self) -> ValResult<Self::Arguments<'_>>;
+
+    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<'_>>;
 
@@ -234,14 +239,40 @@ impl<'py, T: Input<'py> + ?Sized> BorrowInput<'py> for &'_ T {
     }
 }
 
-pub enum Never {}
-
 // Pairs with Iterable below
 pub trait ConsumeIterator<T> {
     type Output;
     fn consume_iterator(self, iterator: impl Iterator<Item = T>) -> Self::Output;
 }
 
+pub trait Arguments<'py> {
+    type Args: PositionalArgs<'py> + ?Sized;
+    type Kwargs: KeywordArgs<'py> + ?Sized;
+
+    fn args(&self) -> Option<&Self::Args>;
+    fn kwargs(&self) -> Option<&Self::Kwargs>;
+}
+
+pub trait PositionalArgs<'py> {
+    type Item<'a>: BorrowInput<'py>
+    where
+        Self: 'a;
+    fn len(&self) -> usize;
+    fn get_item(&self, index: usize) -> Option<Self::Item<'_>>;
+    fn iter(&self) -> impl Iterator<Item = Self::Item<'_>>;
+}
+pub trait KeywordArgs<'py> {
+    type Key<'a>: BorrowInput<'py> + Clone + Into<LocItem>
+    where
+        Self: 'a;
+    type Item<'a>: BorrowInput<'py> + ToPyObject
+    where
+        Self: 'a;
+    fn len(&self) -> usize;
+    fn get_item<'k>(&self, key: &'k LookupKey) -> ValResult<Option<(&'k LookupPath, Self::Item<'_>)>>;
+    fn iter(&self) -> impl Iterator<Item = ValResult<(Self::Key<'_>, Self::Item<'_>)>>;
+}
+
 // This slightly awkward trait is used to define types which can be iterable. This formulation
 // arises because the Python enums have several different underlying iterator types, and we want to
 // be able to dispatch over each of them without overhead.
@@ -251,6 +282,16 @@ pub trait Iterable<'py> {
     fn iterate<R>(self, consumer: impl ConsumeIterator<PyResult<Self::Input>, Output = R>) -> ValResult<R>;
 }
 
+// Optimization pathway for inputs which are already python lists
+pub trait AsPyList<'py>: Iterable<'py> {
+    fn as_py_list(&self) -> Option<&Bound<'py, PyList>>;
+}
+
+/// This type is used for inputs which don't support certain types.
+/// It implements all the associated traits, but never actually gets called.
+
+pub enum Never {}
+
 // Necessary for inputs which don't support certain types, e.g. String -> list
 impl<'py> Iterable<'py> for Never {
     type Input = Bound<'py, PyAny>; // Doesn't really matter what this is
@@ -262,13 +303,46 @@ impl<'py> Iterable<'py> for Never {
     }
 }
 
-// Optimization pathway for inputs which are already python lists
-pub trait AsPyList<'py>: Iterable<'py> {
-    fn as_py_list(&self) -> Option<&Bound<'py, PyList>>;
-}
-
 impl<'py> AsPyList<'py> for Never {
     fn as_py_list(&self) -> Option<&Bound<'py, PyList>> {
         unreachable!()
     }
 }
+
+impl Arguments<'_> for Never {
+    type Args = Never;
+    type Kwargs = Never;
+    fn args(&self) -> Option<&Self::Args> {
+        unreachable!()
+    }
+    fn kwargs(&self) -> Option<&Self::Kwargs> {
+        unreachable!()
+    }
+}
+
+impl<'py> PositionalArgs<'py> for Never {
+    type Item<'a> = Bound<'py, PyAny> where Self: 'a;
+    fn len(&self) -> usize {
+        unreachable!()
+    }
+    fn get_item(&self, _index: usize) -> Option<Self::Item<'_>> {
+        unreachable!()
+    }
+    fn iter(&self) -> impl Iterator<Item = Self::Item<'_>> {
+        [].into_iter()
+    }
+}
+
+impl<'py> KeywordArgs<'py> for Never {
+    type Key<'a> = Bound<'py, PyAny> where Self: 'a;
+    type Item<'a> = Bound<'py, PyAny> where Self: 'a;
+    fn len(&self) -> usize {
+        unreachable!()
+    }
+    fn get_item<'k>(&self, _key: &'k LookupKey) -> ValResult<Option<(&'k LookupPath, Self::Item<'_>)>> {
+        unreachable!()
+    }
+    fn iter(&self) -> impl Iterator<Item = ValResult<(Self::Key<'_>, Self::Item<'_>)>> {
+        [].into_iter()
+    }
+}
diff --git a/src/input/input_json.rs b/src/input/input_json.rs
index e6727dc26..0e488c7d2 100644
--- a/src/input/input_json.rs
+++ b/src/input/input_json.rs
@@ -1,6 +1,6 @@
 use std::borrow::Cow;
 
-use jiter::{JsonArray, JsonValue};
+use jiter::{JsonArray, JsonObject, JsonValue, LazyIndexMap};
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList, PyString};
 use smallvec::SmallVec;
@@ -8,6 +8,7 @@ use speedate::MicrosecondsPrecisionOverflowBehavior;
 use strum::EnumMessage;
 
 use crate::errors::{ErrorType, ErrorTypeDefaults, InputValue, LocItem, ValError, ValResult};
+use crate::lookup_key::{LookupKey, LookupPath};
 use crate::validators::decimal::create_decimal;
 
 use super::datetime::{
@@ -18,8 +19,8 @@ use super::input_abstract::{AsPyList, ConsumeIterator, Iterable, Never, ValMatch
 use super::return_enums::ValidationMatch;
 use super::shared::{float_as_int, int_as_bool, str_as_bool, str_as_float, str_as_int};
 use super::{
-    BorrowInput, EitherBytes, EitherFloat, EitherInt, EitherString, EitherTimedelta, GenericArguments, GenericIterable,
-    GenericIterator, GenericMapping, Input, JsonArgs,
+    Arguments, BorrowInput, EitherBytes, EitherFloat, EitherInt, EitherString, EitherTimedelta, GenericIterable,
+    GenericIterator, GenericMapping, Input, KeywordArgs, PositionalArgs,
 };
 
 /// This is required but since JSON object keys are always strings, I don't think it can be called
@@ -53,7 +54,7 @@ impl<'py> Input<'py> for JsonValue {
         match self {
             JsonValue::Object(object) => {
                 let dict = PyDict::new_bound(py);
-                for (k, v) in object.iter() {
+                for (k, v) in LazyIndexMap::iter(object) {
                     dict.set_item(k, v.to_object(py)).unwrap();
                 }
                 Some(dict)
@@ -62,17 +63,21 @@ impl<'py> Input<'py> for JsonValue {
         }
     }
 
-    fn validate_args(&self) -> ValResult<GenericArguments<'_, 'py>> {
+    type Arguments<'a> = JsonArgs<'a>
+    where
+        Self: 'a,;
+
+    fn validate_args(&self) -> ValResult<JsonArgs<'_>> {
         match self {
-            JsonValue::Object(object) => Ok(JsonArgs::new(None, Some(object)).into()),
-            JsonValue::Array(array) => Ok(JsonArgs::new(Some(array), None).into()),
+            JsonValue::Object(object) => Ok(JsonArgs::new(None, Some(object))),
+            JsonValue::Array(array) => Ok(JsonArgs::new(Some(array), None)),
             _ => Err(ValError::new(ErrorTypeDefaults::ArgumentsType, self)),
         }
     }
 
-    fn validate_dataclass_args<'a>(&'a self, class_name: &str) -> ValResult<GenericArguments<'a, 'py>> {
+    fn validate_dataclass_args<'a>(&'a self, class_name: &str) -> ValResult<JsonArgs<'a>> {
         match self {
-            JsonValue::Object(object) => Ok(JsonArgs::new(None, Some(object)).into()),
+            JsonValue::Object(object) => Ok(JsonArgs::new(None, Some(object))),
             _ => {
                 let class_name = class_name.to_string();
                 Err(ValError::new(
@@ -320,13 +325,15 @@ impl<'py> Input<'py> for str {
         None
     }
 
+    type Arguments<'a> = Never;
+
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn validate_args(&self) -> ValResult<GenericArguments<'_, 'py>> {
+    fn validate_args(&self) -> ValResult<Never> {
         Err(ValError::new(ErrorTypeDefaults::ArgumentsType, self))
     }
 
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn validate_dataclass_args<'a>(&'a self, class_name: &str) -> ValResult<GenericArguments<'a, 'py>> {
+    fn validate_dataclass_args(&self, class_name: &str) -> ValResult<Never> {
         let class_name = class_name.to_string();
         Err(ValError::new(
             ErrorType::DataclassType {
@@ -447,6 +454,13 @@ impl BorrowInput<'_> for String {
     }
 }
 
+impl BorrowInput<'_> for JsonValue {
+    type Input = JsonValue;
+    fn borrow_input(&self) -> &Self::Input {
+        self
+    }
+}
+
 fn string_to_vec(s: &str) -> JsonArray {
     JsonArray::new(s.chars().map(|c| JsonValue::Str(c.to_string())).collect())
 }
@@ -467,3 +481,57 @@ impl<'py> AsPyList<'py> for &'_ JsonArray {
         None
     }
 }
+
+#[cfg_attr(debug_assertions, derive(Debug))]
+pub struct JsonArgs<'a> {
+    args: Option<&'a [JsonValue]>,
+    kwargs: Option<&'a JsonObject>,
+}
+
+impl<'a> JsonArgs<'a> {
+    fn new(args: Option<&'a [JsonValue]>, kwargs: Option<&'a JsonObject>) -> Self {
+        Self { args, kwargs }
+    }
+}
+
+impl<'a> Arguments<'_> for JsonArgs<'a> {
+    type Args = [JsonValue];
+    type Kwargs = JsonObject;
+
+    fn args(&self) -> Option<&Self::Args> {
+        self.args
+    }
+
+    fn kwargs(&self) -> Option<&Self::Kwargs> {
+        self.kwargs
+    }
+}
+
+impl PositionalArgs<'_> for [JsonValue] {
+    type Item<'a> = &'a JsonValue;
+
+    fn len(&self) -> usize {
+        <[JsonValue]>::len(self)
+    }
+    fn get_item(&self, index: usize) -> Option<Self::Item<'_>> {
+        self.get(index)
+    }
+    fn iter(&self) -> impl Iterator<Item = Self::Item<'_>> {
+        <[JsonValue]>::iter(self)
+    }
+}
+
+impl KeywordArgs<'_> for JsonObject {
+    type Key<'a> = &'a str;
+    type Item<'a> = &'a JsonValue;
+
+    fn len(&self) -> usize {
+        LazyIndexMap::len(self)
+    }
+    fn get_item<'k>(&self, key: &'k LookupKey) -> ValResult<Option<(&'k LookupPath, Self::Item<'_>)>> {
+        key.json_get(self)
+    }
+    fn iter(&self) -> impl Iterator<Item = ValResult<(Self::Key<'_>, Self::Item<'_>)>> {
+        LazyIndexMap::iter(self).map(|(k, v)| Ok((k.as_str(), v)))
+    }
+}
diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index 1c192c290..a73608498 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -28,9 +28,12 @@ use super::return_enums::ValidationMatch;
 use super::shared::{
     decimal_as_int, float_as_int, get_enum_meta_object, int_as_bool, str_as_bool, str_as_float, str_as_int,
 };
+use super::Arguments;
+use super::KeywordArgs;
+use super::PositionalArgs;
 use super::{
-    py_string_str, BorrowInput, EitherBytes, EitherFloat, EitherInt, EitherString, EitherTimedelta, GenericArguments,
-    GenericIterable, GenericIterator, GenericMapping, Input, PyArgs,
+    py_string_str, BorrowInput, EitherBytes, EitherFloat, EitherInt, EitherString, EitherTimedelta, GenericIterable,
+    GenericIterator, GenericMapping, Input,
 };
 
 #[cfg(not(PyPy))]
@@ -161,29 +164,31 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
         self.is_callable()
     }
 
-    fn validate_args(&self) -> ValResult<GenericArguments<'_, 'py>> {
+    type Arguments<'a> = PyArgs<'py> where Self: 'a;
+
+    fn validate_args(&self) -> ValResult<PyArgs<'py>> {
         if let Ok(dict) = self.downcast::<PyDict>() {
-            Ok(PyArgs::new(None, Some(dict.clone())).into())
+            Ok(PyArgs::new(None, Some(dict.clone())))
         } else if let Ok(args_kwargs) = self.extract::<ArgsKwargs>() {
             let args = args_kwargs.args.into_bound(self.py());
             let kwargs = args_kwargs.kwargs.map(|d| d.into_bound(self.py()));
-            Ok(PyArgs::new(Some(args), kwargs).into())
+            Ok(PyArgs::new(Some(args), kwargs))
         } else if let Ok(tuple) = self.downcast::<PyTuple>() {
-            Ok(PyArgs::new(Some(tuple.clone()), None).into())
+            Ok(PyArgs::new(Some(tuple.clone()), None))
         } else if let Ok(list) = self.downcast::<PyList>() {
-            Ok(PyArgs::new(Some(list.to_tuple()), None).into())
+            Ok(PyArgs::new(Some(list.to_tuple()), None))
         } else {
             Err(ValError::new(ErrorTypeDefaults::ArgumentsType, self))
         }
     }
 
-    fn validate_dataclass_args<'a>(&'a self, class_name: &str) -> ValResult<GenericArguments<'a, 'py>> {
+    fn validate_dataclass_args<'a>(&'a self, class_name: &str) -> ValResult<PyArgs<'py>> {
         if let Ok(dict) = self.downcast::<PyDict>() {
-            Ok(PyArgs::new(None, Some(dict.clone())).into())
+            Ok(PyArgs::new(None, Some(dict.clone())))
         } else if let Ok(args_kwargs) = self.extract::<ArgsKwargs>() {
             let args = args_kwargs.args.into_bound(self.py());
             let kwargs = args_kwargs.kwargs.map(|d| d.into_bound(self.py()));
-            Ok(PyArgs::new(Some(args), kwargs).into())
+            Ok(PyArgs::new(Some(args), kwargs))
         } else {
             let class_name = class_name.to_string();
             Err(ValError::new(
@@ -831,3 +836,77 @@ fn is_dict_items_type(v: &Bound<'_, PyAny>) -> bool {
         .bind(py);
     v.is_instance(items_type).unwrap_or(false)
 }
+
+#[cfg_attr(debug_assertions, derive(Debug))]
+pub struct PyArgs<'py> {
+    pub args: Option<PyPosArgs<'py>>,
+    pub kwargs: Option<PyKwargs<'py>>,
+}
+
+#[cfg_attr(debug_assertions, derive(Debug))]
+pub struct PyPosArgs<'py>(Bound<'py, PyTuple>);
+#[cfg_attr(debug_assertions, derive(Debug))]
+pub struct PyKwargs<'py>(Bound<'py, PyDict>);
+
+impl<'py> PyArgs<'py> {
+    pub fn new(args: Option<Bound<'py, PyTuple>>, kwargs: Option<Bound<'py, PyDict>>) -> Self {
+        Self {
+            args: args.map(PyPosArgs),
+            kwargs: kwargs.map(PyKwargs),
+        }
+    }
+}
+
+impl<'py> Arguments<'py> for PyArgs<'py> {
+    type Args = PyPosArgs<'py>;
+    type Kwargs = PyKwargs<'py>;
+
+    fn args(&self) -> Option<&PyPosArgs<'py>> {
+        self.args.as_ref()
+    }
+
+    fn kwargs(&self) -> Option<&PyKwargs<'py>> {
+        self.kwargs.as_ref()
+    }
+}
+
+impl<'py> PositionalArgs<'py> for PyPosArgs<'py> {
+    type Item<'a> = Borrowed<'a, 'py, PyAny> where Self: 'a;
+
+    fn len(&self) -> usize {
+        self.0.len()
+    }
+
+    fn get_item(&self, index: usize) -> Option<Self::Item<'_>> {
+        self.0.get_borrowed_item(index).ok()
+    }
+
+    fn iter(&self) -> impl Iterator<Item = Self::Item<'_>> {
+        self.0.iter_borrowed()
+    }
+}
+
+impl<'py> KeywordArgs<'py> for PyKwargs<'py> {
+    type Key<'a> = Bound<'py, PyAny>
+    where
+        Self: 'a;
+
+    type Item<'a> = Bound<'py, PyAny>
+    where
+        Self: 'a;
+
+    fn len(&self) -> usize {
+        self.0.len()
+    }
+
+    fn get_item<'k>(
+        &self,
+        key: &'k crate::lookup_key::LookupKey,
+    ) -> ValResult<Option<(&'k crate::lookup_key::LookupPath, Self::Item<'_>)>> {
+        key.py_get_dict_item(&self.0)
+    }
+
+    fn iter(&self) -> impl Iterator<Item = ValResult<(Self::Key<'_>, Self::Item<'_>)>> {
+        self.0.iter().map(Ok)
+    }
+}
diff --git a/src/input/input_string.rs b/src/input/input_string.rs
index 76c1a9f39..426223672 100644
--- a/src/input/input_string.rs
+++ b/src/input/input_string.rs
@@ -14,8 +14,8 @@ use super::datetime::{
 use super::input_abstract::{Never, ValMatch};
 use super::shared::{str_as_bool, str_as_float, str_as_int};
 use super::{
-    BorrowInput, EitherBytes, EitherFloat, EitherInt, EitherString, EitherTimedelta, GenericArguments, GenericIterable,
-    GenericIterator, GenericMapping, Input, ValidationMatch,
+    Arguments, BorrowInput, EitherBytes, EitherFloat, EitherInt, EitherString, EitherTimedelta, GenericIterable,
+    GenericIterator, GenericMapping, Input, KeywordArgs, ValidationMatch,
 };
 
 #[derive(Debug, Clone)]
@@ -74,15 +74,17 @@ impl<'py> Input<'py> for StringMapping<'py> {
         None
     }
 
-    fn validate_args(&self) -> ValResult<GenericArguments<'_, 'py>> {
+    type Arguments<'a> = StringMappingArgs<'py> where Self: 'a;
+
+    fn validate_args(&self) -> ValResult<StringMappingArgs<'py>> {
         // do we want to support this?
         Err(ValError::new(ErrorTypeDefaults::ArgumentsType, self))
     }
 
-    fn validate_dataclass_args<'a>(&'a self, _dataclass_name: &str) -> ValResult<GenericArguments<'a, 'py>> {
+    fn validate_dataclass_args<'a>(&'a self, _dataclass_name: &str) -> ValResult<StringMappingArgs<'py>> {
         match self {
             StringMapping::String(_) => Err(ValError::new(ErrorTypeDefaults::ArgumentsType, self)),
-            StringMapping::Mapping(m) => Ok(GenericArguments::StringMapping(m.clone())),
+            StringMapping::Mapping(m) => Ok(StringMappingArgs(m.clone())),
         }
     }
 
@@ -215,3 +217,45 @@ impl<'py> BorrowInput<'py> for StringMapping<'py> {
         self
     }
 }
+
+pub struct StringMappingArgs<'py>(Bound<'py, PyDict>);
+
+impl<'py> Arguments<'py> for StringMappingArgs<'py> {
+    type Args = Never;
+    type Kwargs = Self;
+
+    fn args(&self) -> Option<&Self::Args> {
+        None
+    }
+
+    fn kwargs(&self) -> Option<&Self::Kwargs> {
+        Some(self)
+    }
+}
+
+impl<'py> KeywordArgs<'py> for StringMappingArgs<'py> {
+    type Key<'a> = Bound<'py, PyAny>
+    where
+        Self: 'a;
+
+    type Item<'a> = StringMapping<'py>
+    where
+        Self: 'a;
+
+    fn len(&self) -> usize {
+        self.0.len()
+    }
+
+    fn get_item<'k>(
+        &self,
+        key: &'k crate::lookup_key::LookupKey,
+    ) -> ValResult<Option<(&'k crate::lookup_key::LookupPath, Self::Item<'_>)>> {
+        key.py_get_string_mapping_item(&self.0)
+    }
+
+    fn iter(&self) -> impl Iterator<Item = ValResult<(Self::Key<'_>, Self::Item<'_>)>> {
+        self.0
+            .iter()
+            .map(|(key, val)| Ok((key, StringMapping::new_value(&val)?)))
+    }
+}
diff --git a/src/input/mod.rs b/src/input/mod.rs
index 1d5047005..9bf29b6ae 100644
--- a/src/input/mod.rs
+++ b/src/input/mod.rs
@@ -15,13 +15,14 @@ pub(crate) use datetime::{
     duration_as_pytimedelta, pydate_as_date, pydatetime_as_datetime, pytime_as_time, EitherDate, EitherDateTime,
     EitherTime, EitherTimedelta,
 };
-pub(crate) use input_abstract::{AsPyList, BorrowInput, ConsumeIterator, Input, InputType, Iterable};
+pub(crate) use input_abstract::{
+    Arguments, AsPyList, BorrowInput, ConsumeIterator, Input, InputType, Iterable, KeywordArgs, PositionalArgs,
+};
 pub(crate) use input_string::StringMapping;
 pub(crate) use return_enums::{
     no_validator_iter_to_vec, py_string_str, validate_iter_to_vec, AttributesGenericIterator, DictGenericIterator,
-    EitherBytes, EitherFloat, EitherInt, EitherString, GenericArguments, GenericIterable, GenericIterator,
-    GenericMapping, Int, JsonArgs, JsonObjectGenericIterator, MappingGenericIterator, MaxLengthCheck, PyArgs,
-    StringMappingGenericIterator, ValidationMatch,
+    EitherBytes, EitherFloat, EitherInt, EitherString, GenericIterable, GenericIterator, GenericMapping, Int,
+    JsonObjectGenericIterator, MappingGenericIterator, MaxLengthCheck, StringMappingGenericIterator, ValidationMatch,
 };
 
 // Defined here as it's not exported by pyo3
diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index 7c13a2972..463c21a0d 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -783,49 +783,6 @@ impl GenericJsonIterator {
     }
 }
 
-#[cfg_attr(debug_assertions, derive(Debug))]
-pub struct PyArgs<'py> {
-    pub args: Option<Bound<'py, PyTuple>>,
-    pub kwargs: Option<Bound<'py, PyDict>>,
-}
-
-impl<'py> PyArgs<'py> {
-    pub fn new(args: Option<Bound<'py, PyTuple>>, kwargs: Option<Bound<'py, PyDict>>) -> Self {
-        Self { args, kwargs }
-    }
-}
-
-#[cfg_attr(debug_assertions, derive(Debug))]
-pub struct JsonArgs<'a> {
-    pub args: Option<&'a [JsonValue]>,
-    pub kwargs: Option<&'a JsonObject>,
-}
-
-impl<'a> JsonArgs<'a> {
-    pub fn new(args: Option<&'a [JsonValue]>, kwargs: Option<&'a JsonObject>) -> Self {
-        Self { args, kwargs }
-    }
-}
-
-#[cfg_attr(debug_assertions, derive(Debug))]
-pub enum GenericArguments<'a, 'py> {
-    Py(PyArgs<'py>),
-    Json(JsonArgs<'a>),
-    StringMapping(Bound<'py, PyDict>),
-}
-
-impl<'py> From<PyArgs<'py>> for GenericArguments<'_, 'py> {
-    fn from(s: PyArgs<'py>) -> Self {
-        Self::Py(s)
-    }
-}
-
-impl<'a> From<JsonArgs<'a>> for GenericArguments<'a, '_> {
-    fn from(s: JsonArgs<'a>) -> Self {
-        Self::Json(s)
-    }
-}
-
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub enum EitherString<'a> {
     Cow(Cow<'a, str>),
diff --git a/src/validators/arguments.rs b/src/validators/arguments.rs
index e2e2d13de..024348527 100644
--- a/src/validators/arguments.rs
+++ b/src/validators/arguments.rs
@@ -7,7 +7,7 @@ use ahash::AHashSet;
 use crate::build_tools::py_schema_err;
 use crate::build_tools::{schema_or_config_same, ExtraBehavior};
 use crate::errors::{ErrorTypeDefaults, ValError, ValLineError, ValResult};
-use crate::input::{BorrowInput, GenericArguments, Input, ValidationMatch};
+use crate::input::{Arguments, BorrowInput, Input, KeywordArgs, PositionalArgs, ValidationMatch};
 use crate::lookup_key::LookupKey;
 
 use crate::tools::SchemaDict;
@@ -129,34 +129,6 @@ impl BuildValidator for ArgumentsValidator {
     }
 }
 
-macro_rules! py_get {
-    ($obj:ident, $index:ident) => {
-        $obj.get_item($index).ok()
-    };
-}
-pub(super) use py_get;
-
-macro_rules! py_slice {
-    ($obj:ident, $from:expr, $to:expr) => {
-        $obj.get_slice($from, $to)
-    };
-}
-pub(super) use py_slice;
-
-macro_rules! json_get {
-    ($obj:ident, $index:ident) => {
-        $obj.get($index)
-    };
-}
-pub(super) use json_get;
-
-macro_rules! json_slice {
-    ($obj:ident, $from:expr, $to:expr) => {
-        $obj[$from..$to]
-    };
-}
-pub(super) use json_slice;
-
 impl_py_gc_traverse!(Parameter { validator });
 
 impl_py_gc_traverse!(ArgumentsValidator {
@@ -179,158 +151,152 @@ impl Validator for ArgumentsValidator {
         let mut errors: Vec<ValLineError> = Vec::new();
         let mut used_kwargs: AHashSet<&str> = AHashSet::with_capacity(self.parameters.len());
 
-        macro_rules! process {
-            ($args:ident, $get_method:ident, $get_macro:ident, $slice_macro:ident) => {{
-                // go through arguments getting the value from args or kwargs and validating it
-                for (index, parameter) in self.parameters.iter().enumerate() {
-                    let mut pos_value = None;
-                    if let Some(args) = &$args.args {
-                        if parameter.positional {
-                            pos_value = $get_macro!(args, index);
-                        }
-                    }
-                    let mut kw_value = None;
-                    if let Some(kwargs) = &$args.kwargs {
-                        if let Some(ref lookup_key) = parameter.kw_lookup_key {
-                            if let Some((lookup_path, value)) = lookup_key.$get_method(&kwargs)? {
-                                used_kwargs.insert(lookup_path.first_key());
-                                kw_value = Some((lookup_path, value));
-                            }
-                        }
+        // go through arguments getting the value from args or kwargs and validating it
+        for (index, parameter) in self.parameters.iter().enumerate() {
+            let mut pos_value = None;
+            if let Some(args) = args.args() {
+                if parameter.positional {
+                    pos_value = args.get_item(index);
+                }
+            }
+            let mut kw_value = None;
+            if let Some(kwargs) = args.kwargs() {
+                if let Some(ref lookup_key) = parameter.kw_lookup_key {
+                    if let Some((lookup_path, value)) = kwargs.get_item(lookup_key)? {
+                        used_kwargs.insert(lookup_path.first_key());
+                        kw_value = Some((lookup_path, value));
                     }
+                }
+            }
 
-                    match (pos_value, kw_value) {
-                        (Some(_), Some((_, kw_value))) => {
-                            errors.push(ValLineError::new_with_loc(
-                                ErrorTypeDefaults::MultipleArgumentValues,
-                                kw_value.borrow_input(),
-                                parameter.name.clone(),
-                            ));
-                        }
-                        (Some(pos_value), None) => {
-                            match parameter.validator.validate(py, pos_value.borrow_input(), state)
-                            {
-                                Ok(value) => output_args.push(value),
-                                Err(ValError::LineErrors(line_errors)) => {
-                                    errors.extend(line_errors.into_iter().map(|err| err.with_outer_location(index)));
-                                }
-                                Err(err) => return Err(err),
-                            }
-                        }
-                        (None, Some((lookup_path, kw_value))) => {
-                            match parameter.validator.validate(py, kw_value.borrow_input(), state)
-                            {
-                                Ok(value) => output_kwargs.set_item(parameter.kwarg_key.as_ref().unwrap(), value)?,
-                                Err(ValError::LineErrors(line_errors)) => {
-                                    errors.extend(line_errors.into_iter().map(|err| {
-                                        lookup_path.apply_error_loc(err, self.loc_by_alias, &parameter.name)
-                                    }));
-                                }
-                                Err(err) => return Err(err),
-                            }
-                        }
-                        (None, None) => {
-                            if let Some(value) = parameter.validator.default_value(py, Some(parameter.name.as_str()), state)? {
-                                if let Some(ref kwarg_key) = parameter.kwarg_key {
-                                    output_kwargs.set_item(kwarg_key, value)?;
-                                } else {
-                                    output_args.push(value);
-                                }
-                            } else if let Some(ref lookup_key) = parameter.kw_lookup_key {
-                                let error_type = if parameter.positional {
-                                    ErrorTypeDefaults::MissingArgument
-                                } else {
-                                    ErrorTypeDefaults::MissingKeywordOnlyArgument
-                                };
-                                errors.push(lookup_key.error(
-                                    error_type,
-                                    input,
-                                    self.loc_by_alias,
-                                    &parameter.name,
-                                ));
-                            } else {
-                                errors.push(ValLineError::new_with_loc(ErrorTypeDefaults::MissingPositionalOnlyArgument, input, index));
-                            };
+            match (pos_value, kw_value) {
+                (Some(_), Some((_, kw_value))) => {
+                    errors.push(ValLineError::new_with_loc(
+                        ErrorTypeDefaults::MultipleArgumentValues,
+                        kw_value.borrow_input(),
+                        parameter.name.clone(),
+                    ));
+                }
+                (Some(pos_value), None) => match parameter.validator.validate(py, pos_value.borrow_input(), state) {
+                    Ok(value) => output_args.push(value),
+                    Err(ValError::LineErrors(line_errors)) => {
+                        errors.extend(line_errors.into_iter().map(|err| err.with_outer_location(index)));
+                    }
+                    Err(err) => return Err(err),
+                },
+                (None, Some((lookup_path, kw_value))) => {
+                    match parameter.validator.validate(py, kw_value.borrow_input(), state) {
+                        Ok(value) => output_kwargs.set_item(parameter.kwarg_key.as_ref().unwrap(), value)?,
+                        Err(ValError::LineErrors(line_errors)) => {
+                            errors.extend(
+                                line_errors
+                                    .into_iter()
+                                    .map(|err| lookup_path.apply_error_loc(err, self.loc_by_alias, &parameter.name)),
+                            );
                         }
+                        Err(err) => return Err(err),
                     }
                 }
-                // if there are args check any where index > positional_params_count since they won't have been checked yet
-                if let Some(args) = $args.args {
-                    let len = args.len();
-                    if len > self.positional_params_count {
-                        if let Some(ref validator) = self.var_args_validator {
-                            for (index, item) in $slice_macro!(args, self.positional_params_count, len).iter().enumerate() {
-                                match validator.validate(py, item.borrow_input(), state) {
-                                    Ok(value) => output_args.push(value),
-                                    Err(ValError::LineErrors(line_errors)) => {
-                                        errors.extend(
-                                            line_errors
-                                                .into_iter()
-                                                .map(|err| err.with_outer_location(index + self.positional_params_count)),
-                                        );
-                                    }
-                                    Err(err) => return Err(err),
-                                }
-                            }
+                (None, None) => {
+                    if let Some(value) = parameter
+                        .validator
+                        .default_value(py, Some(parameter.name.as_str()), state)?
+                    {
+                        if let Some(ref kwarg_key) = parameter.kwarg_key {
+                            output_kwargs.set_item(kwarg_key, value)?;
+                        } else {
+                            output_args.push(value);
+                        }
+                    } else if let Some(ref lookup_key) = parameter.kw_lookup_key {
+                        let error_type = if parameter.positional {
+                            ErrorTypeDefaults::MissingArgument
                         } else {
-                            for (index, item) in $slice_macro!(args, self.positional_params_count, len).iter().enumerate() {
-                                errors.push(ValLineError::new_with_loc(
-                                    ErrorTypeDefaults::UnexpectedPositionalArgument,
-                                    item.borrow_input(),
-                                    index + self.positional_params_count,
-                                ));
+                            ErrorTypeDefaults::MissingKeywordOnlyArgument
+                        };
+                        errors.push(lookup_key.error(error_type, input, self.loc_by_alias, &parameter.name));
+                    } else {
+                        errors.push(ValLineError::new_with_loc(
+                            ErrorTypeDefaults::MissingPositionalOnlyArgument,
+                            input,
+                            index,
+                        ));
+                    };
+                }
+            }
+        }
+        // if there are args check any where index > positional_params_count since they won't have been checked yet
+        if let Some(args) = args.args() {
+            let len = args.len();
+            if len > self.positional_params_count {
+                if let Some(ref validator) = self.var_args_validator {
+                    for (index, item) in args.iter().enumerate().skip(self.positional_params_count) {
+                        match validator.validate(py, item.borrow_input(), state) {
+                            Ok(value) => output_args.push(value),
+                            Err(ValError::LineErrors(line_errors)) => {
+                                errors.extend(line_errors.into_iter().map(|err| err.with_outer_location(index)));
                             }
+                            Err(err) => return Err(err),
                         }
                     }
+                } else {
+                    for (index, item) in args.iter().enumerate().skip(self.positional_params_count) {
+                        errors.push(ValLineError::new_with_loc(
+                            ErrorTypeDefaults::UnexpectedPositionalArgument,
+                            item,
+                            index,
+                        ));
+                    }
                 }
-                // if there are kwargs check any that haven't been processed yet
-                if let Some(kwargs) = $args.kwargs {
-                    if kwargs.len() > used_kwargs.len() {
-                        for (raw_key, value) in kwargs.iter() {
-                            let either_str = match raw_key.validate_str(true, false).map(ValidationMatch::into_inner) {
-                                Ok(k) => k,
+            }
+        }
+        // if there are kwargs check any that haven't been processed yet
+        if let Some(kwargs) = args.kwargs() {
+            if kwargs.len() > used_kwargs.len() {
+                for result in kwargs.iter() {
+                    let (raw_key, value) = result?;
+                    let either_str = match raw_key
+                        .borrow_input()
+                        .validate_str(true, false)
+                        .map(ValidationMatch::into_inner)
+                    {
+                        Ok(k) => k,
+                        Err(ValError::LineErrors(line_errors)) => {
+                            for err in line_errors {
+                                errors.push(
+                                    err.with_outer_location(raw_key.clone())
+                                        .with_type(ErrorTypeDefaults::InvalidKey),
+                                );
+                            }
+                            continue;
+                        }
+                        Err(err) => return Err(err),
+                    };
+                    if !used_kwargs.contains(either_str.as_cow()?.as_ref()) {
+                        match self.var_kwargs_validator {
+                            Some(ref validator) => match validator.validate(py, value.borrow_input(), state) {
+                                Ok(value) => output_kwargs.set_item(either_str.as_py_string(py), value)?,
                                 Err(ValError::LineErrors(line_errors)) => {
                                     for err in line_errors {
-                                        errors.push(
-                                            err.with_outer_location(raw_key.clone())
-                                                .with_type(ErrorTypeDefaults::InvalidKey),
-                                        );
+                                        errors.push(err.with_outer_location(raw_key.clone()));
                                     }
-                                    continue;
                                 }
                                 Err(err) => return Err(err),
-                            };
-                            if !used_kwargs.contains(either_str.as_cow()?.as_ref()) {
-                                match self.var_kwargs_validator {
-                                    Some(ref validator) => match validator.validate(py, value.borrow_input(), state) {
-                                        Ok(value) => output_kwargs.set_item(either_str.as_py_string(py), value)?,
-                                        Err(ValError::LineErrors(line_errors)) => {
-                                            for err in line_errors {
-                                                errors.push(err.with_outer_location(raw_key.clone()));
-                                            }
-                                        }
-                                        Err(err) => return Err(err),
-                                    },
-                                    None => {
-                                        if let ExtraBehavior::Forbid = self.extra {
-                                            errors.push(ValLineError::new_with_loc(
-                                                ErrorTypeDefaults::UnexpectedKeywordArgument,
-                                                value.borrow_input(),
-                                                raw_key.clone(),
-                                            ));
-                                        }
-                                    }
+                            },
+                            None => {
+                                if let ExtraBehavior::Forbid = self.extra {
+                                    errors.push(ValLineError::new_with_loc(
+                                        ErrorTypeDefaults::UnexpectedKeywordArgument,
+                                        value,
+                                        raw_key.clone(),
+                                    ));
                                 }
-                        }}
+                            }
+                        }
                     }
                 }
-            }};
-        }
-        match args {
-            GenericArguments::Py(a) => process!(a, py_get_dict_item, py_get, py_slice),
-            GenericArguments::Json(a) => process!(a, json_get, json_get, json_slice),
-            GenericArguments::StringMapping(_) => unimplemented!(),
+            }
         }
+
         if !errors.is_empty() {
             Err(ValError::LineErrors(errors))
         } else {
diff --git a/src/validators/dataclass.rs b/src/validators/dataclass.rs
index 766691895..08e2aba1c 100644
--- a/src/validators/dataclass.rs
+++ b/src/validators/dataclass.rs
@@ -9,12 +9,11 @@ use crate::build_tools::py_schema_err;
 use crate::build_tools::{is_strict, schema_or_config_same, ExtraBehavior};
 use crate::errors::{ErrorType, ErrorTypeDefaults, ValError, ValLineError, ValResult};
 use crate::input::InputType;
-use crate::input::{BorrowInput, GenericArguments, Input, ValidationMatch};
+use crate::input::{Arguments, BorrowInput, Input, KeywordArgs, PositionalArgs, ValidationMatch};
 use crate::lookup_key::LookupKey;
 use crate::tools::SchemaDict;
 use crate::validators::function::convert_err;
 
-use super::arguments::{json_get, json_slice, py_get, py_slice};
 use super::model::{create_class, force_setattr, Revalidate};
 use super::validation_state::Exactness;
 use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
@@ -168,195 +167,167 @@ impl Validator for DataclassArgsValidator {
             }};
         }
 
-        macro_rules! process {
-            ($args:ident, $get_method:ident, $get_macro:ident, $slice_macro:ident) => {{
-                // go through fields getting the value from args or kwargs and validating it
-                for (index, field) in self.fields.iter().enumerate() {
-                    if (!field.init) {
-                        match field
-                            .validator
-                            .default_value(py, Some(field.name.as_str()), state)
-                        {
-                            Ok(Some(value)) => {
-                                // Default value exists, and passed validation if required
-                                set_item!(field, value);
-                            }
-                            Ok(None) | Err(ValError::Omit) => continue,
-                            // Note: this will always use the field name even if there is an alias
-                            // However, we don't mind so much because this error can only happen if the
-                            // default value fails validation, which is arguably a developer error.
-                            // We could try to "fix" this in the future if desired.
-                            Err(ValError::LineErrors(line_errors)) => errors.extend(line_errors),
-                            Err(err) => return Err(err),
-                        };
-                        continue;
-                    };
-
-                    let mut pos_value = None;
-                    if let Some(args) = &$args.args {
-                        if !field.kw_only {
-                            pos_value = $get_macro!(args, index);
-                        }
+        // go through fields getting the value from args or kwargs and validating it
+        for (index, field) in self.fields.iter().enumerate() {
+            if !field.init {
+                match field.validator.default_value(py, Some(field.name.as_str()), state) {
+                    Ok(Some(value)) => {
+                        // Default value exists, and passed validation if required
+                        set_item!(field, value);
                     }
+                    Ok(None) | Err(ValError::Omit) => continue,
+                    // Note: this will always use the field name even if there is an alias
+                    // However, we don't mind so much because this error can only happen if the
+                    // default value fails validation, which is arguably a developer error.
+                    // We could try to "fix" this in the future if desired.
+                    Err(ValError::LineErrors(line_errors)) => errors.extend(line_errors),
+                    Err(err) => return Err(err),
+                };
+                continue;
+            };
 
-                    let mut kw_value = None;
-                    if let Some(kwargs) = &$args.kwargs {
-                        if let Some((lookup_path, value)) = field.lookup_key.$get_method(&kwargs)? {
-                            used_keys.insert(lookup_path.first_key());
-                            kw_value = Some((lookup_path, value));
-                        }
+            let mut pos_value = None;
+            if let Some(args) = args.args() {
+                if !field.kw_only {
+                    pos_value = args.get_item(index);
+                }
+            }
+
+            let mut kw_value = None;
+            if let Some(kwargs) = args.kwargs() {
+                if let Some((lookup_path, value)) = kwargs.get_item(&field.lookup_key)? {
+                    used_keys.insert(lookup_path.first_key());
+                    kw_value = Some((lookup_path, value));
+                }
+            }
+            let kw_value = kw_value.as_ref().map(|(path, value)| (path, value.borrow_input()));
+
+            match (pos_value, kw_value) {
+                // found both positional and keyword arguments, error
+                (Some(_), Some((_, kw_value))) => {
+                    errors.push(ValLineError::new_with_loc(
+                        ErrorTypeDefaults::MultipleArgumentValues,
+                        kw_value,
+                        field.name.clone(),
+                    ));
+                }
+                // found a positional argument, validate it
+                (Some(pos_value), None) => match field.validator.validate(py, pos_value.borrow_input(), state) {
+                    Ok(value) => set_item!(field, value),
+                    Err(ValError::LineErrors(line_errors)) => {
+                        errors.extend(line_errors.into_iter().map(|err| err.with_outer_location(index)));
                     }
-                    let kw_value = kw_value
-                        .as_ref()
-                        .map(|(path, value)| (path, value.borrow_input()));
-
-                    match (pos_value, kw_value) {
-                        // found both positional and keyword arguments, error
-                        (Some(_), Some((_, kw_value))) => {
-                            errors.push(ValLineError::new_with_loc(
-                                ErrorTypeDefaults::MultipleArgumentValues,
-                                kw_value,
-                                field.name.clone(),
-                            ));
+                    Err(err) => return Err(err),
+                },
+                // found a keyword argument, validate it
+                (None, Some((lookup_path, kw_value))) => match field.validator.validate(py, kw_value, state) {
+                    Ok(value) => set_item!(field, value),
+                    Err(ValError::LineErrors(line_errors)) => {
+                        errors.extend(
+                            line_errors
+                                .into_iter()
+                                .map(|err| lookup_path.apply_error_loc(err, self.loc_by_alias, &field.name)),
+                        );
+                    }
+                    Err(err) => return Err(err),
+                },
+                // found neither, check if there is a default value, otherwise error
+                (None, None) => {
+                    match field.validator.default_value(py, Some(field.name.as_str()), state) {
+                        Ok(Some(value)) => {
+                            // Default value exists, and passed validation if required
+                            set_item!(field, value);
                         }
-                        // found a positional argument, validate it
-                        (Some(pos_value), None) => {
-                            match field.validator.validate(py, pos_value.borrow_input(), state) {
-                                Ok(value) => set_item!(field, value),
-                                Err(ValError::LineErrors(line_errors)) => {
-                                    errors.extend(line_errors.into_iter().map(|err| err.with_outer_location(index)));
-                                }
-                                Err(err) => return Err(err),
-                            }
+                        Ok(None) => {
+                            // This means there was no default value
+                            errors.push(field.lookup_key.error(
+                                ErrorTypeDefaults::Missing,
+                                input,
+                                self.loc_by_alias,
+                                &field.name,
+                            ));
                         }
-                        // found a keyword argument, validate it
-                        (None, Some((lookup_path, kw_value))) => match field.validator.validate(py, kw_value, state) {
-                            Ok(value) => set_item!(field, value),
-                            Err(ValError::LineErrors(line_errors)) => {
-                                errors.extend(
-                                    line_errors
-                                        .into_iter()
-                                        .map(|err| lookup_path.apply_error_loc(err, self.loc_by_alias, &field.name)),
-                                );
-                            }
-                            Err(err) => return Err(err),
-                        },
-                        // found neither, check if there is a default value, otherwise error
-                        (None, None) => {
-                            match field
-                                .validator
-                                .default_value(py, Some(field.name.as_str()), state)
-                            {
-                                Ok(Some(value)) => {
-                                    // Default value exists, and passed validation if required
-                                    set_item!(field, value);
-                                }
-                                Ok(None) => {
-                                    // This means there was no default value
-                                    errors.push(field.lookup_key.error(
-                                        ErrorTypeDefaults::Missing,
-                                        input,
-                                        self.loc_by_alias,
-                                        &field.name,
-                                    ));
-                                }
-                                Err(ValError::Omit) => continue,
-                                Err(ValError::LineErrors(line_errors)) => {
-                                    for err in line_errors {
-                                        // Note: this will always use the field name even if there is an alias
-                                        // However, we don't mind so much because this error can only happen if the
-                                        // default value fails validation, which is arguably a developer error.
-                                        // We could try to "fix" this in the future if desired.
-                                        errors.push(err);
-                                    }
-                                }
-                                Err(err) => return Err(err),
+                        Err(ValError::Omit) => continue,
+                        Err(ValError::LineErrors(line_errors)) => {
+                            for err in line_errors {
+                                // Note: this will always use the field name even if there is an alias
+                                // However, we don't mind so much because this error can only happen if the
+                                // default value fails validation, which is arguably a developer error.
+                                // We could try to "fix" this in the future if desired.
+                                errors.push(err);
                             }
                         }
+                        Err(err) => return Err(err),
                     }
                 }
-                // if there are more args than positional_count, add an error for each one
-                if let Some(args) = $args.args {
-                    let len = args.len();
-                    if len > self.positional_count {
-                        for (index, item) in $slice_macro!(args, self.positional_count, len).iter().enumerate() {
-                            errors.push(ValLineError::new_with_loc(
-                                ErrorTypeDefaults::UnexpectedPositionalArgument,
-                                item.borrow_input(),
-                                index + self.positional_count,
-                            ));
-                        }
-                    }
+            }
+        }
+        // if there are more args than positional_count, add an error for each one
+        if let Some(args) = args.args() {
+            let len = args.len();
+            if len > self.positional_count {
+                for (index, item) in args.iter().enumerate().skip(self.positional_count) {
+                    errors.push(ValLineError::new_with_loc(
+                        ErrorTypeDefaults::UnexpectedPositionalArgument,
+                        item,
+                        index,
+                    ));
                 }
-                // if there are kwargs check any that haven't been processed yet
-                if let Some(kwargs) = $args.kwargs {
-                    if kwargs.len() != used_keys.len() {
-                        for (raw_key, value) in kwargs.iter() {
-                            match raw_key.validate_str(true, false).map(ValidationMatch::into_inner) {
-                                Ok(either_str) => {
-                                    if !used_keys.contains(either_str.as_cow()?.as_ref()) {
-                                        // Unknown / extra field
-                                        match self.extra_behavior {
-                                            ExtraBehavior::Forbid => {
-                                                errors.push(ValLineError::new_with_loc(
-                                                    ErrorTypeDefaults::UnexpectedKeywordArgument,
-                                                    value.borrow_input(),
-                                                    raw_key.clone(),
-                                                ));
-                                            }
-                                            ExtraBehavior::Ignore => {}
-                                            ExtraBehavior::Allow => {
-                                                if let Some(ref validator) = self.extras_validator {
-                                                    match validator.validate(py, value.borrow_input(), state) {
-                                                        Ok(value) => {
-                                                            output_dict.set_item(either_str.as_py_string(py), value)?
-                                                        }
-                                                        Err(ValError::LineErrors(line_errors)) => {
-                                                            for err in line_errors {
-                                                                errors.push(err.with_outer_location(raw_key.clone()));
-                                                            }
-                                                        }
-                                                        Err(err) => return Err(err),
+            }
+        }
+        // if there are kwargs check any that haven't been processed yet
+        if let Some(kwargs) = args.kwargs() {
+            if kwargs.len() != used_keys.len() {
+                for result in kwargs.iter() {
+                    let (raw_key, value) = result?;
+                    match raw_key
+                        .borrow_input()
+                        .validate_str(true, false)
+                        .map(ValidationMatch::into_inner)
+                    {
+                        Ok(either_str) => {
+                            if !used_keys.contains(either_str.as_cow()?.as_ref()) {
+                                // Unknown / extra field
+                                match self.extra_behavior {
+                                    ExtraBehavior::Forbid => {
+                                        errors.push(ValLineError::new_with_loc(
+                                            ErrorTypeDefaults::UnexpectedKeywordArgument,
+                                            value,
+                                            raw_key.clone(),
+                                        ));
+                                    }
+                                    ExtraBehavior::Ignore => {}
+                                    ExtraBehavior::Allow => {
+                                        if let Some(ref validator) = self.extras_validator {
+                                            match validator.validate(py, value.borrow_input(), state) {
+                                                Ok(value) => {
+                                                    output_dict.set_item(either_str.as_py_string(py), value)?;
+                                                }
+                                                Err(ValError::LineErrors(line_errors)) => {
+                                                    for err in line_errors {
+                                                        errors.push(err.with_outer_location(raw_key.clone()));
                                                     }
-                                                } else {
-                                                    output_dict.set_item(either_str.as_py_string(py), value)?
                                                 }
+                                                Err(err) => return Err(err),
                                             }
+                                        } else {
+                                            output_dict.set_item(either_str.as_py_string(py), value)?;
                                         }
                                     }
                                 }
-                                Err(ValError::LineErrors(line_errors)) => {
-                                    for err in line_errors {
-                                        errors.push(
-                                            err.with_outer_location(raw_key.clone())
-                                                .with_type(ErrorTypeDefaults::InvalidKey),
-                                        );
-                                    }
-                                }
-                                Err(err) => return Err(err),
                             }
                         }
-                    }
-                }
-            }};
-        }
-
-        match args {
-            GenericArguments::Py(a) => process!(a, py_get_dict_item, py_get, py_slice),
-            GenericArguments::Json(a) => process!(a, json_get, json_get, json_slice),
-            GenericArguments::StringMapping(a) => {
-                // StringMapping cannot pass positional args, so wrap the PyDict
-                // in a type with guaranteed empty args array for sake of the process
-                // macro
-                struct StringMappingArgs<'py> {
-                    args: Option<Bound<'py, PyTuple>>,
-                    kwargs: Option<Bound<'py, PyDict>>,
+                        Err(ValError::LineErrors(line_errors)) => {
+                            for err in line_errors {
+                                errors.push(
+                                    err.with_outer_location(raw_key.clone())
+                                        .with_type(ErrorTypeDefaults::InvalidKey),
+                                );
+                            }
+                        }
+                        Err(err) => return Err(err),
+                    };
                 }
-                let a = StringMappingArgs {
-                    args: None,
-                    kwargs: Some(a.clone()),
-                };
-                process!(a, py_get_string_mapping_item, py_get, py_slice);
             }
         }
 

From 092f5f016f9c4f3ae0f214ee20378da312640be6 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Tomasz=20K=C5=82oczko?=
 <31284574+kloczek@users.noreply.github.com>
Date: Tue, 19 Mar 2024 19:03:08 +0000
Subject: [PATCH 237/550] really drop python<=3.7 support (#1232)
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

Signed-off-by: Tomasz Kłoczko <kloczek@github.com>
Co-authored-by: David Hewitt <mail@davidhewitt.dev>
---
 tests/benchmarks/complete_schema.py         | 4 ++--
 tests/benchmarks/test_complete_benchmark.py | 4 ++--
 tests/serializers/test_generator.py         | 6 ++----
 tests/test_errors.py                        | 6 +++---
 tests/validators/test_date.py               | 4 ++--
 tests/validators/test_decimal.py            | 4 ++--
 tests/validators/test_list.py               | 2 +-
 tests/validators/test_tuple.py              | 2 +-
 8 files changed, 15 insertions(+), 17 deletions(-)

diff --git a/tests/benchmarks/complete_schema.py b/tests/benchmarks/complete_schema.py
index cfc522d29..69b840224 100644
--- a/tests/benchmarks/complete_schema.py
+++ b/tests/benchmarks/complete_schema.py
@@ -253,8 +253,8 @@ def input_data_lax():
         'field_frozenset_bytes': frozenset([f'{i}'.encode() for i in range(100)]),
         'field_frozenset_bytes_con': frozenset([f'{i}'.encode() for i in range(42)]),
         'field_tuple_var_len_any': ('a', b'b', True, 1.0, None),
-        'field_tuple_var_len_float': tuple((i + 0.5 for i in range(100))),
-        'field_tuple_var_len_float_con': tuple((i + 0.5 for i in range(42))),
+        'field_tuple_var_len_float': tuple(i + 0.5 for i in range(100)),
+        'field_tuple_var_len_float_con': tuple(i + 0.5 for i in range(42)),
         'field_tuple_fix_len': ('a', 1, 1.0, True),
         'field_dict_any': {'a': 'b', 1: True, 1.0: 1.0},
         'field_dict_str_float': {f'{i}': i + 0.5 for i in range(100)},
diff --git a/tests/benchmarks/test_complete_benchmark.py b/tests/benchmarks/test_complete_benchmark.py
index 3217efe13..23fe58cdf 100644
--- a/tests/benchmarks/test_complete_benchmark.py
+++ b/tests/benchmarks/test_complete_benchmark.py
@@ -50,8 +50,8 @@ def test_complete_valid():
         'field_frozenset_bytes': frozenset([f'{i}'.encode() for i in range(100)]),
         'field_frozenset_bytes_con': frozenset([f'{i}'.encode() for i in range(42)]),
         'field_tuple_var_len_any': ('a', b'b', True, 1.0, None),
-        'field_tuple_var_len_float': tuple((i + 0.5 for i in range(100))),
-        'field_tuple_var_len_float_con': tuple((i + 0.5 for i in range(42))),
+        'field_tuple_var_len_float': tuple(i + 0.5 for i in range(100)),
+        'field_tuple_var_len_float_con': tuple(i + 0.5 for i in range(42)),
         'field_tuple_fix_len': ('a', 1, 1.0, True),
         'field_dict_any': {'a': 'b', 1: True, 1.0: 1.0},
         'field_dict_str_float': {f'{i}': i + 0.5 for i in range(100)},
diff --git a/tests/serializers/test_generator.py b/tests/serializers/test_generator.py
index 13b05a1df..29e9eeb6b 100644
--- a/tests/serializers/test_generator.py
+++ b/tests/serializers/test_generator.py
@@ -5,13 +5,11 @@
 
 
 def gen_ok(*things):
-    for thing in things:
-        yield thing
+    yield from things
 
 
 def gen_error(*things):
-    for thing in things:
-        yield thing
+    yield from things
     raise ValueError('oops')
 
 
diff --git a/tests/test_errors.py b/tests/test_errors.py
index 18821b98c..daabf04c6 100644
--- a/tests/test_errors.py
+++ b/tests/test_errors.py
@@ -397,7 +397,7 @@ def test_error_type(error_type, message, context):
 
 
 def test_all_errors_covered():
-    listed_types = set(error_type for error_type, *_ in all_errors)
+    listed_types = {error_type for error_type, *_ in all_errors}
     actual_types = {e['type'] for e in list_all_errors()}
     assert actual_types == listed_types
 
@@ -464,7 +464,7 @@ def test_custom_context_for_simple_error():
 def test_all_errors():
     errors = list_all_errors()
     # print(f'{len(errors)=}')
-    assert len(errors) == len(set(e['type'] for e in errors)), 'error types are not unique'
+    assert len(errors) == len({e['type'] for e in errors}), 'error types are not unique'
     # insert_assert(errors[:4])
     assert errors[:4] == [
         {
@@ -689,7 +689,7 @@ def singular_raise_py_error(v: Any) -> Any:
                 s.validate_python('anything')
             assert exc_info.value.__cause__ is None
         else:
-            raise AssertionError('Unhandled result: {}'.format(expected_result))
+            raise AssertionError(f'Unhandled result: {expected_result}')
 
 
 def test_validation_error_cause_traceback_preserved():
diff --git a/tests/validators/test_date.py b/tests/validators/test_date.py
index 6a552a57b..9c61a69aa 100644
--- a/tests/validators/test_date.py
+++ b/tests/validators/test_date.py
@@ -3,7 +3,7 @@
 import re
 from datetime import date, datetime, time, timedelta, timezone
 from decimal import Decimal
-from typing import Any, Dict
+from typing import Any
 
 import pytest
 
@@ -199,7 +199,7 @@ def test_date_strict_json_ctx():
         ({'gt': date(2000, 1, 1)}, '2000-01-01', Err('Input should be greater than 2000-01-01 [type=greater_than,')),
     ],
 )
-def test_date_kwargs(kwargs: Dict[str, Any], input_value: date, expected: Err | date):
+def test_date_kwargs(kwargs: dict[str, Any], input_value: date, expected: Err | date):
     v = SchemaValidator({'type': 'date', **kwargs})  # type: ignore
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
diff --git a/tests/validators/test_decimal.py b/tests/validators/test_decimal.py
index 69cd52738..931fe6377 100644
--- a/tests/validators/test_decimal.py
+++ b/tests/validators/test_decimal.py
@@ -4,7 +4,7 @@
 import math
 import re
 from decimal import Decimal
-from typing import Any, Dict
+from typing import Any
 
 import pytest
 from dirty_equals import FunctionCheck, IsStr
@@ -157,7 +157,7 @@ def test_decimal_strict_json(input_value, expected):
         ({'lt': 0.123456}, 1, Err('Input should be less than 0.123456')),
     ],
 )
-def test_decimal_kwargs(py_and_json: PyAndJson, kwargs: Dict[str, Any], input_value, expected):
+def test_decimal_kwargs(py_and_json: PyAndJson, kwargs: dict[str, Any], input_value, expected):
     v = py_and_json({'type': 'decimal', **kwargs})
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
diff --git a/tests/validators/test_list.py b/tests/validators/test_list.py
index 187c0b851..9f7d8738f 100644
--- a/tests/validators/test_list.py
+++ b/tests/validators/test_list.py
@@ -438,7 +438,7 @@ class ListInputTestCase:
 LAX_MODE_INPUTS: List[Any] = [
     (1, 2, 3),
     frozenset((1, 2, 3)),
-    set((1, 2, 3)),
+    {1, 2, 3},
     deque([1, 2, 3]),
     {1: 'a', 2: 'b', 3: 'c'}.keys(),
     {'a': 1, 'b': 2, 'c': 3}.values(),
diff --git a/tests/validators/test_tuple.py b/tests/validators/test_tuple.py
index e62f49f1d..a3d548ced 100644
--- a/tests/validators/test_tuple.py
+++ b/tests/validators/test_tuple.py
@@ -165,7 +165,7 @@ def test_tuple_validate(input_value, expected, variadic_item_index, items):
 )
 def test_tuple_validate_iterator(variadic_item_index, items):
     v = SchemaValidator(core_schema.tuple_schema(items_schema=items, variadic_item_index=variadic_item_index))
-    assert v.validate_python((x for x in [1, 2, '3'])) == (1, 2, 3)
+    assert v.validate_python(x for x in [1, 2, '3']) == (1, 2, 3)
 
 
 @pytest.mark.parametrize(

From 36a1b6c6cebcc666229d8f01cbe28fe10b0443bf Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Wed, 20 Mar 2024 10:34:24 +0000
Subject: [PATCH 238/550] associated types for dict in input (#1237)

---
 src/build_tools.rs             |   2 +-
 src/input/input_abstract.rs    |  85 ++++++++----
 src/input/input_json.rs        |  46 +++++--
 src/input/input_python.rs      |  79 +++++++++--
 src/input/input_string.rs      |  87 +++++++++----
 src/input/mod.rs               |   8 +-
 src/input/return_enums.rs      | 214 ++++++------------------------
 src/lookup_key.rs              |   2 +-
 src/validators/dict.rs         |  70 +++++-----
 src/validators/list.rs         |   3 +-
 src/validators/mod.rs          |   2 +-
 src/validators/model_fields.rs | 232 ++++++++++++++++++---------------
 src/validators/typed_dict.rs   | 223 ++++++++++++++++---------------
 src/validators/union.rs        |  54 +++-----
 14 files changed, 557 insertions(+), 550 deletions(-)

diff --git a/src/build_tools.rs b/src/build_tools.rs
index 23c88970b..3d7e8ccc8 100644
--- a/src/build_tools.rs
+++ b/src/build_tools.rs
@@ -164,7 +164,7 @@ macro_rules! py_schema_err {
 }
 pub(crate) use py_schema_err;
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
 pub(crate) enum ExtraBehavior {
     Allow,
     Forbid,
diff --git a/src/input/input_abstract.rs b/src/input/input_abstract.rs
index a97b2b7de..410beeacb 100644
--- a/src/input/input_abstract.rs
+++ b/src/input/input_abstract.rs
@@ -11,7 +11,7 @@ use crate::{PyMultiHostUrl, PyUrl};
 
 use super::datetime::{EitherDate, EitherDateTime, EitherTime, EitherTimedelta};
 use super::return_enums::{EitherBytes, EitherInt, EitherString};
-use super::{EitherFloat, GenericIterable, GenericIterator, GenericMapping, ValidationMatch};
+use super::{EitherFloat, GenericIterable, GenericIterator, ValidationMatch};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum InputType {
@@ -135,24 +135,28 @@ pub trait Input<'py>: fmt::Debug + ToPyObject {
         self.strict_decimal(py)
     }
 
-    fn validate_dict<'a>(&'a self, strict: bool) -> ValResult<GenericMapping<'a, 'py>> {
+    type Dict<'a>: ValidatedDict<'py>
+    where
+        Self: 'a;
+
+    fn validate_dict(&self, strict: bool) -> ValResult<Self::Dict<'_>> {
         if strict {
             self.strict_dict()
         } else {
             self.lax_dict()
         }
     }
-    fn strict_dict<'a>(&'a self) -> ValResult<GenericMapping<'a, 'py>>;
+    fn strict_dict(&self) -> ValResult<Self::Dict<'_>>;
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn lax_dict<'a>(&'a self) -> ValResult<GenericMapping<'a, 'py>> {
+    fn lax_dict(&self) -> ValResult<Self::Dict<'_>> {
         self.strict_dict()
     }
 
-    fn validate_model_fields<'a>(&'a self, strict: bool, _from_attributes: bool) -> ValResult<GenericMapping<'a, 'py>> {
+    fn validate_model_fields(&self, strict: bool, _from_attributes: bool) -> ValResult<Self::Dict<'_>> {
         self.validate_dict(strict)
     }
 
-    type List<'a>: Iterable<'py> + AsPyList<'py>
+    type List<'a>: ValidatedList<'py>
     where
         Self: 'a;
 
@@ -239,12 +243,6 @@ impl<'py, T: Input<'py> + ?Sized> BorrowInput<'py> for &'_ T {
     }
 }
 
-// Pairs with Iterable below
-pub trait ConsumeIterator<T> {
-    type Output;
-    fn consume_iterator(self, iterator: impl Iterator<Item = T>) -> Self::Output;
-}
-
 pub trait Arguments<'py> {
     type Args: PositionalArgs<'py> + ?Sized;
     type Kwargs: KeywordArgs<'py> + ?Sized;
@@ -273,18 +271,40 @@ pub trait KeywordArgs<'py> {
     fn iter(&self) -> impl Iterator<Item = ValResult<(Self::Key<'_>, Self::Item<'_>)>>;
 }
 
-// This slightly awkward trait is used to define types which can be iterable. This formulation
-// arises because the Python enums have several different underlying iterator types, and we want to
-// be able to dispatch over each of them without overhead.
-pub trait Iterable<'py> {
-    type Input: BorrowInput<'py>;
-    fn len(&self) -> Option<usize>;
-    fn iterate<R>(self, consumer: impl ConsumeIterator<PyResult<Self::Input>, Output = R>) -> ValResult<R>;
+/// Some of the associated types like `ValidatedDict` and `ValidatedList` have multiple possible iterators
+/// depending on the source input. This trait allows to pass a generic consumer to these iterator-producing
+/// methods and dispatch over the different iterator types.
+pub trait ConsumeIterator<T> {
+    type Output;
+    fn consume_iterator(self, iterator: impl Iterator<Item = T>) -> Self::Output;
+}
+
+/// For validations from a dictionary
+pub trait ValidatedDict<'py> {
+    type Key<'a>: BorrowInput<'py> + Clone + Into<LocItem>
+    where
+        Self: 'a;
+    type Item<'a>: BorrowInput<'py>
+    where
+        Self: 'a;
+    fn get_item<'k>(&self, key: &'k LookupKey) -> ValResult<Option<(&'k LookupPath, Self::Item<'_>)>>;
+    fn as_py_dict(&self) -> Option<&Bound<'py, PyDict>>;
+    // FIXME this is a bit of a leaky abstraction
+    fn is_py_get_attr(&self) -> bool {
+        false
+    }
+    fn iterate<'a, R>(
+        &'a self,
+        consumer: impl ConsumeIterator<ValResult<(Self::Key<'a>, Self::Item<'a>)>, Output = R>,
+    ) -> ValResult<R>;
 }
 
 // Optimization pathway for inputs which are already python lists
-pub trait AsPyList<'py>: Iterable<'py> {
+pub trait ValidatedList<'py> {
+    type Item: BorrowInput<'py>;
+    fn len(&self) -> Option<usize>;
     fn as_py_list(&self) -> Option<&Bound<'py, PyList>>;
+    fn iterate<R>(self, consumer: impl ConsumeIterator<PyResult<Self::Item>, Output = R>) -> ValResult<R>;
 }
 
 /// This type is used for inputs which don't support certain types.
@@ -292,21 +312,34 @@ pub trait AsPyList<'py>: Iterable<'py> {
 
 pub enum Never {}
 
-// Necessary for inputs which don't support certain types, e.g. String -> list
-impl<'py> Iterable<'py> for Never {
-    type Input = Bound<'py, PyAny>; // Doesn't really matter what this is
-    fn len(&self) -> Option<usize> {
+impl<'py> ValidatedDict<'py> for Never {
+    type Key<'a> = Bound<'py, PyAny>;
+    type Item<'a> = Bound<'py, PyAny>;
+    fn get_item<'k>(&self, _key: &'k LookupKey) -> ValResult<Option<(&'k LookupPath, Self::Item<'_>)>> {
+        unreachable!()
+    }
+    fn as_py_dict(&self) -> Option<&Bound<'py, PyDict>> {
         unreachable!()
     }
-    fn iterate<R>(self, _consumer: impl ConsumeIterator<PyResult<Self::Input>, Output = R>) -> ValResult<R> {
+    fn iterate<'a, R>(
+        &'a self,
+        _consumer: impl ConsumeIterator<ValResult<(Self::Key<'a>, Self::Item<'a>)>, Output = R>,
+    ) -> ValResult<R> {
         unreachable!()
     }
 }
 
-impl<'py> AsPyList<'py> for Never {
+impl<'py> ValidatedList<'py> for Never {
+    type Item = Bound<'py, PyAny>;
+    fn len(&self) -> Option<usize> {
+        unreachable!()
+    }
     fn as_py_list(&self) -> Option<&Bound<'py, PyList>> {
         unreachable!()
     }
+    fn iterate<R>(self, _consumer: impl ConsumeIterator<PyResult<Self::Item>, Output = R>) -> ValResult<R> {
+        unreachable!()
+    }
 }
 
 impl Arguments<'_> for Never {
diff --git a/src/input/input_json.rs b/src/input/input_json.rs
index 0e488c7d2..33c93f885 100644
--- a/src/input/input_json.rs
+++ b/src/input/input_json.rs
@@ -15,12 +15,12 @@ use super::datetime::{
     bytes_as_date, bytes_as_datetime, bytes_as_time, bytes_as_timedelta, float_as_datetime, float_as_duration,
     float_as_time, int_as_datetime, int_as_duration, int_as_time, EitherDate, EitherDateTime, EitherTime,
 };
-use super::input_abstract::{AsPyList, ConsumeIterator, Iterable, Never, ValMatch};
+use super::input_abstract::{ConsumeIterator, Never, ValMatch};
 use super::return_enums::ValidationMatch;
 use super::shared::{float_as_int, int_as_bool, str_as_bool, str_as_float, str_as_int};
 use super::{
     Arguments, BorrowInput, EitherBytes, EitherFloat, EitherInt, EitherString, EitherTimedelta, GenericIterable,
-    GenericIterator, GenericMapping, Input, KeywordArgs, PositionalArgs,
+    GenericIterator, Input, KeywordArgs, PositionalArgs, ValidatedDict, ValidatedList,
 };
 
 /// This is required but since JSON object keys are always strings, I don't think it can be called
@@ -168,14 +168,16 @@ impl<'py> Input<'py> for JsonValue {
         }
     }
 
-    fn validate_dict<'a>(&'a self, _strict: bool) -> ValResult<GenericMapping<'a, 'py>> {
+    type Dict<'a> = &'a JsonObject;
+
+    fn validate_dict(&self, _strict: bool) -> ValResult<Self::Dict<'_>> {
         match self {
-            JsonValue::Object(dict) => Ok(dict.into()),
+            JsonValue::Object(dict) => Ok(dict),
             _ => Err(ValError::new(ErrorTypeDefaults::DictType, self)),
         }
     }
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn strict_dict<'a>(&'a self) -> ValResult<GenericMapping<'a, 'py>> {
+    fn strict_dict(&self) -> ValResult<Self::Dict<'_>> {
         self.validate_dict(false)
     }
 
@@ -377,8 +379,10 @@ impl<'py> Input<'py> for str {
         create_decimal(self.to_object(py).bind(py), self)
     }
 
+    type Dict<'a> = Never;
+
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn strict_dict<'a>(&'a self) -> ValResult<GenericMapping<'a, 'py>> {
+    fn strict_dict(&self) -> ValResult<Never> {
         Err(ValError::new(ErrorTypeDefaults::DictType, self))
     }
 
@@ -465,18 +469,36 @@ fn string_to_vec(s: &str) -> JsonArray {
     JsonArray::new(s.chars().map(|c| JsonValue::Str(c.to_string())).collect())
 }
 
-impl<'a> Iterable<'_> for &'a JsonArray {
-    type Input = &'a JsonValue;
+impl<'py> ValidatedDict<'py> for &'_ JsonObject {
+    type Key<'a> = &'a str where Self: 'a;
+
+    type Item<'a> = &'a JsonValue where Self: 'a;
+
+    fn get_item<'k>(&self, key: &'k LookupKey) -> ValResult<Option<(&'k LookupPath, Self::Item<'_>)>> {
+        key.json_get(self)
+    }
+
+    fn as_py_dict(&self) -> Option<&Bound<'py, PyDict>> {
+        None
+    }
+
+    fn iterate<'a, R>(
+        &'a self,
+        consumer: impl ConsumeIterator<ValResult<(Self::Key<'a>, Self::Item<'a>)>, Output = R>,
+    ) -> ValResult<R> {
+        Ok(consumer.consume_iterator(LazyIndexMap::iter(self).map(|(k, v)| Ok((k.as_str(), v)))))
+    }
+}
+
+impl<'a, 'py> ValidatedList<'py> for &'a JsonArray {
+    type Item = &'a JsonValue;
 
     fn len(&self) -> Option<usize> {
         Some(SmallVec::len(self))
     }
-    fn iterate<R>(self, consumer: impl ConsumeIterator<PyResult<Self::Input>, Output = R>) -> ValResult<R> {
+    fn iterate<R>(self, consumer: impl ConsumeIterator<PyResult<Self::Item>, Output = R>) -> ValResult<R> {
         Ok(consumer.consume_iterator(self.iter().map(Ok)))
     }
-}
-
-impl<'py> AsPyList<'py> for &'_ JsonArray {
     fn as_py_list(&self) -> Option<&Bound<'py, PyList>> {
         None
     }
diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index a73608498..1b7f71106 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -3,6 +3,7 @@ use std::str::from_utf8;
 
 use pyo3::intern;
 use pyo3::prelude::*;
+
 use pyo3::types::{
     PyBool, PyByteArray, PyBytes, PyDate, PyDateTime, PyDict, PyFloat, PyFrozenSet, PyInt, PyIterator, PyList,
     PyMapping, PySequence, PySet, PyString, PyTime, PyTuple, PyType,
@@ -24,16 +25,18 @@ use super::datetime::{
     EitherTime,
 };
 use super::input_abstract::ValMatch;
-use super::return_enums::ValidationMatch;
+use super::return_enums::{iterate_attributes, iterate_mapping_items, ValidationMatch};
 use super::shared::{
     decimal_as_int, float_as_int, get_enum_meta_object, int_as_bool, str_as_bool, str_as_float, str_as_int,
 };
 use super::Arguments;
+use super::ConsumeIterator;
 use super::KeywordArgs;
 use super::PositionalArgs;
+use super::ValidatedDict;
 use super::{
     py_string_str, BorrowInput, EitherBytes, EitherFloat, EitherInt, EitherString, EitherTimedelta, GenericIterable,
-    GenericIterator, GenericMapping, Input,
+    GenericIterator, Input,
 };
 
 #[cfg(not(PyPy))]
@@ -419,40 +422,46 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
         }
     }
 
-    fn strict_dict<'a>(&'a self) -> ValResult<GenericMapping<'a, 'py>> {
+    type Dict<'a> = GenericPyMapping<'a, 'py> where Self: 'a;
+
+    fn strict_dict<'a>(&'a self) -> ValResult<GenericPyMapping<'a, 'py>> {
         if let Ok(dict) = self.downcast::<PyDict>() {
-            Ok(dict.into())
+            Ok(GenericPyMapping::Dict(dict))
         } else {
             Err(ValError::new(ErrorTypeDefaults::DictType, self))
         }
     }
 
-    fn lax_dict<'a>(&'a self) -> ValResult<GenericMapping<'a, 'py>> {
+    fn lax_dict<'a>(&'a self) -> ValResult<GenericPyMapping<'a, 'py>> {
         if let Ok(dict) = self.downcast::<PyDict>() {
-            Ok(dict.into())
+            Ok(GenericPyMapping::Dict(dict))
         } else if let Ok(mapping) = self.downcast::<PyMapping>() {
-            Ok(mapping.into())
+            Ok(GenericPyMapping::Mapping(mapping))
         } else {
             Err(ValError::new(ErrorTypeDefaults::DictType, self))
         }
     }
 
-    fn validate_model_fields<'a>(&'a self, strict: bool, from_attributes: bool) -> ValResult<GenericMapping<'a, 'py>> {
+    fn validate_model_fields<'a>(
+        &'a self,
+        strict: bool,
+        from_attributes: bool,
+    ) -> ValResult<GenericPyMapping<'a, 'py>> {
         if from_attributes {
             // if from_attributes, first try a dict, then mapping then from_attributes
             if let Ok(dict) = self.downcast::<PyDict>() {
-                return Ok(dict.into());
+                return Ok(GenericPyMapping::Dict(dict));
             } else if !strict {
                 if let Ok(mapping) = self.downcast::<PyMapping>() {
-                    return Ok(mapping.into());
+                    return Ok(GenericPyMapping::Mapping(mapping));
                 }
             }
 
             if from_attributes_applicable(self) {
-                Ok(GenericMapping::PyGetAttr(self.to_owned(), None))
+                Ok(GenericPyMapping::GetAttr(self.to_owned(), None))
             } else if let Ok((obj, kwargs)) = self.extract() {
                 if from_attributes_applicable(&obj) {
-                    Ok(GenericMapping::PyGetAttr(obj, Some(kwargs)))
+                    Ok(GenericPyMapping::GetAttr(obj, Some(kwargs)))
                 } else {
                     Err(ValError::new(ErrorTypeDefaults::ModelAttributesType, self))
                 }
@@ -910,3 +919,49 @@ impl<'py> KeywordArgs<'py> for PyKwargs<'py> {
         self.0.iter().map(Ok)
     }
 }
+
+#[cfg_attr(debug_assertions, derive(Debug))]
+pub enum GenericPyMapping<'a, 'py> {
+    Dict(&'a Bound<'py, PyDict>),
+    Mapping(&'a Bound<'py, PyMapping>),
+    GetAttr(Bound<'py, PyAny>, Option<Bound<'py, PyDict>>),
+}
+
+impl<'py> ValidatedDict<'py> for GenericPyMapping<'_, 'py> {
+    type Key<'a> = Bound<'py, PyAny>
+    where
+        Self: 'a;
+
+    type Item<'a> = Bound<'py, PyAny>
+    where
+        Self: 'a;
+
+    fn get_item<'k>(
+        &self,
+        key: &'k crate::lookup_key::LookupKey,
+    ) -> ValResult<Option<(&'k crate::lookup_key::LookupPath, Self::Item<'_>)>> {
+        match self {
+            Self::Dict(dict) => key.py_get_dict_item(dict),
+            Self::Mapping(mapping) => key.py_get_mapping_item(mapping),
+            Self::GetAttr(obj, dict) => key.py_get_attr(obj, dict.as_ref()),
+        }
+    }
+
+    fn as_py_dict(&self) -> Option<&Bound<'py, PyDict>> {
+        match self {
+            Self::Dict(dict) => Some(dict),
+            _ => None,
+        }
+    }
+
+    fn iterate<'a, R>(
+        &'a self,
+        consumer: impl ConsumeIterator<ValResult<(Self::Key<'a>, Self::Item<'a>)>, Output = R>,
+    ) -> ValResult<R> {
+        match self {
+            Self::Dict(dict) => Ok(consumer.consume_iterator(dict.iter().map(Ok))),
+            Self::Mapping(mapping) => Ok(consumer.consume_iterator(iterate_mapping_items(mapping)?)),
+            Self::GetAttr(obj, _) => Ok(consumer.consume_iterator(iterate_attributes(obj))),
+        }
+    }
+}
diff --git a/src/input/input_string.rs b/src/input/input_string.rs
index 426223672..ca51acc67 100644
--- a/src/input/input_string.rs
+++ b/src/input/input_string.rs
@@ -5,6 +5,7 @@ use speedate::MicrosecondsPrecisionOverflowBehavior;
 
 use crate::errors::{ErrorTypeDefaults, InputValue, LocItem, ValError, ValResult};
 use crate::input::py_string_str;
+use crate::lookup_key::{LookupKey, LookupPath};
 use crate::tools::safe_repr;
 use crate::validators::decimal::create_decimal;
 
@@ -15,7 +16,7 @@ use super::input_abstract::{Never, ValMatch};
 use super::shared::{str_as_bool, str_as_float, str_as_int};
 use super::{
     Arguments, BorrowInput, EitherBytes, EitherFloat, EitherInt, EitherString, EitherTimedelta, GenericIterable,
-    GenericIterator, GenericMapping, Input, KeywordArgs, ValidationMatch,
+    GenericIterator, Input, KeywordArgs, ValidatedDict, ValidationMatch,
 };
 
 #[derive(Debug, Clone)]
@@ -34,21 +35,26 @@ impl<'py> ToPyObject for StringMapping<'py> {
 }
 
 impl<'py> StringMapping<'py> {
-    pub fn new_key(py_key: &Bound<'py, PyAny>) -> ValResult<Self> {
-        if let Ok(py_str) = py_key.downcast::<PyString>() {
-            Ok(Self::String(py_str.clone()))
-        } else {
-            Err(ValError::new(ErrorTypeDefaults::StringType, py_key))
+    pub fn new_key(py_key: Bound<'py, PyAny>) -> ValResult<Self> {
+        match py_key.downcast_into::<PyString>() {
+            Ok(value) => Ok(Self::String(value)),
+            Err(downcast_error) => Err(ValError::new(
+                ErrorTypeDefaults::StringType,
+                downcast_error.into_inner(),
+            )),
         }
     }
 
-    pub fn new_value(py_value: &Bound<'py, PyAny>) -> ValResult<Self> {
-        if let Ok(py_str) = py_value.downcast::<PyString>() {
-            Ok(Self::String(py_str.clone()))
-        } else if let Ok(value) = py_value.downcast::<PyDict>() {
-            Ok(Self::Mapping(value.clone()))
-        } else {
-            Err(ValError::new(ErrorTypeDefaults::StringType, py_value))
+    pub fn new_value(py_value: Bound<'py, PyAny>) -> ValResult<Self> {
+        match py_value.downcast_into::<PyString>() {
+            Ok(py_str) => Ok(Self::String(py_str)),
+            Err(downcast_error) => match downcast_error.into_inner().downcast_into::<PyDict>() {
+                Ok(value) => Ok(Self::Mapping(value)),
+                Err(downcast_error) => Err(ValError::new(
+                    ErrorTypeDefaults::StringType,
+                    downcast_error.into_inner(),
+                )),
+            },
         }
     }
 }
@@ -74,17 +80,17 @@ impl<'py> Input<'py> for StringMapping<'py> {
         None
     }
 
-    type Arguments<'a> = StringMappingArgs<'py> where Self: 'a;
+    type Arguments<'a> = StringMappingDict<'py> where Self: 'a;
 
-    fn validate_args(&self) -> ValResult<StringMappingArgs<'py>> {
+    fn validate_args(&self) -> ValResult<StringMappingDict<'py>> {
         // do we want to support this?
         Err(ValError::new(ErrorTypeDefaults::ArgumentsType, self))
     }
 
-    fn validate_dataclass_args<'a>(&'a self, _dataclass_name: &str) -> ValResult<StringMappingArgs<'py>> {
+    fn validate_dataclass_args<'a>(&'a self, _dataclass_name: &str) -> ValResult<StringMappingDict<'py>> {
         match self {
             StringMapping::String(_) => Err(ValError::new(ErrorTypeDefaults::ArgumentsType, self)),
-            StringMapping::Mapping(m) => Ok(StringMappingArgs(m.clone())),
+            StringMapping::Mapping(m) => Ok(StringMappingDict(m.clone())),
         }
     }
 
@@ -134,10 +140,12 @@ impl<'py> Input<'py> for StringMapping<'py> {
         }
     }
 
-    fn strict_dict<'a>(&'a self) -> ValResult<GenericMapping<'a, 'py>> {
+    type Dict<'a> = StringMappingDict<'py> where Self: 'a;
+
+    fn strict_dict(&self) -> ValResult<StringMappingDict<'py>> {
         match self {
             Self::String(_) => Err(ValError::new(ErrorTypeDefaults::DictType, self)),
-            Self::Mapping(d) => Ok(GenericMapping::StringMapping(d)),
+            Self::Mapping(d) => Ok(StringMappingDict(d.clone())),
         }
     }
 
@@ -218,9 +226,9 @@ impl<'py> BorrowInput<'py> for StringMapping<'py> {
     }
 }
 
-pub struct StringMappingArgs<'py>(Bound<'py, PyDict>);
+pub struct StringMappingDict<'py>(Bound<'py, PyDict>);
 
-impl<'py> Arguments<'py> for StringMappingArgs<'py> {
+impl<'py> Arguments<'py> for StringMappingDict<'py> {
     type Args = Never;
     type Kwargs = Self;
 
@@ -233,8 +241,8 @@ impl<'py> Arguments<'py> for StringMappingArgs<'py> {
     }
 }
 
-impl<'py> KeywordArgs<'py> for StringMappingArgs<'py> {
-    type Key<'a> = Bound<'py, PyAny>
+impl<'py> KeywordArgs<'py> for StringMappingDict<'py> {
+    type Key<'a> = StringMapping<'py>
     where
         Self: 'a;
 
@@ -246,16 +254,39 @@ impl<'py> KeywordArgs<'py> for StringMappingArgs<'py> {
         self.0.len()
     }
 
-    fn get_item<'k>(
-        &self,
-        key: &'k crate::lookup_key::LookupKey,
-    ) -> ValResult<Option<(&'k crate::lookup_key::LookupPath, Self::Item<'_>)>> {
+    fn get_item<'k>(&self, key: &'k LookupKey) -> ValResult<Option<(&'k LookupPath, Self::Item<'_>)>> {
         key.py_get_string_mapping_item(&self.0)
     }
 
     fn iter(&self) -> impl Iterator<Item = ValResult<(Self::Key<'_>, Self::Item<'_>)>> {
         self.0
             .iter()
-            .map(|(key, val)| Ok((key, StringMapping::new_value(&val)?)))
+            .map(|(key, val)| Ok((StringMapping::new_key(key)?, StringMapping::new_value(val)?)))
+    }
+}
+
+impl<'py> ValidatedDict<'py> for StringMappingDict<'py> {
+    type Key<'a> = StringMapping<'py>
+    where
+        Self: 'a;
+
+    type Item<'a> = StringMapping<'py>
+    where
+        Self: 'a;
+    fn get_item<'k>(&self, key: &'k LookupKey) -> ValResult<Option<(&'k LookupPath, Self::Item<'_>)>> {
+        key.py_get_string_mapping_item(&self.0)
+    }
+    fn as_py_dict(&self) -> Option<&Bound<'py, PyDict>> {
+        None
+    }
+    fn iterate<'a, R>(
+        &'a self,
+        consumer: impl super::ConsumeIterator<ValResult<(Self::Key<'a>, Self::Item<'a>)>, Output = R>,
+    ) -> ValResult<R> {
+        Ok(consumer.consume_iterator(
+            self.0
+                .iter()
+                .map(|(key, val)| Ok((StringMapping::new_key(key)?, StringMapping::new_value(val)?))),
+        ))
     }
 }
diff --git a/src/input/mod.rs b/src/input/mod.rs
index 9bf29b6ae..a42368a3d 100644
--- a/src/input/mod.rs
+++ b/src/input/mod.rs
@@ -16,13 +16,13 @@ pub(crate) use datetime::{
     EitherTime, EitherTimedelta,
 };
 pub(crate) use input_abstract::{
-    Arguments, AsPyList, BorrowInput, ConsumeIterator, Input, InputType, Iterable, KeywordArgs, PositionalArgs,
+    Arguments, BorrowInput, ConsumeIterator, Input, InputType, KeywordArgs, PositionalArgs, ValidatedDict,
+    ValidatedList,
 };
 pub(crate) use input_string::StringMapping;
 pub(crate) use return_enums::{
-    no_validator_iter_to_vec, py_string_str, validate_iter_to_vec, AttributesGenericIterator, DictGenericIterator,
-    EitherBytes, EitherFloat, EitherInt, EitherString, GenericIterable, GenericIterator, GenericMapping, Int,
-    JsonObjectGenericIterator, MappingGenericIterator, MaxLengthCheck, StringMappingGenericIterator, ValidationMatch,
+    no_validator_iter_to_vec, py_string_str, validate_iter_to_vec, EitherBytes, EitherFloat, EitherInt, EitherString,
+    GenericIterable, GenericIterator, Int, MaxLengthCheck, ValidationMatch,
 };
 
 // Defined here as it's not exported by pyo3
diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index 463c21a0d..e01379b11 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -1,23 +1,22 @@
 use std::borrow::Cow;
 use std::cmp::Ordering;
 use std::ops::Rem;
-use std::slice::Iter as SliceIter;
 use std::str::FromStr;
 
 use jiter::{JsonArray, JsonObject, JsonValue};
 use num_bigint::BigInt;
 
 use pyo3::exceptions::PyTypeError;
+use pyo3::ffi;
+use pyo3::intern;
 use pyo3::prelude::*;
-use pyo3::types::iter::{BoundDictIterator, BoundListIterator};
+#[cfg(not(PyPy))]
+use pyo3::types::PyFunction;
 use pyo3::types::{
     PyByteArray, PyBytes, PyDict, PyFloat, PyFrozenSet, PyIterator, PyList, PyMapping, PySequence, PySet, PyString,
     PyTuple,
 };
-use pyo3::{ffi, intern};
 
-#[cfg(not(PyPy))]
-use pyo3::types::PyFunction;
 use serde::{ser::Error, Serialize, Serializer};
 
 use crate::errors::{
@@ -26,9 +25,7 @@ use crate::errors::{
 use crate::tools::{extract_i64, py_err};
 use crate::validators::{CombinedValidator, Exactness, ValidationState, Validator};
 
-use super::input_abstract::{AsPyList, ConsumeIterator, Iterable};
-use super::input_string::StringMapping;
-use super::{py_error_on_minusone, BorrowInput, Input};
+use super::{py_error_on_minusone, BorrowInput, ConsumeIterator, Input, ValidatedList};
 
 pub struct ValidationMatch<T>(T, Exactness);
 
@@ -456,12 +453,12 @@ impl<'py> GenericIterable<'_, 'py> {
     }
 }
 
-impl<'py> Iterable<'py> for GenericIterable<'_, 'py> {
-    type Input = Bound<'py, PyAny>;
+impl<'py> ValidatedList<'py> for GenericIterable<'_, 'py> {
+    type Item = Bound<'py, PyAny>;
     fn len(&self) -> Option<usize> {
         self.generic_len()
     }
-    fn iterate<R>(self, consumer: impl ConsumeIterator<PyResult<Self::Input>, Output = R>) -> ValResult<R> {
+    fn iterate<R>(self, consumer: impl ConsumeIterator<PyResult<Self::Item>, Output = R>) -> ValResult<R> {
         match self {
             GenericIterable::List(iter) => Ok(consumer.consume_iterator(iter.iter().map(Ok))),
             GenericIterable::Tuple(iter) => Ok(consumer.consume_iterator(iter.iter().map(Ok))),
@@ -482,9 +479,6 @@ impl<'py> Iterable<'py> for GenericIterable<'_, 'py> {
             _ => unreachable!(),
         }
     }
-}
-
-impl<'py> AsPyList<'py> for GenericIterable<'_, 'py> {
     fn as_py_list(&self) -> Option<&Bound<'py, PyList>> {
         match self {
             GenericIterable::List(iter) => Some(iter),
@@ -493,56 +487,29 @@ impl<'py> AsPyList<'py> for GenericIterable<'_, 'py> {
     }
 }
 
-#[cfg_attr(debug_assertions, derive(Debug))]
-pub enum GenericMapping<'a, 'py> {
-    PyDict(&'a Bound<'py, PyDict>),
-    PyMapping(&'a Bound<'py, PyMapping>),
-    StringMapping(&'a Bound<'py, PyDict>),
-    PyGetAttr(Bound<'py, PyAny>, Option<Bound<'py, PyDict>>),
-    JsonObject(&'a JsonObject),
-}
-
-macro_rules! derive_from {
-    ($enum:ident, $key:ident, $type:ty $(, $extra_types:ident )*) => {
-        impl<'a, 'py> From<&'a Bound<'py, $type>> for $enum<'a, 'py> {
-            fn from(s: &'a Bound<'py, $type>) -> Self {
-                Self::$key(s $(, $extra_types )*)
-            }
-        }
-    };
-}
-
-derive_from!(GenericMapping, PyDict, PyDict);
-derive_from!(GenericMapping, PyMapping, PyMapping);
-
-impl<'a> From<&'a JsonObject> for GenericMapping<'a, '_> {
-    fn from(s: &'a JsonObject) -> Self {
-        Self::JsonObject(s)
-    }
-}
-
-pub struct DictGenericIterator<'py> {
-    dict_iter: BoundDictIterator<'py>,
-}
-
-impl<'py> DictGenericIterator<'py> {
-    pub fn new(dict: &Bound<'py, PyDict>) -> ValResult<Self> {
-        Ok(Self { dict_iter: dict.iter() })
-    }
-}
-
-impl<'py> Iterator for DictGenericIterator<'py> {
-    type Item = ValResult<(Bound<'py, PyAny>, Bound<'py, PyAny>)>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.dict_iter.next().map(Ok)
-    }
-    // size_hint is omitted as it isn't needed
-}
-
-pub struct MappingGenericIterator<'py> {
-    input: Bound<'py, PyAny>,
-    iter: Bound<'py, PyIterator>,
+pub(crate) fn iterate_mapping_items<'a, 'py>(
+    mapping: &'a Bound<'py, PyMapping>,
+) -> ValResult<impl Iterator<Item = ValResult<(Bound<'py, PyAny>, Bound<'py, PyAny>)>> + 'a> {
+    let py = mapping.py();
+    let input = mapping.as_any();
+    let iterator = mapping
+        .items()
+        .map_err(|e| mapping_err(e, py, input))?
+        .iter()
+        .map_err(|e| mapping_err(e, py, input))?
+        .map(move |item| match item {
+            Ok(item) => item.extract().map_err(|_| {
+                ValError::new(
+                    ErrorType::MappingType {
+                        error: MAPPING_TUPLE_ERROR.into(),
+                        context: None,
+                    },
+                    input,
+                )
+            }),
+            Err(e) => Err(mapping_err(e, py, input)),
+        });
+    Ok(iterator)
 }
 
 fn mapping_err<'py>(err: PyErr, py: Python<'py>, input: &'py (impl Input<'py> + ?Sized)) -> ValError {
@@ -555,97 +522,18 @@ fn mapping_err<'py>(err: PyErr, py: Python<'py>, input: &'py (impl Input<'py> +
     )
 }
 
-impl<'py> MappingGenericIterator<'py> {
-    pub fn new(mapping: &Bound<'py, PyMapping>) -> ValResult<Self> {
-        let py = mapping.py();
-        let input = mapping.as_any();
-        let iter = mapping
-            .items()
-            .map_err(|e| mapping_err(e, py, input))?
-            .iter()
-            .map_err(|e| mapping_err(e, py, input))?;
-        Ok(Self {
-            input: input.clone(),
-            iter,
-        })
-    }
-}
-
 const MAPPING_TUPLE_ERROR: &str = "Mapping items must be tuples of (key, value) pairs";
 
-impl<'py> Iterator for MappingGenericIterator<'py> {
-    type Item = ValResult<(Bound<'py, PyAny>, Bound<'py, PyAny>)>;
+/// Iterate over attributes of an object
+pub(crate) fn iterate_attributes<'a, 'py>(
+    object: &'a Bound<'py, PyAny>,
+) -> impl Iterator<Item = ValResult<(Bound<'py, PyAny>, Bound<'py, PyAny>)>> + 'a {
+    let mut attributes_iterator = object.dir().into_iter();
 
-    fn next(&mut self) -> Option<Self::Item> {
-        Some(match self.iter.next()? {
-            Ok(item) => item.extract().map_err(|_| {
-                ValError::new(
-                    ErrorType::MappingType {
-                        error: MAPPING_TUPLE_ERROR.into(),
-                        context: None,
-                    },
-                    &self.input,
-                )
-            }),
-            Err(e) => Err(mapping_err(e, self.iter.py(), &self.input)),
-        })
-    }
-}
-
-pub struct StringMappingGenericIterator<'py> {
-    dict_iter: BoundDictIterator<'py>,
-}
-
-impl<'py> StringMappingGenericIterator<'py> {
-    pub fn new(dict: &Bound<'py, PyDict>) -> ValResult<Self> {
-        Ok(Self { dict_iter: dict.iter() })
-    }
-}
-
-impl<'py> Iterator for StringMappingGenericIterator<'py> {
-    // key (the first member of the tuple could be a simple String)
-    type Item = ValResult<(StringMapping<'py>, StringMapping<'py>)>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        match self.dict_iter.next() {
-            Some((py_key, py_value)) => {
-                let key = match StringMapping::new_key(&py_key) {
-                    Ok(key) => key,
-                    Err(e) => return Some(Err(e)),
-                };
-                let value = match StringMapping::new_value(&py_value) {
-                    Ok(value) => value,
-                    Err(e) => return Some(Err(e)),
-                };
-                Some(Ok((key, value)))
-            }
-            None => None,
-        }
-    }
-}
-
-pub struct AttributesGenericIterator<'py> {
-    object: Bound<'py, PyAny>,
-    attributes_iterator: BoundListIterator<'py>,
-}
-
-impl<'py> AttributesGenericIterator<'py> {
-    pub fn new(py_any: &Bound<'py, PyAny>) -> ValResult<Self> {
-        let attributes_iterator = py_any.dir().into_iter();
-        Ok(Self {
-            object: py_any.clone(),
-            attributes_iterator,
-        })
-    }
-}
-
-impl<'py> Iterator for AttributesGenericIterator<'py> {
-    type Item = ValResult<(Bound<'py, PyAny>, Bound<'py, PyAny>)>;
-
-    fn next(&mut self) -> Option<Self::Item> {
+    std::iter::from_fn(move || {
         // loop until we find an attribute who's name does not start with underscore,
         // or we get to the end of the list of attributes
-        let name = self.attributes_iterator.next()?;
+        let name = attributes_iterator.next()?;
         // from benchmarks this is 14x faster than using the python `startswith` method
         let name_cow = match name.downcast::<PyString>() {
             Ok(name) => name.to_string_lossy(),
@@ -653,7 +541,7 @@ impl<'py> Iterator for AttributesGenericIterator<'py> {
         };
         if !name_cow.as_ref().starts_with('_') {
             // getattr is most likely to fail due to an exception in a @property, skip
-            if let Ok(attr) = self.object.getattr(name_cow.as_ref()) {
+            if let Ok(attr) = object.getattr(name_cow.as_ref()) {
                 // we don't want bound methods to be included, is there a better way to check?
                 // ref https://stackoverflow.com/a/18955425/949890
                 let is_bound = matches!(attr.hasattr(intern!(attr.py(), "__self__")), Ok(true));
@@ -674,29 +562,7 @@ impl<'py> Iterator for AttributesGenericIterator<'py> {
             }
         }
         None
-    }
-    // size_hint is omitted as it isn't needed
-}
-
-pub struct JsonObjectGenericIterator<'py> {
-    object_iter: SliceIter<'py, (String, JsonValue)>,
-}
-
-impl<'py> JsonObjectGenericIterator<'py> {
-    pub fn new(json_object: &'py JsonObject) -> ValResult<Self> {
-        Ok(Self {
-            object_iter: json_object.iter(),
-        })
-    }
-}
-
-impl<'py> Iterator for JsonObjectGenericIterator<'py> {
-    type Item = ValResult<(&'py String, &'py JsonValue)>;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.object_iter.next().map(|(key, value)| Ok((key, value)))
-    }
-    // size_hint is omitted as it isn't needed
+    })
 }
 
 #[derive(Debug, Clone)]
diff --git a/src/lookup_key.rs b/src/lookup_key.rs
index a7772a184..f1ccfa142 100644
--- a/src/lookup_key.rs
+++ b/src/lookup_key.rs
@@ -147,7 +147,7 @@ impl LookupKey {
         dict: &Bound<'py, PyDict>,
     ) -> ValResult<Option<(&'s LookupPath, StringMapping<'py>)>> {
         if let Some((path, py_any)) = self.py_get_dict_item(dict)? {
-            let value = StringMapping::new_value(&py_any)?;
+            let value = StringMapping::new_value(py_any)?;
             Ok(Some((path, value)))
         } else {
             Ok(None)
diff --git a/src/validators/dict.rs b/src/validators/dict.rs
index 48a7c82b2..ea0000236 100644
--- a/src/validators/dict.rs
+++ b/src/validators/dict.rs
@@ -5,10 +5,8 @@ use pyo3::types::PyDict;
 use crate::build_tools::is_strict;
 use crate::errors::{LocItem, ValError, ValLineError, ValResult};
 use crate::input::BorrowInput;
-use crate::input::{
-    DictGenericIterator, GenericMapping, Input, JsonObjectGenericIterator, MappingGenericIterator,
-    StringMappingGenericIterator,
-};
+use crate::input::ConsumeIterator;
+use crate::input::{Input, ValidatedDict};
 
 use crate::tools::SchemaDict;
 
@@ -75,22 +73,15 @@ impl Validator for DictValidator {
     ) -> ValResult<PyObject> {
         let strict = state.strict_or(self.strict);
         let dict = input.validate_dict(strict)?;
-        match dict {
-            GenericMapping::PyDict(py_dict) => {
-                self.validate_generic_mapping(py, input, DictGenericIterator::new(py_dict)?, state)
-            }
-            GenericMapping::PyMapping(mapping) => {
-                state.floor_exactness(super::Exactness::Lax);
-                self.validate_generic_mapping(py, input, MappingGenericIterator::new(mapping)?, state)
-            }
-            GenericMapping::StringMapping(dict) => {
-                self.validate_generic_mapping(py, input, StringMappingGenericIterator::new(dict)?, state)
-            }
-            GenericMapping::PyGetAttr(_, _) => unreachable!(),
-            GenericMapping::JsonObject(json_object) => {
-                self.validate_generic_mapping(py, input, JsonObjectGenericIterator::new(json_object)?, state)
-            }
-        }
+        dict.iterate(ValidateToDict {
+            py,
+            input,
+            min_length: self.min_length,
+            max_length: self.max_length,
+            key_validator: &self.key_validator,
+            value_validator: &self.value_validator,
+            state,
+        })?
     }
 
     fn get_name(&self) -> &str {
@@ -98,24 +89,30 @@ impl Validator for DictValidator {
     }
 }
 
-impl DictValidator {
-    fn validate_generic_mapping<'py>(
-        &self,
-        py: Python<'py>,
-        input: &(impl Input<'py> + ?Sized),
-        mapping_iter: impl Iterator<
-            Item = ValResult<(impl BorrowInput<'py> + Clone + Into<LocItem>, impl BorrowInput<'py>)>,
-        >,
-        state: &mut ValidationState<'_, 'py>,
-    ) -> ValResult<PyObject> {
-        let output = PyDict::new_bound(py);
+struct ValidateToDict<'a, 's, 'py, I: Input<'py> + ?Sized> {
+    py: Python<'py>,
+    input: &'a I,
+    min_length: Option<usize>,
+    max_length: Option<usize>,
+    key_validator: &'a CombinedValidator,
+    value_validator: &'a CombinedValidator,
+    state: &'a mut ValidationState<'s, 'py>,
+}
+
+impl<'py, Key, Value, I: Input<'py> + ?Sized> ConsumeIterator<ValResult<(Key, Value)>>
+    for ValidateToDict<'_, '_, 'py, I>
+where
+    Key: BorrowInput<'py> + Clone + Into<LocItem>,
+    Value: BorrowInput<'py>,
+{
+    type Output = ValResult<PyObject>;
+    fn consume_iterator(self, iterator: impl Iterator<Item = ValResult<(Key, Value)>>) -> ValResult<PyObject> {
+        let output = PyDict::new_bound(self.py);
         let mut errors: Vec<ValLineError> = Vec::new();
 
-        let key_validator = self.key_validator.as_ref();
-        let value_validator = self.value_validator.as_ref();
-        for item_result in mapping_iter {
+        for item_result in iterator {
             let (key, value) = item_result?;
-            let output_key = match key_validator.validate(py, key.borrow_input(), state) {
+            let output_key = match self.key_validator.validate(self.py, key.borrow_input(), self.state) {
                 Ok(value) => Some(value),
                 Err(ValError::LineErrors(line_errors)) => {
                     for err in line_errors {
@@ -127,7 +124,7 @@ impl DictValidator {
                 Err(ValError::Omit) => continue,
                 Err(err) => return Err(err),
             };
-            let output_value = match value_validator.validate(py, value.borrow_input(), state) {
+            let output_value = match self.value_validator.validate(self.py, value.borrow_input(), self.state) {
                 Ok(value) => Some(value),
                 Err(ValError::LineErrors(line_errors)) => {
                     for err in line_errors {
@@ -144,6 +141,7 @@ impl DictValidator {
         }
 
         if errors.is_empty() {
+            let input = self.input;
             length_check!(input, "Dictionary", self.min_length, self.max_length, output);
             Ok(output.into())
         } else {
diff --git a/src/validators/list.rs b/src/validators/list.rs
index 4d56e1160..21825ca54 100644
--- a/src/validators/list.rs
+++ b/src/validators/list.rs
@@ -5,8 +5,7 @@ use pyo3::types::PyDict;
 
 use crate::errors::ValResult;
 use crate::input::{
-    no_validator_iter_to_vec, validate_iter_to_vec, AsPyList, BorrowInput, ConsumeIterator, Input, Iterable,
-    MaxLengthCheck,
+    no_validator_iter_to_vec, validate_iter_to_vec, BorrowInput, ConsumeIterator, Input, MaxLengthCheck, ValidatedList,
 };
 use crate::tools::SchemaDict;
 
diff --git a/src/validators/mod.rs b/src/validators/mod.rs
index 4201ce422..07ae2e6b4 100644
--- a/src/validators/mod.rs
+++ b/src/validators/mod.rs
@@ -234,7 +234,7 @@ impl SchemaValidator {
         context: Option<&Bound<'_, PyAny>>,
     ) -> PyResult<PyObject> {
         let t = InputType::String;
-        let string_mapping = StringMapping::new_value(&input).map_err(|e| self.prepare_validation_err(py, e, t))?;
+        let string_mapping = StringMapping::new_value(input).map_err(|e| self.prepare_validation_err(py, e, t))?;
 
         match self._validate(py, &string_mapping, t, strict, None, context, None) {
             Ok(r) => Ok(r),
diff --git a/src/validators/model_fields.rs b/src/validators/model_fields.rs
index 7ae4973fb..f470557dd 100644
--- a/src/validators/model_fields.rs
+++ b/src/validators/model_fields.rs
@@ -7,11 +7,10 @@ use ahash::AHashSet;
 
 use crate::build_tools::py_schema_err;
 use crate::build_tools::{is_strict, schema_or_config_same, ExtraBehavior};
+use crate::errors::LocItem;
 use crate::errors::{ErrorType, ErrorTypeDefaults, ValError, ValLineError, ValResult};
-use crate::input::{
-    AttributesGenericIterator, BorrowInput, DictGenericIterator, GenericMapping, Input, JsonObjectGenericIterator,
-    MappingGenericIterator, StringMappingGenericIterator, ValidationMatch,
-};
+use crate::input::ConsumeIterator;
+use crate::input::{BorrowInput, Input, ValidatedDict, ValidationMatch};
 use crate::lookup_key::LookupKey;
 use crate::tools::SchemaDict;
 
@@ -154,102 +153,121 @@ impl Validator for ModelFieldsValidator {
 
         // we only care about which keys have been used if we're iterating over the object for extra after
         // the first pass
-        let mut used_keys: Option<AHashSet<&str>> = match (&self.extra_behavior, &dict) {
-            (_, GenericMapping::PyGetAttr(_, _)) => None,
-            (ExtraBehavior::Allow | ExtraBehavior::Forbid, _) => Some(AHashSet::with_capacity(self.fields.len())),
-            _ => None,
-        };
+        let mut used_keys: Option<AHashSet<&str>> =
+            if self.extra_behavior == ExtraBehavior::Ignore || dict.is_py_get_attr() {
+                None
+            } else {
+                Some(AHashSet::with_capacity(self.fields.len()))
+            };
 
-        macro_rules! process {
-            ($dict:expr, $get_method:ident, $iter:ty $(,$kwargs:expr)?) => {{
-                {
-                    let state = &mut state.rebind_extra(|extra| extra.data = Some(model_dict.clone()));
+        {
+            let state = &mut state.rebind_extra(|extra| extra.data = Some(model_dict.clone()));
 
-                    for field in &self.fields {
-                        let op_key_value = match field.lookup_key.$get_method($dict $(, $kwargs )? ) {
-                            Ok(v) => v,
-                            Err(ValError::LineErrors(line_errors)) => {
-                                for err in line_errors {
-                                    errors.push(err.with_outer_location(&field.name));
-                                }
-                                continue;
-                            }
-                            Err(err) => return Err(err),
-                        };
-                        if let Some((lookup_path, value)) = op_key_value {
-                            if let Some(ref mut used_keys) = used_keys {
-                                // key is "used" whether or not validation passes, since we want to skip this key in
-                                // extra logic either way
-                                used_keys.insert(lookup_path.first_key());
-                            }
-                            match field.validator.validate(py, value.borrow_input(), state) {
-                                Ok(value) => {
-                                    model_dict.set_item(&field.name_py, value)?;
-                                    fields_set_vec.push(field.name_py.clone_ref(py));
-                                }
-                                Err(ValError::Omit) => continue,
-                                Err(ValError::LineErrors(line_errors)) => {
-                                    for err in line_errors {
-                                        errors.push(
-                                            lookup_path.apply_error_loc(err, self.loc_by_alias, &field.name)
-
-                                        );
-                                    }
-                                }
-                                Err(err) => return Err(err),
+            for field in &self.fields {
+                let op_key_value = match dict.get_item(&field.lookup_key) {
+                    Ok(v) => v,
+                    Err(ValError::LineErrors(line_errors)) => {
+                        for err in line_errors {
+                            errors.push(err.with_outer_location(&field.name));
+                        }
+                        continue;
+                    }
+                    Err(err) => return Err(err),
+                };
+                if let Some((lookup_path, value)) = op_key_value {
+                    if let Some(ref mut used_keys) = used_keys {
+                        // key is "used" whether or not validation passes, since we want to skip this key in
+                        // extra logic either way
+                        used_keys.insert(lookup_path.first_key());
+                    }
+                    match field.validator.validate(py, value.borrow_input(), state) {
+                        Ok(value) => {
+                            model_dict.set_item(&field.name_py, value)?;
+                            fields_set_vec.push(field.name_py.clone_ref(py));
+                        }
+                        Err(ValError::Omit) => continue,
+                        Err(ValError::LineErrors(line_errors)) => {
+                            for err in line_errors {
+                                errors.push(lookup_path.apply_error_loc(err, self.loc_by_alias, &field.name));
                             }
-                            continue;
                         }
+                        Err(err) => return Err(err),
+                    }
+                    continue;
+                }
 
-                        match field.validator.default_value(py, Some(field.name.as_str()), state) {
-                            Ok(Some(value)) => {
-                                // Default value exists, and passed validation if required
-                                model_dict.set_item(&field.name_py, value)?;
-                            },
-                            Ok(None) => {
-                                // This means there was no default value
-                                errors.push(field.lookup_key.error(
-                                    ErrorTypeDefaults::Missing,
-                                    input,
-                                    self.loc_by_alias,
-                                    &field.name
-                                ));
-                            },
-                            Err(ValError::Omit) => continue,
-                            Err(ValError::LineErrors(line_errors)) => {
-                                for err in line_errors {
-                                    // Note: this will always use the field name even if there is an alias
-                                    // However, we don't mind so much because this error can only happen if the
-                                    // default value fails validation, which is arguably a developer error.
-                                    // We could try to "fix" this in the future if desired.
-                                    errors.push(err);
-                                }
-                            }
-                            Err(err) => return Err(err),
+                match field.validator.default_value(py, Some(field.name.as_str()), state) {
+                    Ok(Some(value)) => {
+                        // Default value exists, and passed validation if required
+                        model_dict.set_item(&field.name_py, value)?;
+                    }
+                    Ok(None) => {
+                        // This means there was no default value
+                        errors.push(field.lookup_key.error(
+                            ErrorTypeDefaults::Missing,
+                            input,
+                            self.loc_by_alias,
+                            &field.name,
+                        ));
+                    }
+                    Err(ValError::Omit) => continue,
+                    Err(ValError::LineErrors(line_errors)) => {
+                        for err in line_errors {
+                            // Note: this will always use the field name even if there is an alias
+                            // However, we don't mind so much because this error can only happen if the
+                            // default value fails validation, which is arguably a developer error.
+                            // We could try to "fix" this in the future if desired.
+                            errors.push(err);
                         }
                     }
+                    Err(err) => return Err(err),
                 }
+            }
+        }
+
+        if let Some(used_keys) = used_keys {
+            struct ValidateToModelExtra<'a, 's, 'py> {
+                py: Python<'py>,
+                used_keys: AHashSet<&'a str>,
+                errors: &'a mut Vec<ValLineError>,
+                fields_set_vec: &'a mut Vec<Py<PyString>>,
+                extra_behavior: ExtraBehavior,
+                extras_validator: Option<&'a CombinedValidator>,
+                state: &'a mut ValidationState<'s, 'py>,
+            }
 
-                if let Some(ref mut used_keys) = used_keys {
-                    let model_extra_dict = PyDict::new_bound(py);
-                    for item_result in <$iter>::new($dict)? {
+            impl<'py, Key, Value> ConsumeIterator<ValResult<(Key, Value)>> for ValidateToModelExtra<'_, '_, 'py>
+            where
+                Key: BorrowInput<'py> + Clone + Into<LocItem>,
+                Value: BorrowInput<'py>,
+            {
+                type Output = ValResult<Bound<'py, PyDict>>;
+                fn consume_iterator(
+                    self,
+                    iterator: impl Iterator<Item = ValResult<(Key, Value)>>,
+                ) -> ValResult<Bound<'py, PyDict>> {
+                    let model_extra_dict = PyDict::new_bound(self.py);
+                    for item_result in iterator {
                         let (raw_key, value) = item_result?;
-                        let either_str = match raw_key.validate_str(true, false).map(ValidationMatch::into_inner) {
+                        let either_str = match raw_key
+                            .borrow_input()
+                            .validate_str(true, false)
+                            .map(ValidationMatch::into_inner)
+                        {
                             Ok(k) => k,
                             Err(ValError::LineErrors(line_errors)) => {
                                 for err in line_errors {
-                                    errors.push(
+                                    self.errors.push(
                                         err.with_outer_location(raw_key.clone())
-                                            .with_type(ErrorTypeDefaults::InvalidKey)
-
+                                            .with_type(ErrorTypeDefaults::InvalidKey),
                                     );
                                 }
                                 continue;
                             }
                             Err(err) => return Err(err),
                         };
-                        let cow = either_str.as_cow().map_err(|err| err)?;
-                        if used_keys.contains(cow.as_ref()) {
+                        let cow = either_str.as_cow()?;
+                        if self.used_keys.contains(cow.as_ref()) {
                             continue;
                         }
 
@@ -257,54 +275,52 @@ impl Validator for ModelFieldsValidator {
                         // Unknown / extra field
                         match self.extra_behavior {
                             ExtraBehavior::Forbid => {
-                                errors.push(
-                                    ValLineError::new_with_loc(
-                                        ErrorTypeDefaults::ExtraForbidden,
-                                        value,
-                                        raw_key.clone(),
-                                    )
-
-                                );
+                                self.errors.push(ValLineError::new_with_loc(
+                                    ErrorTypeDefaults::ExtraForbidden,
+                                    value,
+                                    raw_key.clone(),
+                                ));
                             }
                             ExtraBehavior::Ignore => {}
                             ExtraBehavior::Allow => {
-                            let py_key = either_str.as_py_string(py);
-                                if let Some(ref validator) = self.extras_validator {
-                                    match validator.validate(py, value, state) {
+                                let py_key = either_str.as_py_string(self.py);
+                                if let Some(validator) = self.extras_validator {
+                                    match validator.validate(self.py, value, self.state) {
                                         Ok(value) => {
                                             model_extra_dict.set_item(&py_key, value)?;
-                                            fields_set_vec.push(py_key.into());
+                                            self.fields_set_vec.push(py_key.into());
                                         }
                                         Err(ValError::LineErrors(line_errors)) => {
                                             for err in line_errors {
-                                                errors.push(err.with_outer_location(raw_key.clone()));
+                                                self.errors.push(err.with_outer_location(raw_key.clone()));
                                             }
                                         }
                                         Err(err) => return Err(err),
                                     }
                                 } else {
-                                    model_extra_dict.set_item(&py_key, value.to_object(py))?;
-                                    fields_set_vec.push(py_key.into());
+                                    model_extra_dict.set_item(&py_key, value.to_object(self.py))?;
+                                    self.fields_set_vec.push(py_key.into());
                                 };
                             }
                         }
                     }
-                    if matches!(self.extra_behavior, ExtraBehavior::Allow) {
-                        model_extra_dict_op = Some(model_extra_dict);
-                    }
+                    Ok(model_extra_dict)
                 }
-            }};
-        }
-        match dict {
-            GenericMapping::PyDict(d) => {
-                process!(&d, py_get_dict_item, DictGenericIterator);
             }
-            GenericMapping::PyMapping(d) => process!(&d, py_get_mapping_item, MappingGenericIterator),
-            GenericMapping::StringMapping(d) => process!(&d, py_get_string_mapping_item, StringMappingGenericIterator),
-            GenericMapping::PyGetAttr(d, kwargs) => {
-                process!(&d, py_get_attr, AttributesGenericIterator, kwargs.as_ref());
+
+            let model_extra_dict = dict.iterate(ValidateToModelExtra {
+                py,
+                used_keys,
+                errors: &mut errors,
+                fields_set_vec: &mut fields_set_vec,
+                extra_behavior: self.extra_behavior,
+                extras_validator: self.extras_validator.as_deref(),
+                state,
+            })??;
+
+            if matches!(self.extra_behavior, ExtraBehavior::Allow) {
+                model_extra_dict_op = Some(model_extra_dict);
             }
-            GenericMapping::JsonObject(d) => process!(d, json_get, JsonObjectGenericIterator),
         }
 
         if !errors.is_empty() {
diff --git a/src/validators/typed_dict.rs b/src/validators/typed_dict.rs
index afde8868c..956ebac31 100644
--- a/src/validators/typed_dict.rs
+++ b/src/validators/typed_dict.rs
@@ -6,11 +6,12 @@ use ahash::AHashSet;
 
 use crate::build_tools::py_schema_err;
 use crate::build_tools::{is_strict, schema_or_config, schema_or_config_same, ExtraBehavior};
+use crate::errors::LocItem;
 use crate::errors::{ErrorTypeDefaults, ValError, ValLineError, ValResult};
-use crate::input::{
-    AttributesGenericIterator, BorrowInput, DictGenericIterator, GenericMapping, Input, JsonObjectGenericIterator,
-    MappingGenericIterator, StringMappingGenericIterator, ValidationMatch,
-};
+use crate::input::BorrowInput;
+use crate::input::ConsumeIterator;
+use crate::input::ValidationMatch;
+use crate::input::{Input, ValidatedDict};
 use crate::lookup_key::LookupKey;
 use crate::tools::SchemaDict;
 
@@ -155,102 +156,116 @@ impl Validator for TypedDictValidator {
 
         // we only care about which keys have been used if we're iterating over the object for extra after
         // the first pass
-        let mut used_keys: Option<AHashSet<&str>> = match (&self.extra_behavior, &dict) {
-            (_, GenericMapping::PyGetAttr(_, _)) => None,
-            (ExtraBehavior::Allow | ExtraBehavior::Forbid, _) => Some(AHashSet::with_capacity(self.fields.len())),
-            _ => None,
+        let mut used_keys: Option<AHashSet<&str>> = match self.extra_behavior {
+            ExtraBehavior::Allow | ExtraBehavior::Forbid => Some(AHashSet::with_capacity(self.fields.len())),
+            ExtraBehavior::Ignore => None,
         };
 
-        macro_rules! process {
-            ($dict:expr, $get_method:ident, $iter:ty $(,$kwargs:expr)?) => {{
-                {
-                    let state = &mut state.rebind_extra(|extra| extra.data = Some(output_dict.clone()));
+        {
+            let state = &mut state.rebind_extra(|extra| extra.data = Some(output_dict.clone()));
 
-                    for field in &self.fields {
-                        let op_key_value = match field.lookup_key.$get_method($dict $(, $kwargs )? ) {
-                            Ok(v) => v,
-                            Err(ValError::LineErrors(line_errors)) => {
-                                for err in line_errors {
-                                    errors.push(err.with_outer_location(&field.name));
-                                }
-                                continue;
-                            }
-                            Err(err) => return Err(err),
-                        };
-                        if let Some((lookup_path, value)) = op_key_value {
-                            if let Some(ref mut used_keys) = used_keys {
-                                // key is "used" whether or not validation passes, since we want to skip this key in
-                                // extra logic either way
-                                used_keys.insert(lookup_path.first_key());
-                            }
-                            match field.validator.validate(py, value.borrow_input(), state) {
-                                Ok(value) => {
-                                    output_dict.set_item(&field.name_py, value)?;
-                                }
-                                Err(ValError::Omit) => continue,
-                                Err(ValError::LineErrors(line_errors)) => {
-                                    for err in line_errors {
-                                        errors.push(
-                                            lookup_path
-                                            .apply_error_loc(err, self.loc_by_alias, &field.name)
-                                        );
-                                    }
-                                }
-                                Err(err) => return Err(err),
+            for field in &self.fields {
+                let op_key_value = match dict.get_item(&field.lookup_key) {
+                    Ok(v) => v,
+                    Err(ValError::LineErrors(line_errors)) => {
+                        for err in line_errors {
+                            errors.push(err.with_outer_location(&field.name));
+                        }
+                        continue;
+                    }
+                    Err(err) => return Err(err),
+                };
+                if let Some((lookup_path, value)) = op_key_value {
+                    if let Some(ref mut used_keys) = used_keys {
+                        // key is "used" whether or not validation passes, since we want to skip this key in
+                        // extra logic either way
+                        used_keys.insert(lookup_path.first_key());
+                    }
+                    match field.validator.validate(py, value.borrow_input(), state) {
+                        Ok(value) => {
+                            output_dict.set_item(&field.name_py, value)?;
+                        }
+                        Err(ValError::Omit) => continue,
+                        Err(ValError::LineErrors(line_errors)) => {
+                            for err in line_errors {
+                                errors.push(lookup_path.apply_error_loc(err, self.loc_by_alias, &field.name));
                             }
-                            continue;
                         }
+                        Err(err) => return Err(err),
+                    }
+                    continue;
+                }
 
-                        match field.validator.default_value(py, Some(field.name.as_str()), state) {
-                            Ok(Some(value)) => {
-                                // Default value exists, and passed validation if required
-                                output_dict.set_item(&field.name_py, value)?;
-                            },
-                            Ok(None) => {
-                                // This means there was no default value
-                                if (field.required) {
-                                    errors.push(field.lookup_key.error(
-                                        ErrorTypeDefaults::Missing,
-                                        input,
-                                        self.loc_by_alias,
-                                        &field.name
-                                    ));
-                                }
-                            },
-                            Err(ValError::Omit) => continue,
-                            Err(ValError::LineErrors(line_errors)) => {
-                                for err in line_errors {
-                                    // Note: this will always use the field name even if there is an alias
-                                    // However, we don't mind so much because this error can only happen if the
-                                    // default value fails validation, which is arguably a developer error.
-                                    // We could try to "fix" this in the future if desired.
-                                    errors.push(err);
-                                }
-                            }
-                            Err(err) => return Err(err),
+                match field.validator.default_value(py, Some(field.name.as_str()), state) {
+                    Ok(Some(value)) => {
+                        // Default value exists, and passed validation if required
+                        output_dict.set_item(&field.name_py, value)?;
+                    }
+                    Ok(None) => {
+                        // This means there was no default value
+                        if field.required {
+                            errors.push(field.lookup_key.error(
+                                ErrorTypeDefaults::Missing,
+                                input,
+                                self.loc_by_alias,
+                                &field.name,
+                            ));
+                        }
+                    }
+                    Err(ValError::Omit) => continue,
+                    Err(ValError::LineErrors(line_errors)) => {
+                        for err in line_errors {
+                            // Note: this will always use the field name even if there is an alias
+                            // However, we don't mind so much because this error can only happen if the
+                            // default value fails validation, which is arguably a developer error.
+                            // We could try to "fix" this in the future if desired.
+                            errors.push(err);
                         }
                     }
+                    Err(err) => return Err(err),
                 }
+            }
+        }
 
-                if let Some(ref mut used_keys) = used_keys {
-                    for item_result in <$iter>::new($dict)? {
+        if let Some(used_keys) = used_keys {
+            struct ValidateExtras<'a, 's, 'py> {
+                py: Python<'py>,
+                used_keys: AHashSet<&'a str>,
+                errors: &'a mut Vec<ValLineError>,
+                extras_validator: Option<&'a CombinedValidator>,
+                output_dict: &'a Bound<'py, PyDict>,
+                state: &'a mut ValidationState<'s, 'py>,
+                extra_behavior: ExtraBehavior,
+            }
+
+            impl<'py, Key, Value> ConsumeIterator<ValResult<(Key, Value)>> for ValidateExtras<'_, '_, 'py>
+            where
+                Key: BorrowInput<'py> + Clone + Into<LocItem>,
+                Value: BorrowInput<'py>,
+            {
+                type Output = ValResult<()>;
+                fn consume_iterator(self, iterator: impl Iterator<Item = ValResult<(Key, Value)>>) -> ValResult<()> {
+                    for item_result in iterator {
                         let (raw_key, value) = item_result?;
-                        let either_str = match raw_key.validate_str(true, false).map(ValidationMatch::into_inner) {
+                        let either_str = match raw_key
+                            .borrow_input()
+                            .validate_str(true, false)
+                            .map(ValidationMatch::into_inner)
+                        {
                             Ok(k) => k,
                             Err(ValError::LineErrors(line_errors)) => {
                                 for err in line_errors {
-                                    errors.push(
+                                    self.errors.push(
                                         err.with_outer_location(raw_key.clone())
-                                            .with_type(ErrorTypeDefaults::InvalidKey)
-
+                                            .with_type(ErrorTypeDefaults::InvalidKey),
                                     );
                                 }
                                 continue;
                             }
                             Err(err) => return Err(err),
                         };
-                        let cow = either_str.as_cow().map_err(|err| err)?;
-                        if used_keys.contains(cow.as_ref()) {
+                        let cow = either_str.as_cow()?;
+                        if self.used_keys.contains(cow.as_ref()) {
                             continue;
                         }
 
@@ -258,51 +273,47 @@ impl Validator for TypedDictValidator {
                         // Unknown / extra field
                         match self.extra_behavior {
                             ExtraBehavior::Forbid => {
-                                errors.push(
-                                    ValLineError::new_with_loc(
-                                        ErrorTypeDefaults::ExtraForbidden,
-                                        value,
-                                        raw_key.clone(),
-                                    )
-
-                                );
+                                self.errors.push(ValLineError::new_with_loc(
+                                    ErrorTypeDefaults::ExtraForbidden,
+                                    value,
+                                    raw_key.clone(),
+                                ));
                             }
                             ExtraBehavior::Ignore => {}
                             ExtraBehavior::Allow => {
-                            let py_key = either_str.as_py_string(py);
-                                if let Some(ref validator) = self.extras_validator {
-                                    match validator.validate(py, value, state) {
+                                let py_key = either_str.as_py_string(self.py);
+                                if let Some(validator) = self.extras_validator {
+                                    match validator.validate(self.py, value, self.state) {
                                         Ok(value) => {
-                                            output_dict.set_item(py_key, value)?;
+                                            self.output_dict.set_item(py_key, value)?;
                                         }
                                         Err(ValError::LineErrors(line_errors)) => {
                                             for err in line_errors {
-                                                errors.push(
-                                                    err.with_outer_location(raw_key.clone())
-                                                );
+                                                self.errors.push(err.with_outer_location(raw_key.clone()));
                                             }
                                         }
                                         Err(err) => return Err(err),
                                     }
                                 } else {
-                                    output_dict.set_item(py_key, value.to_object(py))?;
+                                    self.output_dict.set_item(py_key, value.to_object(self.py))?;
                                 };
                             }
                         }
                     }
+
+                    Ok(())
                 }
-            }};
-        }
-        match dict {
-            GenericMapping::PyDict(d) => {
-                process!(&d, py_get_dict_item, DictGenericIterator);
             }
-            GenericMapping::PyMapping(d) => process!(&d, py_get_mapping_item, MappingGenericIterator),
-            GenericMapping::StringMapping(d) => process!(&d, py_get_string_mapping_item, StringMappingGenericIterator),
-            GenericMapping::PyGetAttr(d, kwargs) => {
-                process!(&d, py_get_attr, AttributesGenericIterator, kwargs.as_ref());
-            }
-            GenericMapping::JsonObject(d) => process!(d, json_get, JsonObjectGenericIterator),
+
+            dict.iterate(ValidateExtras {
+                used_keys,
+                py,
+                errors: &mut errors,
+                extras_validator: self.extras_validator.as_deref(),
+                output_dict: &output_dict,
+                state,
+                extra_behavior: self.extra_behavior,
+            })??;
         }
 
         if !errors.is_empty() {
diff --git a/src/validators/union.rs b/src/validators/union.rs
index 7001f9280..874da49af 100644
--- a/src/validators/union.rs
+++ b/src/validators/union.rs
@@ -9,7 +9,7 @@ use smallvec::SmallVec;
 use crate::build_tools::py_schema_err;
 use crate::build_tools::{is_strict, schema_or_config};
 use crate::errors::{ErrorType, ToErrorValue, ValError, ValLineError, ValResult};
-use crate::input::{GenericMapping, Input};
+use crate::input::{BorrowInput, Input, ValidatedDict};
 use crate::lookup_key::LookupKey;
 use crate::py_gc::PyGcTraverse;
 use crate::tools::SchemaDict;
@@ -396,38 +396,19 @@ impl Validator for TaggedUnionValidator {
         input: &(impl Input<'py> + ?Sized),
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
-        match self.discriminator {
-            Discriminator::LookupKey(ref lookup_key) => {
-                macro_rules! find_validator {
-                    ($get_method:ident, $($dict:expr),+) => {{
-                        // note all these methods return PyResult<Option<(data, data)>>, the outer Err is just for
-                        // errors when getting attributes which should be "raised"
-                        match lookup_key.$get_method($( $dict ),+)? {
-                            Some((_, value)) => Ok(value.to_object(py)),
-                            None => Err(self.tag_not_found(input)),
-                        }
-                    }};
-                }
+        match &self.discriminator {
+            Discriminator::LookupKey(lookup_key) => {
                 let from_attributes = state.extra().from_attributes.unwrap_or(self.from_attributes);
                 let dict = input.validate_model_fields(self.strict, from_attributes)?;
-                let tag = match dict {
-                    GenericMapping::PyDict(dict) => {
-                        find_validator!(py_get_dict_item, &dict)
-                    }
-                    GenericMapping::PyMapping(mapping) => {
-                        find_validator!(py_get_mapping_item, &mapping)
-                    }
-                    GenericMapping::StringMapping(d) => {
-                        find_validator!(py_get_dict_item, &d)
-                    }
-                    GenericMapping::PyGetAttr(obj, kwargs) => {
-                        find_validator!(py_get_attr, &obj, kwargs.as_ref())
-                    }
-                    GenericMapping::JsonObject(mapping) => find_validator!(json_get, mapping),
-                }?;
-                self.find_call_validator(py, tag.bind(py), input, state)
+                // note this methods returns PyResult<Option<(data, data)>>, the outer Err is just for
+                // errors when getting attributes which should be "raised"
+                let tag = match dict.get_item(lookup_key)? {
+                    Some((_, value)) => value,
+                    None => return Err(self.tag_not_found(input)),
+                };
+                self.find_call_validator(py, tag.borrow_input().to_object(py).bind(py), input, state)
             }
-            Discriminator::Function(ref func) => {
+            Discriminator::Function(func) => {
                 let tag: Py<PyAny> = func.call1(py, (input.to_object(py),))?;
                 if tag.is_none(py) {
                     Err(self.tag_not_found(input))
@@ -453,19 +434,14 @@ impl TaggedUnionValidator {
         input: &(impl Input<'py> + ?Sized),
     ) -> ValResult<Bound<'py, PyString>> {
         let dict = input.strict_dict()?;
-        let tag = match &dict {
-            GenericMapping::PyDict(dict) => match dict.get_item(intern!(py, "type"))? {
-                Some(t) => t.downcast_into::<PyString>()?,
-                None => return Err(self.tag_not_found(input)),
-            },
-            _ => unreachable!(),
+        let dict = dict.as_py_dict().expect("self schema is always a Python dictionary");
+        let tag = match dict.get_item(intern!(py, "type"))? {
+            Some(t) => t.downcast_into::<PyString>()?,
+            None => return Err(self.tag_not_found(input)),
         };
         let tag = tag.to_str()?;
         // custom logic to distinguish between different function and tuple schemas
         if tag == "function" {
-            let GenericMapping::PyDict(dict) = dict else {
-                unreachable!()
-            };
             let Some(mode) = dict.get_item(intern!(py, "mode"))? else {
                 return Err(self.tag_not_found(input));
             };

From d73668f4470e8c4acf627a6be967ee7399722fef Mon Sep 17 00:00:00 2001
From: Samuel Colvin <s@muelcolvin.com>
Date: Wed, 20 Mar 2024 15:08:07 +0000
Subject: [PATCH 239/550] Rust enums validator (#1235)

---
 python/pydantic_core/core_schema.py        |  65 +++++
 src/input/input_abstract.rs                |   4 +
 src/input/input_python.rs                  |   4 +
 src/serializers/shared.rs                  |   2 +
 src/serializers/type_serializers/enum_.rs  | 125 ++++++++++
 src/serializers/type_serializers/float.rs  |  16 +-
 src/serializers/type_serializers/format.rs |   4 +-
 src/serializers/type_serializers/mod.rs    |   1 +
 src/serializers/type_serializers/simple.rs |  12 +-
 src/serializers/type_serializers/string.rs |   8 +-
 src/validators/enum_.rs                    | 214 ++++++++++++++++
 src/validators/is_instance.rs              |  18 +-
 src/validators/literal.rs                  | 102 ++++++--
 src/validators/mod.rs                      |   8 +
 tests/benchmarks/test_micro_benchmarks.py  |  60 +++++
 tests/serializers/test_enum.py             | 105 ++++++++
 tests/test_schema_functions.py             |  11 +
 tests/validators/test_enums.py             | 269 +++++++++++++++++++++
 18 files changed, 993 insertions(+), 35 deletions(-)
 create mode 100644 src/serializers/type_serializers/enum_.rs
 create mode 100644 src/validators/enum_.rs
 create mode 100644 tests/serializers/test_enum.py
 create mode 100644 tests/validators/test_enums.py

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index 8e36e8da0..b52b3d9c6 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -1165,6 +1165,69 @@ def literal_schema(
     return _dict_not_none(type='literal', expected=expected, ref=ref, metadata=metadata, serialization=serialization)
 
 
+class EnumSchema(TypedDict, total=False):
+    type: Required[Literal['enum']]
+    cls: Required[Any]
+    members: Required[List[Any]]
+    sub_type: Literal['str', 'int', 'float']
+    missing: Callable[[Any], Any]
+    strict: bool
+    ref: str
+    metadata: Any
+    serialization: SerSchema
+
+
+def enum_schema(
+    cls: Any,
+    members: list[Any],
+    *,
+    sub_type: Literal['str', 'int', 'float'] | None = None,
+    missing: Callable[[Any], Any] | None = None,
+    strict: bool | None = None,
+    ref: str | None = None,
+    metadata: Any = None,
+    serialization: SerSchema | None = None,
+) -> EnumSchema:
+    """
+    Returns a schema that matches an enum value, e.g.:
+
+    ```py
+    from enum import Enum
+    from pydantic_core import SchemaValidator, core_schema
+
+    class Color(Enum):
+        RED = 1
+        GREEN = 2
+        BLUE = 3
+
+    schema = core_schema.enum_schema(Color, list(Color.__members__.values()))
+    v = SchemaValidator(schema)
+    assert v.validate_python(2) is Color.GREEN
+    ```
+
+    Args:
+        cls: The enum class
+        members: The members of the enum, generally `list(MyEnum.__members__.values())`
+        sub_type: The type of the enum, either 'str' or 'int' or None for plain enums
+        missing: A function to use when the value is not found in the enum, from `_missing_`
+        strict: Whether to use strict mode, defaults to False
+        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
+        serialization: Custom serialization schema
+    """
+    return _dict_not_none(
+        type='enum',
+        cls=cls,
+        members=members,
+        sub_type=sub_type,
+        missing=missing,
+        strict=strict,
+        ref=ref,
+        metadata=metadata,
+        serialization=serialization,
+    )
+
+
 # must match input/parse_json.rs::JsonType::try_from
 JsonType = Literal['null', 'bool', 'int', 'float', 'str', 'list', 'dict']
 
@@ -3670,6 +3733,7 @@ def definition_reference_schema(
         DatetimeSchema,
         TimedeltaSchema,
         LiteralSchema,
+        EnumSchema,
         IsInstanceSchema,
         IsSubclassSchema,
         CallableSchema,
@@ -3724,6 +3788,7 @@ def definition_reference_schema(
     'datetime',
     'timedelta',
     'literal',
+    'enum',
     'is-instance',
     'is-subclass',
     'callable',
diff --git a/src/input/input_abstract.rs b/src/input/input_abstract.rs
index 410beeacb..38237cc05 100644
--- a/src/input/input_abstract.rs
+++ b/src/input/input_abstract.rs
@@ -64,6 +64,10 @@ pub trait Input<'py>: fmt::Debug + ToPyObject {
         None
     }
 
+    fn input_is_exact_instance(&self, _class: &Bound<'py, PyType>) -> bool {
+        false
+    }
+
     fn is_python(&self) -> bool {
         false
     }
diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index 1b7f71106..7acb09a8f 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -138,6 +138,10 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
         }
     }
 
+    fn input_is_exact_instance(&self, class: &Bound<'py, PyType>) -> bool {
+        self.is_exact_instance(class)
+    }
+
     fn is_python(&self) -> bool {
         true
     }
diff --git a/src/serializers/shared.rs b/src/serializers/shared.rs
index 3607df6d6..b9e0a727d 100644
--- a/src/serializers/shared.rs
+++ b/src/serializers/shared.rs
@@ -139,6 +139,7 @@ combined_serializer! {
         JsonOrPython: super::type_serializers::json_or_python::JsonOrPythonSerializer;
         Union: super::type_serializers::union::UnionSerializer;
         Literal: super::type_serializers::literal::LiteralSerializer;
+        Enum: super::type_serializers::enum_::EnumSerializer;
         Recursive: super::type_serializers::definitions::DefinitionRefSerializer;
         Tuple: super::type_serializers::tuple::TupleSerializer;
     }
@@ -246,6 +247,7 @@ impl PyGcTraverse for CombinedSerializer {
             CombinedSerializer::JsonOrPython(inner) => inner.py_gc_traverse(visit),
             CombinedSerializer::Union(inner) => inner.py_gc_traverse(visit),
             CombinedSerializer::Literal(inner) => inner.py_gc_traverse(visit),
+            CombinedSerializer::Enum(inner) => inner.py_gc_traverse(visit),
             CombinedSerializer::Recursive(inner) => inner.py_gc_traverse(visit),
             CombinedSerializer::Tuple(inner) => inner.py_gc_traverse(visit),
             CombinedSerializer::Uuid(inner) => inner.py_gc_traverse(visit),
diff --git a/src/serializers/type_serializers/enum_.rs b/src/serializers/type_serializers/enum_.rs
new file mode 100644
index 000000000..d4d8aec02
--- /dev/null
+++ b/src/serializers/type_serializers/enum_.rs
@@ -0,0 +1,125 @@
+use std::borrow::Cow;
+
+use crate::build_tools::py_schema_err;
+use pyo3::intern;
+use pyo3::prelude::*;
+use pyo3::types::{PyDict, PyType};
+
+use crate::definitions::DefinitionsBuilder;
+use crate::serializers::errors::py_err_se_err;
+use crate::serializers::infer::{infer_json_key, infer_serialize, infer_to_python};
+use crate::tools::SchemaDict;
+
+use super::float::FloatSerializer;
+use super::simple::IntSerializer;
+use super::string::StrSerializer;
+use super::{BuildSerializer, CombinedSerializer, Extra, TypeSerializer};
+
+#[derive(Debug, Clone)]
+pub struct EnumSerializer {
+    class: Py<PyType>,
+    serializer: Option<Box<CombinedSerializer>>,
+}
+
+impl BuildSerializer for EnumSerializer {
+    const EXPECTED_TYPE: &'static str = "enum";
+
+    fn build(
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
+        _definitions: &mut DefinitionsBuilder<CombinedSerializer>,
+    ) -> PyResult<CombinedSerializer> {
+        let sub_type: Option<String> = schema.get_as(intern!(schema.py(), "sub_type"))?;
+
+        let serializer = match sub_type.as_deref() {
+            Some("int") => Some(Box::new(IntSerializer::new().into())),
+            Some("str") => Some(Box::new(StrSerializer::new().into())),
+            Some("float") => Some(Box::new(FloatSerializer::new(schema.py(), config)?.into())),
+            Some(_) => return py_schema_err!("`sub_type` must be one of: 'int', 'str', 'float' or None"),
+            None => None,
+        };
+        Ok(Self {
+            class: schema.get_as_req(intern!(schema.py(), "cls"))?,
+            serializer,
+        }
+        .into())
+    }
+}
+
+impl_py_gc_traverse!(EnumSerializer { serializer });
+
+impl TypeSerializer for EnumSerializer {
+    fn to_python(
+        &self,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
+        extra: &Extra,
+    ) -> PyResult<PyObject> {
+        let py = value.py();
+        if value.is_exact_instance(self.class.bind(py)) {
+            // if we're in JSON mode, we need to get the value attribute and serialize that
+            if extra.mode.is_json() {
+                let dot_value = value.getattr(intern!(py, "value"))?;
+                match self.serializer {
+                    Some(ref s) => s.to_python(&dot_value, include, exclude, extra),
+                    None => infer_to_python(&dot_value, include, exclude, extra),
+                }
+            } else {
+                // if we're not in JSON mode, we assume the value is safe to return directly
+                Ok(value.into_py(py))
+            }
+        } else {
+            extra.warnings.on_fallback_py(self.get_name(), value, extra)?;
+            infer_to_python(value, include, exclude, extra)
+        }
+    }
+
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
+        let py = key.py();
+        if key.is_exact_instance(self.class.bind(py)) {
+            let dot_value = key.getattr(intern!(py, "value"))?;
+            let k = match self.serializer {
+                Some(ref s) => s.json_key(&dot_value, extra),
+                None => infer_json_key(&dot_value, extra),
+            }?;
+            // since dot_value is a local reference, we need to allocate it and returned an
+            // owned variant of cow.
+            Ok(Cow::Owned(k.into_owned()))
+        } 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: &Bound<'_, PyAny>,
+        serializer: S,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
+        extra: &Extra,
+    ) -> Result<S::Ok, S::Error> {
+        if value.is_exact_instance(self.class.bind(value.py())) {
+            let dot_value = value.getattr(intern!(value.py(), "value")).map_err(py_err_se_err)?;
+            match self.serializer {
+                Some(ref s) => s.serde_serialize(&dot_value, serializer, include, exclude, extra),
+                None => infer_serialize(&dot_value, serializer, include, exclude, extra),
+            }
+        } else {
+            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
+    }
+
+    fn retry_with_lax_check(&self) -> bool {
+        match self.serializer {
+            Some(ref s) => s.retry_with_lax_check(),
+            None => false,
+        }
+    }
+}
diff --git a/src/serializers/type_serializers/float.rs b/src/serializers/type_serializers/float.rs
index 7abf28999..f3cb81380 100644
--- a/src/serializers/type_serializers/float.rs
+++ b/src/serializers/type_serializers/float.rs
@@ -20,6 +20,16 @@ pub struct FloatSerializer {
     inf_nan_mode: InfNanMode,
 }
 
+impl FloatSerializer {
+    pub fn new(py: Python, config: Option<&Bound<'_, PyDict>>) -> PyResult<Self> {
+        let inf_nan_mode = config
+            .and_then(|c| c.get_as(intern!(py, "ser_json_inf_nan")).transpose())
+            .transpose()?
+            .unwrap_or_default();
+        Ok(Self { inf_nan_mode })
+    }
+}
+
 impl BuildSerializer for FloatSerializer {
     const EXPECTED_TYPE: &'static str = "float";
 
@@ -28,11 +38,7 @@ impl BuildSerializer for FloatSerializer {
         config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
-        let inf_nan_mode = config
-            .and_then(|c| c.get_as(intern!(schema.py(), "ser_json_inf_nan")).transpose())
-            .transpose()?
-            .unwrap_or_default();
-        Ok(Self { inf_nan_mode }.into())
+        Self::new(schema.py(), config).map(Into::into)
     }
 }
 
diff --git a/src/serializers/type_serializers/format.rs b/src/serializers/type_serializers/format.rs
index 1991a2086..8b180f505 100644
--- a/src/serializers/type_serializers/format.rs
+++ b/src/serializers/type_serializers/format.rs
@@ -122,7 +122,7 @@ impl TypeSerializer for FormatSerializer {
         }
     }
 
-    fn json_key<'py>(&self, key: &Bound<'py, PyAny>, _extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, _extra: &Extra) -> PyResult<Cow<'a, str>> {
         if self.when_used.should_use_json(key) {
             let py_str = self
                 .call(key)
@@ -198,7 +198,7 @@ impl TypeSerializer for ToStringSerializer {
         }
     }
 
-    fn json_key<'py>(&self, key: &Bound<'py, PyAny>, _extra: &Extra) -> PyResult<Cow<'py, str>> {
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, _extra: &Extra) -> PyResult<Cow<'a, str>> {
         if self.when_used.should_use_json(key) {
             Ok(Cow::Owned(key.str()?.to_string_lossy().into_owned()))
         } else {
diff --git a/src/serializers/type_serializers/mod.rs b/src/serializers/type_serializers/mod.rs
index decb07aaf..da36f0bc1 100644
--- a/src/serializers/type_serializers/mod.rs
+++ b/src/serializers/type_serializers/mod.rs
@@ -5,6 +5,7 @@ pub mod datetime_etc;
 pub mod decimal;
 pub mod definitions;
 pub mod dict;
+pub mod enum_;
 pub mod float;
 pub mod format;
 pub mod function;
diff --git a/src/serializers/type_serializers/simple.rs b/src/serializers/type_serializers/simple.rs
index e1d0f3c0b..5ad315a31 100644
--- a/src/serializers/type_serializers/simple.rs
+++ b/src/serializers/type_serializers/simple.rs
@@ -90,6 +90,12 @@ macro_rules! build_simple_serializer {
         #[derive(Debug, Clone)]
         pub struct $struct_name;
 
+        impl $struct_name {
+            pub fn new() -> Self {
+                Self {}
+            }
+        }
+
         impl BuildSerializer for $struct_name {
             const EXPECTED_TYPE: &'static str = $expected_type;
 
@@ -98,7 +104,7 @@ macro_rules! build_simple_serializer {
                 _config: Option<&Bound<'_, PyDict>>,
                 _definitions: &mut DefinitionsBuilder<CombinedSerializer>,
             ) -> PyResult<CombinedSerializer> {
-                Ok(Self {}.into())
+                Ok(Self::new().into())
             }
         }
 
@@ -172,13 +178,13 @@ macro_rules! build_simple_serializer {
     };
 }
 
-pub(crate) fn to_str_json_key<'py>(key: &Bound<'py, PyAny>) -> PyResult<Cow<'py, str>> {
+pub(crate) fn to_str_json_key<'a>(key: &'a Bound<'_, PyAny>) -> PyResult<Cow<'a, str>> {
     Ok(Cow::Owned(key.str()?.to_string_lossy().into_owned()))
 }
 
 build_simple_serializer!(IntSerializer, "int", Int, ObType::Int, to_str_json_key, true);
 
-pub(crate) fn bool_json_key<'py>(key: &Bound<'py, PyAny>) -> PyResult<Cow<'py, str>> {
+pub(crate) fn bool_json_key<'a>(key: &'a Bound<'_, PyAny>) -> PyResult<Cow<'a, str>> {
     let v = if key.is_truthy().unwrap_or(false) {
         "true"
     } else {
diff --git a/src/serializers/type_serializers/string.rs b/src/serializers/type_serializers/string.rs
index 48fba0e64..33b7d0d12 100644
--- a/src/serializers/type_serializers/string.rs
+++ b/src/serializers/type_serializers/string.rs
@@ -13,6 +13,12 @@ use super::{
 #[derive(Debug, Clone)]
 pub struct StrSerializer;
 
+impl StrSerializer {
+    pub fn new() -> Self {
+        Self {}
+    }
+}
+
 impl BuildSerializer for StrSerializer {
     const EXPECTED_TYPE: &'static str = "str";
 
@@ -21,7 +27,7 @@ impl BuildSerializer for StrSerializer {
         _config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
-        Ok(Self {}.into())
+        Ok(Self::new().into())
     }
 }
 
diff --git a/src/validators/enum_.rs b/src/validators/enum_.rs
new file mode 100644
index 000000000..cc8a3d7b3
--- /dev/null
+++ b/src/validators/enum_.rs
@@ -0,0 +1,214 @@
+// Validator for Enums, so named because "enum" is a reserved keyword in Rust.
+use std::marker::PhantomData;
+
+use pyo3::exceptions::PyTypeError;
+use pyo3::intern;
+use pyo3::prelude::*;
+use pyo3::types::{PyDict, PyList, PyType};
+
+use crate::build_tools::{is_strict, py_schema_err};
+use crate::errors::{ErrorType, ValError, ValResult};
+use crate::input::Input;
+use crate::tools::{safe_repr, SchemaDict};
+
+use super::is_instance::class_repr;
+use super::literal::{expected_repr_name, LiteralLookup};
+use super::{BuildValidator, CombinedValidator, DefinitionsBuilder, Exactness, ValidationState, Validator};
+
+#[derive(Debug, Clone)]
+pub struct BuildEnumValidator;
+
+impl BuildValidator for BuildEnumValidator {
+    const EXPECTED_TYPE: &'static str = "enum";
+
+    fn build(
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
+        _definitions: &mut DefinitionsBuilder<CombinedValidator>,
+    ) -> PyResult<CombinedValidator> {
+        let members: Bound<PyList> = schema.get_as_req(intern!(schema.py(), "members"))?;
+        if members.is_empty() {
+            return py_schema_err!("`members` should have length > 0");
+        }
+
+        let py = schema.py();
+        let value_str = intern!(py, "value");
+        let expected: Vec<(Bound<'_, PyAny>, PyObject)> = members
+            .iter()
+            .map(|v| Ok((v.getattr(value_str)?, v.into())))
+            .collect::<PyResult<_>>()?;
+
+        let repr_args: Vec<String> = expected
+            .iter()
+            .map(|(k, _)| k.repr()?.extract())
+            .collect::<PyResult<_>>()?;
+
+        let class: Bound<PyType> = schema.get_as_req(intern!(py, "cls"))?;
+        let class_repr = class_repr(schema, &class)?;
+
+        let lookup = LiteralLookup::new(py, expected.into_iter())?;
+
+        macro_rules! build {
+            ($vv:ty, $name_prefix:literal) => {
+                EnumValidator {
+                    phantom: PhantomData::<$vv>,
+                    class: class.clone().into(),
+                    lookup,
+                    missing: schema.get_as(intern!(py, "missing"))?,
+                    expected_repr: expected_repr_name(repr_args, "").0,
+                    strict: is_strict(schema, config)?,
+                    class_repr: class_repr.clone(),
+                    name: format!("{}[{class_repr}]", $name_prefix),
+                }
+            };
+        }
+
+        let sub_type: Option<String> = schema.get_as(intern!(py, "sub_type"))?;
+        match sub_type.as_deref() {
+            Some("int") => Ok(CombinedValidator::IntEnum(build!(IntEnumValidator, "int-enum"))),
+            Some("str") => Ok(CombinedValidator::StrEnum(build!(StrEnumValidator, "str-enum"))),
+            Some("float") => Ok(CombinedValidator::FloatEnum(build!(FloatEnumValidator, "float-enum"))),
+            Some(_) => py_schema_err!("`sub_type` must be one of: 'int', 'str', 'float' or None"),
+            None => Ok(CombinedValidator::PlainEnum(build!(PlainEnumValidator, "enum"))),
+        }
+    }
+}
+
+pub trait EnumValidateValue: std::fmt::Debug + Clone + Send + Sync {
+    fn validate_value<'py, I: Input<'py> + ?Sized>(
+        py: Python<'py>,
+        input: &I,
+        lookup: &LiteralLookup<PyObject>,
+        strict: bool,
+    ) -> ValResult<Option<PyObject>>;
+}
+
+#[derive(Debug, Clone)]
+pub struct EnumValidator<T: EnumValidateValue> {
+    phantom: PhantomData<T>,
+    class: Py<PyType>,
+    lookup: LiteralLookup<PyObject>,
+    missing: Option<PyObject>,
+    expected_repr: String,
+    strict: bool,
+    class_repr: String,
+    name: String,
+}
+
+impl<T: EnumValidateValue> Validator for EnumValidator<T> {
+    fn validate<'py>(
+        &self,
+        py: Python<'py>,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
+    ) -> ValResult<PyObject> {
+        let class = self.class.bind(py);
+        if input.input_is_exact_instance(class) {
+            return Ok(input.to_object(py));
+        }
+        let strict = state.strict_or(self.strict);
+        if strict && input.is_python() {
+            // TODO what about instances of subclasses?
+            return Err(ValError::new(
+                ErrorType::IsInstanceOf {
+                    class: self.class_repr.clone(),
+                    context: None,
+                },
+                input,
+            ));
+        } else if let Some(v) = T::validate_value(py, input, &self.lookup, strict)? {
+            state.floor_exactness(Exactness::Lax);
+            return Ok(v);
+        } else if let Some(ref missing) = self.missing {
+            state.floor_exactness(Exactness::Lax);
+            let enum_value = missing.bind(py).call1((input.to_object(py),))?;
+            // check enum_value is an instance of the class like
+            // https://github.com/python/cpython/blob/v3.12.2/Lib/enum.py#L1148
+            if enum_value.is_instance(class)? {
+                return Ok(enum_value.into());
+            } else if !enum_value.is(&py.None()) {
+                let type_error = PyTypeError::new_err(format!(
+                    "error in {}._missing_: returned {} instead of None or a valid member",
+                    class.name().unwrap_or_else(|_| "<Unknown>".into()),
+                    safe_repr(&enum_value)
+                ));
+                return Err(type_error.into());
+            }
+        }
+        Err(ValError::new(
+            ErrorType::Enum {
+                expected: self.expected_repr.clone(),
+                context: None,
+            },
+            input,
+        ))
+    }
+
+    fn get_name(&self) -> &str {
+        &self.name
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct PlainEnumValidator;
+
+impl_py_gc_traverse!(EnumValidator<PlainEnumValidator> { class, missing });
+
+impl EnumValidateValue for PlainEnumValidator {
+    fn validate_value<'py, I: Input<'py> + ?Sized>(
+        py: Python<'py>,
+        input: &I,
+        lookup: &LiteralLookup<PyObject>,
+        _strict: bool,
+    ) -> ValResult<Option<PyObject>> {
+        Ok(lookup.validate(py, input)?.map(|(_, v)| v.clone_ref(py)))
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct IntEnumValidator;
+
+impl_py_gc_traverse!(EnumValidator<IntEnumValidator> { class, missing });
+
+impl EnumValidateValue for IntEnumValidator {
+    fn validate_value<'py, I: Input<'py> + ?Sized>(
+        py: Python<'py>,
+        input: &I,
+        lookup: &LiteralLookup<PyObject>,
+        strict: bool,
+    ) -> ValResult<Option<PyObject>> {
+        Ok(lookup.validate_int(py, input, strict)?.map(|v| v.clone_ref(py)))
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct StrEnumValidator;
+
+impl_py_gc_traverse!(EnumValidator<StrEnumValidator> { class, missing });
+
+impl EnumValidateValue for StrEnumValidator {
+    fn validate_value<'py, I: Input<'py> + ?Sized>(
+        py: Python,
+        input: &I,
+        lookup: &LiteralLookup<PyObject>,
+        strict: bool,
+    ) -> ValResult<Option<PyObject>> {
+        Ok(lookup.validate_str(input, strict)?.map(|v| v.clone_ref(py)))
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct FloatEnumValidator;
+
+impl_py_gc_traverse!(EnumValidator<FloatEnumValidator> { class, missing });
+
+impl EnumValidateValue for FloatEnumValidator {
+    fn validate_value<'py, I: Input<'py> + ?Sized>(
+        py: Python<'py>,
+        input: &I,
+        lookup: &LiteralLookup<PyObject>,
+        strict: bool,
+    ) -> ValResult<Option<PyObject>> {
+        Ok(lookup.validate_float(py, input, strict)?.map(|v| v.clone_ref(py)))
+    }
+}
diff --git a/src/validators/is_instance.rs b/src/validators/is_instance.rs
index 7eb7961d5..7cbf241ea 100644
--- a/src/validators/is_instance.rs
+++ b/src/validators/is_instance.rs
@@ -35,13 +35,7 @@ impl BuildValidator for IsInstanceValidator {
             return py_schema_err!("'cls' must be valid as the first argument to 'isinstance'");
         }
 
-        let class_repr = match schema.get_as(intern!(py, "cls_repr"))? {
-            Some(s) => s,
-            None => match class.extract::<&PyType>() {
-                Ok(t) => t.qualname()?.to_string(),
-                Err(_) => class.repr()?.extract()?,
-            },
-        };
+        let class_repr = class_repr(schema, &class)?;
         let name = format!("{}[{class_repr}]", Self::EXPECTED_TYPE);
         Ok(Self {
             class: class.into(),
@@ -85,3 +79,13 @@ impl Validator for IsInstanceValidator {
         &self.name
     }
 }
+
+pub fn class_repr(schema: &Bound<'_, PyDict>, class: &Bound<'_, PyAny>) -> PyResult<String> {
+    match schema.get_as(intern!(schema.py(), "cls_repr"))? {
+        Some(s) => Ok(s),
+        None => match class.extract::<&PyType>() {
+            Ok(t) => Ok(t.qualname()?.to_string()),
+            Err(_) => Ok(class.repr()?.extract()?),
+        },
+    }
+}
diff --git a/src/validators/literal.rs b/src/validators/literal.rs
index 69784efca..0ace83f25 100644
--- a/src/validators/literal.rs
+++ b/src/validators/literal.rs
@@ -1,12 +1,14 @@
 // Validator for things inside of a typing.Literal[]
 // which can be an int, a string, bytes or an Enum value (including `class Foo(str, Enum)` type enums)
 use core::fmt::Debug;
+use std::cmp::Ordering;
 
-use ahash::AHashMap;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList};
 use pyo3::{intern, PyTraverseError, PyVisit};
 
+use ahash::AHashMap;
+
 use crate::build_tools::{py_schema_err, py_schema_error_type};
 use crate::errors::{ErrorType, ValError, ValResult};
 use crate::input::{Input, ValidationMatch};
@@ -15,7 +17,7 @@ use crate::tools::SchemaDict;
 
 use super::{BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Default)]
 struct BoolLiteral {
     pub true_id: Option<usize>,
     pub false_id: Option<usize>,
@@ -30,20 +32,21 @@ pub struct LiteralLookup<T: Debug> {
     expected_bool: Option<BoolLiteral>,
     expected_int: Option<AHashMap<i64, usize>>,
     expected_str: Option<AHashMap<String, usize>>,
-    // Catch all for Enum and bytes (the latter only because it is seldom used)
-    expected_py: Option<Py<PyDict>>,
+    // Catch all for hashable types like Enum and bytes (the latter only because it is seldom used)
+    expected_py_dict: Option<Py<PyDict>>,
+    // Catch all for unhashable types like list
+    expected_py_list: Option<Py<PyList>>,
+
     pub values: Vec<T>,
 }
 
 impl<T: Debug> LiteralLookup<T> {
     pub fn new<'py>(py: Python<'py>, expected: impl Iterator<Item = (Bound<'py, PyAny>, T)>) -> PyResult<Self> {
+        let mut expected_bool = BoolLiteral::default();
         let mut expected_int = AHashMap::new();
         let mut expected_str: AHashMap<String, usize> = AHashMap::new();
-        let mut expected_bool = BoolLiteral {
-            true_id: None,
-            false_id: None,
-        };
-        let expected_py = PyDict::new_bound(py);
+        let expected_py_dict = PyDict::new_bound(py);
+        let expected_py_list = PyList::empty_bound(py);
         let mut values = Vec::new();
         for (k, v) in expected {
             let id = values.len();
@@ -65,8 +68,8 @@ impl<T: Debug> LiteralLookup<T> {
                     .as_cow()
                     .map_err(|_| py_schema_error_type!("error extracting str {:?}", k))?;
                 expected_str.insert(str.to_string(), id);
-            } else {
-                expected_py.set_item(&k, id)?;
+            } else if expected_py_dict.set_item(&k, id).is_err() {
+                expected_py_list.append((&k, id))?;
             }
         }
 
@@ -83,9 +86,13 @@ impl<T: Debug> LiteralLookup<T> {
                 true => None,
                 false => Some(expected_str),
             },
-            expected_py: match expected_py.is_empty() {
+            expected_py_dict: match expected_py_dict.is_empty() {
                 true => None,
-                false => Some(expected_py.into()),
+                false => Some(expected_py_dict.into()),
+            },
+            expected_py_list: match expected_py_list.is_empty() {
+                true => None,
+                false => Some(expected_py_list.into()),
             },
             values,
         })
@@ -134,23 +141,84 @@ impl<T: Debug> LiteralLookup<T> {
                 }
             }
         }
-        // must be an enum or bytes
-        if let Some(expected_py) = &self.expected_py {
+        if let Some(expected_py_dict) = &self.expected_py_dict {
             // We don't use ? to unpack the result of `get_item` in the next line because unhashable
             // inputs will produce a TypeError, which in this case we just want to treat equivalently
             // to a failed lookup
-            if let Ok(Some(v)) = expected_py.bind(py).get_item(input) {
+            if let Ok(Some(v)) = expected_py_dict.bind(py).get_item(input) {
                 let id: usize = v.extract().unwrap();
                 return Ok(Some((input, &self.values[id])));
             }
         };
+        if let Some(expected_py_list) = &self.expected_py_list {
+            for item in expected_py_list.bind(py) {
+                let (k, id): (Bound<PyAny>, usize) = item.extract()?;
+                if k.compare(input.to_object(py).bind(py))
+                    .unwrap_or(Ordering::Less)
+                    .is_eq()
+                {
+                    return Ok(Some((input, &self.values[id])));
+                }
+            }
+        };
+        Ok(None)
+    }
+
+    /// Used by int enums
+    pub fn validate_int<'a, 'py, I: Input<'py> + ?Sized>(
+        &self,
+        py: Python<'py>,
+        input: &'a I,
+        strict: bool,
+    ) -> ValResult<Option<&T>> {
+        if let Some(expected_ints) = &self.expected_int {
+            if let Ok(either_int) = input.validate_int(strict) {
+                let int = either_int.into_inner().into_i64(py)?;
+                if let Some(id) = expected_ints.get(&int) {
+                    return Ok(Some(&self.values[*id]));
+                }
+            }
+        }
+        Ok(None)
+    }
+
+    /// Used by str enums
+    pub fn validate_str<'a, 'py, I: Input<'py> + ?Sized>(&self, input: &'a I, strict: bool) -> ValResult<Option<&T>> {
+        if let Some(expected_strings) = &self.expected_str {
+            if let Ok(either_str) = input.validate_str(strict, false) {
+                let s = either_str.into_inner();
+                if let Some(id) = expected_strings.get(s.as_cow()?.as_ref()) {
+                    return Ok(Some(&self.values[*id]));
+                }
+            }
+        }
+        Ok(None)
+    }
+
+    /// Used by float enums
+    pub fn validate_float<'a, 'py, I: Input<'py> + ?Sized>(
+        &self,
+        py: Python<'py>,
+        input: &'a I,
+        strict: bool,
+    ) -> ValResult<Option<&T>> {
+        if let Some(expected_py) = &self.expected_py_dict {
+            if let Ok(either_float) = input.validate_float(strict) {
+                let f = either_float.into_inner().as_f64();
+                let py_float = f.to_object(py);
+                if let Ok(Some(v)) = expected_py.bind(py).get_item(py_float.bind(py)) {
+                    let id: usize = v.extract().unwrap();
+                    return Ok(Some(&self.values[id]));
+                }
+            }
+        }
         Ok(None)
     }
 }
 
 impl<T: PyGcTraverse + Debug> PyGcTraverse for LiteralLookup<T> {
     fn py_gc_traverse(&self, visit: &PyVisit<'_>) -> Result<(), PyTraverseError> {
-        self.expected_py.py_gc_traverse(visit)?;
+        self.expected_py_dict.py_gc_traverse(visit)?;
         self.values.py_gc_traverse(visit)?;
         Ok(())
     }
diff --git a/src/validators/mod.rs b/src/validators/mod.rs
index 07ae2e6b4..ac5d6d63c 100644
--- a/src/validators/mod.rs
+++ b/src/validators/mod.rs
@@ -30,6 +30,7 @@ mod datetime;
 pub(crate) mod decimal;
 mod definitions;
 mod dict;
+mod enum_;
 mod float;
 mod frozenset;
 mod function;
@@ -513,6 +514,8 @@ pub fn build_validator(
         call::CallValidator,
         // literals
         literal::LiteralValidator,
+        // enums
+        enum_::BuildEnumValidator,
         // any
         any::AnyValidator,
         // bytes
@@ -656,6 +659,11 @@ pub enum CombinedValidator {
     FunctionCall(call::CallValidator),
     // literals
     Literal(literal::LiteralValidator),
+    // enums
+    IntEnum(enum_::EnumValidator<enum_::IntEnumValidator>),
+    StrEnum(enum_::EnumValidator<enum_::StrEnumValidator>),
+    FloatEnum(enum_::EnumValidator<enum_::FloatEnumValidator>),
+    PlainEnum(enum_::EnumValidator<enum_::PlainEnumValidator>),
     // any
     Any(any::AnyValidator),
     // bytes
diff --git a/tests/benchmarks/test_micro_benchmarks.py b/tests/benchmarks/test_micro_benchmarks.py
index 80b3e6a47..da7868c69 100644
--- a/tests/benchmarks/test_micro_benchmarks.py
+++ b/tests/benchmarks/test_micro_benchmarks.py
@@ -1386,3 +1386,63 @@ def test_decimal_from_string_pyd(self, benchmark, pydantic_validator):
     @pytest.mark.benchmark(group='decimal from str')
     def test_decimal_from_string_limit(self, benchmark):
         benchmark(decimal.Decimal, '123.456789')
+
+
+class FooInt(int, Enum):
+    a = 1
+    b = 2
+    c = 3
+
+
+@pytest.mark.benchmark(group='enum int')
+def test_enum_int_python(benchmark):
+    def to_enum(input_value: Any, /) -> Enum:
+        try:
+            return FooInt(input_value)
+        except ValueError:
+            raise PydanticCustomError('enum', 'Input should be {expected}', {'expected': '1, 2 or 3'})
+
+    v = SchemaValidator(core_schema.no_info_after_validator_function(to_enum, core_schema.int_schema()))
+
+    assert v.validate_python(1) is FooInt.a
+
+    benchmark(v.validate_python, 1)
+
+
+@pytest.mark.benchmark(group='enum int')
+def test_enum_int_core(benchmark):
+    v = SchemaValidator(core_schema.enum_schema(FooInt, list(FooInt.__members__.values()), sub_type='int'))
+
+    assert v.validate_python(1) is FooInt.a
+
+    benchmark(v.validate_python, 1)
+
+
+class FooStr(str, Enum):
+    a = 'apple'
+    b = 'banana'
+    c = 'carrot'
+
+
+@pytest.mark.benchmark(group='enum str')
+def test_enum_str_python(benchmark):
+    def to_enum(input_value: Any, /) -> Enum:
+        try:
+            return FooStr(input_value)
+        except ValueError:
+            raise PydanticCustomError('enum', 'Input should be {expected}', {'expected': 'apple, banana or carrot'})
+
+    v = SchemaValidator(core_schema.no_info_after_validator_function(to_enum, core_schema.str_schema()))
+
+    assert v.validate_python('apple') is FooStr.a
+
+    benchmark(v.validate_python, 'apple')
+
+
+@pytest.mark.benchmark(group='enum str')
+def test_enum_str_core(benchmark):
+    v = SchemaValidator(core_schema.enum_schema(FooStr, list(FooStr.__members__.values()), sub_type='str'))
+
+    assert v.validate_python('apple') is FooStr.a
+
+    benchmark(v.validate_python, 'apple')
diff --git a/tests/serializers/test_enum.py b/tests/serializers/test_enum.py
new file mode 100644
index 000000000..5161a2b39
--- /dev/null
+++ b/tests/serializers/test_enum.py
@@ -0,0 +1,105 @@
+from enum import Enum
+
+import pytest
+
+from pydantic_core import SchemaSerializer, core_schema
+
+
+def test_plain_enum():
+    class MyEnum(Enum):
+        a = 1
+        b = 2
+
+    v = SchemaSerializer(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values())))
+
+    # debug(v)
+    assert v.to_python(MyEnum.a) is MyEnum.a
+    assert v.to_python(MyEnum.a, mode='json') == 1
+    assert v.to_json(MyEnum.a) == b'1'
+
+    with pytest.warns(UserWarning, match='Expected `enum` but got `int` - serialized value may not be as expected'):
+        assert v.to_python(1) == 1
+    with pytest.warns(UserWarning, match='Expected `enum` but got `int` - serialized value may not be as expected'):
+        assert v.to_json(1) == b'1'
+
+
+def test_int_enum():
+    class MyEnum(int, Enum):
+        a = 1
+        b = 2
+
+    v = SchemaSerializer(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), sub_type='int'))
+
+    # debug(v)
+    assert v.to_python(MyEnum.a) is MyEnum.a
+    assert v.to_python(MyEnum.a, mode='json') == 1
+    assert v.to_json(MyEnum.a) == b'1'
+
+    with pytest.warns(UserWarning, match='Expected `enum` but got `int` - serialized value may not be as expected'):
+        assert v.to_python(1) == 1
+    with pytest.warns(UserWarning, match='Expected `enum` but got `int` - serialized value may not be as expected'):
+        assert v.to_json(1) == b'1'
+
+
+def test_str_enum():
+    class MyEnum(str, Enum):
+        a = 'a'
+        b = 'b'
+
+    v = SchemaSerializer(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), sub_type='str'))
+
+    # debug(v)
+    assert v.to_python(MyEnum.a) is MyEnum.a
+    assert v.to_python(MyEnum.a, mode='json') == 'a'
+    assert v.to_json(MyEnum.a) == b'"a"'
+
+    with pytest.warns(UserWarning, match='Expected `enum` but got `str` - serialized value may not be as expected'):
+        assert v.to_python('a') == 'a'
+    with pytest.warns(UserWarning, match='Expected `enum` but got `str` - serialized value may not be as expected'):
+        assert v.to_json('a') == b'"a"'
+
+
+def test_plain_dict_key():
+    class MyEnum(Enum):
+        a = 1
+        b = 2
+
+    v = SchemaSerializer(
+        core_schema.dict_schema(
+            core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values())),
+            core_schema.str_schema(),
+        )
+    )
+
+    # debug(v)
+    assert v.to_python({MyEnum.a: 'x'}) == {MyEnum.a: 'x'}
+    assert v.to_python({MyEnum.a: 'x'}, mode='json') == {'1': 'x'}
+    assert v.to_json({MyEnum.a: 'x'}) == b'{"1":"x"}'
+
+    with pytest.warns(UserWarning, match='Expected `enum` but got `str` - serialized value may not be as expected'):
+        assert v.to_python({'x': 'x'}) == {'x': 'x'}
+    with pytest.warns(UserWarning, match='Expected `enum` but got `str` - serialized value may not be as expected'):
+        assert v.to_json({'x': 'x'}) == b'{"x":"x"}'
+
+
+def test_int_dict_key():
+    class MyEnum(int, Enum):
+        a = 1
+        b = 2
+
+    v = SchemaSerializer(
+        core_schema.dict_schema(
+            core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), sub_type='int'),
+            core_schema.str_schema(),
+        )
+    )
+
+    # debug(v)
+    assert v.to_python({MyEnum.a: 'x'}) == {MyEnum.a: 'x'}
+    assert v.to_python({MyEnum.a: 'x'}, mode='json') == {'1': 'x'}
+    assert v.to_json({MyEnum.a: 'x'}) == b'{"1":"x"}'
+
+    with pytest.warns(UserWarning, match='Expected `enum` but got `str` - serialized value may not be as expected'):
+        assert v.to_python({'x': 'x'}) == {'x': 'x'}
+    with pytest.warns(UserWarning, match='Expected `enum` but got `str` - serialized value may not be as expected'):
+        assert v.to_json({'x': 'x'}) == b'{"x":"x"}'
diff --git a/tests/test_schema_functions.py b/tests/test_schema_functions.py
index 2a6032174..0971f0b9a 100644
--- a/tests/test_schema_functions.py
+++ b/tests/test_schema_functions.py
@@ -1,6 +1,7 @@
 import dataclasses
 import re
 from datetime import date
+from enum import Enum
 from typing import Any
 
 import pytest
@@ -26,6 +27,11 @@ class MyDataclass:
     y: str
 
 
+class MyEnum(int, Enum):
+    a = 1
+    b = 2
+
+
 def ids_function(val):
     if callable(val):
         return val.__name__
@@ -75,6 +81,11 @@ def args(*args, **kwargs):
         {'type': 'timedelta', 'microseconds_precision': 'error'},
     ),
     (core_schema.literal_schema, args(['a', 'b']), {'type': 'literal', 'expected': ['a', 'b']}),
+    (
+        core_schema.enum_schema,
+        args(MyEnum, list(MyEnum.__members__.values())),
+        {'type': 'enum', 'cls': MyEnum, 'members': [MyEnum.a, MyEnum.b]},
+    ),
     (core_schema.is_instance_schema, args(int), {'type': 'is-instance', 'cls': int}),
     (core_schema.callable_schema, args(), {'type': 'callable'}),
     (core_schema.list_schema, args(), {'type': 'list'}),
diff --git a/tests/validators/test_enums.py b/tests/validators/test_enums.py
new file mode 100644
index 000000000..89db8aa21
--- /dev/null
+++ b/tests/validators/test_enums.py
@@ -0,0 +1,269 @@
+import re
+import sys
+from enum import Enum
+
+import pytest
+
+from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema
+
+
+def test_plain_enum():
+    class MyEnum(Enum):
+        a = 1
+        b = 2
+
+    v = SchemaValidator(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values())))
+
+    # debug(v)
+    assert v.validate_python(MyEnum.a) is MyEnum.a
+    assert v.validate_python(MyEnum.b) is MyEnum.b
+    assert v.validate_python(1) is MyEnum.a
+    assert v.validate_python(2) is MyEnum.b
+
+    assert v.validate_json('1') is MyEnum.a
+    # assert v.validate_json('"1"') is MyEnum.a
+
+    with pytest.raises(ValidationError, match=r'Input should be 1 or 2 \[type=enum, input_value=3, input_type=int\]'):
+        v.validate_python(3)
+
+    with pytest.raises(ValidationError, match=r"Input should be 1 or 2 \[type=enum, input_value='1', input_type=str\]"):
+        v.validate_python('1')
+
+    assert v.validate_python(MyEnum.a, strict=True) is MyEnum.a
+
+    e = (
+        'Input should be an instance of test_plain_enum.<locals>.MyEnum '
+        '[type=is_instance_of, input_value=1, input_type=int]'
+    )
+    with pytest.raises(ValidationError, match=re.escape(e)):
+        v.validate_python(1, strict=True)
+
+    assert v.validate_json('1', strict=True) is MyEnum.a
+    with pytest.raises(ValidationError, match='type=enum'):
+        v.validate_json('"1"', strict=True)
+
+    v_strict = SchemaValidator(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), strict=True))
+    assert v_strict.validate_python(MyEnum.a) is MyEnum.a
+
+    with pytest.raises(ValidationError, match=re.escape(e)):
+        v_strict.validate_python(1, strict=True)
+
+    v_strict_f = SchemaValidator(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), strict=True))
+    assert v_strict_f.validate_python(MyEnum.a) is MyEnum.a
+
+    with pytest.raises(ValidationError, match=re.escape(e)):
+        v_strict_f.validate_python(1, strict=True)
+
+
+def test_int_enum():
+    class MyEnum(int, Enum):
+        a = 1
+        b = 2
+
+    v = SchemaValidator(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), sub_type='int'))
+
+    # debug(v)
+    assert v.validate_python(MyEnum.a) is MyEnum.a
+    assert v.validate_python(1) is MyEnum.a
+    assert v.validate_python(1.0) is MyEnum.a
+    assert v.validate_python('1') is MyEnum.a
+
+    assert v.validate_json('1') is MyEnum.a
+    assert v.validate_json('"1"') is MyEnum.a
+
+    with pytest.raises(ValidationError, match=r'Input should be 1 or 2 \[type=enum, input_value=3, input_type=int\]'):
+        v.validate_python(3)
+
+    assert v.validate_python(MyEnum.a, strict=True) is MyEnum.a
+
+    e = (
+        'Input should be an instance of test_int_enum.<locals>.MyEnum '
+        '[type=is_instance_of, input_value=1, input_type=int]'
+    )
+    with pytest.raises(ValidationError, match=re.escape(e)):
+        v.validate_python(1, strict=True)
+
+    assert v.validate_json('1', strict=True) is MyEnum.a
+
+    with pytest.raises(ValidationError, match=r"Input should be 1 or 2 \[type=enum, input_value='1', input_type=str\]"):
+        v.validate_json('"1"', strict=True)
+
+
+def test_str_enum():
+    class MyEnum(str, Enum):
+        a = 'x'
+        b = 'y'
+
+    v = SchemaValidator(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), sub_type='str'))
+
+    # debug(v)
+    assert v.validate_python('x') is MyEnum.a
+    assert v.validate_python(MyEnum.a) is MyEnum.a
+    assert v.validate_python(b'x') is MyEnum.a
+
+    assert v.validate_json('"x"') is MyEnum.a
+
+    with pytest.raises(
+        ValidationError, match=r"Input should be 'x' or 'y' \[type=enum, input_value='a', input_type=str\]"
+    ):
+        v.validate_python('a')
+
+    assert v.validate_python(MyEnum.a, strict=True) is MyEnum.a
+
+    e = (
+        'Input should be an instance of test_str_enum.<locals>.MyEnum '
+        "[type=is_instance_of, input_value='x', input_type=str]"
+    )
+    with pytest.raises(ValidationError, match=re.escape(e)):
+        v.validate_python('x', strict=True)
+    assert v.validate_json('"x"', strict=True) is MyEnum.a
+
+
+def test_float_enum():
+    class MyEnum(float, Enum):
+        a = 1.5
+        b = 2.5
+        c = 3.0
+
+    v = SchemaValidator(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), sub_type='float'))
+
+    # debug(v)
+    assert v.validate_python(MyEnum.a) is MyEnum.a
+    assert v.validate_python(1.5) is MyEnum.a
+    assert v.validate_python('1.5') is MyEnum.a
+    assert v.validate_python(3) is MyEnum.c
+
+    assert v.validate_json('1.5') is MyEnum.a
+    assert v.validate_json('"1.5"') is MyEnum.a
+
+    e = r'Input should be 1.5, 2.5 or 3.0 \[type=enum, input_value=4.0, input_type=float\]'
+    with pytest.raises(ValidationError, match=e):
+        v.validate_python(4.0)
+
+    assert v.validate_python(MyEnum.a, strict=True) is MyEnum.a
+
+    e = (
+        'Input should be an instance of test_float_enum.<locals>.MyEnum '
+        '[type=is_instance_of, input_value=1.5, input_type=float]'
+    )
+    with pytest.raises(ValidationError, match=re.escape(e)):
+        v.validate_python(1.5, strict=True)
+
+    assert v.validate_json('1.5', strict=True) is MyEnum.a
+
+    with pytest.raises(ValidationError, match='type=enum'):
+        v.validate_json('"3.0"', strict=True)
+
+
+def test_enum_missing():
+    class MyEnum(Enum):
+        a = 1
+        b = 2
+
+        @classmethod
+        def _missing_(cls, v):
+            return cls.b
+
+    assert MyEnum(1) is MyEnum.a
+    assert MyEnum(2) is MyEnum.b
+    assert MyEnum(3) is MyEnum.b
+
+    v = SchemaValidator(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), missing=MyEnum._missing_))
+
+    # debug(v)
+    assert v.validate_python(MyEnum.a) is MyEnum.a
+    assert v.validate_python(1) is MyEnum.a
+    assert v.validate_python(2) is MyEnum.b
+    assert v.validate_python(3) is MyEnum.b
+
+    assert v.validate_json('1') is MyEnum.a
+    assert v.validate_json('3') is MyEnum.b
+
+
+def test_enum_missing_none():
+    class MyEnum(Enum):
+        a = 1
+        b = 2
+
+        @classmethod
+        def _missing_(cls, v):
+            return None
+
+    assert MyEnum(1) is MyEnum.a
+    assert MyEnum(2) is MyEnum.b
+    with pytest.raises(ValueError, match='3 is not a valid'):
+        MyEnum(3)
+
+    v = SchemaValidator(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), missing=MyEnum._missing_))
+
+    # debug(v)
+    assert v.validate_python(MyEnum.a) is MyEnum.a
+    assert v.validate_python(1) is MyEnum.a
+    with pytest.raises(ValidationError, match=r'Input should be 1 or 2 \[type=enum, input_value=3, input_type=int\]'):
+        v.validate_python(3)
+
+    assert v.validate_json('1') is MyEnum.a
+    with pytest.raises(ValidationError, match=r'Input should be 1 or 2 \[type=enum, input_value=3, input_type=int\]'):
+        v.validate_json('3')
+
+
+def test_enum_missing_wrong():
+    class MyEnum(Enum):
+        a = 1
+        b = 2
+
+        @classmethod
+        def _missing_(cls, v):
+            return 'foobar'
+
+    assert MyEnum(1) is MyEnum.a
+    assert MyEnum(2) is MyEnum.b
+    # different error from pypy
+    if sys.implementation.name == 'pypy':
+        e = "returned 'foobar' instead of None or a valid member"
+    else:
+        e = "error in MyEnum._missing_: returned 'foobar' instead of None or a valid member"
+    with pytest.raises(TypeError, match=e):
+        MyEnum(3)
+
+    v = SchemaValidator(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), missing=MyEnum._missing_))
+    with pytest.raises(TypeError, match=e):
+        v.validate_python(3)
+
+
+def test_enum_exactness():
+    class MyEnum(int, Enum):
+        a = 1
+        b = 2
+
+    v = SchemaValidator(
+        core_schema.union_schema(
+            [
+                core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values()), missing=MyEnum._missing_),
+                core_schema.int_schema(),
+            ],
+        )
+    )
+    assert v.validate_python(MyEnum.a) is MyEnum.a
+    assert v.validate_python(1) == 1
+    assert v.validate_python(1) is not MyEnum.a
+
+
+def test_plain_enum_lists():
+    class MyEnum(Enum):
+        a = [1]
+        b = [2]
+
+    assert MyEnum([1]) is MyEnum.a
+    v = SchemaValidator(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values())))
+    assert v.validate_python(MyEnum.a) is MyEnum.a
+    assert v.validate_python([1]) is MyEnum.a
+    assert v.validate_python([2]) is MyEnum.b
+
+
+def test_plain_enum_empty():
+    class MyEnum(Enum):
+        pass
+
+    with pytest.raises(SchemaError, match='`members` should have length > 0'):
+        SchemaValidator(core_schema.enum_schema(MyEnum, []))

From 3d2e53ee8484b7ebb3f99b37932703e356a91da7 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Wed, 20 Mar 2024 18:56:46 +0000
Subject: [PATCH 240/550] remaining associated types (#1238)

---
 src/input/input_abstract.rs |  81 +++++-----
 src/input/input_json.rs     |  78 +++++-----
 src/input/input_python.rs   | 297 +++++++++++++++++-------------------
 src/input/input_string.rs   |  18 +--
 src/input/mod.rs            |   6 +-
 src/input/return_enums.rs   | 252 +-----------------------------
 src/validators/frozenset.rs |  51 +++++--
 src/validators/set.rs       |  49 ++++--
 src/validators/tuple.rs     | 135 ++++++++--------
 9 files changed, 384 insertions(+), 583 deletions(-)

diff --git a/src/input/input_abstract.rs b/src/input/input_abstract.rs
index 38237cc05..a5ae2a6be 100644
--- a/src/input/input_abstract.rs
+++ b/src/input/input_abstract.rs
@@ -11,7 +11,7 @@ use crate::{PyMultiHostUrl, PyUrl};
 
 use super::datetime::{EitherDate, EitherDateTime, EitherTime, EitherTimedelta};
 use super::return_enums::{EitherBytes, EitherInt, EitherString};
-use super::{EitherFloat, GenericIterable, GenericIterator, ValidationMatch};
+use super::{EitherFloat, GenericIterator, ValidationMatch};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
 pub enum InputType {
@@ -166,46 +166,19 @@ pub trait Input<'py>: fmt::Debug + ToPyObject {
 
     fn validate_list(&self, strict: bool) -> ValMatch<Self::List<'_>>;
 
-    fn validate_tuple<'a>(&'a self, strict: bool) -> ValResult<GenericIterable<'a, 'py>> {
-        if strict {
-            self.strict_tuple()
-        } else {
-            self.lax_tuple()
-        }
-    }
-    fn strict_tuple<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>>;
-    #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn lax_tuple<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
-        self.strict_tuple()
-    }
+    type Tuple<'a>: ValidatedTuple<'py>
+    where
+        Self: 'a;
 
-    fn validate_set<'a>(&'a self, strict: bool) -> ValResult<GenericIterable<'a, 'py>> {
-        if strict {
-            self.strict_set()
-        } else {
-            self.lax_set()
-        }
-    }
-    fn strict_set<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>>;
-    #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn lax_set<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
-        self.strict_set()
-    }
+    fn validate_tuple(&self, strict: bool) -> ValMatch<Self::Tuple<'_>>;
 
-    fn validate_frozenset<'a>(&'a self, strict: bool) -> ValResult<GenericIterable<'a, 'py>> {
-        if strict {
-            self.strict_frozenset()
-        } else {
-            self.lax_frozenset()
-        }
-    }
-    fn strict_frozenset<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>>;
-    #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn lax_frozenset<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
-        self.strict_frozenset()
-    }
+    type Set<'a>: ValidatedSet<'py>
+    where
+        Self: 'a;
+
+    fn validate_set(&self, strict: bool) -> ValMatch<Self::Set<'_>>;
 
-    fn extract_generic_iterable<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>>;
+    fn validate_frozenset(&self, strict: bool) -> ValMatch<Self::Set<'_>>;
 
     fn validate_iter(&self) -> ValResult<GenericIterator>;
 
@@ -303,7 +276,7 @@ pub trait ValidatedDict<'py> {
     ) -> ValResult<R>;
 }
 
-// Optimization pathway for inputs which are already python lists
+/// For validations from a list
 pub trait ValidatedList<'py> {
     type Item: BorrowInput<'py>;
     fn len(&self) -> Option<usize>;
@@ -311,6 +284,19 @@ pub trait ValidatedList<'py> {
     fn iterate<R>(self, consumer: impl ConsumeIterator<PyResult<Self::Item>, Output = R>) -> ValResult<R>;
 }
 
+/// For validations from a tuple
+pub trait ValidatedTuple<'py> {
+    type Item: BorrowInput<'py>;
+    fn len(&self) -> Option<usize>;
+    fn iterate<R>(self, consumer: impl ConsumeIterator<PyResult<Self::Item>, Output = R>) -> ValResult<R>;
+}
+
+/// For validations from a set
+pub trait ValidatedSet<'py> {
+    type Item: BorrowInput<'py>;
+    fn iterate<R>(self, consumer: impl ConsumeIterator<PyResult<Self::Item>, Output = R>) -> ValResult<R>;
+}
+
 /// This type is used for inputs which don't support certain types.
 /// It implements all the associated traits, but never actually gets called.
 
@@ -346,6 +332,23 @@ impl<'py> ValidatedList<'py> for Never {
     }
 }
 
+impl<'py> ValidatedTuple<'py> for Never {
+    type Item = Bound<'py, PyAny>;
+    fn len(&self) -> Option<usize> {
+        unreachable!()
+    }
+    fn iterate<R>(self, _consumer: impl ConsumeIterator<PyResult<Self::Item>, Output = R>) -> ValResult<R> {
+        unreachable!()
+    }
+}
+
+impl<'py> ValidatedSet<'py> for Never {
+    type Item = Bound<'py, PyAny>;
+    fn iterate<R>(self, _consumer: impl ConsumeIterator<PyResult<Self::Item>, Output = R>) -> ValResult<R> {
+        unreachable!()
+    }
+}
+
 impl Arguments<'_> for Never {
     type Args = Never;
     type Kwargs = Never;
diff --git a/src/input/input_json.rs b/src/input/input_json.rs
index 33c93f885..1a79f1ea6 100644
--- a/src/input/input_json.rs
+++ b/src/input/input_json.rs
@@ -19,8 +19,8 @@ use super::input_abstract::{ConsumeIterator, Never, ValMatch};
 use super::return_enums::ValidationMatch;
 use super::shared::{float_as_int, int_as_bool, str_as_bool, str_as_float, str_as_int};
 use super::{
-    Arguments, BorrowInput, EitherBytes, EitherFloat, EitherInt, EitherString, EitherTimedelta, GenericIterable,
-    GenericIterator, Input, KeywordArgs, PositionalArgs, ValidatedDict, ValidatedList,
+    Arguments, BorrowInput, EitherBytes, EitherFloat, EitherInt, EitherString, EitherTimedelta, GenericIterator, Input,
+    KeywordArgs, PositionalArgs, ValidatedDict, ValidatedList, ValidatedSet, ValidatedTuple,
 };
 
 /// This is required but since JSON object keys are always strings, I don't think it can be called
@@ -185,55 +185,38 @@ impl<'py> Input<'py> for JsonValue {
 
     fn validate_list(&self, _strict: bool) -> ValMatch<&JsonArray> {
         match self {
-            JsonValue::Array(a) => Ok(ValidationMatch::strict(a)),
+            JsonValue::Array(a) => Ok(ValidationMatch::exact(a)),
             _ => Err(ValError::new(ErrorTypeDefaults::ListType, self)),
         }
     }
 
-    fn validate_tuple<'a>(&'a self, _strict: bool) -> ValResult<GenericIterable<'a, 'py>> {
+    type Tuple<'a> = &'a JsonArray;
+
+    fn validate_tuple(&self, _strict: bool) -> ValMatch<&JsonArray> {
         // just as in set's case, List has to be allowed
         match self {
-            JsonValue::Array(a) => Ok(GenericIterable::JsonArray(a)),
+            JsonValue::Array(a) => Ok(ValidationMatch::strict(a)),
             _ => Err(ValError::new(ErrorTypeDefaults::TupleType, self)),
         }
     }
-    #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn strict_tuple<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
-        self.validate_tuple(false)
-    }
 
-    fn validate_set<'a>(&'a self, _strict: bool) -> ValResult<GenericIterable<'a, 'py>> {
+    type Set<'a> = &'a JsonArray;
+
+    fn validate_set(&self, _strict: bool) -> ValMatch<&JsonArray> {
         // we allow a list here since otherwise it would be impossible to create a set from JSON
         match self {
-            JsonValue::Array(a) => Ok(GenericIterable::JsonArray(a)),
+            JsonValue::Array(a) => Ok(ValidationMatch::strict(a)),
             _ => Err(ValError::new(ErrorTypeDefaults::SetType, self)),
         }
     }
-    #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn strict_set<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
-        self.validate_set(false)
-    }
 
-    fn validate_frozenset<'a>(&'a self, _strict: bool) -> ValResult<GenericIterable<'a, 'py>> {
+    fn validate_frozenset(&self, _strict: bool) -> ValMatch<&JsonArray> {
         // we allow a list here since otherwise it would be impossible to create a frozenset from JSON
         match self {
-            JsonValue::Array(a) => Ok(GenericIterable::JsonArray(a)),
+            JsonValue::Array(a) => Ok(ValidationMatch::strict(a)),
             _ => Err(ValError::new(ErrorTypeDefaults::FrozenSetType, self)),
         }
     }
-    #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn strict_frozenset<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
-        self.validate_frozenset(false)
-    }
-
-    fn extract_generic_iterable(&self) -> ValResult<GenericIterable<'_, 'py>> {
-        match self {
-            JsonValue::Array(a) => Ok(GenericIterable::JsonArray(a)),
-            JsonValue::Str(s) => Ok(GenericIterable::JsonString(s)),
-            JsonValue::Object(object) => Ok(GenericIterable::JsonObject(object)),
-            _ => Err(ValError::new(ErrorTypeDefaults::IterableType, self)),
-        }
-    }
 
     fn validate_iter(&self) -> ValResult<GenericIterator> {
         match self {
@@ -392,23 +375,23 @@ impl<'py> Input<'py> for str {
         Err(ValError::new(ErrorTypeDefaults::ListType, self))
     }
 
+    type Tuple<'a> = Never;
+
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn strict_tuple<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
+    fn validate_tuple(&self, _strict: bool) -> ValMatch<Never> {
         Err(ValError::new(ErrorTypeDefaults::TupleType, self))
     }
 
+    type Set<'a> = Never;
+
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn strict_set<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
+    fn validate_set(&self, _strict: bool) -> ValMatch<Never> {
         Err(ValError::new(ErrorTypeDefaults::SetType, self))
     }
 
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn strict_frozenset<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
-        Err(ValError::new(ErrorTypeDefaults::FrozenSetType, self))
-    }
-
-    fn extract_generic_iterable<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
-        Ok(GenericIterable::JsonString(self))
+    fn validate_frozenset(&self, _strict: bool) -> ValMatch<Never> {
+        Err(ValError::new(ErrorTypeDefaults::SetType, self))
     }
 
     fn validate_iter(&self) -> ValResult<GenericIterator> {
@@ -504,6 +487,25 @@ impl<'a, 'py> ValidatedList<'py> for &'a JsonArray {
     }
 }
 
+impl<'a, 'py> ValidatedTuple<'py> for &'a JsonArray {
+    type Item = &'a JsonValue;
+
+    fn len(&self) -> Option<usize> {
+        Some(SmallVec::len(self))
+    }
+    fn iterate<R>(self, consumer: impl ConsumeIterator<PyResult<Self::Item>, Output = R>) -> ValResult<R> {
+        Ok(consumer.consume_iterator(self.iter().map(Ok)))
+    }
+}
+
+impl<'a, 'py> ValidatedSet<'py> for &'a JsonArray {
+    type Item = &'a JsonValue;
+
+    fn iterate<R>(self, consumer: impl ConsumeIterator<PyResult<Self::Item>, Output = R>) -> ValResult<R> {
+        Ok(consumer.consume_iterator(self.iter().map(Ok)))
+    }
+}
+
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub struct JsonArgs<'a> {
     args: Option<&'a [JsonValue]>,
diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index 7acb09a8f..fe00ee1f9 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -6,10 +6,8 @@ use pyo3::prelude::*;
 
 use pyo3::types::{
     PyBool, PyByteArray, PyBytes, PyDate, PyDateTime, PyDict, PyFloat, PyFrozenSet, PyInt, PyIterator, PyList,
-    PyMapping, PySequence, PySet, PyString, PyTime, PyTuple, PyType,
+    PyMapping, PySet, PyString, PyTime, PyTuple, PyType,
 };
-#[cfg(not(PyPy))]
-use pyo3::types::{PyDictItems, PyDictKeys, PyDictValues};
 
 use speedate::MicrosecondsPrecisionOverflowBehavior;
 
@@ -34,71 +32,14 @@ use super::ConsumeIterator;
 use super::KeywordArgs;
 use super::PositionalArgs;
 use super::ValidatedDict;
+use super::ValidatedList;
+use super::ValidatedSet;
+use super::ValidatedTuple;
 use super::{
-    py_string_str, BorrowInput, EitherBytes, EitherFloat, EitherInt, EitherString, EitherTimedelta, GenericIterable,
-    GenericIterator, Input,
+    py_string_str, BorrowInput, EitherBytes, EitherFloat, EitherInt, EitherString, EitherTimedelta, GenericIterator,
+    Input,
 };
 
-#[cfg(not(PyPy))]
-macro_rules! extract_dict_keys {
-    ($py:expr, $obj:expr) => {
-        $obj.downcast::<PyDictKeys>()
-            .ok()
-            .map(|v| PyIterator::from_bound_object(v).unwrap())
-    };
-}
-
-#[cfg(PyPy)]
-macro_rules! extract_dict_keys {
-    ($py:expr, $obj:expr) => {
-        if is_dict_keys_type($obj) {
-            Some(PyIterator::from_bound_object($obj).unwrap())
-        } else {
-            None
-        }
-    };
-}
-
-#[cfg(not(PyPy))]
-macro_rules! extract_dict_values {
-    ($py:expr, $obj:expr) => {
-        $obj.downcast::<PyDictValues>()
-            .ok()
-            .map(|v| PyIterator::from_bound_object(v).unwrap())
-    };
-}
-
-#[cfg(PyPy)]
-macro_rules! extract_dict_values {
-    ($py:expr, $obj:expr) => {
-        if is_dict_values_type($obj) {
-            Some(PyIterator::from_bound_object($obj).unwrap())
-        } else {
-            None
-        }
-    };
-}
-
-#[cfg(not(PyPy))]
-macro_rules! extract_dict_items {
-    ($py:expr, $obj:expr) => {
-        $obj.downcast::<PyDictItems>()
-            .ok()
-            .map(|v| PyIterator::from_bound_object(v).unwrap())
-    };
-}
-
-#[cfg(PyPy)]
-macro_rules! extract_dict_items {
-    ($py:expr, $obj:expr) => {
-        if is_dict_items_type($obj) {
-            Some(PyIterator::from_bound_object($obj).unwrap())
-        } else {
-            None
-        }
-    };
-}
-
 impl From<&Bound<'_, PyAny>> for LocItem {
     fn from(py_any: &Bound<'_, PyAny>) -> Self {
         if let Ok(py_str) = py_any.downcast::<PyString>() {
@@ -480,120 +421,58 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
         }
     }
 
-    type List<'a> = GenericIterable<'a, 'py> where Self: 'a;
+    type List<'a> = PySequenceIterable<'a, 'py> where Self: 'a;
 
-    fn validate_list<'a>(&'a self, strict: bool) -> ValMatch<GenericIterable<'a, 'py>> {
+    fn validate_list<'a>(&'a self, strict: bool) -> ValMatch<PySequenceIterable<'a, 'py>> {
         if let Ok(list) = self.downcast::<PyList>() {
-            return Ok(ValidationMatch::exact(GenericIterable::List(list)));
+            return Ok(ValidationMatch::exact(PySequenceIterable::List(list)));
         } else if !strict {
-            match self.extract_generic_iterable() {
-                Ok(
-                    GenericIterable::PyString(_)
-                    | GenericIterable::Bytes(_)
-                    | GenericIterable::Dict(_)
-                    | GenericIterable::Mapping(_),
-                )
-                | Err(_) => {}
-                Ok(other) => return Ok(ValidationMatch::lax(other)),
+            if let Ok(other) = extract_sequence_iterable(self) {
+                return Ok(ValidationMatch::lax(other));
             }
         }
 
         Err(ValError::new(ErrorTypeDefaults::ListType, self))
     }
 
-    fn strict_tuple<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
-        match self.lax_tuple()? {
-            GenericIterable::Tuple(iter) => Ok(GenericIterable::Tuple(iter)),
-            _ => Err(ValError::new(ErrorTypeDefaults::TupleType, self)),
-        }
-    }
+    type Tuple<'a> = PySequenceIterable<'a, 'py> where Self: 'a;
 
-    fn lax_tuple<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
-        match self
-            .extract_generic_iterable()
-            .map_err(|_| ValError::new(ErrorTypeDefaults::TupleType, self))?
-        {
-            GenericIterable::PyString(_)
-            | GenericIterable::Bytes(_)
-            | GenericIterable::Dict(_)
-            | GenericIterable::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::TupleType, self)),
-            other => Ok(other),
+    fn validate_tuple<'a>(&'a self, strict: bool) -> ValMatch<PySequenceIterable<'a, 'py>> {
+        if let Ok(tup) = self.downcast::<PyTuple>() {
+            return Ok(ValidationMatch::exact(PySequenceIterable::Tuple(tup)));
+        } else if !strict {
+            if let Ok(other) = extract_sequence_iterable(self) {
+                return Ok(ValidationMatch::lax(other));
+            }
         }
-    }
 
-    fn strict_set<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
-        match self.lax_set()? {
-            GenericIterable::Set(iter) => Ok(GenericIterable::Set(iter)),
-            _ => Err(ValError::new(ErrorTypeDefaults::SetType, self)),
-        }
+        Err(ValError::new(ErrorTypeDefaults::TupleType, self))
     }
 
-    fn lax_set<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
-        match self
-            .extract_generic_iterable()
-            .map_err(|_| ValError::new(ErrorTypeDefaults::SetType, self))?
-        {
-            GenericIterable::PyString(_)
-            | GenericIterable::Bytes(_)
-            | GenericIterable::Dict(_)
-            | GenericIterable::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::SetType, self)),
-            other => Ok(other),
-        }
-    }
+    type Set<'a> = PySequenceIterable<'a, 'py> where Self: 'a;
 
-    fn strict_frozenset<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
-        match self.lax_frozenset()? {
-            GenericIterable::FrozenSet(iter) => Ok(GenericIterable::FrozenSet(iter)),
-            _ => Err(ValError::new(ErrorTypeDefaults::FrozenSetType, self)),
+    fn validate_set<'a>(&'a self, strict: bool) -> ValMatch<PySequenceIterable<'a, 'py>> {
+        if let Ok(set) = self.downcast::<PySet>() {
+            return Ok(ValidationMatch::exact(PySequenceIterable::Set(set)));
+        } else if !strict {
+            if let Ok(other) = extract_sequence_iterable(self) {
+                return Ok(ValidationMatch::lax(other));
+            }
         }
+
+        Err(ValError::new(ErrorTypeDefaults::SetType, self))
     }
 
-    fn lax_frozenset<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
-        match self
-            .extract_generic_iterable()
-            .map_err(|_| ValError::new(ErrorTypeDefaults::FrozenSetType, self))?
-        {
-            GenericIterable::PyString(_)
-            | GenericIterable::Bytes(_)
-            | GenericIterable::Dict(_)
-            | GenericIterable::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::FrozenSetType, self)),
-            other => Ok(other),
-        }
-    }
-
-    fn extract_generic_iterable<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
-        // Handle concrete non-overlapping types first, then abstract types
-        if let Ok(iterable) = self.downcast::<PyList>() {
-            Ok(GenericIterable::List(iterable))
-        } else if let Ok(iterable) = self.downcast::<PyTuple>() {
-            Ok(GenericIterable::Tuple(iterable))
-        } else if let Ok(iterable) = self.downcast::<PySet>() {
-            Ok(GenericIterable::Set(iterable))
-        } else if let Ok(iterable) = self.downcast::<PyFrozenSet>() {
-            Ok(GenericIterable::FrozenSet(iterable))
-        } else if let Ok(iterable) = self.downcast::<PyDict>() {
-            Ok(GenericIterable::Dict(iterable))
-        } else if let Some(iterable) = extract_dict_keys!(self.py(), self) {
-            Ok(GenericIterable::DictKeys(iterable))
-        } else if let Some(iterable) = extract_dict_values!(self.py(), self) {
-            Ok(GenericIterable::DictValues(iterable))
-        } else if let Some(iterable) = extract_dict_items!(self.py(), self) {
-            Ok(GenericIterable::DictItems(iterable))
-        } else if let Ok(iterable) = self.downcast::<PyMapping>() {
-            Ok(GenericIterable::Mapping(iterable))
-        } else if let Ok(iterable) = self.downcast::<PyString>() {
-            Ok(GenericIterable::PyString(iterable))
-        } else if let Ok(iterable) = self.downcast::<PyBytes>() {
-            Ok(GenericIterable::Bytes(iterable))
-        } else if let Ok(iterable) = self.downcast::<PyByteArray>() {
-            Ok(GenericIterable::PyByteArray(iterable))
-        } else if let Ok(iterable) = self.downcast::<PySequence>() {
-            Ok(GenericIterable::Sequence(iterable))
-        } else if let Ok(iterable) = self.iter() {
-            Ok(GenericIterable::Iterator(iterable))
-        } else {
-            Err(ValError::new(ErrorTypeDefaults::IterableType, self))
+    fn validate_frozenset<'a>(&'a self, strict: bool) -> ValMatch<PySequenceIterable<'a, 'py>> {
+        if let Ok(frozenset) = self.downcast::<PyFrozenSet>() {
+            return Ok(ValidationMatch::exact(PySequenceIterable::FrozenSet(frozenset)));
+        } else if !strict {
+            if let Ok(other) = extract_sequence_iterable(self) {
+                return Ok(ValidationMatch::lax(other));
+            }
         }
+
+        Err(ValError::new(ErrorTypeDefaults::FrozenSetType, self))
     }
 
     fn validate_iter(&self) -> ValResult<GenericIterator> {
@@ -969,3 +848,101 @@ impl<'py> ValidatedDict<'py> for GenericPyMapping<'_, 'py> {
         }
     }
 }
+
+/// Container for all the collections (sized iterable containers) types, which
+/// can mostly be converted to each other in lax mode.
+/// This mostly matches python's definition of `Collection`.
+pub enum PySequenceIterable<'a, 'py> {
+    List(&'a Bound<'py, PyList>),
+    Tuple(&'a Bound<'py, PyTuple>),
+    Set(&'a Bound<'py, PySet>),
+    FrozenSet(&'a Bound<'py, PyFrozenSet>),
+    Iterator(Bound<'py, PyIterator>),
+}
+
+/// Extract types which can be iterated to produce a sequence-like container like a list, tuple, set
+/// or frozenset
+fn extract_sequence_iterable<'a, 'py>(obj: &'a Bound<'py, PyAny>) -> ValResult<PySequenceIterable<'a, 'py>> {
+    // Handle concrete non-overlapping types first, then abstract types
+    if let Ok(iterable) = obj.downcast::<PyList>() {
+        Ok(PySequenceIterable::List(iterable))
+    } else if let Ok(iterable) = obj.downcast::<PyTuple>() {
+        Ok(PySequenceIterable::Tuple(iterable))
+    } else if let Ok(iterable) = obj.downcast::<PySet>() {
+        Ok(PySequenceIterable::Set(iterable))
+    } else if let Ok(iterable) = obj.downcast::<PyFrozenSet>() {
+        Ok(PySequenceIterable::FrozenSet(iterable))
+    } else {
+        // Try to get this as a generable iterable thing, but exclude string and mapping types
+        if !(obj.is_instance_of::<PyString>()
+            || obj.is_instance_of::<PyBytes>()
+            || obj.is_instance_of::<PyByteArray>()
+            || obj.is_instance_of::<PyDict>()
+            || obj.downcast::<PyMapping>().is_ok())
+        {
+            if let Ok(iter) = obj.iter() {
+                return Ok(PySequenceIterable::Iterator(iter));
+            }
+        }
+
+        Err(ValError::new(ErrorTypeDefaults::IterableType, obj))
+    }
+}
+
+impl<'py> PySequenceIterable<'_, 'py> {
+    pub fn generic_len(&self) -> Option<usize> {
+        match &self {
+            PySequenceIterable::List(iter) => Some(iter.len()),
+            PySequenceIterable::Tuple(iter) => Some(iter.len()),
+            PySequenceIterable::Set(iter) => Some(iter.len()),
+            PySequenceIterable::FrozenSet(iter) => Some(iter.len()),
+            PySequenceIterable::Iterator(iter) => iter.len().ok(),
+        }
+    }
+
+    fn generic_iterate<R>(
+        self,
+        consumer: impl ConsumeIterator<PyResult<Bound<'py, PyAny>>, Output = R>,
+    ) -> ValResult<R> {
+        match self {
+            PySequenceIterable::List(iter) => Ok(consumer.consume_iterator(iter.iter().map(Ok))),
+            PySequenceIterable::Tuple(iter) => Ok(consumer.consume_iterator(iter.iter().map(Ok))),
+            PySequenceIterable::Set(iter) => Ok(consumer.consume_iterator(iter.iter().map(Ok))),
+            PySequenceIterable::FrozenSet(iter) => Ok(consumer.consume_iterator(iter.iter().map(Ok))),
+            PySequenceIterable::Iterator(iter) => Ok(consumer.consume_iterator(iter.iter()?)),
+        }
+    }
+}
+
+impl<'py> ValidatedList<'py> for PySequenceIterable<'_, 'py> {
+    type Item = Bound<'py, PyAny>;
+    fn len(&self) -> Option<usize> {
+        self.generic_len()
+    }
+    fn iterate<R>(self, consumer: impl ConsumeIterator<PyResult<Self::Item>, Output = R>) -> ValResult<R> {
+        self.generic_iterate(consumer)
+    }
+    fn as_py_list(&self) -> Option<&Bound<'py, PyList>> {
+        match self {
+            PySequenceIterable::List(iter) => Some(iter),
+            _ => None,
+        }
+    }
+}
+
+impl<'py> ValidatedTuple<'py> for PySequenceIterable<'_, 'py> {
+    type Item = Bound<'py, PyAny>;
+    fn len(&self) -> Option<usize> {
+        self.generic_len()
+    }
+    fn iterate<R>(self, consumer: impl ConsumeIterator<PyResult<Self::Item>, Output = R>) -> ValResult<R> {
+        self.generic_iterate(consumer)
+    }
+}
+
+impl<'py> ValidatedSet<'py> for PySequenceIterable<'_, 'py> {
+    type Item = Bound<'py, PyAny>;
+    fn iterate<R>(self, consumer: impl ConsumeIterator<PyResult<Self::Item>, Output = R>) -> ValResult<R> {
+        self.generic_iterate(consumer)
+    }
+}
diff --git a/src/input/input_string.rs b/src/input/input_string.rs
index ca51acc67..520bbba61 100644
--- a/src/input/input_string.rs
+++ b/src/input/input_string.rs
@@ -15,8 +15,8 @@ use super::datetime::{
 use super::input_abstract::{Never, ValMatch};
 use super::shared::{str_as_bool, str_as_float, str_as_int};
 use super::{
-    Arguments, BorrowInput, EitherBytes, EitherFloat, EitherInt, EitherString, EitherTimedelta, GenericIterable,
-    GenericIterator, Input, KeywordArgs, ValidatedDict, ValidationMatch,
+    Arguments, BorrowInput, EitherBytes, EitherFloat, EitherInt, EitherString, EitherTimedelta, GenericIterator, Input,
+    KeywordArgs, ValidatedDict, ValidationMatch,
 };
 
 #[derive(Debug, Clone)]
@@ -155,22 +155,22 @@ impl<'py> Input<'py> for StringMapping<'py> {
         Err(ValError::new(ErrorTypeDefaults::ListType, self))
     }
 
-    fn strict_tuple<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
+    type Tuple<'a> = Never where Self: 'a;
+
+    fn validate_tuple(&self, _strict: bool) -> ValMatch<Never> {
         Err(ValError::new(ErrorTypeDefaults::TupleType, self))
     }
 
-    fn strict_set<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
+    type Set<'a> = Never where Self: 'a;
+
+    fn validate_set(&self, _strict: bool) -> ValMatch<Never> {
         Err(ValError::new(ErrorTypeDefaults::SetType, self))
     }
 
-    fn strict_frozenset<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
+    fn validate_frozenset(&self, _strict: bool) -> ValMatch<Never> {
         Err(ValError::new(ErrorTypeDefaults::FrozenSetType, self))
     }
 
-    fn extract_generic_iterable<'a>(&'a self) -> ValResult<GenericIterable<'a, 'py>> {
-        Err(ValError::new(ErrorTypeDefaults::IterableType, self))
-    }
-
     fn validate_iter(&self) -> ValResult<GenericIterator> {
         Err(ValError::new(ErrorTypeDefaults::IterableType, self))
     }
diff --git a/src/input/mod.rs b/src/input/mod.rs
index a42368a3d..5a2fdeb69 100644
--- a/src/input/mod.rs
+++ b/src/input/mod.rs
@@ -17,12 +17,12 @@ pub(crate) use datetime::{
 };
 pub(crate) use input_abstract::{
     Arguments, BorrowInput, ConsumeIterator, Input, InputType, KeywordArgs, PositionalArgs, ValidatedDict,
-    ValidatedList,
+    ValidatedList, ValidatedSet, ValidatedTuple,
 };
 pub(crate) use input_string::StringMapping;
 pub(crate) use return_enums::{
-    no_validator_iter_to_vec, py_string_str, validate_iter_to_vec, EitherBytes, EitherFloat, EitherInt, EitherString,
-    GenericIterable, GenericIterator, Int, MaxLengthCheck, ValidationMatch,
+    no_validator_iter_to_vec, py_string_str, validate_iter_to_set, validate_iter_to_vec, EitherBytes, EitherFloat,
+    EitherInt, EitherString, GenericIterator, Int, MaxLengthCheck, ValidationMatch,
 };
 
 // Defined here as it's not exported by pyo3
diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index e01379b11..b4a699735 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -3,7 +3,7 @@ use std::cmp::Ordering;
 use std::ops::Rem;
 use std::str::FromStr;
 
-use jiter::{JsonArray, JsonObject, JsonValue};
+use jiter::{JsonArray, JsonValue};
 use num_bigint::BigInt;
 
 use pyo3::exceptions::PyTypeError;
@@ -12,10 +12,7 @@ use pyo3::intern;
 use pyo3::prelude::*;
 #[cfg(not(PyPy))]
 use pyo3::types::PyFunction;
-use pyo3::types::{
-    PyByteArray, PyBytes, PyDict, PyFloat, PyFrozenSet, PyIterator, PyList, PyMapping, PySequence, PySet, PyString,
-    PyTuple,
-};
+use pyo3::types::{PyBytes, PyFloat, PyFrozenSet, PyIterator, PyMapping, PySet, PyString};
 
 use serde::{ser::Error, Serialize, Serializer};
 
@@ -25,7 +22,7 @@ use crate::errors::{
 use crate::tools::{extract_i64, py_err};
 use crate::validators::{CombinedValidator, Exactness, ValidationState, Validator};
 
-use super::{py_error_on_minusone, BorrowInput, ConsumeIterator, Input, ValidatedList};
+use super::{py_error_on_minusone, BorrowInput, Input};
 
 pub struct ValidationMatch<T>(T, Exactness);
 
@@ -60,89 +57,6 @@ impl<T> ValidationMatch<T> {
     }
 }
 
-/// Container for all the collections (sized iterable containers) types, which
-/// can mostly be converted to each other in lax mode.
-/// This mostly matches python's definition of `Collection`.
-#[cfg_attr(debug_assertions, derive(Debug))]
-pub enum GenericIterable<'a, 'py> {
-    List(&'a Bound<'py, PyList>),
-    Tuple(&'a Bound<'py, PyTuple>),
-    Set(&'a Bound<'py, PySet>),
-    FrozenSet(&'a Bound<'py, PyFrozenSet>),
-    Dict(&'a Bound<'py, PyDict>),
-    // Treat dict values / keys / items as generic iterators
-    // since PyPy doesn't export the concrete types
-    DictKeys(Bound<'py, PyIterator>),
-    DictValues(Bound<'py, PyIterator>),
-    DictItems(Bound<'py, PyIterator>),
-    Mapping(&'a Bound<'py, PyMapping>),
-    PyString(&'a Bound<'py, PyString>),
-    Bytes(&'a Bound<'py, PyBytes>),
-    PyByteArray(&'a Bound<'py, PyByteArray>),
-    Sequence(&'a Bound<'py, PySequence>),
-    Iterator(Bound<'py, PyIterator>),
-    JsonArray(&'a [JsonValue]),
-    JsonObject(&'a JsonObject),
-    JsonString(&'a str),
-}
-
-impl<'py> GenericIterable<'_, 'py> {
-    pub fn as_sequence_iterator(
-        &self,
-        py: Python<'py>,
-    ) -> PyResult<Box<dyn Iterator<Item = PyResult<Bound<'py, PyAny>>> + '_>> {
-        match self {
-            GenericIterable::List(iter) => Ok(Box::new(iter.iter().map(Ok))),
-            GenericIterable::Tuple(iter) => Ok(Box::new(iter.iter().map(Ok))),
-            GenericIterable::Set(iter) => Ok(Box::new(iter.iter().map(Ok))),
-            GenericIterable::FrozenSet(iter) => Ok(Box::new(iter.iter().map(Ok))),
-            // Note that this iterates over only the keys, just like doing iter({}) in Python
-            GenericIterable::Dict(iter) => Ok(Box::new(iter.iter().map(|(k, _)| Ok(k)))),
-            GenericIterable::DictKeys(iter) => Ok(Box::new(iter.iter()?)),
-            GenericIterable::DictValues(iter) => Ok(Box::new(iter.iter()?)),
-            GenericIterable::DictItems(iter) => Ok(Box::new(iter.iter()?)),
-            // Note that this iterates over only the keys, just like doing iter({}) in Python
-            GenericIterable::Mapping(iter) => Ok(Box::new(iter.keys()?.iter()?)),
-            GenericIterable::PyString(iter) => Ok(Box::new(iter.iter()?)),
-            GenericIterable::Bytes(iter) => Ok(Box::new(iter.iter()?)),
-            GenericIterable::PyByteArray(iter) => Ok(Box::new(iter.iter()?)),
-            GenericIterable::Sequence(iter) => Ok(Box::new(iter.iter()?)),
-            GenericIterable::Iterator(iter) => Ok(Box::new(iter.iter()?)),
-            GenericIterable::JsonArray(iter) => Ok(Box::new(iter.iter().map(move |v| {
-                let v = v.to_object(py).into_bound(py);
-                Ok(v)
-            }))),
-            // Note that this iterates over only the keys, just like doing iter({}) in Python, just for consistency
-            GenericIterable::JsonObject(iter) => Ok(Box::new(
-                iter.iter().map(move |(k, _)| Ok(k.to_object(py).into_bound(py))),
-            )),
-            GenericIterable::JsonString(s) => Ok(Box::new(PyString::new_bound(py, s).iter()?)),
-        }
-    }
-
-    pub fn as_sequence_iterator_py(&self) -> PyResult<Box<dyn Iterator<Item = PyResult<Bound<'py, PyAny>>> + '_>> {
-        match self {
-            GenericIterable::List(iter) => Ok(Box::new(iter.iter().map(Ok))),
-            GenericIterable::Tuple(iter) => Ok(Box::new(iter.iter().map(Ok))),
-            GenericIterable::Set(iter) => Ok(Box::new(iter.iter().map(Ok))),
-            GenericIterable::FrozenSet(iter) => Ok(Box::new(iter.iter().map(Ok))),
-            // Note that this iterates over only the keys, just like doing iter({}) in Python
-            GenericIterable::Dict(iter) => Ok(Box::new(iter.iter().map(|(k, _)| Ok(k)))),
-            GenericIterable::DictKeys(iter) => Ok(Box::new(iter.iter()?)),
-            GenericIterable::DictValues(iter) => Ok(Box::new(iter.iter()?)),
-            GenericIterable::DictItems(iter) => Ok(Box::new(iter.iter()?)),
-            // Note that this iterates over only the keys, just like doing iter({}) in Python
-            GenericIterable::Mapping(iter) => Ok(Box::new(iter.keys()?.iter()?)),
-            GenericIterable::PyString(iter) => Ok(Box::new(iter.iter()?)),
-            GenericIterable::Bytes(iter) => Ok(Box::new(iter.iter()?)),
-            GenericIterable::PyByteArray(iter) => Ok(Box::new(iter.iter()?)),
-            GenericIterable::Sequence(iter) => Ok(Box::new(iter.iter()?)),
-            GenericIterable::Iterator(iter) => Ok(Box::new(iter.iter()?)),
-            _ => unreachable!(),
-        }
-    }
-}
-
 pub struct MaxLengthCheck<'a, INPUT: ?Sized> {
     current_length: usize,
     max_length: Option<usize>,
@@ -266,7 +180,7 @@ impl BuildSet for Bound<'_, PyFrozenSet> {
 }
 
 #[allow(clippy::too_many_arguments)]
-fn validate_iter_to_set<'py>(
+pub(crate) fn validate_iter_to_set<'py>(
     py: Python<'py>,
     set: &impl BuildSet,
     iter: impl Iterator<Item = PyResult<impl BorrowInput<'py>>>,
@@ -329,164 +243,6 @@ pub(crate) fn no_validator_iter_to_vec<'py>(
         .collect()
 }
 
-// pretty arbitrary default capacity when creating vecs from iteration
-static DEFAULT_CAPACITY: usize = 10;
-
-impl<'py> GenericIterable<'_, 'py> {
-    pub fn generic_len(&self) -> Option<usize> {
-        match &self {
-            GenericIterable::List(iter) => Some(iter.len()),
-            GenericIterable::Tuple(iter) => Some(iter.len()),
-            GenericIterable::Set(iter) => Some(iter.len()),
-            GenericIterable::FrozenSet(iter) => Some(iter.len()),
-            GenericIterable::Dict(iter) => Some(iter.len()),
-            GenericIterable::DictKeys(iter) => iter.len().ok(),
-            GenericIterable::DictValues(iter) => iter.len().ok(),
-            GenericIterable::DictItems(iter) => iter.len().ok(),
-            GenericIterable::Mapping(iter) => iter.len().ok(),
-            GenericIterable::PyString(iter) => iter.len().ok(),
-            GenericIterable::Bytes(iter) => iter.len().ok(),
-            GenericIterable::PyByteArray(iter) => Some(iter.len()),
-            GenericIterable::Sequence(iter) => iter.len().ok(),
-            GenericIterable::Iterator(iter) => iter.len().ok(),
-            GenericIterable::JsonArray(iter) => Some(iter.len()),
-            GenericIterable::JsonObject(iter) => Some(iter.len()),
-            GenericIterable::JsonString(iter) => Some(iter.len()),
-        }
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    pub fn validate_to_vec(
-        &self,
-        py: Python<'py>,
-        input: &(impl Input<'py> + ?Sized),
-        max_length: Option<usize>,
-        field_type: &'static str,
-        validator: &CombinedValidator,
-        state: &mut ValidationState<'_, 'py>,
-    ) -> ValResult<Vec<PyObject>> {
-        let actual_length = self.generic_len();
-        let capacity = actual_length.unwrap_or(DEFAULT_CAPACITY);
-        let max_length_check = MaxLengthCheck::new(max_length, field_type, input, actual_length);
-
-        macro_rules! validate {
-            ($iter:expr) => {
-                validate_iter_to_vec(py, $iter, capacity, max_length_check, validator, state)
-            };
-        }
-
-        match self {
-            GenericIterable::List(collection) => validate!(collection.iter().map(Ok)),
-            GenericIterable::Tuple(collection) => validate!(collection.iter().map(Ok)),
-            GenericIterable::Set(collection) => validate!(collection.iter().map(Ok)),
-            GenericIterable::FrozenSet(collection) => validate!(collection.iter().map(Ok)),
-            GenericIterable::Sequence(collection) => validate!(collection.iter()?),
-            GenericIterable::Iterator(collection) => validate!(collection.iter()?),
-            GenericIterable::JsonArray(collection) => validate!(collection.iter().map(Ok)),
-            other => validate!(other.as_sequence_iterator(py)?),
-        }
-    }
-
-    #[allow(clippy::too_many_arguments)]
-    pub fn validate_to_set(
-        &self,
-        py: Python<'py>,
-        set: &impl BuildSet,
-        input: &(impl Input<'py> + ?Sized),
-        max_length: Option<usize>,
-        field_type: &'static str,
-        validator: &CombinedValidator,
-        state: &mut ValidationState<'_, 'py>,
-    ) -> ValResult<()> {
-        macro_rules! validate_set {
-            ($iter:expr) => {
-                validate_iter_to_set(py, set, $iter, input, field_type, max_length, validator, state)
-            };
-        }
-
-        match self {
-            GenericIterable::List(collection) => validate_set!(collection.iter().map(Ok)),
-            GenericIterable::Tuple(collection) => validate_set!(collection.iter().map(Ok)),
-            GenericIterable::Set(collection) => validate_set!(collection.iter().map(Ok)),
-            GenericIterable::FrozenSet(collection) => validate_set!(collection.iter().map(Ok)),
-            GenericIterable::Sequence(collection) => validate_set!(collection.iter()?),
-            GenericIterable::Iterator(collection) => validate_set!(collection.iter()?),
-            GenericIterable::JsonArray(collection) => validate_set!(collection.iter().map(Ok)),
-            other => validate_set!(other.as_sequence_iterator(py)?),
-        }
-    }
-
-    pub fn to_vec(
-        &self,
-        py: Python<'py>,
-        input: &(impl Input<'py> + ?Sized),
-        field_type: &'static str,
-        max_length: Option<usize>,
-    ) -> ValResult<Vec<PyObject>> {
-        let actual_length = self.generic_len();
-        let max_length_check = MaxLengthCheck::new(max_length, field_type, input, actual_length);
-
-        match self {
-            GenericIterable::List(collection) => {
-                no_validator_iter_to_vec(py, input, collection.iter().map(Ok), max_length_check)
-            }
-            GenericIterable::Tuple(collection) => {
-                no_validator_iter_to_vec(py, input, collection.iter().map(Ok), max_length_check)
-            }
-            GenericIterable::Set(collection) => {
-                no_validator_iter_to_vec(py, input, collection.iter().map(Ok), max_length_check)
-            }
-            GenericIterable::FrozenSet(collection) => {
-                no_validator_iter_to_vec(py, input, collection.iter().map(Ok), max_length_check)
-            }
-            GenericIterable::Sequence(collection) => {
-                no_validator_iter_to_vec(py, input, collection.iter()?, max_length_check)
-            }
-            GenericIterable::Iterator(collection) => {
-                no_validator_iter_to_vec(py, input, collection.iter()?, max_length_check)
-            }
-            GenericIterable::JsonArray(collection) => {
-                no_validator_iter_to_vec(py, input, collection.iter().map(Ok), max_length_check)
-            }
-            other => no_validator_iter_to_vec(py, input, other.as_sequence_iterator(py)?, max_length_check),
-        }
-    }
-}
-
-impl<'py> ValidatedList<'py> for GenericIterable<'_, 'py> {
-    type Item = Bound<'py, PyAny>;
-    fn len(&self) -> Option<usize> {
-        self.generic_len()
-    }
-    fn iterate<R>(self, consumer: impl ConsumeIterator<PyResult<Self::Item>, Output = R>) -> ValResult<R> {
-        match self {
-            GenericIterable::List(iter) => Ok(consumer.consume_iterator(iter.iter().map(Ok))),
-            GenericIterable::Tuple(iter) => Ok(consumer.consume_iterator(iter.iter().map(Ok))),
-            GenericIterable::Set(iter) => Ok(consumer.consume_iterator(iter.iter().map(Ok))),
-            GenericIterable::FrozenSet(iter) => Ok(consumer.consume_iterator(iter.iter().map(Ok))),
-            // Note that this iterates over only the keys, just like doing iter({}) in Python
-            GenericIterable::Dict(iter) => Ok(consumer.consume_iterator(iter.iter().map(|(k, _)| Ok(k)))),
-            GenericIterable::DictKeys(iter) => Ok(consumer.consume_iterator(iter.iter()?)),
-            GenericIterable::DictValues(iter) => Ok(consumer.consume_iterator(iter.iter()?)),
-            GenericIterable::DictItems(iter) => Ok(consumer.consume_iterator(iter.iter()?)),
-            // Note that this iterates over only the keys, just like doing iter({}) in Python
-            GenericIterable::Mapping(iter) => Ok(consumer.consume_iterator(iter.keys()?.iter()?)),
-            GenericIterable::PyString(iter) => Ok(consumer.consume_iterator(iter.iter()?)),
-            GenericIterable::Bytes(iter) => Ok(consumer.consume_iterator(iter.iter()?)),
-            GenericIterable::PyByteArray(iter) => Ok(consumer.consume_iterator(iter.iter()?)),
-            GenericIterable::Sequence(iter) => Ok(consumer.consume_iterator(iter.iter()?)),
-            GenericIterable::Iterator(iter) => Ok(consumer.consume_iterator(iter.iter()?)),
-            _ => unreachable!(),
-        }
-    }
-    fn as_py_list(&self) -> Option<&Bound<'py, PyList>> {
-        match self {
-            GenericIterable::List(iter) => Some(iter),
-            _ => None,
-        }
-    }
-}
-
 pub(crate) fn iterate_mapping_items<'a, 'py>(
     mapping: &'a Bound<'py, PyMapping>,
 ) -> ValResult<impl Iterator<Item = ValResult<(Bound<'py, PyAny>, Bound<'py, PyAny>)>> + 'a> {
diff --git a/src/validators/frozenset.rs b/src/validators/frozenset.rs
index b6b395630..fcb7ffe7c 100644
--- a/src/validators/frozenset.rs
+++ b/src/validators/frozenset.rs
@@ -2,9 +2,8 @@ use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyFrozenSet};
 
 use crate::errors::ValResult;
-use crate::input::{GenericIterable, Input};
+use crate::input::{validate_iter_to_set, BorrowInput, ConsumeIterator, Input, ValidatedSet};
 use crate::tools::SchemaDict;
-use crate::validators::Exactness;
 
 use super::list::min_length_check;
 use super::set::set_build;
@@ -34,23 +33,16 @@ impl Validator for FrozenSetValidator {
         input: &(impl Input<'py> + ?Sized),
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
-        let collection = input.validate_frozenset(state.strict_or(self.strict))?;
-        let exactness = match &collection {
-            GenericIterable::FrozenSet(_) => Exactness::Exact,
-            GenericIterable::Set(_) | GenericIterable::JsonArray(_) => Exactness::Strict,
-            _ => Exactness::Lax,
-        };
-        state.floor_exactness(exactness);
+        let collection = input.validate_frozenset(state.strict_or(self.strict))?.unpack(state);
         let f_set = PyFrozenSet::empty_bound(py)?;
-        collection.validate_to_set(
+        collection.iterate(ValidateToFrozenSet {
             py,
-            &f_set,
             input,
-            self.max_length,
-            "Frozenset",
-            &self.item_validator,
+            f_set: &f_set,
+            max_length: self.max_length,
+            item_validator: &self.item_validator,
             state,
-        )?;
+        })??;
         min_length_check!(input, "Frozenset", self.min_length, f_set);
         Ok(f_set.into_py(py))
     }
@@ -59,3 +51,32 @@ impl Validator for FrozenSetValidator {
         &self.name
     }
 }
+
+struct ValidateToFrozenSet<'a, 's, 'py, I: Input<'py> + ?Sized> {
+    py: Python<'py>,
+    input: &'a I,
+    f_set: &'a Bound<'py, PyFrozenSet>,
+    max_length: Option<usize>,
+    item_validator: &'a CombinedValidator,
+    state: &'a mut ValidationState<'s, 'py>,
+}
+
+impl<'py, T, I> ConsumeIterator<PyResult<T>> for ValidateToFrozenSet<'_, '_, 'py, I>
+where
+    T: BorrowInput<'py>,
+    I: Input<'py> + ?Sized,
+{
+    type Output = ValResult<()>;
+    fn consume_iterator(self, iterator: impl Iterator<Item = PyResult<T>>) -> ValResult<()> {
+        validate_iter_to_set(
+            self.py,
+            self.f_set,
+            iterator,
+            self.input,
+            "Frozenset",
+            self.max_length,
+            self.item_validator,
+            self.state,
+        )
+    }
+}
diff --git a/src/validators/set.rs b/src/validators/set.rs
index 727d1a01f..3ebd2e40b 100644
--- a/src/validators/set.rs
+++ b/src/validators/set.rs
@@ -2,9 +2,8 @@ use pyo3::prelude::*;
 use pyo3::types::{PyDict, PySet};
 
 use crate::errors::ValResult;
-use crate::input::{GenericIterable, Input};
+use crate::input::{validate_iter_to_set, BorrowInput, ConsumeIterator, Input, ValidatedSet};
 use crate::tools::SchemaDict;
-use crate::validators::Exactness;
 
 use super::list::min_length_check;
 use super::{BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
@@ -64,15 +63,16 @@ impl Validator for SetValidator {
         input: &(impl Input<'py> + ?Sized),
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
-        let collection = input.validate_set(state.strict_or(self.strict))?;
-        let exactness = match &collection {
-            GenericIterable::Set(_) => Exactness::Exact,
-            GenericIterable::FrozenSet(_) | GenericIterable::JsonArray(_) => Exactness::Strict,
-            _ => Exactness::Lax,
-        };
-        state.floor_exactness(exactness);
+        let collection = input.validate_set(state.strict_or(self.strict))?.unpack(state);
         let set = PySet::empty_bound(py)?;
-        collection.validate_to_set(py, &set, input, self.max_length, "Set", &self.item_validator, state)?;
+        collection.iterate(ValidateToSet {
+            py,
+            input,
+            set: &set,
+            max_length: self.max_length,
+            item_validator: &self.item_validator,
+            state,
+        })??;
         min_length_check!(input, "Set", self.min_length, set);
         Ok(set.into_py(py))
     }
@@ -81,3 +81,32 @@ impl Validator for SetValidator {
         &self.name
     }
 }
+
+struct ValidateToSet<'a, 's, 'py, I: Input<'py> + ?Sized> {
+    py: Python<'py>,
+    input: &'a I,
+    set: &'a Bound<'py, PySet>,
+    max_length: Option<usize>,
+    item_validator: &'a CombinedValidator,
+    state: &'a mut ValidationState<'s, 'py>,
+}
+
+impl<'py, T, I> ConsumeIterator<PyResult<T>> for ValidateToSet<'_, '_, 'py, I>
+where
+    T: BorrowInput<'py>,
+    I: Input<'py> + ?Sized,
+{
+    type Output = ValResult<()>;
+    fn consume_iterator(self, iterator: impl Iterator<Item = PyResult<T>>) -> ValResult<()> {
+        validate_iter_to_set(
+            self.py,
+            self.set,
+            iterator,
+            self.input,
+            "Set",
+            self.max_length,
+            self.item_validator,
+            self.state,
+        )
+    }
+}
diff --git a/src/validators/tuple.rs b/src/validators/tuple.rs
index 601e591b3..3c5adb186 100644
--- a/src/validators/tuple.rs
+++ b/src/validators/tuple.rs
@@ -5,10 +5,9 @@ use std::collections::VecDeque;
 
 use crate::build_tools::is_strict;
 use crate::errors::{py_err_string, ErrorType, ErrorTypeDefaults, ValError, ValLineError, ValResult};
-use crate::input::BorrowInput;
-use crate::input::{GenericIterable, Input};
+use crate::input::ConsumeIterator;
+use crate::input::{BorrowInput, Input, ValidatedTuple};
 use crate::tools::SchemaDict;
-use crate::validators::Exactness;
 
 use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
 
@@ -248,67 +247,19 @@ impl Validator for TupleValidator {
         input: &(impl Input<'py> + ?Sized),
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
-        let collection = input.validate_tuple(state.strict_or(self.strict))?;
-        let exactness = match &collection {
-            GenericIterable::Tuple(_) | GenericIterable::JsonArray(_) => Exactness::Exact,
-            GenericIterable::List(_) => Exactness::Strict,
-            _ => Exactness::Lax,
-        };
-        state.floor_exactness(exactness);
-        let actual_length = collection.generic_len();
+        let collection = input.validate_tuple(state.strict_or(self.strict))?.unpack(state);
+        let actual_length = collection.len();
 
         let mut errors: Vec<ValLineError> = Vec::new();
 
-        let mut iteration_error = None;
-
-        macro_rules! iter {
-            ($collection_iter:expr) => {
-                self.validate_tuple_variable(
-                    py,
-                    input,
-                    state,
-                    &mut errors,
-                    &mut NextCountingIterator::new($collection_iter, 0),
-                    actual_length,
-                )
-            };
-        }
-
-        let output = match collection {
-            GenericIterable::List(collection_iter) => iter!(collection_iter.iter())?,
-            GenericIterable::Tuple(collection_iter) => iter!(collection_iter.iter())?,
-            GenericIterable::JsonArray(collection_iter) => iter!(collection_iter.iter())?,
-            other => iter!({
-                let mut sequence_iterator = other.as_sequence_iterator(py)?;
-                let iteration_error = &mut iteration_error;
-                let mut index: usize = 0;
-                std::iter::from_fn(move || {
-                    if iteration_error.is_some() {
-                        return None;
-                    }
-                    index += 1;
-                    match sequence_iterator.next() {
-                        Some(Ok(item)) => Some(item),
-                        Some(Err(e)) => {
-                            *iteration_error = Some(ValError::new_with_loc(
-                                ErrorType::IterationError {
-                                    error: py_err_string(py, e),
-                                    context: None,
-                                },
-                                input,
-                                index,
-                            ));
-                            None
-                        }
-                        None => None,
-                    }
-                })
-            })?,
-        };
-
-        if let Some(err) = iteration_error {
-            return Err(err);
-        }
+        let output = collection.iterate(ValidateToTuple {
+            py,
+            input,
+            actual_length,
+            validator: self,
+            errors: &mut errors,
+            state,
+        })??;
 
         if let Some(min_length) = self.min_length {
             let actual_length = output.len();
@@ -337,6 +288,68 @@ impl Validator for TupleValidator {
     }
 }
 
+struct ValidateToTuple<'a, 's, 'py, I: Input<'py> + ?Sized> {
+    py: Python<'py>,
+    input: &'a I,
+    actual_length: Option<usize>,
+    validator: &'a TupleValidator,
+    errors: &'a mut Vec<ValLineError>,
+    state: &'a mut ValidationState<'s, 'py>,
+}
+
+impl<'py, T, I> ConsumeIterator<PyResult<T>> for ValidateToTuple<'_, '_, 'py, I>
+where
+    T: BorrowInput<'py>,
+    I: Input<'py> + ?Sized,
+{
+    type Output = ValResult<Vec<PyObject>>;
+    fn consume_iterator(self, mut iterator: impl Iterator<Item = PyResult<T>>) -> ValResult<Vec<PyObject>> {
+        let mut iteration_error = None;
+
+        let output = self.validator.validate_tuple_variable(
+            self.py,
+            self.input,
+            self.state,
+            self.errors,
+            &mut NextCountingIterator::new(
+                {
+                    let iteration_error = &mut iteration_error;
+                    let mut index: usize = 0;
+                    std::iter::from_fn(move || {
+                        if iteration_error.is_some() {
+                            return None;
+                        }
+                        index += 1;
+                        match iterator.next() {
+                            Some(Ok(item)) => Some(item),
+                            Some(Err(e)) => {
+                                *iteration_error = Some(ValError::new_with_loc(
+                                    ErrorType::IterationError {
+                                        error: py_err_string(self.py, e),
+                                        context: None,
+                                    },
+                                    self.input,
+                                    index,
+                                ));
+                                None
+                            }
+                            None => None,
+                        }
+                    })
+                },
+                0,
+            ),
+            self.actual_length,
+        )?;
+
+        if let Some(err) = iteration_error {
+            return Err(err);
+        }
+
+        Ok(output)
+    }
+}
+
 struct NextCountingIterator<I: Iterator> {
     inner: I,
     count: usize,

From 639959238c3e513234b8b7c4eba85a42178e547f Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Wed, 20 Mar 2024 20:26:44 +0000
Subject: [PATCH 241/550] support json cow of jiter 0.1.0 (#1231)

---
 Cargo.lock                  |   4 +-
 Cargo.toml                  |   2 +-
 src/errors/line_error.rs    |   2 +-
 src/errors/location.rs      |   7 +++
 src/input/input_abstract.rs |   2 +-
 src/input/input_json.rs     | 100 ++++++++++++++++++------------------
 src/input/input_python.rs   |   2 +-
 src/input/input_string.rs   |   2 +-
 src/input/return_enums.rs   |  38 ++++++++++----
 src/lookup_key.rs           |  18 +++----
 src/validators/generator.rs |   4 +-
 11 files changed, 102 insertions(+), 79 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 667d15b1b..88d00f3c1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -148,9 +148,9 @@ checksum = "62b02a5381cc465bd3041d84623d0fa3b66738b52b8e2fc3bab8ad63ab032f4a"
 
 [[package]]
 name = "jiter"
-version = "0.0.7"
+version = "0.1.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c2a1b6e316923afd3087ec73829f646a67c18f3a5bd61624247b05e652e4a99d"
+checksum = "a9cbc4bba9fee7e90f7ab23d53caa097007c6b870b2ca0a33334e774eb34c1ff"
 dependencies = [
  "ahash",
  "hashbrown",
diff --git a/Cargo.toml b/Cargo.toml
index ff97d1dbf..a3762466e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -44,7 +44,7 @@ base64 = "0.21.7"
 num-bigint = "0.4.4"
 python3-dll-a = "0.2.7"
 uuid = "1.7.0"
-jiter = {version = "0.0.7", features = ["python"]}
+jiter = { version = "0.1.0", features = ["python"] }
 
 [lib]
 name = "_pydantic_core"
diff --git a/src/errors/line_error.rs b/src/errors/line_error.rs
index 9a9d6ef6f..c3d2b66dc 100644
--- a/src/errors/line_error.rs
+++ b/src/errors/line_error.rs
@@ -151,7 +151,7 @@ impl ValLineError {
 #[derive(Clone)]
 pub enum InputValue {
     Python(PyObject),
-    Json(JsonValue),
+    Json(JsonValue<'static>),
 }
 
 impl ToPyObject for InputValue {
diff --git a/src/errors/location.rs b/src/errors/location.rs
index 138d327ce..07e1623d7 100644
--- a/src/errors/location.rs
+++ b/src/errors/location.rs
@@ -1,5 +1,6 @@
 use pyo3::exceptions::PyTypeError;
 use pyo3::sync::GILOnceCell;
+use std::borrow::Cow;
 use std::fmt;
 
 use pyo3::prelude::*;
@@ -52,6 +53,12 @@ impl From<&str> for LocItem {
     }
 }
 
+impl From<Cow<'_, str>> for LocItem {
+    fn from(s: Cow<'_, str>) -> Self {
+        Self::S(s.into_owned())
+    }
+}
+
 impl From<i64> for LocItem {
     fn from(i: i64) -> Self {
         Self::I(i)
diff --git a/src/input/input_abstract.rs b/src/input/input_abstract.rs
index a5ae2a6be..7e6649603 100644
--- a/src/input/input_abstract.rs
+++ b/src/input/input_abstract.rs
@@ -180,7 +180,7 @@ pub trait Input<'py>: fmt::Debug + ToPyObject {
 
     fn validate_frozenset(&self, strict: bool) -> ValMatch<Self::Set<'_>>;
 
-    fn validate_iter(&self) -> ValResult<GenericIterator>;
+    fn validate_iter(&self) -> ValResult<GenericIterator<'static>>;
 
     fn validate_date(&self, strict: bool) -> ValMatch<EitherDate<'py>>;
 
diff --git a/src/input/input_json.rs b/src/input/input_json.rs
index 1a79f1ea6..f2bf74998 100644
--- a/src/input/input_json.rs
+++ b/src/input/input_json.rs
@@ -24,26 +24,26 @@ use super::{
 };
 
 /// This is required but since JSON object keys are always strings, I don't think it can be called
-impl From<&JsonValue> for LocItem {
+impl From<&JsonValue<'_>> for LocItem {
     fn from(json_value: &JsonValue) -> Self {
         match json_value {
             JsonValue::Int(i) => (*i).into(),
-            JsonValue::Str(s) => s.as_str().into(),
+            JsonValue::Str(s) => s.clone().into(),
             v => format!("{v:?}").into(),
         }
     }
 }
 
-impl From<JsonValue> for LocItem {
+impl From<JsonValue<'_>> for LocItem {
     fn from(json_value: JsonValue) -> Self {
         (&json_value).into()
     }
 }
 
-impl<'py> Input<'py> for JsonValue {
+impl<'py, 'data> Input<'py> for JsonValue<'data> {
     fn as_error_value(&self) -> InputValue {
         // cloning JsonValue is cheap due to use of Arc
-        InputValue::Json(self.clone())
+        InputValue::Json(self.to_static())
     }
 
     fn is_none(&self) -> bool {
@@ -63,11 +63,11 @@ impl<'py> Input<'py> for JsonValue {
         }
     }
 
-    type Arguments<'a> = JsonArgs<'a>
+    type Arguments<'a> = JsonArgs<'a, 'data>
     where
         Self: 'a,;
 
-    fn validate_args(&self) -> ValResult<JsonArgs<'_>> {
+    fn validate_args(&self) -> ValResult<JsonArgs<'_, 'data>> {
         match self {
             JsonValue::Object(object) => Ok(JsonArgs::new(None, Some(object))),
             JsonValue::Array(array) => Ok(JsonArgs::new(Some(array), None)),
@@ -75,7 +75,7 @@ impl<'py> Input<'py> for JsonValue {
         }
     }
 
-    fn validate_dataclass_args<'a>(&'a self, class_name: &str) -> ValResult<JsonArgs<'a>> {
+    fn validate_dataclass_args<'a>(&'a self, class_name: &str) -> ValResult<JsonArgs<'a, 'data>> {
         match self {
             JsonValue::Object(object) => Ok(JsonArgs::new(None, Some(object))),
             _ => {
@@ -98,7 +98,7 @@ impl<'py> Input<'py> for JsonValue {
         // TODO: in V3 we may want to make JSON str always win if in union, for consistency,
         // see https://github.com/pydantic/pydantic-core/pull/867#discussion_r1386582501
         match self {
-            JsonValue::Str(s) => Ok(ValidationMatch::strict(s.as_str().into())),
+            JsonValue::Str(s) => Ok(ValidationMatch::strict(s.as_ref().into())),
             JsonValue::Int(i) if !strict && coerce_numbers_to_str => Ok(ValidationMatch::lax(i.to_string().into())),
             JsonValue::BigInt(b) if !strict && coerce_numbers_to_str => Ok(ValidationMatch::lax(b.to_string().into())),
             JsonValue::Float(f) if !strict && coerce_numbers_to_str => Ok(ValidationMatch::lax(f.to_string().into())),
@@ -142,7 +142,7 @@ impl<'py> Input<'py> for JsonValue {
 
     fn exact_str(&self) -> ValResult<EitherString<'_>> {
         match self {
-            JsonValue::Str(s) => Ok(s.as_str().into()),
+            JsonValue::Str(s) => Ok(s.as_ref().into()),
             _ => Err(ValError::new(ErrorTypeDefaults::StringType, self)),
         }
     }
@@ -168,7 +168,7 @@ impl<'py> Input<'py> for JsonValue {
         }
     }
 
-    type Dict<'a> = &'a JsonObject;
+    type Dict<'a> = &'a JsonObject<'data> where Self: 'a;
 
     fn validate_dict(&self, _strict: bool) -> ValResult<Self::Dict<'_>> {
         match self {
@@ -181,18 +181,18 @@ impl<'py> Input<'py> for JsonValue {
         self.validate_dict(false)
     }
 
-    type List<'a> = &'a JsonArray;
+    type List<'a> = &'a JsonArray<'data> where Self: 'a;
 
-    fn validate_list(&self, _strict: bool) -> ValMatch<&JsonArray> {
+    fn validate_list(&self, _strict: bool) -> ValMatch<&JsonArray<'data>> {
         match self {
             JsonValue::Array(a) => Ok(ValidationMatch::exact(a)),
             _ => Err(ValError::new(ErrorTypeDefaults::ListType, self)),
         }
     }
 
-    type Tuple<'a> = &'a JsonArray;
+    type Tuple<'a> = &'a JsonArray<'data> where Self: 'a;
 
-    fn validate_tuple(&self, _strict: bool) -> ValMatch<&JsonArray> {
+    fn validate_tuple(&self, _strict: bool) -> ValMatch<&JsonArray<'data>> {
         // just as in set's case, List has to be allowed
         match self {
             JsonValue::Array(a) => Ok(ValidationMatch::strict(a)),
@@ -200,9 +200,9 @@ impl<'py> Input<'py> for JsonValue {
         }
     }
 
-    type Set<'a> = &'a JsonArray;
+    type Set<'a> = &'a JsonArray<'data> where Self: 'a;
 
-    fn validate_set(&self, _strict: bool) -> ValMatch<&JsonArray> {
+    fn validate_set(&self, _strict: bool) -> ValMatch<&JsonArray<'data>> {
         // we allow a list here since otherwise it would be impossible to create a set from JSON
         match self {
             JsonValue::Array(a) => Ok(ValidationMatch::strict(a)),
@@ -210,7 +210,7 @@ impl<'py> Input<'py> for JsonValue {
         }
     }
 
-    fn validate_frozenset(&self, _strict: bool) -> ValMatch<&JsonArray> {
+    fn validate_frozenset(&self, _strict: bool) -> ValMatch<&JsonArray<'data>> {
         // we allow a list here since otherwise it would be impossible to create a frozenset from JSON
         match self {
             JsonValue::Array(a) => Ok(ValidationMatch::strict(a)),
@@ -218,14 +218,14 @@ impl<'py> Input<'py> for JsonValue {
         }
     }
 
-    fn validate_iter(&self) -> ValResult<GenericIterator> {
+    fn validate_iter(&self) -> ValResult<GenericIterator<'static>> {
         match self {
-            JsonValue::Array(a) => Ok(a.clone().into()),
+            JsonValue::Array(a) => Ok(GenericIterator::from(a.clone()).into_static()),
             JsonValue::Str(s) => Ok(string_to_vec(s).into()),
             JsonValue::Object(object) => {
                 // return keys iterator to match python's behavior
                 let keys: JsonArray = JsonArray::new(object.keys().map(|k| JsonValue::Str(k.clone())).collect());
-                Ok(keys.into())
+                Ok(GenericIterator::from(keys).into_static())
             }
             _ => Err(ValError::new(ErrorTypeDefaults::IterableType, self)),
         }
@@ -303,7 +303,7 @@ impl<'py> Input<'py> for str {
     fn as_error_value(&self) -> InputValue {
         // Justification for the clone: this is on the error pathway and we are generally ok
         // with errors having a performance penalty
-        InputValue::Json(JsonValue::Str(self.to_owned()))
+        InputValue::Json(JsonValue::Str(self.to_owned().into()))
     }
 
     fn as_kwargs(&self, _py: Python<'py>) -> Option<Bound<'py, PyDict>> {
@@ -394,7 +394,7 @@ impl<'py> Input<'py> for str {
         Err(ValError::new(ErrorTypeDefaults::SetType, self))
     }
 
-    fn validate_iter(&self) -> ValResult<GenericIterator> {
+    fn validate_iter(&self) -> ValResult<GenericIterator<'static>> {
         Ok(string_to_vec(self).into())
     }
 
@@ -441,21 +441,21 @@ impl BorrowInput<'_> for String {
     }
 }
 
-impl BorrowInput<'_> for JsonValue {
-    type Input = JsonValue;
+impl<'data> BorrowInput<'_> for JsonValue<'data> {
+    type Input = JsonValue<'data>;
     fn borrow_input(&self) -> &Self::Input {
         self
     }
 }
 
-fn string_to_vec(s: &str) -> JsonArray {
-    JsonArray::new(s.chars().map(|c| JsonValue::Str(c.to_string())).collect())
+fn string_to_vec(s: &str) -> JsonArray<'static> {
+    JsonArray::new(s.chars().map(|c| JsonValue::Str(c.to_string().into())).collect())
 }
 
-impl<'py> ValidatedDict<'py> for &'_ JsonObject {
+impl<'py, 'data> ValidatedDict<'py> for &'_ JsonObject<'data> {
     type Key<'a> = &'a str where Self: 'a;
 
-    type Item<'a> = &'a JsonValue where Self: 'a;
+    type Item<'a> = &'a JsonValue<'data> where Self: 'a;
 
     fn get_item<'k>(&self, key: &'k LookupKey) -> ValResult<Option<(&'k LookupPath, Self::Item<'_>)>> {
         key.json_get(self)
@@ -469,12 +469,12 @@ impl<'py> ValidatedDict<'py> for &'_ JsonObject {
         &'a self,
         consumer: impl ConsumeIterator<ValResult<(Self::Key<'a>, Self::Item<'a>)>, Output = R>,
     ) -> ValResult<R> {
-        Ok(consumer.consume_iterator(LazyIndexMap::iter(self).map(|(k, v)| Ok((k.as_str(), v)))))
+        Ok(consumer.consume_iterator(LazyIndexMap::iter(self).map(|(k, v)| Ok((k.as_ref(), v)))))
     }
 }
 
-impl<'a, 'py> ValidatedList<'py> for &'a JsonArray {
-    type Item = &'a JsonValue;
+impl<'a, 'py, 'data> ValidatedList<'py> for &'a JsonArray<'data> {
+    type Item = &'a JsonValue<'data>;
 
     fn len(&self) -> Option<usize> {
         Some(SmallVec::len(self))
@@ -487,8 +487,8 @@ impl<'a, 'py> ValidatedList<'py> for &'a JsonArray {
     }
 }
 
-impl<'a, 'py> ValidatedTuple<'py> for &'a JsonArray {
-    type Item = &'a JsonValue;
+impl<'a, 'data> ValidatedTuple<'_> for &'a JsonArray<'data> {
+    type Item = &'a JsonValue<'data>;
 
     fn len(&self) -> Option<usize> {
         Some(SmallVec::len(self))
@@ -498,8 +498,8 @@ impl<'a, 'py> ValidatedTuple<'py> for &'a JsonArray {
     }
 }
 
-impl<'a, 'py> ValidatedSet<'py> for &'a JsonArray {
-    type Item = &'a JsonValue;
+impl<'a, 'data> ValidatedSet<'_> for &'a JsonArray<'data> {
+    type Item = &'a JsonValue<'data>;
 
     fn iterate<R>(self, consumer: impl ConsumeIterator<PyResult<Self::Item>, Output = R>) -> ValResult<R> {
         Ok(consumer.consume_iterator(self.iter().map(Ok)))
@@ -507,20 +507,20 @@ impl<'a, 'py> ValidatedSet<'py> for &'a JsonArray {
 }
 
 #[cfg_attr(debug_assertions, derive(Debug))]
-pub struct JsonArgs<'a> {
-    args: Option<&'a [JsonValue]>,
-    kwargs: Option<&'a JsonObject>,
+pub struct JsonArgs<'a, 'data> {
+    args: Option<&'a [JsonValue<'data>]>,
+    kwargs: Option<&'a JsonObject<'data>>,
 }
 
-impl<'a> JsonArgs<'a> {
-    fn new(args: Option<&'a [JsonValue]>, kwargs: Option<&'a JsonObject>) -> Self {
+impl<'a, 'data> JsonArgs<'a, 'data> {
+    fn new(args: Option<&'a [JsonValue<'data>]>, kwargs: Option<&'a JsonObject<'data>>) -> Self {
         Self { args, kwargs }
     }
 }
 
-impl<'a> Arguments<'_> for JsonArgs<'a> {
-    type Args = [JsonValue];
-    type Kwargs = JsonObject;
+impl<'a, 'data> Arguments<'_> for JsonArgs<'a, 'data> {
+    type Args = [JsonValue<'data>];
+    type Kwargs = JsonObject<'data>;
 
     fn args(&self) -> Option<&Self::Args> {
         self.args
@@ -531,8 +531,8 @@ impl<'a> Arguments<'_> for JsonArgs<'a> {
     }
 }
 
-impl PositionalArgs<'_> for [JsonValue] {
-    type Item<'a> = &'a JsonValue;
+impl<'data> PositionalArgs<'_> for [JsonValue<'data>] {
+    type Item<'a> = &'a JsonValue<'data> where Self: 'a;
 
     fn len(&self) -> usize {
         <[JsonValue]>::len(self)
@@ -545,9 +545,9 @@ impl PositionalArgs<'_> for [JsonValue] {
     }
 }
 
-impl KeywordArgs<'_> for JsonObject {
-    type Key<'a> = &'a str;
-    type Item<'a> = &'a JsonValue;
+impl<'data> KeywordArgs<'_> for JsonObject<'data> {
+    type Key<'a> = &'a str where Self: 'a;
+    type Item<'a> = &'a JsonValue<'data> where Self: 'a;
 
     fn len(&self) -> usize {
         LazyIndexMap::len(self)
@@ -556,6 +556,6 @@ impl KeywordArgs<'_> for JsonObject {
         key.json_get(self)
     }
     fn iter(&self) -> impl Iterator<Item = ValResult<(Self::Key<'_>, Self::Item<'_>)>> {
-        LazyIndexMap::iter(self).map(|(k, v)| Ok((k.as_str(), v)))
+        LazyIndexMap::iter(self).map(|(k, v)| Ok((k.as_ref(), v)))
     }
 }
diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index fe00ee1f9..f59dea1f8 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -475,7 +475,7 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
         Err(ValError::new(ErrorTypeDefaults::FrozenSetType, self))
     }
 
-    fn validate_iter(&self) -> ValResult<GenericIterator> {
+    fn validate_iter(&self) -> ValResult<GenericIterator<'static>> {
         if self.iter().is_ok() {
             Ok(self.into())
         } else {
diff --git a/src/input/input_string.rs b/src/input/input_string.rs
index 520bbba61..3c61cdebc 100644
--- a/src/input/input_string.rs
+++ b/src/input/input_string.rs
@@ -171,7 +171,7 @@ impl<'py> Input<'py> for StringMapping<'py> {
         Err(ValError::new(ErrorTypeDefaults::FrozenSetType, self))
     }
 
-    fn validate_iter(&self) -> ValResult<GenericIterator> {
+    fn validate_iter(&self) -> ValResult<GenericIterator<'static>> {
         Err(ValError::new(ErrorTypeDefaults::IterableType, self))
     }
 
diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index b4a699735..753ace478 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -321,20 +321,29 @@ pub(crate) fn iterate_attributes<'a, 'py>(
     })
 }
 
-#[derive(Debug, Clone)]
-pub enum GenericIterator {
+#[derive(Debug)]
+pub enum GenericIterator<'data> {
     PyIterator(GenericPyIterator),
-    JsonArray(GenericJsonIterator),
+    JsonArray(GenericJsonIterator<'data>),
 }
 
-impl From<JsonArray> for GenericIterator {
-    fn from(array: JsonArray) -> Self {
+impl GenericIterator<'_> {
+    pub(crate) fn into_static(self) -> GenericIterator<'static> {
+        match self {
+            GenericIterator::PyIterator(iter) => GenericIterator::PyIterator(iter),
+            GenericIterator::JsonArray(iter) => GenericIterator::JsonArray(iter.into_static()),
+        }
+    }
+}
+
+impl<'data> From<JsonArray<'data>> for GenericIterator<'data> {
+    fn from(array: JsonArray<'data>) -> Self {
         let json_iter = GenericJsonIterator { array, index: 0 };
         Self::JsonArray(json_iter)
     }
 }
 
-impl From<&Bound<'_, PyAny>> for GenericIterator {
+impl From<&Bound<'_, PyAny>> for GenericIterator<'_> {
     fn from(obj: &Bound<'_, PyAny>) -> Self {
         let py_iter = GenericPyIterator {
             obj: obj.clone().into(),
@@ -377,13 +386,13 @@ impl GenericPyIterator {
 }
 
 #[derive(Debug, Clone)]
-pub struct GenericJsonIterator {
-    array: JsonArray,
+pub struct GenericJsonIterator<'data> {
+    array: JsonArray<'data>,
     index: usize,
 }
 
-impl GenericJsonIterator {
-    pub fn next(&mut self, _py: Python) -> PyResult<Option<(&JsonValue, usize)>> {
+impl<'data> GenericJsonIterator<'data> {
+    pub fn next(&mut self, _py: Python) -> PyResult<Option<(&JsonValue<'data>, usize)>> {
         if self.index < self.array.len() {
             // panic here is impossible due to bounds check above; compiler should be
             // able to optimize it away even
@@ -397,12 +406,19 @@ impl GenericJsonIterator {
     }
 
     pub fn input_as_error_value(&self, _py: Python<'_>) -> InputValue {
-        InputValue::Json(JsonValue::Array(self.array.clone()))
+        InputValue::Json(JsonValue::Array(self.array.clone()).into_static())
     }
 
     pub fn index(&self) -> usize {
         self.index
     }
+
+    pub fn into_static(self) -> GenericJsonIterator<'static> {
+        GenericJsonIterator {
+            array: JsonArray::new(self.array.iter().map(JsonValue::to_static).collect()),
+            index: self.index,
+        }
+    }
 }
 
 #[cfg_attr(debug_assertions, derive(Debug))]
diff --git a/src/lookup_key.rs b/src/lookup_key.rs
index f1ccfa142..bacdb5fd1 100644
--- a/src/lookup_key.rs
+++ b/src/lookup_key.rs
@@ -260,12 +260,12 @@ impl LookupKey {
         }
     }
 
-    pub fn json_get<'data, 's>(
+    pub fn json_get<'a, 'data, 's>(
         &'s self,
-        dict: &'data JsonObject,
-    ) -> ValResult<Option<(&'s LookupPath, &'data JsonValue)>> {
+        dict: &'a JsonObject<'data>,
+    ) -> ValResult<Option<(&'s LookupPath, &'a JsonValue<'data>)>> {
         match self {
-            Self::Simple { key, path, .. } => match dict.get(key) {
+            Self::Simple { key, path, .. } => match dict.get(key.as_str()) {
                 Some(value) => Ok(Some((path, value))),
                 None => Ok(None),
             },
@@ -275,9 +275,9 @@ impl LookupKey {
                 key2,
                 path2,
                 ..
-            } => match dict.get(key1) {
+            } => match dict.get(key1.as_str()) {
                 Some(value) => Ok(Some((path1, value))),
-                None => match dict.get(key2) {
+                None => match dict.get(key2.as_str()) {
                     Some(value) => Ok(Some((path2, value))),
                     None => Ok(None),
                 },
@@ -475,7 +475,7 @@ impl PathItem {
         }
     }
 
-    pub fn json_get<'a>(&self, any_json: &'a JsonValue) -> Option<&'a JsonValue> {
+    pub fn json_get<'a, 'data>(&self, any_json: &'a JsonValue<'data>) -> Option<&'a JsonValue<'data>> {
         match any_json {
             JsonValue::Object(v_obj) => self.json_obj_get(v_obj),
             JsonValue::Array(v_array) => match self {
@@ -493,9 +493,9 @@ impl PathItem {
         }
     }
 
-    pub fn json_obj_get<'a>(&self, json_obj: &'a JsonObject) -> Option<&'a JsonValue> {
+    pub fn json_obj_get<'a, 'data>(&self, json_obj: &'a JsonObject<'data>) -> Option<&'a JsonValue<'data>> {
         match self {
-            Self::S(key, _) => json_obj.get(key),
+            Self::S(key, _) => json_obj.get(key.as_str()),
             _ => None,
         }
     }
diff --git a/src/validators/generator.rs b/src/validators/generator.rs
index f73532268..f7c932397 100644
--- a/src/validators/generator.rs
+++ b/src/validators/generator.rs
@@ -65,7 +65,7 @@ impl Validator for GeneratorValidator {
         input: &(impl Input<'py> + ?Sized),
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
-        let iterator = input.validate_iter()?;
+        let iterator = input.validate_iter()?.into_static();
         let validator = self.item_validator.as_ref().map(|v| {
             InternalValidator::new(
                 py,
@@ -96,7 +96,7 @@ impl Validator for GeneratorValidator {
 #[pyclass(module = "pydantic_core._pydantic_core")]
 #[derive(Debug)]
 struct ValidatorIterator {
-    iterator: GenericIterator,
+    iterator: GenericIterator<'static>,
     validator: Option<InternalValidator>,
     min_length: Option<usize>,
     max_length: Option<usize>,

From ebf55d669d601b7b03ca20f9b8b12c321b7c3f47 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Thu, 21 Mar 2024 10:39:55 +0000
Subject: [PATCH 242/550] refactor `Input` trait to have single `as_python`
 cast for python inputs (#1241)

---
 src/input/input_abstract.rs   |  33 +-------
 src/input/input_python.rs     |  56 ++++----------
 src/input/mod.rs              |   1 +
 src/url.rs                    |  21 ++---
 src/validators/callable.rs    |   2 +-
 src/validators/dataclass.rs   |   7 +-
 src/validators/definitions.rs |  19 ++---
 src/validators/enum_.rs       |   4 +-
 src/validators/is_instance.rs |  10 +--
 src/validators/is_subclass.rs |  13 +++-
 src/validators/literal.rs     |   2 +-
 src/validators/model.rs       |   4 +-
 src/validators/url.rs         | 141 ++++++++++++++++++++++++++--------
 src/validators/uuid.rs        |   3 +-
 tests/validators/test_url.py  |   4 +-
 15 files changed, 178 insertions(+), 142 deletions(-)

diff --git a/src/input/input_abstract.rs b/src/input/input_abstract.rs
index 7e6649603..5e915c548 100644
--- a/src/input/input_abstract.rs
+++ b/src/input/input_abstract.rs
@@ -1,13 +1,12 @@
 use std::fmt;
 
 use pyo3::exceptions::PyValueError;
-use pyo3::types::{PyDict, PyList, PyType};
+use pyo3::types::{PyDict, PyList};
 use pyo3::{intern, prelude::*};
 
 use crate::errors::{ErrorTypeDefaults, InputValue, LocItem, ValError, ValResult};
 use crate::lookup_key::{LookupKey, LookupPath};
 use crate::tools::py_err;
-use crate::{PyMultiHostUrl, PyUrl};
 
 use super::datetime::{EitherDate, EitherDateTime, EitherTime, EitherTimedelta};
 use super::return_enums::{EitherBytes, EitherInt, EitherString};
@@ -52,44 +51,16 @@ pub type ValMatch<T> = ValResult<ValidationMatch<T>>;
 pub trait Input<'py>: fmt::Debug + ToPyObject {
     fn as_error_value(&self) -> InputValue;
 
-    fn identity(&self) -> Option<usize> {
-        None
-    }
-
     fn is_none(&self) -> bool {
         false
     }
 
-    fn input_is_instance(&self, _class: &Bound<'py, PyType>) -> Option<&Bound<'py, PyAny>> {
+    fn as_python(&self) -> Option<&Bound<'py, PyAny>> {
         None
     }
 
-    fn input_is_exact_instance(&self, _class: &Bound<'py, PyType>) -> bool {
-        false
-    }
-
-    fn is_python(&self) -> bool {
-        false
-    }
-
     fn as_kwargs(&self, py: Python<'py>) -> Option<Bound<'py, PyDict>>;
 
-    fn input_is_subclass(&self, _class: &Bound<'_, PyType>) -> PyResult<bool> {
-        Ok(false)
-    }
-
-    fn input_as_url(&self) -> Option<PyUrl> {
-        None
-    }
-
-    fn input_as_multi_host_url(&self) -> Option<PyMultiHostUrl> {
-        None
-    }
-
-    fn callable(&self) -> bool {
-        false
-    }
-
     type Arguments<'a>: Arguments<'py>
     where
         Self: 'a;
diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index f59dea1f8..0c9a807b1 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -4,18 +4,20 @@ use std::str::from_utf8;
 use pyo3::intern;
 use pyo3::prelude::*;
 
+use pyo3::types::PyType;
 use pyo3::types::{
     PyBool, PyByteArray, PyBytes, PyDate, PyDateTime, PyDict, PyFloat, PyFrozenSet, PyInt, PyIterator, PyList,
-    PyMapping, PySet, PyString, PyTime, PyTuple, PyType,
+    PyMapping, PySet, PyString, PyTime, PyTuple,
 };
 
+use pyo3::PyTypeCheck;
 use speedate::MicrosecondsPrecisionOverflowBehavior;
 
 use crate::errors::{ErrorType, ErrorTypeDefaults, InputValue, LocItem, ValError, ValResult};
 use crate::tools::{extract_i64, safe_repr};
 use crate::validators::decimal::{create_decimal, get_decimal_type};
 use crate::validators::Exactness;
-use crate::{ArgsKwargs, PyMultiHostUrl, PyUrl};
+use crate::ArgsKwargs;
 
 use super::datetime::{
     bytes_as_date, bytes_as_datetime, bytes_as_time, bytes_as_timedelta, date_as_datetime, float_as_datetime,
@@ -40,6 +42,17 @@ use super::{
     Input,
 };
 
+pub(crate) fn downcast_python_input<'py, T: PyTypeCheck>(input: &(impl Input<'py> + ?Sized)) -> Option<&Bound<'py, T>> {
+    input.as_python().and_then(|any| any.downcast::<T>().ok())
+}
+
+pub(crate) fn input_as_python_instance<'a, 'py>(
+    input: &'a (impl Input<'py> + ?Sized),
+    class: &Bound<'py, PyType>,
+) -> Option<&'a Bound<'py, PyAny>> {
+    input.as_python().filter(|any| any.is_instance(class).unwrap_or(false))
+}
+
 impl From<&Bound<'_, PyAny>> for LocItem {
     fn from(py_any: &Bound<'_, PyAny>) -> Self {
         if let Ok(py_str) = py_any.downcast::<PyString>() {
@@ -63,28 +76,12 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
         InputValue::Python(self.clone().into())
     }
 
-    fn identity(&self) -> Option<usize> {
-        Some(self.as_ptr() as usize)
-    }
-
     fn is_none(&self) -> bool {
         PyAnyMethods::is_none(self)
     }
 
-    fn input_is_instance(&self, class: &Bound<'py, PyType>) -> Option<&Bound<'py, PyAny>> {
-        if self.is_instance(class).unwrap_or(false) {
-            Some(self)
-        } else {
-            None
-        }
-    }
-
-    fn input_is_exact_instance(&self, class: &Bound<'py, PyType>) -> bool {
-        self.is_exact_instance(class)
-    }
-
-    fn is_python(&self) -> bool {
-        true
+    fn as_python(&self) -> Option<&Bound<'py, PyAny>> {
+        Some(self)
     }
 
     fn as_kwargs(&self, py: Python<'py>) -> Option<Bound<'py, PyDict>> {
@@ -93,25 +90,6 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
             .map(|dict| dict.to_owned().unbind().into_bound(py))
     }
 
-    fn input_is_subclass(&self, class: &Bound<'_, PyType>) -> PyResult<bool> {
-        match self.downcast::<PyType>() {
-            Ok(py_type) => py_type.is_subclass(class),
-            Err(_) => Ok(false),
-        }
-    }
-
-    fn input_as_url(&self) -> Option<PyUrl> {
-        self.extract::<PyUrl>().ok()
-    }
-
-    fn input_as_multi_host_url(&self) -> Option<PyMultiHostUrl> {
-        self.extract::<PyMultiHostUrl>().ok()
-    }
-
-    fn callable(&self) -> bool {
-        self.is_callable()
-    }
-
     type Arguments<'a> = PyArgs<'py> where Self: 'a;
 
     fn validate_args(&self) -> ValResult<PyArgs<'py>> {
diff --git a/src/input/mod.rs b/src/input/mod.rs
index 5a2fdeb69..779454b3c 100644
--- a/src/input/mod.rs
+++ b/src/input/mod.rs
@@ -19,6 +19,7 @@ pub(crate) use input_abstract::{
     Arguments, BorrowInput, ConsumeIterator, Input, InputType, KeywordArgs, PositionalArgs, ValidatedDict,
     ValidatedList, ValidatedSet, ValidatedTuple,
 };
+pub(crate) use input_python::{downcast_python_input, input_as_python_instance};
 pub(crate) use input_string::StringMapping;
 pub(crate) use return_enums::{
     no_validator_iter_to_vec, py_string_str, validate_iter_to_set, validate_iter_to_vec, EitherBytes, EitherFloat,
diff --git a/src/url.rs b/src/url.rs
index 4f02f36d9..881347f25 100644
--- a/src/url.rs
+++ b/src/url.rs
@@ -16,8 +16,8 @@ use crate::SchemaValidator;
 
 static SCHEMA_DEFINITION_URL: GILOnceCell<SchemaValidator> = GILOnceCell::new();
 
-#[pyclass(name = "Url", module = "pydantic_core._pydantic_core", subclass)]
-#[derive(Clone)]
+#[pyclass(name = "Url", module = "pydantic_core._pydantic_core", subclass, frozen)]
+#[derive(Clone, Hash)]
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub struct PyUrl {
     lib_url: Url,
@@ -28,8 +28,8 @@ impl PyUrl {
         Self { lib_url }
     }
 
-    pub fn into_url(self) -> Url {
-        self.lib_url
+    pub fn url(&self) -> &Url {
+        &self.lib_url
     }
 }
 
@@ -138,7 +138,7 @@ impl PyUrl {
 
     fn __hash__(&self) -> u64 {
         let mut s = DefaultHasher::new();
-        self.lib_url.to_string().hash(&mut s);
+        self.hash(&mut s);
         s.finish()
     }
 
@@ -192,8 +192,8 @@ impl PyUrl {
     }
 }
 
-#[pyclass(name = "MultiHostUrl", module = "pydantic_core._pydantic_core", subclass)]
-#[derive(Clone)]
+#[pyclass(name = "MultiHostUrl", module = "pydantic_core._pydantic_core", subclass, frozen)]
+#[derive(Clone, Hash)]
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub struct PyMultiHostUrl {
     ref_url: PyUrl,
@@ -208,6 +208,10 @@ impl PyMultiHostUrl {
         }
     }
 
+    pub fn lib_url(&self) -> &Url {
+        &self.ref_url.lib_url
+    }
+
     pub fn mut_lib_url(&mut self) -> &mut Url {
         &mut self.ref_url.lib_url
     }
@@ -338,8 +342,7 @@ impl PyMultiHostUrl {
 
     fn __hash__(&self) -> u64 {
         let mut s = DefaultHasher::new();
-        self.ref_url.clone().into_url().to_string().hash(&mut s);
-        self.extra_urls.hash(&mut s);
+        self.hash(&mut s);
         s.finish()
     }
 
diff --git a/src/validators/callable.rs b/src/validators/callable.rs
index 235dc6dd0..1019d5c1e 100644
--- a/src/validators/callable.rs
+++ b/src/validators/callable.rs
@@ -32,7 +32,7 @@ impl Validator for CallableValidator {
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         state.floor_exactness(Exactness::Lax);
-        match input.callable() {
+        match input.as_python().is_some_and(PyAnyMethods::is_callable) {
             true => Ok(input.to_object(py)),
             false => Err(ValError::new(ErrorTypeDefaults::CallableType, input)),
         }
diff --git a/src/validators/dataclass.rs b/src/validators/dataclass.rs
index 08e2aba1c..907e1511e 100644
--- a/src/validators/dataclass.rs
+++ b/src/validators/dataclass.rs
@@ -8,8 +8,9 @@ use ahash::AHashSet;
 use crate::build_tools::py_schema_err;
 use crate::build_tools::{is_strict, schema_or_config_same, ExtraBehavior};
 use crate::errors::{ErrorType, ErrorTypeDefaults, ValError, ValLineError, ValResult};
-use crate::input::InputType;
-use crate::input::{Arguments, BorrowInput, Input, KeywordArgs, PositionalArgs, ValidationMatch};
+use crate::input::{
+    input_as_python_instance, Arguments, BorrowInput, Input, InputType, KeywordArgs, PositionalArgs, ValidationMatch,
+};
 use crate::lookup_key::LookupKey;
 use crate::tools::SchemaDict;
 use crate::validators::function::convert_err;
@@ -501,7 +502,7 @@ impl Validator for DataclassValidator {
 
         // same logic as on models
         let class = self.class.bind(py);
-        if let Some(py_input) = input.input_is_instance(class) {
+        if let Some(py_input) = input_as_python_instance(input, class) {
             if self.revalidate.should_revalidate(py_input, class) {
                 let input_dict = self.dataclass_to_dict(py_input)?;
                 let val_output = self.validator.validate(py, input_dict.as_any(), state)?;
diff --git a/src/validators/definitions.rs b/src/validators/definitions.rs
index 9cbb32271..a96138c48 100644
--- a/src/validators/definitions.rs
+++ b/src/validators/definitions.rs
@@ -77,7 +77,8 @@ impl Validator for DefinitionRefValidator {
     ) -> ValResult<PyObject> {
         self.definition.read(|validator| {
             let validator = validator.unwrap();
-            if let Some(id) = input.identity() {
+            if let Some(id) = input.as_python().map(py_identity) {
+                // Python objects can be cyclic, so need recursion guard
                 let Ok(mut guard) = RecursionGuard::new(state, id, self.definition.id()) else {
                     return Err(ValError::new(ErrorTypeDefaults::RecursionLoop, input));
                 };
@@ -98,14 +99,10 @@ impl Validator for DefinitionRefValidator {
     ) -> ValResult<PyObject> {
         self.definition.read(|validator| {
             let validator = validator.unwrap();
-            if let Some(id) = obj.identity() {
-                let Ok(mut guard) = RecursionGuard::new(state, id, self.definition.id()) else {
-                    return Err(ValError::new(ErrorTypeDefaults::RecursionLoop, obj));
-                };
-                validator.validate_assignment(py, obj, field_name, field_value, guard.state())
-            } else {
-                validator.validate_assignment(py, obj, field_name, field_value, state)
-            }
+            let Ok(mut guard) = RecursionGuard::new(state, py_identity(obj), self.definition.id()) else {
+                return Err(ValError::new(ErrorTypeDefaults::RecursionLoop, obj));
+            };
+            validator.validate_assignment(py, obj, field_name, field_value, guard.state())
         })
     }
 
@@ -113,3 +110,7 @@ impl Validator for DefinitionRefValidator {
         self.definition.get_or_init_name(|v| v.get_name().into())
     }
 }
+
+fn py_identity(obj: &Bound<'_, PyAny>) -> usize {
+    obj.as_ptr() as usize
+}
diff --git a/src/validators/enum_.rs b/src/validators/enum_.rs
index cc8a3d7b3..cf65c2f96 100644
--- a/src/validators/enum_.rs
+++ b/src/validators/enum_.rs
@@ -103,11 +103,11 @@ impl<T: EnumValidateValue> Validator for EnumValidator<T> {
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let class = self.class.bind(py);
-        if input.input_is_exact_instance(class) {
+        if input.as_python().is_some_and(|any| any.is_exact_instance(class)) {
             return Ok(input.to_object(py));
         }
         let strict = state.strict_or(self.strict);
-        if strict && input.is_python() {
+        if strict && input.as_python().is_some() {
             // TODO what about instances of subclasses?
             return Err(ValError::new(
                 ErrorType::IsInstanceOf {
diff --git a/src/validators/is_instance.rs b/src/validators/is_instance.rs
index 7cbf241ea..d904e82fb 100644
--- a/src/validators/is_instance.rs
+++ b/src/validators/is_instance.rs
@@ -55,16 +55,14 @@ impl Validator for IsInstanceValidator {
         input: &(impl Input<'py> + ?Sized),
         _state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
-        if !input.is_python() {
+        let Some(obj) = input.as_python() else {
             return Err(ValError::InternalErr(PyNotImplementedError::new_err(
                 "Cannot check isinstance when validating from json, \
                             use a JsonOrPython validator instead.",
             )));
-        }
-
-        let ob: Py<PyAny> = input.to_object(py);
-        match ob.bind(py).is_instance(self.class.bind(py))? {
-            true => Ok(ob),
+        };
+        match obj.is_instance(self.class.bind(py))? {
+            true => Ok(obj.clone().unbind()),
             false => Err(ValError::new(
                 ErrorType::IsInstanceOf {
                     class: self.class_repr.clone(),
diff --git a/src/validators/is_subclass.rs b/src/validators/is_subclass.rs
index da4599794..50deb8ae3 100644
--- a/src/validators/is_subclass.rs
+++ b/src/validators/is_subclass.rs
@@ -1,3 +1,4 @@
+use pyo3::exceptions::PyNotImplementedError;
 use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyType};
@@ -49,9 +50,15 @@ impl Validator for IsSubclassValidator {
         input: &(impl Input<'py> + ?Sized),
         _state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
-        match input.input_is_subclass(self.class.bind(py))? {
-            true => Ok(input.to_object(py)),
-            false => Err(ValError::new(
+        let Some(obj) = input.as_python() else {
+            return Err(ValError::InternalErr(PyNotImplementedError::new_err(
+                "Cannot check issubclass when validating from json, \
+                            use a JsonOrPython validator instead.",
+            )));
+        };
+        match obj.downcast::<PyType>() {
+            Ok(py_type) if py_type.is_subclass(self.class.bind(py))? => Ok(obj.clone().unbind()),
+            _ => Err(ValError::new(
                 ErrorType::IsSubclassOf {
                     class: self.class_repr.clone(),
                     context: None,
diff --git a/src/validators/literal.rs b/src/validators/literal.rs
index 0ace83f25..9c4eb7292 100644
--- a/src/validators/literal.rs
+++ b/src/validators/literal.rs
@@ -123,7 +123,7 @@ impl<T: Debug> LiteralLookup<T> {
             }
         }
         if let Some(expected_strings) = &self.expected_str {
-            let validation_result = if input.is_python() {
+            let validation_result = if input.as_python().is_some() {
                 input.exact_str()
             } else {
                 // Strings coming from JSON are treated as "strict" but not "exact" for reasons
diff --git a/src/validators/model.rs b/src/validators/model.rs
index db6f032f1..741b6f9f0 100644
--- a/src/validators/model.rs
+++ b/src/validators/model.rs
@@ -13,7 +13,7 @@ use super::{
 use crate::build_tools::py_schema_err;
 use crate::build_tools::schema_or_config_same;
 use crate::errors::{ErrorType, ErrorTypeDefaults, ValError, ValResult};
-use crate::input::{py_error_on_minusone, Input};
+use crate::input::{input_as_python_instance, py_error_on_minusone, Input};
 use crate::tools::{py_err, SchemaDict};
 use crate::PydanticUndefinedType;
 
@@ -124,7 +124,7 @@ impl Validator for ModelValidator {
         // if the input is an instance of the class, we "revalidate" it - e.g. we extract and reuse `__pydantic_fields_set__`
         // but use from attributes to create a new instance of the model field type
         let class = self.class.bind(py);
-        if let Some(py_input) = input.input_is_instance(class) {
+        if let Some(py_input) = input_as_python_instance(input, class) {
             if self.revalidate.should_revalidate(py_input, class) {
                 let fields_set = py_input.getattr(intern!(py, DUNDER_FIELDS_SET_KEY))?;
                 if self.root_model {
diff --git a/src/validators/url.rs b/src/validators/url.rs
index 786b2d653..5ec3a139f 100644
--- a/src/validators/url.rs
+++ b/src/validators/url.rs
@@ -12,6 +12,7 @@ use url::{ParseError, SyntaxViolation, Url};
 use crate::build_tools::{is_strict, py_schema_err};
 use crate::errors::ToErrorValue;
 use crate::errors::{ErrorType, ErrorTypeDefaults, ValError, ValResult};
+use crate::input::downcast_python_input;
 use crate::input::Input;
 use crate::tools::SchemaDict;
 use crate::url::{schema_is_special, PyMultiHostUrl, PyUrl};
@@ -67,10 +68,10 @@ impl Validator for UrlValidator {
         input: &(impl Input<'py> + ?Sized),
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
-        let mut lib_url = self.get_url(input, state.strict_or(self.strict))?;
+        let mut either_url = self.get_url(input, state.strict_or(self.strict))?;
 
         if let Some((ref allowed_schemes, ref expected_schemes_repr)) = self.allowed_schemes {
-            if !allowed_schemes.contains(lib_url.scheme()) {
+            if !allowed_schemes.contains(either_url.url().scheme()) {
                 let expected_schemes = expected_schemes_repr.clone();
                 return Err(ValError::new(
                     ErrorType::UrlScheme {
@@ -83,7 +84,7 @@ impl Validator for UrlValidator {
         }
 
         match check_sub_defaults(
-            &mut lib_url,
+            &mut either_url,
             self.host_required,
             &self.default_host,
             self.default_port,
@@ -92,7 +93,7 @@ impl Validator for UrlValidator {
             Ok(()) => {
                 // Lax rather than strict to preserve V2.4 semantic that str wins over url in union
                 state.floor_exactness(Exactness::Lax);
-                Ok(PyUrl::new(lib_url).into_py(py))
+                Ok(either_url.into_py(py))
             }
             Err(error_type) => Err(ValError::new(error_type, input)),
         }
@@ -104,7 +105,7 @@ impl Validator for UrlValidator {
 }
 
 impl UrlValidator {
-    fn get_url<'py>(&self, input: &(impl Input<'py> + ?Sized), strict: bool) -> ValResult<Url> {
+    fn get_url<'py>(&self, input: &(impl Input<'py> + ?Sized), strict: bool) -> ValResult<EitherUrl<'py>> {
         match input.validate_str(strict, false) {
             Ok(val_match) => {
                 let either_str = val_match.into_inner();
@@ -113,20 +114,19 @@ impl UrlValidator {
 
                 self.check_length(input, url_str)?;
 
-                parse_url(url_str, input, strict)
+                parse_url(url_str, input, strict).map(EitherUrl::Rust)
             }
             Err(_) => {
                 // we don't need to worry about whether the url was parsed in strict mode before,
                 // even if it was, any syntax errors would have been fixed by the first validation
-                if let Some(py_url) = input.input_as_url() {
-                    let lib_url = py_url.into_url();
-                    self.check_length(input, lib_url.as_str())?;
-                    Ok(lib_url)
-                } else if let Some(multi_host_url) = input.input_as_multi_host_url() {
-                    let url_str = multi_host_url.__str__();
+                if let Some(py_url) = downcast_python_input::<PyUrl>(input) {
+                    self.check_length(input, py_url.get().url().as_str())?;
+                    Ok(EitherUrl::Py(py_url.clone()))
+                } else if let Some(multi_host_url) = downcast_python_input::<PyMultiHostUrl>(input) {
+                    let url_str = multi_host_url.get().__str__();
                     self.check_length(input, &url_str)?;
 
-                    parse_url(&url_str, input, strict)
+                    parse_url(&url_str, input, strict).map(EitherUrl::Rust)
                 } else {
                     Err(ValError::new(ErrorTypeDefaults::UrlType, input))
                 }
@@ -150,6 +150,39 @@ impl UrlValidator {
     }
 }
 
+enum EitherUrl<'py> {
+    Py(Bound<'py, PyUrl>),
+    Rust(Url),
+}
+
+impl EitherUrl<'_> {
+    fn into_py(self, py: Python) -> PyObject {
+        match self {
+            EitherUrl::Py(py_url) => py_url.into_py(py),
+            EitherUrl::Rust(rust_url) => PyUrl::new(rust_url).into_py(py),
+        }
+    }
+}
+
+impl CopyFromPyUrl for EitherUrl<'_> {
+    fn url(&self) -> &Url {
+        match self {
+            EitherUrl::Py(py_url) => py_url.get().url(),
+            EitherUrl::Rust(rust_url) => rust_url,
+        }
+    }
+
+    fn url_mut(&mut self) -> &mut Url {
+        if let EitherUrl::Py(py_url) = self {
+            *self = EitherUrl::Rust(py_url.get().url().clone());
+        }
+        match self {
+            EitherUrl::Py(_) => unreachable!(),
+            EitherUrl::Rust(rust_url) => rust_url,
+        }
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct MultiHostUrlValidator {
     strict: bool,
@@ -204,7 +237,7 @@ impl Validator for MultiHostUrlValidator {
         let mut multi_url = self.get_url(input, state.strict_or(self.strict))?;
 
         if let Some((ref allowed_schemes, ref expected_schemes_repr)) = self.allowed_schemes {
-            if !allowed_schemes.contains(multi_url.scheme()) {
+            if !allowed_schemes.contains(multi_url.url().scheme()) {
                 let expected_schemes = expected_schemes_repr.clone();
                 return Err(ValError::new(
                     ErrorType::UrlScheme {
@@ -216,7 +249,7 @@ impl Validator for MultiHostUrlValidator {
             }
         }
         match check_sub_defaults(
-            multi_url.mut_lib_url(),
+            &mut multi_url,
             self.host_required,
             &self.default_host,
             self.default_port,
@@ -237,7 +270,7 @@ impl Validator for MultiHostUrlValidator {
 }
 
 impl MultiHostUrlValidator {
-    fn get_url<'py>(&self, input: &(impl Input<'py> + ?Sized), strict: bool) -> ValResult<PyMultiHostUrl> {
+    fn get_url<'py>(&self, input: &(impl Input<'py> + ?Sized), strict: bool) -> ValResult<EitherMultiHostUrl<'py>> {
         match input.validate_str(strict, false) {
             Ok(val_match) => {
                 let either_str = val_match.into_inner();
@@ -246,18 +279,20 @@ impl MultiHostUrlValidator {
 
                 self.check_length(input, || url_str.len())?;
 
-                parse_multihost_url(url_str, input, strict)
+                parse_multihost_url(url_str, input, strict).map(EitherMultiHostUrl::Rust)
             }
             Err(_) => {
                 // we don't need to worry about whether the url was parsed in strict mode before,
                 // even if it was, any syntax errors would have been fixed by the first validation
-                if let Some(multi_url) = input.input_as_multi_host_url() {
-                    self.check_length(input, || multi_url.__str__().len())?;
-                    Ok(multi_url)
-                } else if let Some(py_url) = input.input_as_url() {
-                    let lib_url = py_url.into_url();
-                    self.check_length(input, || lib_url.as_str().len())?;
-                    Ok(PyMultiHostUrl::new(lib_url, None))
+                if let Some(multi_url) = downcast_python_input::<PyMultiHostUrl>(input) {
+                    self.check_length(input, || multi_url.get().__str__().len())?;
+                    Ok(EitherMultiHostUrl::Py(multi_url.clone()))
+                } else if let Some(py_url) = downcast_python_input::<PyUrl>(input) {
+                    self.check_length(input, || py_url.get().url().as_str().len())?;
+                    Ok(EitherMultiHostUrl::Rust(PyMultiHostUrl::new(
+                        py_url.get().url().clone(),
+                        None,
+                    )))
                 } else {
                     Err(ValError::new(ErrorTypeDefaults::UrlType, input))
                 }
@@ -284,6 +319,39 @@ impl MultiHostUrlValidator {
     }
 }
 
+enum EitherMultiHostUrl<'py> {
+    Py(Bound<'py, PyMultiHostUrl>),
+    Rust(PyMultiHostUrl),
+}
+
+impl EitherMultiHostUrl<'_> {
+    fn into_py(self, py: Python) -> PyObject {
+        match self {
+            EitherMultiHostUrl::Py(py_multi_url) => py_multi_url.into_py(py),
+            EitherMultiHostUrl::Rust(rust_multi_url) => rust_multi_url.into_py(py),
+        }
+    }
+}
+
+impl CopyFromPyUrl for EitherMultiHostUrl<'_> {
+    fn url(&self) -> &Url {
+        match self {
+            EitherMultiHostUrl::Py(py_multi_url) => py_multi_url.get().lib_url(),
+            EitherMultiHostUrl::Rust(rust_multi_url) => rust_multi_url.lib_url(),
+        }
+    }
+
+    fn url_mut(&mut self) -> &mut Url {
+        if let EitherMultiHostUrl::Py(py_multi_url) = self {
+            *self = EitherMultiHostUrl::Rust(py_multi_url.get().clone());
+        }
+        match self {
+            EitherMultiHostUrl::Py(_) => unreachable!(),
+            EitherMultiHostUrl::Rust(rust_multi_url) => rust_multi_url.mut_lib_url(),
+        }
+    }
+}
+
 fn parse_multihost_url<'py>(
     url_str: &str,
     input: &(impl Input<'py> + ?Sized),
@@ -466,7 +534,7 @@ fn parse_url(url_str: &str, input: impl ToErrorValue, strict: bool) -> ValResult
 
 /// check host_required and substitute `default_host`, `default_port` & `default_path` if they aren't set
 fn check_sub_defaults(
-    lib_url: &mut Url,
+    url: &mut impl CopyFromPyUrl,
     host_required: bool,
     default_host: &Option<String>,
     default_port: Option<u16>,
@@ -476,9 +544,9 @@ fn check_sub_defaults(
         error: e.to_string(),
         context: None,
     };
-    if !lib_url.has_host() {
-        if let Some(ref default_host) = default_host {
-            lib_url.set_host(Some(default_host)).map_err(map_parse_err)?;
+    if let Some(ref default_host) = default_host {
+        if !url.url().has_host() {
+            url.url_mut().set_host(Some(default_host)).map_err(map_parse_err)?;
         } else if host_required {
             return Err(ErrorType::UrlParsing {
                 error: ParseError::EmptyHost.to_string(),
@@ -486,22 +554,29 @@ fn check_sub_defaults(
             });
         }
     }
-    if lib_url.port().is_none() {
-        if let Some(default_port) = default_port {
-            lib_url
+    if let Some(default_port) = default_port {
+        if url.url().port().is_none() {
+            url.url_mut()
                 .set_port(Some(default_port))
                 .map_err(|()| map_parse_err(ParseError::EmptyHost))?;
         }
     }
     if let Some(ref default_path) = default_path {
-        let path = lib_url.path();
+        let path = url.url().path();
         if path.is_empty() || path == "/" {
-            lib_url.set_path(default_path);
+            url.url_mut().set_path(default_path);
         }
     }
     Ok(())
 }
 
+/// Abstraction to create a new Url only when necessary if the existing Url is a PyUrl
+/// and needs to be updated with new defaults
+trait CopyFromPyUrl {
+    fn url(&self) -> &Url;
+    fn url_mut(&mut self) -> &mut Url;
+}
+
 fn get_allowed_schemas(schema: &Bound<'_, PyDict>, name: &'static str) -> PyResult<(AllowedSchemas, String)> {
     match schema.get_as::<&PyList>(intern!(schema.py(), "allowed_schemes"))? {
         Some(list) => {
diff --git a/src/validators/uuid.rs b/src/validators/uuid.rs
index 460a61834..f5d713aa2 100644
--- a/src/validators/uuid.rs
+++ b/src/validators/uuid.rs
@@ -9,6 +9,7 @@ use uuid::Variant;
 
 use crate::build_tools::is_strict;
 use crate::errors::{ErrorType, ErrorTypeDefaults, ValError, ValResult};
+use crate::input::input_as_python_instance;
 use crate::input::Input;
 use crate::input::InputType;
 use crate::tools::SchemaDict;
@@ -93,7 +94,7 @@ impl Validator for UuidValidator {
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let class = get_uuid_type(py)?;
-        if let Some(py_input) = input.input_is_instance(class) {
+        if let Some(py_input) = input_as_python_instance(input, class) {
             if let Some(expected_version) = self.version {
                 let py_input_version: Option<usize> = py_input.getattr(intern!(py, "version"))?.extract()?;
                 if !match py_input_version {
diff --git a/tests/validators/test_url.py b/tests/validators/test_url.py
index 421f5e683..1c349885e 100644
--- a/tests/validators/test_url.py
+++ b/tests/validators/test_url.py
@@ -495,7 +495,7 @@ def test_url_to_url(url_validator, multi_host_url_validator):
     url2 = url_validator.validate_python(url)
     assert isinstance(url2, Url)
     assert str(url2) == 'https://example.com/'
-    assert url is not url2
+    assert url is url2
 
     multi_url = multi_host_url_validator.validate_python('https://example.com')
     assert isinstance(multi_url, MultiHostUrl)
@@ -982,7 +982,7 @@ def test_url_to_multi_url(url_validator, multi_host_url_validator):
     url3 = multi_host_url_validator.validate_python(url2)
     assert isinstance(url3, MultiHostUrl)
     assert str(url3) == 'https://example.com/'
-    assert url2 is not url3
+    assert url2 is url3
 
 
 def test_multi_wrong_type(multi_host_url_validator):

From abaab102810bdf11534be66010ad9a2b87511039 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Thu, 21 Mar 2024 14:06:24 +0000
Subject: [PATCH 243/550] bump version to 2.17.0 (#1239)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 88d00f3c1..31280f2cb 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -304,7 +304,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.16.2"
+version = "2.17.0"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index a3762466e..076a92666 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.16.2"
+version = "2.17.0"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From 1287d226b71a791096548a70bb7531453fd5a3b0 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Thu, 21 Mar 2024 09:20:33 -0500
Subject: [PATCH 244/550] Allow case where `__pydantic_extra__` is `None`, even
 if `extra='allow'` (#1236)

Co-authored-by: David Hewitt <david.hewitt@pydantic.dev>
---
 src/serializers/fields.rs       |  8 +------
 tests/serializers/test_other.py | 38 ++++++++++++++++++++++++++++++++-
 2 files changed, 38 insertions(+), 8 deletions(-)

diff --git a/src/serializers/fields.rs b/src/serializers/fields.rs
index f2dc50eb7..db87ea9c8 100644
--- a/src/serializers/fields.rs
+++ b/src/serializers/fields.rs
@@ -132,13 +132,7 @@ impl GeneralFieldsSerializer {
 
     fn extract_dicts<'a>(&self, value: &Bound<'a, PyAny>) -> Option<(Bound<'a, PyDict>, Option<Bound<'a, PyDict>>)> {
         match self.mode {
-            FieldsMode::ModelExtra => {
-                if let Ok((main_dict, extra_dict)) = value.extract() {
-                    Some((main_dict, Some(extra_dict)))
-                } else {
-                    None
-                }
-            }
+            FieldsMode::ModelExtra => value.extract().ok(),
             _ => {
                 if let Ok(main_dict) = value.downcast::<PyDict>() {
                     Some((main_dict.clone(), None))
diff --git a/tests/serializers/test_other.py b/tests/serializers/test_other.py
index 42549b0b5..505c003d4 100644
--- a/tests/serializers/test_other.py
+++ b/tests/serializers/test_other.py
@@ -1,6 +1,6 @@
 import pytest
 
-from pydantic_core import SchemaSerializer, core_schema
+from pydantic_core import SchemaSerializer, SchemaValidator, core_schema
 
 from ..conftest import plain_repr
 
@@ -60,3 +60,39 @@ def test_lax_or_strict_custom_ser():
     assert s.to_python('abc') == ' abc '
     assert s.to_python('abc', mode='json') == ' abc '
     assert s.to_json('abc') == b'" abc "'
+
+
+def test_serialize_with_extra_on_superclass() -> None:
+    class Parent:
+        x: int
+
+    class Other(Parent):
+        y: str
+
+    Parent.__pydantic_core_schema__ = core_schema.model_schema(
+        Parent,
+        core_schema.model_fields_schema(
+            {
+                'x': core_schema.model_field(core_schema.int_schema()),
+            }
+        ),
+        config=core_schema.CoreConfig(extra_fields_behavior='allow'),
+    )
+    Parent.__pydantic_validator__ = SchemaValidator(Parent.__pydantic_core_schema__)
+    Parent.__pydantic_serializer__ = SchemaSerializer(Parent.__pydantic_core_schema__)
+
+    Other.__pydantic_core_schema__ = core_schema.model_schema(
+        Other,
+        core_schema.model_fields_schema(
+            {
+                'x': core_schema.model_field(core_schema.int_schema()),
+                'y': core_schema.model_field(core_schema.str_schema()),
+            }
+        ),
+        config=core_schema.CoreConfig(extra_fields_behavior='forbid'),
+    )
+    Other.__pydantic_validator__ = SchemaValidator(Other.__pydantic_core_schema__)
+    Other.__pydantic_serializer__ = SchemaSerializer(Other.__pydantic_core_schema__)
+
+    other = Other.__pydantic_validator__.validate_python({'x': 1, 'y': 'some string'})
+    assert Parent.__pydantic_serializer__.to_python(other) == {'x': 1}

From da161402cebdd7f53c1078522bf5922a6a170169 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Thu, 21 Mar 2024 09:34:41 -0500
Subject: [PATCH 245/550] Add `serialize_as_any` runtime flag support (#1194)

Co-authored-by: David Hewitt <mail@davidhewitt.dev>
---
 python/pydantic_core/_pydantic_core.pyi       |   8 +
 python/pydantic_core/core_schema.py           |   2 +
 src/errors/validation_exception.rs            |  18 +-
 src/serializers/extra.rs                      |  55 +++++-
 src/serializers/fields.rs                     |  42 ++++-
 src/serializers/infer.rs                      |   2 +
 src/serializers/mod.rs                        |  26 ++-
 src/serializers/type_serializers/dataclass.rs |  31 +++-
 src/serializers/type_serializers/function.rs  |   8 +-
 src/serializers/type_serializers/model.rs     |  61 ++++---
 tests/serializers/test_functions.py           |  18 +-
 tests/serializers/test_serialize_as_any.py    | 157 ++++++++++++++++++
 tests/test.rs                                 |   4 +-
 tests/test_typing.py                          |   4 +-
 14 files changed, 380 insertions(+), 56 deletions(-)
 create mode 100644 tests/serializers/test_serialize_as_any.py

diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index 7679d9c74..334334087 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -266,6 +266,7 @@ class SchemaSerializer:
         round_trip: bool = False,
         warnings: bool = True,
         fallback: Callable[[Any], Any] | None = None,
+        serialize_as_any: bool = False,
         context: dict[str, Any] | None = None,
     ) -> Any:
         """
@@ -286,6 +287,7 @@ class SchemaSerializer:
             warnings: Whether to log warnings when invalid fields are encountered.
             fallback: A function to call when an unknown value is encountered,
                 if `None` a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
+            serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
             context: The context to use for serialization, this is passed to functional serializers as
                 [`info.context`][pydantic_core.core_schema.SerializationInfo.context].
 
@@ -309,6 +311,7 @@ class SchemaSerializer:
         round_trip: bool = False,
         warnings: bool = True,
         fallback: Callable[[Any], Any] | None = None,
+        serialize_as_any: bool = False,
         context: dict[str, Any] | None = None,
     ) -> bytes:
         """
@@ -328,6 +331,7 @@ class SchemaSerializer:
             warnings: Whether to log warnings when invalid fields are encountered.
             fallback: A function to call when an unknown value is encountered,
                 if `None` a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
+            serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
             context: The context to use for serialization, this is passed to functional serializers as
                 [`info.context`][pydantic_core.core_schema.SerializationInfo.context].
 
@@ -352,6 +356,7 @@ def to_json(
     inf_nan_mode: Literal['null', 'constants'] = 'constants',
     serialize_unknown: bool = False,
     fallback: Callable[[Any], Any] | None = None,
+    serialize_as_any: bool = False,
     context: dict[str, Any] | None = None,
 ) -> bytes:
     """
@@ -374,6 +379,7 @@ def to_json(
             `"<Unserializable {value_type} object>"` will be used.
         fallback: A function to call when an unknown value is encountered,
             if `None` a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
+        serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
         context: The context to use for serialization, this is passed to functional serializers as
             [`info.context`][pydantic_core.core_schema.SerializationInfo.context].
 
@@ -416,6 +422,7 @@ def to_jsonable_python(
     inf_nan_mode: Literal['null', 'constants'] = 'constants',
     serialize_unknown: bool = False,
     fallback: Callable[[Any], Any] | None = None,
+    serialize_as_any: bool = False,
     context: dict[str, Any] | None = None,
 ) -> Any:
     """
@@ -438,6 +445,7 @@ def to_jsonable_python(
             `"<Unserializable {value_type} object>"` will be used.
         fallback: A function to call when an unknown value is encountered,
             if `None` a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
+        serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
         context: The context to use for serialization, this is passed to functional serializers as
             [`info.context`][pydantic_core.core_schema.SerializationInfo.context].
 
diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index b52b3d9c6..1b1ecc7fa 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -142,6 +142,8 @@ def exclude_defaults(self) -> bool: ...
     def exclude_none(self) -> bool: ...
 
     @property
+    def serialize_as_any(self) -> bool: ...
+
     def round_trip(self) -> bool: ...
 
     def mode_is_json(self) -> bool: ...
diff --git a/src/errors/validation_exception.rs b/src/errors/validation_exception.rs
index 8960c8ff2..3a4c3f0c2 100644
--- a/src/errors/validation_exception.rs
+++ b/src/errors/validation_exception.rs
@@ -17,7 +17,7 @@ use crate::build_tools::py_schema_error_type;
 use crate::errors::LocItem;
 use crate::get_pydantic_version;
 use crate::input::InputType;
-use crate::serializers::{SerMode, SerializationState};
+use crate::serializers::{DuckTypingSerMode, Extra, SerMode, SerializationState};
 use crate::tools::{safe_repr, SchemaDict};
 
 use super::line_error::ValLineError;
@@ -323,7 +323,17 @@ impl ValidationError {
         include_input: bool,
     ) -> PyResult<Bound<'py, PyString>> {
         let state = SerializationState::new("iso8601", "utf8", "constants")?;
-        let extra = state.extra(py, &SerMode::Json, true, false, false, true, None, None);
+        let extra = state.extra(
+            py,
+            &SerMode::Json,
+            true,
+            false,
+            false,
+            true,
+            None,
+            DuckTypingSerMode::SchemaBased,
+            None,
+        );
         let serializer = ValidationErrorSerializer {
             py,
             line_errors: &self.line_errors,
@@ -604,7 +614,7 @@ struct ValidationErrorSerializer<'py> {
     url_prefix: Option<&'py str>,
     include_context: bool,
     include_input: bool,
-    extra: &'py crate::serializers::Extra<'py>,
+    extra: &'py Extra<'py>,
     input_type: &'py InputType,
 }
 
@@ -636,7 +646,7 @@ struct PyLineErrorSerializer<'py> {
     url_prefix: Option<&'py str>,
     include_context: bool,
     include_input: bool,
-    extra: &'py crate::serializers::Extra<'py>,
+    extra: &'py Extra<'py>,
     input_type: &'py InputType,
 }
 
diff --git a/src/serializers/extra.rs b/src/serializers/extra.rs
index 4067892cf..ca1eda11f 100644
--- a/src/serializers/extra.rs
+++ b/src/serializers/extra.rs
@@ -23,6 +23,45 @@ pub(crate) struct SerializationState {
     config: SerializationConfig,
 }
 
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum DuckTypingSerMode {
+    // Don't check the type of the value, use the type of the schema
+    SchemaBased,
+    // Check the type of the value, use the type of the value
+    NeedsInference,
+    // We already checked the type of the value
+    // we don't want to infer again, but if we recurse down
+    // we do want to flip this back to NeedsInference for the
+    // fields / keys / items of any inner serializers
+    Inferred,
+}
+
+impl DuckTypingSerMode {
+    pub fn from_bool(serialize_as_any: bool) -> Self {
+        if serialize_as_any {
+            DuckTypingSerMode::NeedsInference
+        } else {
+            DuckTypingSerMode::SchemaBased
+        }
+    }
+
+    pub fn to_bool(self) -> bool {
+        match self {
+            DuckTypingSerMode::SchemaBased => false,
+            DuckTypingSerMode::NeedsInference => true,
+            DuckTypingSerMode::Inferred => true,
+        }
+    }
+
+    pub fn next_mode(self) -> Self {
+        match self {
+            DuckTypingSerMode::SchemaBased => DuckTypingSerMode::SchemaBased,
+            DuckTypingSerMode::NeedsInference => DuckTypingSerMode::Inferred,
+            DuckTypingSerMode::Inferred => DuckTypingSerMode::NeedsInference,
+        }
+    }
+}
+
 impl SerializationState {
     pub fn new(timedelta_mode: &str, bytes_mode: &str, inf_nan_mode: &str) -> PyResult<Self> {
         let warnings = CollectWarnings::new(false);
@@ -44,8 +83,9 @@ impl SerializationState {
         exclude_none: bool,
         round_trip: bool,
         serialize_unknown: bool,
-        fallback: Option<&'py Bound<'py, PyAny>>,
-        context: Option<&'py Bound<'py, PyAny>>,
+        fallback: Option<&'py Bound<'_, PyAny>>,
+        duck_typing_ser_mode: DuckTypingSerMode,
+        context: Option<&'py Bound<'_, PyAny>>,
     ) -> Extra<'py> {
         Extra::new(
             py,
@@ -60,6 +100,7 @@ impl SerializationState {
             &self.rec_guard,
             serialize_unknown,
             fallback,
+            duck_typing_ser_mode,
             context,
         )
     }
@@ -92,6 +133,7 @@ pub(crate) struct Extra<'a> {
     pub field_name: Option<&'a str>,
     pub serialize_unknown: bool,
     pub fallback: Option<&'a Bound<'a, PyAny>>,
+    pub duck_typing_ser_mode: DuckTypingSerMode,
     pub context: Option<&'a Bound<'a, PyAny>>,
 }
 
@@ -110,6 +152,7 @@ impl<'a> Extra<'a> {
         rec_guard: &'a SerRecursionState,
         serialize_unknown: bool,
         fallback: Option<&'a Bound<'a, PyAny>>,
+        duck_typing_ser_mode: DuckTypingSerMode,
         context: Option<&'a Bound<'a, PyAny>>,
     ) -> Self {
         Self {
@@ -128,6 +171,7 @@ impl<'a> Extra<'a> {
             field_name: None,
             serialize_unknown,
             fallback,
+            duck_typing_ser_mode,
             context,
         }
     }
@@ -187,6 +231,7 @@ pub(crate) struct ExtraOwned {
     field_name: Option<String>,
     serialize_unknown: bool,
     pub fallback: Option<PyObject>,
+    duck_typing_ser_mode: DuckTypingSerMode,
     pub context: Option<PyObject>,
 }
 
@@ -206,8 +251,9 @@ impl ExtraOwned {
             model: extra.model.map(|model| model.clone().into()),
             field_name: extra.field_name.map(ToString::to_string),
             serialize_unknown: extra.serialize_unknown,
-            fallback: extra.fallback.map(|fallback| fallback.clone().into()),
-            context: extra.context.map(|context| context.clone().into()),
+            fallback: extra.fallback.map(|model| model.clone().into()),
+            duck_typing_ser_mode: extra.duck_typing_ser_mode,
+            context: extra.context.map(|model| model.clone().into()),
         }
     }
 
@@ -228,6 +274,7 @@ impl ExtraOwned {
             field_name: self.field_name.as_deref(),
             serialize_unknown: self.serialize_unknown,
             fallback: self.fallback.as_ref().map(|m| m.bind(py)),
+            duck_typing_ser_mode: self.duck_typing_ser_mode,
             context: self.context.as_ref().map(|m| m.bind(py)),
         }
     }
diff --git a/src/serializers/fields.rs b/src/serializers/fields.rs
index db87ea9c8..bf72ec218 100644
--- a/src/serializers/fields.rs
+++ b/src/serializers/fields.rs
@@ -8,6 +8,7 @@ use serde::ser::SerializeMap;
 use smallvec::SmallVec;
 
 use crate::serializers::extra::SerCheck;
+use crate::serializers::DuckTypingSerMode;
 use crate::PydanticSerializationUnexpectedValue;
 
 use super::computed_fields::ComputedFields;
@@ -322,15 +323,30 @@ impl TypeSerializer for GeneralFieldsSerializer {
         // then do not touch it
         // If there is no model, we (a TypedDict) are the model
         let model = extra.model.map_or_else(|| Some(value), Some);
-        let td_extra = Extra { model, ..*extra };
+
+        // If there is no model, use duck typing ser logic for TypedDict
+        // If there is a model, skip this step, as BaseModel and dataclass duck typing
+        // is handled in their respective serializers
+        if extra.model.is_none() {
+            let duck_typing_ser_mode = extra.duck_typing_ser_mode.next_mode();
+            let td_extra = Extra {
+                model,
+                duck_typing_ser_mode,
+                ..*extra
+            };
+            if td_extra.duck_typing_ser_mode == DuckTypingSerMode::Inferred {
+                return infer_to_python(value, include, exclude, &td_extra);
+            }
+        }
         let (main_dict, extra_dict) = if let Some(main_extra_dict) = self.extract_dicts(value) {
             main_extra_dict
         } else {
-            td_extra.warnings.on_fallback_py(self.get_name(), value, &td_extra)?;
-            return infer_to_python(value, include, exclude, &td_extra);
+            extra.warnings.on_fallback_py(self.get_name(), value, extra)?;
+            return infer_to_python(value, include, exclude, extra);
         };
 
-        let output_dict = self.main_to_python(py, dict_items(&main_dict), include, exclude, td_extra)?;
+        let output_dict =
+            self.main_to_python(py, dict_items(&main_dict), include, exclude, Extra { model, ..*extra })?;
 
         // this is used to include `__pydantic_extra__` in serialization on models
         if let Some(extra_dict) = extra_dict {
@@ -376,7 +392,21 @@ impl TypeSerializer for GeneralFieldsSerializer {
         // then do not touch it
         // If there is no model, we (a TypedDict) are the model
         let model = extra.model.map_or_else(|| Some(value), Some);
-        let td_extra = Extra { model, ..*extra };
+
+        // If there is no model, use duck typing ser logic for TypedDict
+        // If there is a model, skip this step, as BaseModel and dataclass duck typing
+        // is handled in their respective serializers
+        if extra.model.is_none() {
+            let duck_typing_ser_mode = extra.duck_typing_ser_mode.next_mode();
+            let td_extra = Extra {
+                model,
+                duck_typing_ser_mode,
+                ..*extra
+            };
+            if td_extra.duck_typing_ser_mode == DuckTypingSerMode::Inferred {
+                return infer_serialize(value, serializer, include, exclude, &td_extra);
+            }
+        }
         let expected_len = match self.mode {
             FieldsMode::TypedDictAllow => main_dict.len() + self.computed_field_count(),
             _ => self.fields.len() + option_length!(extra_dict) + self.computed_field_count(),
@@ -389,7 +419,7 @@ impl TypeSerializer for GeneralFieldsSerializer {
             serializer,
             include,
             exclude,
-            td_extra,
+            Extra { model, ..*extra },
         )?;
 
         // this is used to include `__pydantic_extra__` in serialization on models
diff --git a/src/serializers/infer.rs b/src/serializers/infer.rs
index 8be6bfd22..5c6abd7e8 100644
--- a/src/serializers/infer.rs
+++ b/src/serializers/infer.rs
@@ -103,6 +103,7 @@ pub(crate) fn infer_to_python_known(
             extra.rec_guard,
             extra.serialize_unknown,
             extra.fallback,
+            extra.duck_typing_ser_mode,
             extra.context,
         );
         serializer.serializer.to_python(value, include, exclude, &extra)
@@ -475,6 +476,7 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
                 extra.rec_guard,
                 extra.serialize_unknown,
                 extra.fallback,
+                extra.duck_typing_ser_mode,
                 extra.context,
             );
             let pydantic_serializer =
diff --git a/src/serializers/mod.rs b/src/serializers/mod.rs
index aef5be702..14650a9df 100644
--- a/src/serializers/mod.rs
+++ b/src/serializers/mod.rs
@@ -11,7 +11,7 @@ use crate::py_gc::PyGcTraverse;
 use config::SerializationConfig;
 pub use errors::{PydanticSerializationError, PydanticSerializationUnexpectedValue};
 use extra::{CollectWarnings, SerRecursionState};
-pub(crate) use extra::{Extra, SerMode, SerializationState};
+pub(crate) use extra::{DuckTypingSerMode, Extra, SerMode, SerializationState};
 pub use shared::CombinedSerializer;
 use shared::{to_json_bytes, BuildSerializer, TypeSerializer};
 
@@ -55,6 +55,7 @@ impl SchemaSerializer {
         rec_guard: &'a SerRecursionState,
         serialize_unknown: bool,
         fallback: Option<&'a Bound<'a, PyAny>>,
+        duck_typing_ser_mode: DuckTypingSerMode,
         context: Option<&'a Bound<'a, PyAny>>,
     ) -> Extra<'b> {
         Extra::new(
@@ -70,6 +71,7 @@ impl SchemaSerializer {
             rec_guard,
             serialize_unknown,
             fallback,
+            duck_typing_ser_mode,
             context,
         )
     }
@@ -97,7 +99,7 @@ impl SchemaSerializer {
     #[allow(clippy::too_many_arguments)]
     #[pyo3(signature = (value, *, mode = None, include = None, exclude = None, by_alias = true,
         exclude_unset = false, exclude_defaults = false, exclude_none = false, round_trip = false, warnings = true,
-        fallback = None, context = None))]
+        fallback = None, serialize_as_any = false, context = None))]
     pub fn to_python(
         &self,
         py: Python,
@@ -112,11 +114,13 @@ impl SchemaSerializer {
         round_trip: bool,
         warnings: bool,
         fallback: Option<&Bound<'_, PyAny>>,
+        serialize_as_any: bool,
         context: Option<&Bound<'_, PyAny>>,
     ) -> PyResult<PyObject> {
         let mode: SerMode = mode.into();
         let warnings = CollectWarnings::new(warnings);
         let rec_guard = SerRecursionState::default();
+        let duck_typing_ser_mode = DuckTypingSerMode::from_bool(serialize_as_any);
         let extra = self.build_extra(
             py,
             &mode,
@@ -129,6 +133,7 @@ impl SchemaSerializer {
             &rec_guard,
             false,
             fallback,
+            duck_typing_ser_mode,
             context,
         );
         let v = self.serializer.to_python(value, include, exclude, &extra)?;
@@ -139,7 +144,7 @@ impl SchemaSerializer {
     #[allow(clippy::too_many_arguments)]
     #[pyo3(signature = (value, *, indent = None, include = None, exclude = None, by_alias = true,
         exclude_unset = false, exclude_defaults = false, exclude_none = false, round_trip = false, warnings = true,
-        fallback = None, context = None))]
+        fallback = None, serialize_as_any = false, context = None))]
     pub fn to_json(
         &self,
         py: Python,
@@ -154,10 +159,12 @@ impl SchemaSerializer {
         round_trip: bool,
         warnings: bool,
         fallback: Option<&Bound<'_, PyAny>>,
+        serialize_as_any: bool,
         context: Option<&Bound<'_, PyAny>>,
     ) -> PyResult<PyObject> {
         let warnings = CollectWarnings::new(warnings);
         let rec_guard = SerRecursionState::default();
+        let duck_typing_ser_mode = DuckTypingSerMode::from_bool(serialize_as_any);
         let extra = self.build_extra(
             py,
             &SerMode::Json,
@@ -170,6 +177,7 @@ impl SchemaSerializer {
             &rec_guard,
             false,
             fallback,
+            duck_typing_ser_mode,
             context,
         );
         let bytes = to_json_bytes(
@@ -219,7 +227,8 @@ impl SchemaSerializer {
 #[pyfunction]
 #[pyo3(signature = (value, *, indent = None, include = None, exclude = None, by_alias = true,
     exclude_none = false, round_trip = false, timedelta_mode = "iso8601", bytes_mode = "utf8",
-    inf_nan_mode = "constants", serialize_unknown = false, fallback = None, context = None))]
+    inf_nan_mode = "constants", serialize_unknown = false, fallback = None, serialize_as_any = false,
+    context = None))]
 pub fn to_json(
     py: Python,
     value: &Bound<'_, PyAny>,
@@ -234,9 +243,11 @@ pub fn to_json(
     inf_nan_mode: &str,
     serialize_unknown: bool,
     fallback: Option<&Bound<'_, PyAny>>,
+    serialize_as_any: bool,
     context: Option<&Bound<'_, PyAny>>,
 ) -> PyResult<PyObject> {
     let state = SerializationState::new(timedelta_mode, bytes_mode, inf_nan_mode)?;
+    let duck_typing_ser_mode = DuckTypingSerMode::from_bool(serialize_as_any);
     let extra = state.extra(
         py,
         &SerMode::Json,
@@ -245,6 +256,7 @@ pub fn to_json(
         round_trip,
         serialize_unknown,
         fallback,
+        duck_typing_ser_mode,
         context,
     );
     let serializer = type_serializers::any::AnySerializer.into();
@@ -257,7 +269,8 @@ pub fn to_json(
 #[allow(clippy::too_many_arguments)]
 #[pyfunction]
 #[pyo3(signature = (value, *, include = None, exclude = None, by_alias = true, exclude_none = false, round_trip = false,
-    timedelta_mode = "iso8601", bytes_mode = "utf8", inf_nan_mode = "constants", serialize_unknown = false, fallback = None, context = None))]
+    timedelta_mode = "iso8601", bytes_mode = "utf8", inf_nan_mode = "constants", serialize_unknown = false, fallback = None,
+    serialize_as_any = false, context = None))]
 pub fn to_jsonable_python(
     py: Python,
     value: &Bound<'_, PyAny>,
@@ -271,9 +284,11 @@ pub fn to_jsonable_python(
     inf_nan_mode: &str,
     serialize_unknown: bool,
     fallback: Option<&Bound<'_, PyAny>>,
+    serialize_as_any: bool,
     context: Option<&Bound<'_, PyAny>>,
 ) -> PyResult<PyObject> {
     let state = SerializationState::new(timedelta_mode, bytes_mode, inf_nan_mode)?;
+    let duck_typing_ser_mode = DuckTypingSerMode::from_bool(serialize_as_any);
     let extra = state.extra(
         py,
         &SerMode::Json,
@@ -282,6 +297,7 @@ pub fn to_jsonable_python(
         round_trip,
         serialize_unknown,
         fallback,
+        duck_typing_ser_mode,
         context,
     );
     let v = infer::infer_to_python(value, include, exclude, &extra)?;
diff --git a/src/serializers/type_serializers/dataclass.rs b/src/serializers/type_serializers/dataclass.rs
index 2c4954d4d..193e75b66 100644
--- a/src/serializers/type_serializers/dataclass.rs
+++ b/src/serializers/type_serializers/dataclass.rs
@@ -8,6 +8,7 @@ use serde::ser::SerializeMap;
 
 use crate::build_tools::{py_schema_error_type, ExtraBehavior};
 use crate::definitions::DefinitionsBuilder;
+use crate::serializers::DuckTypingSerMode;
 use crate::tools::SchemaDict;
 
 use super::{
@@ -132,11 +133,17 @@ impl TypeSerializer for DataclassSerializer {
         exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
+        let model = Some(value);
+        let duck_typing_ser_mode = extra.duck_typing_ser_mode.next_mode();
         let dc_extra = Extra {
-            model: Some(value),
+            model,
+            duck_typing_ser_mode,
             ..*extra
         };
-        if self.allow_value(value, extra)? {
+        if dc_extra.duck_typing_ser_mode == DuckTypingSerMode::Inferred {
+            return infer_to_python(value, include, exclude, &dc_extra);
+        }
+        if self.allow_value(value, &dc_extra)? {
             let py = value.py();
             if let CombinedSerializer::Fields(ref fields_serializer) = *self.serializer {
                 let output_dict = fields_serializer.main_to_python(
@@ -147,7 +154,7 @@ impl TypeSerializer for DataclassSerializer {
                     dc_extra,
                 )?;
 
-                fields_serializer.add_computed_fields_python(Some(value), &output_dict, include, exclude, extra)?;
+                fields_serializer.add_computed_fields_python(model, &output_dict, include, exclude, extra)?;
                 Ok(output_dict.into_py(py))
             } else {
                 let inner_value = self.get_inner_value(value)?;
@@ -176,9 +183,17 @@ impl TypeSerializer for DataclassSerializer {
         exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
+        let duck_typing_ser_mode = extra.duck_typing_ser_mode.next_mode();
         let model = Some(value);
-        let dc_extra = Extra { model, ..*extra };
-        if self.allow_value(value, extra).map_err(py_err_se_err)? {
+        let dc_extra = Extra {
+            model,
+            duck_typing_ser_mode,
+            ..*extra
+        };
+        if dc_extra.duck_typing_ser_mode == DuckTypingSerMode::Inferred {
+            return infer_serialize(value, serializer, include, exclude, &dc_extra);
+        }
+        if self.allow_value(value, &dc_extra).map_err(py_err_se_err)? {
             if let CombinedSerializer::Fields(ref fields_serializer) = *self.serializer {
                 let expected_len = self.fields.len() + fields_serializer.computed_field_count();
                 let mut map = fields_serializer.main_serde_serialize(
@@ -194,11 +209,11 @@ impl TypeSerializer for DataclassSerializer {
             } else {
                 let inner_value = self.get_inner_value(value).map_err(py_err_se_err)?;
                 self.serializer
-                    .serde_serialize(&inner_value, serializer, include, exclude, extra)
+                    .serde_serialize(&inner_value, serializer, include, exclude, &dc_extra)
             }
         } else {
-            extra.warnings.on_fallback_ser::<S>(self.get_name(), value, extra)?;
-            infer_serialize(value, serializer, include, exclude, extra)
+            extra.warnings.on_fallback_ser::<S>(self.get_name(), value, &dc_extra)?;
+            infer_serialize(value, serializer, include, exclude, &dc_extra)
         }
     }
 
diff --git a/src/serializers/type_serializers/function.rs b/src/serializers/type_serializers/function.rs
index 415db806a..01bc6606a 100644
--- a/src/serializers/type_serializers/function.rs
+++ b/src/serializers/type_serializers/function.rs
@@ -541,6 +541,8 @@ struct SerializationInfo {
     #[pyo3(get)]
     round_trip: bool,
     field_name: Option<String>,
+    #[pyo3(get)]
+    serialize_as_any: bool,
 }
 
 impl SerializationInfo {
@@ -564,6 +566,7 @@ impl SerializationInfo {
                     exclude_none: extra.exclude_none,
                     round_trip: extra.round_trip,
                     field_name: Some(field_name.to_string()),
+                    serialize_as_any: extra.duck_typing_ser_mode.to_bool(),
                 }),
                 _ => Err(PyRuntimeError::new_err(
                     "Model field context expected for field serialization info but no model field was found",
@@ -581,6 +584,7 @@ impl SerializationInfo {
                 exclude_none: extra.exclude_none,
                 round_trip: extra.round_trip,
                 field_name: None,
+                serialize_as_any: extra.duck_typing_ser_mode.to_bool(),
             })
         }
     }
@@ -634,12 +638,13 @@ impl SerializationInfo {
         d.set_item("exclude_defaults", self.exclude_defaults)?;
         d.set_item("exclude_none", self.exclude_none)?;
         d.set_item("round_trip", self.round_trip)?;
+        d.set_item("serialize_as_any", self.serialize_as_any)?;
         Ok(d)
     }
 
     fn __repr__(&self, py: Python) -> PyResult<String> {
         Ok(format!(
-            "SerializationInfo(include={}, exclude={}, context={}, mode='{}', by_alias={}, exclude_unset={}, exclude_defaults={}, exclude_none={}, round_trip={})",
+            "SerializationInfo(include={}, exclude={}, context={}, mode='{}', by_alias={}, exclude_unset={}, exclude_defaults={}, exclude_none={}, round_trip={}, serialize_as_any={})",
             match self.include {
                 Some(ref include) => include.bind(py).repr()?.to_str()?.to_owned(),
                 None => "None".to_owned(),
@@ -658,6 +663,7 @@ impl SerializationInfo {
             py_bool(self.exclude_defaults),
             py_bool(self.exclude_none),
             py_bool(self.round_trip),
+            py_bool(self.serialize_as_any),
         ))
     }
 
diff --git a/src/serializers/type_serializers/model.rs b/src/serializers/type_serializers/model.rs
index e40fa2f7f..5459c63ac 100644
--- a/src/serializers/type_serializers/model.rs
+++ b/src/serializers/type_serializers/model.rs
@@ -15,6 +15,7 @@ use crate::build_tools::py_schema_err;
 use crate::build_tools::{py_schema_error_type, ExtraBehavior};
 use crate::definitions::DefinitionsBuilder;
 use crate::serializers::errors::PydanticSerializationUnexpectedValue;
+use crate::serializers::extra::DuckTypingSerMode;
 use crate::tools::SchemaDict;
 
 const ROOT_FIELD: &str = "root";
@@ -164,28 +165,38 @@ impl TypeSerializer for ModelSerializer {
         exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
-        let mut extra = Extra {
-            model: Some(value),
+        let model = Some(value);
+        let duck_typing_ser_mode = extra.duck_typing_ser_mode.next_mode();
+        let model_extra = Extra {
+            model,
             field_name: None,
+            duck_typing_ser_mode,
             ..*extra
         };
+        if model_extra.duck_typing_ser_mode == DuckTypingSerMode::Inferred {
+            return infer_to_python(value, include, exclude, &model_extra);
+        }
         if self.root_model {
-            extra.field_name = Some(ROOT_FIELD);
+            let field_name = Some(ROOT_FIELD);
+            let root_extra = Extra {
+                field_name,
+                ..model_extra
+            };
             let py = value.py();
             let root = value.getattr(intern!(py, ROOT_FIELD)).map_err(|original_err| {
-                if extra.check.enabled() {
+                if root_extra.check.enabled() {
                     PydanticSerializationUnexpectedValue::new_err(None)
                 } else {
                     original_err
                 }
             })?;
-            self.serializer.to_python(&root, include, exclude, &extra)
-        } else if self.allow_value(value, &extra)? {
-            let inner_value = self.get_inner_value(value, &extra)?;
-            self.serializer.to_python(&inner_value, include, exclude, &extra)
+            self.serializer.to_python(&root, include, exclude, &root_extra)
+        } else if self.allow_value(value, &model_extra)? {
+            let inner_value = self.get_inner_value(value, &model_extra)?;
+            self.serializer.to_python(&inner_value, include, exclude, &model_extra)
         } else {
-            extra.warnings.on_fallback_py(self.get_name(), value, &extra)?;
-            infer_to_python(value, include, exclude, &extra)
+            extra.warnings.on_fallback_py(self.get_name(), value, &model_extra)?;
+            infer_to_python(value, include, exclude, &model_extra)
         }
     }
 
@@ -206,24 +217,36 @@ impl TypeSerializer for ModelSerializer {
         exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
-        let mut extra = Extra {
-            model: Some(value),
+        let model = Some(value);
+        let duck_typing_ser_mode = extra.duck_typing_ser_mode.next_mode();
+        let model_extra = Extra {
+            model,
             field_name: None,
+            duck_typing_ser_mode,
             ..*extra
         };
+        if model_extra.duck_typing_ser_mode == DuckTypingSerMode::Inferred {
+            return infer_serialize(value, serializer, include, exclude, &model_extra);
+        }
         if self.root_model {
-            extra.field_name = Some(ROOT_FIELD);
+            let field_name = Some(ROOT_FIELD);
+            let root_extra = Extra {
+                field_name,
+                ..model_extra
+            };
             let py = value.py();
             let root = value.getattr(intern!(py, ROOT_FIELD)).map_err(py_err_se_err)?;
             self.serializer
-                .serde_serialize(&root, serializer, include, exclude, &extra)
-        } else if self.allow_value(value, &extra).map_err(py_err_se_err)? {
-            let inner_value = self.get_inner_value(value, &extra).map_err(py_err_se_err)?;
+                .serde_serialize(&root, serializer, include, exclude, &root_extra)
+        } else if self.allow_value(value, &model_extra).map_err(py_err_se_err)? {
+            let inner_value = self.get_inner_value(value, &model_extra).map_err(py_err_se_err)?;
             self.serializer
-                .serde_serialize(&inner_value, serializer, include, exclude, &extra)
+                .serde_serialize(&inner_value, serializer, include, exclude, &model_extra)
         } else {
-            extra.warnings.on_fallback_ser::<S>(self.get_name(), value, &extra)?;
-            infer_serialize(value, serializer, include, exclude, &extra)
+            extra
+                .warnings
+                .on_fallback_ser::<S>(self.get_name(), value, &model_extra)?;
+            infer_serialize(value, serializer, include, exclude, &model_extra)
         }
     }
 
diff --git a/tests/serializers/test_functions.py b/tests/serializers/test_functions.py
index e9a59bad2..c5b28ec31 100644
--- a/tests/serializers/test_functions.py
+++ b/tests/serializers/test_functions.py
@@ -73,6 +73,7 @@ def double(value, info):
         'exclude_defaults': False,
         'exclude_none': False,
         'round_trip': False,
+        'serialize_as_any': False,
     }
     assert s.to_python('x') == 'xx'
 
@@ -85,6 +86,7 @@ def double(value, info):
         'exclude_defaults': False,
         'exclude_none': False,
         'round_trip': False,
+        'serialize_as_any': False,
     }
 
     assert s.to_json(42) == b'84'
@@ -96,6 +98,7 @@ def double(value, info):
         'exclude_defaults': False,
         'exclude_none': False,
         'round_trip': False,
+        'serialize_as_any': False,
     }
 
     assert s.to_python(7, mode='json', by_alias=False, exclude_unset=True) == 14
@@ -107,6 +110,7 @@ def double(value, info):
         'exclude_defaults': False,
         'exclude_none': False,
         'round_trip': False,
+        'serialize_as_any': False,
     }
 
     assert s.to_python(1, include={1, 2, 3}, exclude={'foo': {'bar'}}) == 2
@@ -120,6 +124,7 @@ def double(value, info):
         'exclude_defaults': False,
         'exclude_none': False,
         'round_trip': False,
+        'serialize_as_any': False,
     }
 
     assert s.to_python(1, context='context') == 2
@@ -132,6 +137,7 @@ def double(value, info):
         'exclude_defaults': False,
         'exclude_none': False,
         'round_trip': False,
+        'serialize_as_any': False,
     }
 
 
@@ -225,27 +231,27 @@ def append_args(value, info):
     )
     assert s.to_python(123) == (
         "123 info=SerializationInfo(include=None, exclude=None, context=None, mode='python', by_alias=True, exclude_unset=False, "
-        'exclude_defaults=False, exclude_none=False, round_trip=False)'
+        'exclude_defaults=False, exclude_none=False, round_trip=False, serialize_as_any=False)'
     )
     assert s.to_python(123, mode='other') == (
         "123 info=SerializationInfo(include=None, exclude=None, context=None, mode='other', by_alias=True, exclude_unset=False, "
-        'exclude_defaults=False, exclude_none=False, round_trip=False)'
+        'exclude_defaults=False, exclude_none=False, round_trip=False, serialize_as_any=False)'
     )
     assert s.to_python(123, include={'x'}) == (
         "123 info=SerializationInfo(include={'x'}, exclude=None, context=None, mode='python', by_alias=True, exclude_unset=False, "
-        'exclude_defaults=False, exclude_none=False, round_trip=False)'
+        'exclude_defaults=False, exclude_none=False, round_trip=False, serialize_as_any=False)'
     )
     assert s.to_python(123, context='context') == (
         "123 info=SerializationInfo(include=None, exclude=None, context='context', mode='python', by_alias=True, exclude_unset=False, "
-        'exclude_defaults=False, exclude_none=False, round_trip=False)'
+        'exclude_defaults=False, exclude_none=False, round_trip=False, serialize_as_any=False)'
     )
     assert s.to_python(123, mode='json', exclude={1: {2}}) == (
         "123 info=SerializationInfo(include=None, exclude={1: {2}}, context=None, mode='json', by_alias=True, exclude_unset=False, "
-        'exclude_defaults=False, exclude_none=False, round_trip=False)'
+        'exclude_defaults=False, exclude_none=False, round_trip=False, serialize_as_any=False)'
     )
     assert s.to_json(123) == (
         b"\"123 info=SerializationInfo(include=None, exclude=None, context=None, mode='json', by_alias=True, exclude_unset=False, "
-        b'exclude_defaults=False, exclude_none=False, round_trip=False)"'
+        b'exclude_defaults=False, exclude_none=False, round_trip=False, serialize_as_any=False)"'
     )
 
 
diff --git a/tests/serializers/test_serialize_as_any.py b/tests/serializers/test_serialize_as_any.py
new file mode 100644
index 000000000..1d1be238b
--- /dev/null
+++ b/tests/serializers/test_serialize_as_any.py
@@ -0,0 +1,157 @@
+from dataclasses import dataclass
+
+from typing_extensions import TypedDict
+
+from pydantic_core import SchemaSerializer, SchemaValidator, core_schema
+
+
+def test_serialize_as_any_with_models() -> None:
+    class Parent:
+        x: int
+
+    class Child(Parent):
+        y: str
+
+    Parent.__pydantic_core_schema__ = core_schema.model_schema(
+        Parent,
+        core_schema.model_fields_schema(
+            {
+                'x': core_schema.model_field(core_schema.int_schema()),
+            }
+        ),
+    )
+    Parent.__pydantic_validator__ = SchemaValidator(Parent.__pydantic_core_schema__)
+    Parent.__pydantic_serializer__ = SchemaSerializer(Parent.__pydantic_core_schema__)
+
+    Child.__pydantic_core_schema__ = core_schema.model_schema(
+        Child,
+        core_schema.model_fields_schema(
+            {
+                'x': core_schema.model_field(core_schema.int_schema()),
+                'y': core_schema.model_field(core_schema.str_schema()),
+            }
+        ),
+    )
+    Child.__pydantic_validator__ = SchemaValidator(Child.__pydantic_core_schema__)
+    Child.__pydantic_serializer__ = SchemaSerializer(Child.__pydantic_core_schema__)
+
+    child = Child.__pydantic_validator__.validate_python({'x': 1, 'y': 'hopefully not a secret'})
+    assert Parent.__pydantic_serializer__.to_python(child, serialize_as_any=False) == {'x': 1}
+    assert Parent.__pydantic_serializer__.to_python(child, serialize_as_any=True) == {
+        'x': 1,
+        'y': 'hopefully not a secret',
+    }
+
+
+def test_serialize_as_any_with_dataclass() -> None:
+    @dataclass
+    class Parent:
+        x: int
+
+    class Child(Parent):
+        y: str
+
+    Parent.__pydantic_core_schema__ = core_schema.dataclass_schema(
+        Parent,
+        core_schema.dataclass_args_schema(
+            'Parent',
+            [
+                core_schema.dataclass_field(name='x', schema=core_schema.int_schema()),
+            ],
+        ),
+        ['x'],
+    )
+    Parent.__pydantic_validator__ = SchemaValidator(Parent.__pydantic_core_schema__)
+    Parent.__pydantic_serializer__ = SchemaSerializer(Parent.__pydantic_core_schema__)
+
+    Child.__pydantic_core_schema__ = core_schema.dataclass_schema(
+        Child,
+        core_schema.dataclass_args_schema(
+            'Child',
+            [
+                core_schema.dataclass_field(name='x', schema=core_schema.int_schema()),
+                core_schema.dataclass_field(name='y', schema=core_schema.str_schema()),
+            ],
+        ),
+        ['x', 'y'],
+    )
+    Child.__pydantic_validator__ = SchemaValidator(Child.__pydantic_core_schema__)
+    Child.__pydantic_serializer__ = SchemaSerializer(Child.__pydantic_core_schema__)
+
+    child = Child.__pydantic_validator__.validate_python({'x': 1, 'y': 'hopefully not a secret'})
+    assert Parent.__pydantic_serializer__.to_python(child, serialize_as_any=False) == {'x': 1}
+    assert Parent.__pydantic_serializer__.to_python(child, serialize_as_any=True) == {
+        'x': 1,
+        'y': 'hopefully not a secret',
+    }
+
+
+def test_serialize_as_any_with_typeddict() -> None:
+    class Parent(TypedDict):
+        x: int
+
+    class Child(Parent):
+        y: str
+
+    Parent.__pydantic_core_schema__ = core_schema.typed_dict_schema(
+        {
+            'x': core_schema.typed_dict_field(core_schema.int_schema()),
+        }
+    )
+    Parent.__pydantic_validator__ = SchemaValidator(Parent.__pydantic_core_schema__)
+    Parent.__pydantic_serializer__ = SchemaSerializer(Parent.__pydantic_core_schema__)
+
+    Child.__pydantic_core_schema__ = core_schema.typed_dict_schema(
+        {
+            'x': core_schema.typed_dict_field(core_schema.int_schema()),
+            'y': core_schema.typed_dict_field(core_schema.str_schema()),
+        }
+    )
+    Child.__pydantic_validator__ = SchemaValidator(Child.__pydantic_core_schema__)
+    Child.__pydantic_serializer__ = SchemaSerializer(Child.__pydantic_core_schema__)
+
+    child = Child.__pydantic_validator__.validate_python({'x': 1, 'y': 'hopefully not a secret'})
+    assert Parent.__pydantic_serializer__.to_python(child, serialize_as_any=False) == {'x': 1}
+    assert Parent.__pydantic_serializer__.to_python(child, serialize_as_any=True) == {
+        'x': 1,
+        'y': 'hopefully not a secret',
+    }
+
+
+def test_serialize_as_any_with_unrelated_models() -> None:
+    class Parent:
+        x: int
+
+    class Other:
+        y: str
+
+    Parent.__pydantic_core_schema__ = core_schema.model_schema(
+        Parent,
+        core_schema.model_fields_schema(
+            {
+                'x': core_schema.model_field(core_schema.int_schema()),
+            }
+        ),
+    )
+    Parent.__pydantic_validator__ = SchemaValidator(Parent.__pydantic_core_schema__)
+    Parent.__pydantic_serializer__ = SchemaSerializer(Parent.__pydantic_core_schema__)
+
+    Other.__pydantic_core_schema__ = core_schema.model_schema(
+        Other,
+        core_schema.model_fields_schema(
+            {
+                'y': core_schema.model_field(core_schema.str_schema()),
+            }
+        ),
+        config=core_schema.CoreConfig(extra_fields_behavior='allow'),
+    )
+    Other.__pydantic_validator__ = SchemaValidator(Other.__pydantic_core_schema__)
+    Other.__pydantic_serializer__ = SchemaSerializer(Other.__pydantic_core_schema__)
+
+    other = Other.__pydantic_validator__.validate_python({'x': 1, 'y': 'hopefully not a secret'})
+    assert Parent.__pydantic_serializer__.to_python(other, serialize_as_any=False) == {}
+    # note, without extra='allow', the 'x' field would not be included, as it's not in the schema
+    assert Parent.__pydantic_serializer__.to_python(other, serialize_as_any=True) == {
+        'x': 1,
+        'y': 'hopefully not a secret',
+    }
diff --git a/tests/test.rs b/tests/test.rs
index 2609316ad..53c99daf6 100644
--- a/tests/test.rs
+++ b/tests/test.rs
@@ -85,7 +85,7 @@ a = A()
             let serialized = SchemaSerializer::py_new(schema, None)
                 .unwrap()
                 .to_json(
-                    py, &a, None, None, None, true, false, false, false, false, true, None, None,
+                    py, &a, None, None, None, true, false, false, false, false, true, None, false, None,
                 )
                 .unwrap();
             let serialized: &[u8] = serialized.extract(py).unwrap();
@@ -188,6 +188,7 @@ dump_json_input_2 = {'a': 'something'}
                     false,
                     false,
                     None,
+                    false,
                     None,
                 )
                 .unwrap();
@@ -208,6 +209,7 @@ dump_json_input_2 = {'a': 'something'}
                     false,
                     false,
                     None,
+                    false,
                     None,
                 )
                 .unwrap();
diff --git a/tests/test_typing.py b/tests/test_typing.py
index 22ba1f6e3..2f460fb48 100644
--- a/tests/test_typing.py
+++ b/tests/test_typing.py
@@ -233,7 +233,7 @@ def f(input: Any, info: core_schema.SerializationInfo, /) -> str:
     )
     assert s.to_python(123) == (
         "SerializationInfo(include=None, exclude=None, context=None, mode='python', by_alias=True, exclude_unset=False, "
-        'exclude_defaults=False, exclude_none=False, round_trip=False)'
+        'exclude_defaults=False, exclude_none=False, round_trip=False, serialize_as_any=False)'
     )
 
 
@@ -254,7 +254,7 @@ def f(
     assert s.to_python(123, mode='json') == (
         'SerializationCallable(serializer=str) '
         "SerializationInfo(include=None, exclude=None, context=None, mode='json', by_alias=True, exclude_unset=False, "
-        'exclude_defaults=False, exclude_none=False, round_trip=False)'
+        'exclude_defaults=False, exclude_none=False, round_trip=False, serialize_as_any=False)'
     )
 
 

From 193f5d7a8627c988b1c7fab9a3712c779afbbe94 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Thu, 21 Mar 2024 10:36:42 -0500
Subject: [PATCH 246/550] Uprev `speedate` (#1244)

---
 Cargo.lock                          |  4 ++--
 Cargo.toml                          |  2 +-
 tests/serializers/test_any.py       |  6 +++---
 tests/serializers/test_timedelta.py | 12 ++++++------
 4 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 31280f2cb..910e9b456 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -506,9 +506,9 @@ checksum = "e6ecd384b10a64542d77071bd64bd7b231f4ed5940fba55e98c3de13824cf3d7"
 
 [[package]]
 name = "speedate"
-version = "0.13.0"
+version = "0.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "242f76c50fd18cbf098607090ade73a08d39cfd84ea835f3796a2c855223b19b"
+checksum = "c323c4e6fece5a5a1a2a7f726d243144cce9fbcfe3ce4d9f3c6ede726a2bc780"
 dependencies = [
  "strum",
  "strum_macros 0.25.3",
diff --git a/Cargo.toml b/Cargo.toml
index 076a92666..46b1ed4ca 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -34,7 +34,7 @@ strum_macros = "0.26.1"
 serde_json = {version = "1.0.114", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.8"
 serde = { version = "1.0.196", features = ["derive"] }
-speedate = "0.13.0"
+speedate = "0.14.0"
 smallvec = "1.13.1"
 ahash = "0.8.10"
 url = "2.5.0"
diff --git a/tests/serializers/test_any.py b/tests/serializers/test_any.py
index 875a3fcf1..281c96970 100644
--- a/tests/serializers/test_any.py
+++ b/tests/serializers/test_any.py
@@ -105,7 +105,7 @@ def test_set_member_db(any_serializer):
         (datetime(2032, 1, 1, 1, 1), b'"2032-01-01T01:01:00"'),
         (date(2022, 12, 3), b'"2022-12-03"'),
         (time(12, 30, 45), b'"12:30:45"'),
-        (timedelta(hours=2), b'"PT7200S"'),
+        (timedelta(hours=2), b'"PT2H"'),
         (MyDataclass(1, 'foo', 2), b'{"a":1,"b":"foo"}'),
         (MyModel(a=1, b='foo'), b'{"a":1,"b":"foo"}'),
         ([MyDataclass(1, 'a', 2), MyModel(a=2, b='b')], b'[{"a":1,"b":"a"},{"a":2,"b":"b"}]'),
@@ -164,8 +164,8 @@ def test_any_with_date_serializer():
 def test_any_with_timedelta_serializer():
     s = SchemaSerializer(core_schema.any_schema(serialization={'type': 'timedelta'}))
     assert s.to_python(timedelta(hours=2)) == timedelta(hours=2)
-    assert s.to_python(timedelta(hours=2), mode='json') == 'PT7200S'
-    assert s.to_json(timedelta(hours=2)) == b'"PT7200S"'
+    assert s.to_python(timedelta(hours=2), mode='json') == 'PT2H'
+    assert s.to_json(timedelta(hours=2)) == b'"PT2H"'
 
     with pytest.warns(UserWarning) as warning_info:
         assert s.to_python(b'bang', mode='json') == 'bang'
diff --git a/tests/serializers/test_timedelta.py b/tests/serializers/test_timedelta.py
index 391da1d52..91b5716b0 100644
--- a/tests/serializers/test_timedelta.py
+++ b/tests/serializers/test_timedelta.py
@@ -14,8 +14,8 @@ def test_timedelta():
     v = SchemaSerializer(core_schema.timedelta_schema())
     assert v.to_python(timedelta(days=2, hours=3, minutes=4)) == timedelta(days=2, hours=3, minutes=4)
 
-    assert v.to_python(timedelta(days=2, hours=3, minutes=4), mode='json') == 'P2DT11040S'
-    assert v.to_json(timedelta(days=2, hours=3, minutes=4)) == b'"P2DT11040S"'
+    assert v.to_python(timedelta(days=2, hours=3, minutes=4), mode='json') == 'P2DT3H4M'
+    assert v.to_json(timedelta(days=2, hours=3, minutes=4)) == b'"P2DT3H4M"'
 
     with pytest.warns(
         UserWarning, match='Expected `timedelta` but got `int` - serialized value may not be as expected'
@@ -39,8 +39,8 @@ def test_timedelta_float():
 def test_timedelta_key():
     v = SchemaSerializer(core_schema.dict_schema(core_schema.timedelta_schema(), core_schema.int_schema()))
     assert v.to_python({timedelta(days=2, hours=3, minutes=4): 1}) == {timedelta(days=2, hours=3, minutes=4): 1}
-    assert v.to_python({timedelta(days=2, hours=3, minutes=4): 1}, mode='json') == {'P2DT11040S': 1}
-    assert v.to_json({timedelta(days=2, hours=3, minutes=4): 1}) == b'{"P2DT11040S":1}'
+    assert v.to_python({timedelta(days=2, hours=3, minutes=4): 1}, mode='json') == {'P2DT3H4M': 1}
+    assert v.to_json({timedelta(days=2, hours=3, minutes=4): 1}) == b'{"P2DT3H4M":1}'
 
 
 @pytest.mark.skipif(not pandas, reason='pandas not installed')
@@ -48,5 +48,5 @@ def test_pandas():
     v = SchemaSerializer(core_schema.timedelta_schema())
     d = pandas.Timestamp('2023-01-01T02:00:00Z') - pandas.Timestamp('2023-01-01T00:00:00Z')
     assert v.to_python(d) == d
-    assert v.to_python(d, mode='json') == 'PT7200S'
-    assert v.to_json(d) == b'"PT7200S"'
+    assert v.to_python(d, mode='json') == 'PT2H'
+    assert v.to_json(d) == b'"PT2H"'

From 0830d0dcd0a0d2f21f8269468c55d27434133f4e Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Tue, 26 Mar 2024 14:17:39 +0000
Subject: [PATCH 247/550] update to PyO3 0.21 final (#1248)

---
 Cargo.lock              | 20 ++++++++++----------
 Cargo.toml              |  6 +++---
 src/argument_markers.rs |  2 +-
 3 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 910e9b456..cb04a926b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -329,9 +329,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.21.0-beta.0"
+version = "0.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5d0c41d899f822e5f39186d6da130a822a0a43edb19992b51bf4ef6cd0b4cfd1"
+checksum = "a02a88a17e74cadbc8ce77855e1d6c8ad0ab82901a4a9b5046bd01c1c0bd95cd"
 dependencies = [
  "cfg-if",
  "indoc",
@@ -348,9 +348,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.21.0-beta.0"
+version = "0.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5509c2aa78c7e770077e41ba86f806e60dcee812e924ccb2d6fe78c0a0128ce2"
+checksum = "a5eb0b6ecba38961f6f4bd6cd5906dfab3cd426ff37b2eed5771006aa31656f1"
 dependencies = [
  "once_cell",
  "python3-dll-a",
@@ -359,9 +359,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.21.0-beta.0"
+version = "0.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6bb234a86ed619a661f3bb3c2493aaff9cb937e33e198d17f5f20a15881e155"
+checksum = "ba8a6e48a29b5d22e4fdaf132d8ba8d3203ee9f06362d48f244346902a594ec3"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -369,9 +369,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.21.0-beta.0"
+version = "0.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f0b787de2c6832eb1eb393c9f82f976a5a87bda979780d9b853878846a8d2e4b"
+checksum = "4e80493c5965f94a747d0782a607b2328a4eea5391327b152b00e2f3b001cede"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -381,9 +381,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.21.0-beta.0"
+version = "0.21.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e3b7beed357786d2afe845871964e824ad8af0df38a403f7d01cdc81aadb211"
+checksum = "fcd7d86f42004025200e12a6a8119bd878329e6fddef8178eaafa4e4b5906c5b"
 dependencies = [
  "heck",
  "proc-macro2",
diff --git a/Cargo.toml b/Cargo.toml
index 46b1ed4ca..c0022a3cf 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -27,7 +27,7 @@ include = [
 rust-version = "1.76"
 
 [dependencies]
-pyo3 = { version = "0.21.0-beta.0", features = ["generate-import-lib", "num-bigint"] }
+pyo3 = { version = "0.21.0", features = ["generate-import-lib", "num-bigint"] }
 regex = "1.10.3"
 strum = { version = "0.25.0", features = ["derive"] }
 strum_macros = "0.26.1"
@@ -71,12 +71,12 @@ debug = true
 strip = false
 
 [dev-dependencies]
-pyo3 = { version = "0.21.0-beta.0", features = ["auto-initialize"] }
+pyo3 = { version = "0.21.0", features = ["auto-initialize"] }
 
 [build-dependencies]
 version_check = "0.9.4"
 # used where logic has to be version/distribution specific, e.g. pypy
-pyo3-build-config = { version = "0.21.0-beta.0" }
+pyo3-build-config = { version = "0.21.0" }
 
 [lints.clippy]
 dbg_macro = "warn"
diff --git a/src/argument_markers.rs b/src/argument_markers.rs
index b3ca97c8d..4a9e80bbd 100644
--- a/src/argument_markers.rs
+++ b/src/argument_markers.rs
@@ -30,7 +30,7 @@ impl ArgsKwargs {
 #[pymethods]
 impl ArgsKwargs {
     #[new]
-    fn py_new(py: Python, args: &PyTuple, kwargs: Option<&Bound<'_, PyDict>>) -> Self {
+    fn py_new(py: Python, args: &Bound<'_, PyTuple>, kwargs: Option<&Bound<'_, PyDict>>) -> Self {
         Self {
             args: args.into_py(py),
             kwargs: match kwargs {

From c607fd82bed154a473b13c2e42a9b6b71b1c945d Mon Sep 17 00:00:00 2001
From: Neev Cohen <70970900+NeevCohen@users.noreply.github.com>
Date: Tue, 26 Mar 2024 21:56:53 +0100
Subject: [PATCH 248/550] Add `coerce_numbers_to_str` option in `str_schema`
 (#1249)

---
 python/pydantic_core/core_schema.py |  3 +++
 src/validators/string.rs            | 10 +++-------
 tests/validators/test_string.py     | 31 +++++++++++++++++++++++++++++
 3 files changed, 37 insertions(+), 7 deletions(-)

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index 1b1ecc7fa..b5c4ae203 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -764,6 +764,7 @@ def str_schema(
     to_upper: bool | None = None,
     regex_engine: Literal['rust-regex', 'python-re'] | None = None,
     strict: bool | None = None,
+    coerce_numbers_to_str: bool | None = None,
     ref: str | None = None,
     metadata: Any = None,
     serialization: SerSchema | None = None,
@@ -793,6 +794,7 @@ def str_schema(
             - `python-re` use the [`re`](https://docs.python.org/3/library/re.html) module,
               which supports all regex features, but may be slower.
         strict: Whether the value should be a string or a value that can be converted to a string
+        coerce_numbers_to_str: Whether to enable coercion of any `Number` type to `str` (not applicable in `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
         serialization: Custom serialization schema
@@ -807,6 +809,7 @@ def str_schema(
         to_upper=to_upper,
         regex_engine=regex_engine,
         strict=strict,
+        coerce_numbers_to_str=coerce_numbers_to_str,
         ref=ref,
         metadata=metadata,
         serialization=serialization,
diff --git a/src/validators/string.rs b/src/validators/string.rs
index 645217edd..6b7b01d24 100644
--- a/src/validators/string.rs
+++ b/src/validators/string.rs
@@ -3,7 +3,7 @@ use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyString};
 use regex::Regex;
 
-use crate::build_tools::{is_strict, py_schema_error_type, schema_or_config};
+use crate::build_tools::{is_strict, py_schema_error_type, schema_or_config, schema_or_config_same};
 use crate::errors::{ErrorType, ValError, ValResult};
 use crate::input::Input;
 use crate::tools::SchemaDict;
@@ -184,12 +184,8 @@ impl StrConstrainedValidator {
         let to_upper: bool =
             schema_or_config(schema, config, intern!(py, "to_upper"), intern!(py, "str_to_upper"))?.unwrap_or(false);
 
-        let coerce_numbers_to_str = match config {
-            Some(c) => c
-                .get_item("coerce_numbers_to_str")?
-                .map_or(Ok(false), |any| any.is_truthy())?,
-            None => false,
-        };
+        let coerce_numbers_to_str: bool =
+            schema_or_config_same(schema, config, intern!(py, "coerce_numbers_to_str"))?.unwrap_or(false);
 
         Ok(Self {
             strict: is_strict(schema, config)?,
diff --git a/tests/validators/test_string.py b/tests/validators/test_string.py
index 22bcd5445..203c17b1e 100644
--- a/tests/validators/test_string.py
+++ b/tests/validators/test_string.py
@@ -367,3 +367,34 @@ def test_backtracking_regex_python(mode) -> None:
     with pytest.raises(ValidationError):
         # not a valid match for the pattern
         v.validate_python('r#"#')
+
+
+@pytest.mark.parametrize('number', (42, 443, 10242))
+def test_coerce_numbers_to_str_schema(number: int):
+    v = SchemaValidator(core_schema.str_schema(coerce_numbers_to_str=True))
+    assert v.validate_python(number) == str(number)
+    assert v.validate_json(str(number)) == str(number)
+
+
+@pytest.mark.parametrize('number', (42, 443, 10242))
+def test_coerce_numbers_to_str_schema_precedence(number: int):
+    config = core_schema.CoreConfig(coerce_numbers_to_str=False)
+    v = SchemaValidator(core_schema.str_schema(coerce_numbers_to_str=True), config=config)
+    assert v.validate_python(number) == str(number)
+    assert v.validate_json(str(number)) == str(number)
+
+    config = core_schema.CoreConfig(coerce_numbers_to_str=True)
+    v = SchemaValidator(core_schema.str_schema(coerce_numbers_to_str=False), config=config)
+    with pytest.raises(ValidationError):
+        v.validate_python(number)
+    with pytest.raises(ValidationError):
+        v.validate_json(str(number))
+
+
+@pytest.mark.parametrize('number', (42, 443, 10242))
+def test_coerce_numbers_to_str_schema_with_strict_mode(number: int):
+    v = SchemaValidator(core_schema.str_schema(coerce_numbers_to_str=True, strict=True))
+    with pytest.raises(ValidationError):
+        v.validate_python(number)
+    with pytest.raises(ValidationError):
+        v.validate_json(str(number))

From 2e2c13936f590d26e74d5688e13d9df813f69767 Mon Sep 17 00:00:00 2001
From: Samuel Colvin <s@muelcolvin.com>
Date: Wed, 27 Mar 2024 09:50:41 -0600
Subject: [PATCH 249/550] caching strings from JSON (#1240)

Co-authored-by: David Hewitt <mail@davidhewitt.dev>
---
 .mypy-stubtest-allowlist                  |  2 ++
 Cargo.lock                                | 15 ++---------
 Cargo.toml                                |  2 +-
 python/pydantic_core/_pydantic_core.pyi   | 15 ++++++++---
 python/pydantic_core/core_schema.py       |  3 +++
 src/input/return_enums.rs                 | 18 ++++++-------
 src/lib.rs                                | 19 +++++++++++---
 src/validators/arguments.rs               |  9 ++++---
 src/validators/dataclass.rs               | 10 ++++---
 src/validators/generator.rs               |  4 +++
 src/validators/json.rs                    |  4 +--
 src/validators/mod.rs                     | 32 ++++++++++++++++++++---
 src/validators/model_fields.rs            |  2 +-
 src/validators/string.rs                  | 10 +++----
 src/validators/typed_dict.rs              |  2 +-
 src/validators/union.rs                   |  5 ++--
 src/validators/validation_state.rs        | 17 ++++++++++++
 tests/benchmarks/test_micro_benchmarks.py | 26 ++++++++++++++++++
 tests/test_config.py                      | 14 ++++++++++
 tests/test_json.py                        | 11 ++++++++
 tests/validators/test_bool.py             | 10 +++++--
 tests/validators/test_definitions.py      |  2 +-
 tests/validators/test_float.py            |  4 +--
 tests/validators/test_frozenset.py        |  4 ++-
 tests/validators/test_int.py              | 10 +++++--
 tests/validators/test_string.py           |  2 +-
 tests/validators/test_union.py            |  2 +-
 27 files changed, 195 insertions(+), 59 deletions(-)

diff --git a/.mypy-stubtest-allowlist b/.mypy-stubtest-allowlist
index c75b9bf8a..0f9ad4418 100644
--- a/.mypy-stubtest-allowlist
+++ b/.mypy-stubtest-allowlist
@@ -1,2 +1,4 @@
 # TODO: don't want to expose this staticmethod, requires https://github.com/PyO3/pyo3/issues/2384
 pydantic_core._pydantic_core.PydanticUndefinedType.new
+# As per #1240, from_json has custom logic to coverage the `cache_strings` kwarg
+pydantic_core._pydantic_core.from_json
diff --git a/Cargo.lock b/Cargo.lock
index cb04a926b..e120e74c4 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -24,12 +24,6 @@ dependencies = [
  "memchr",
 ]
 
-[[package]]
-name = "allocator-api2"
-version = "0.2.16"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0942ffc6dcaadf03badf6e6a2d0228460359d5e34b57ccdc720b7382dfbd5ec5"
-
 [[package]]
 name = "autocfg"
 version = "1.1.0"
@@ -103,10 +97,6 @@ name = "hashbrown"
 version = "0.14.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "290f1a1d9242c78d09ce40a5e87e7554ee637af1351968159f4952f028f75604"
-dependencies = [
- "ahash",
- "allocator-api2",
-]
 
 [[package]]
 name = "heck"
@@ -148,12 +138,11 @@ checksum = "62b02a5381cc465bd3041d84623d0fa3b66738b52b8e2fc3bab8ad63ab032f4a"
 
 [[package]]
 name = "jiter"
-version = "0.1.0"
+version = "0.1.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9cbc4bba9fee7e90f7ab23d53caa097007c6b870b2ca0a33334e774eb34c1ff"
+checksum = "2c0b7c896d2b1da897be13affb0bbf7bff95437e9c50823ede962addadae58d8"
 dependencies = [
  "ahash",
- "hashbrown",
  "lexical-parse-float",
  "num-bigint",
  "num-traits",
diff --git a/Cargo.toml b/Cargo.toml
index c0022a3cf..420509290 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -44,7 +44,7 @@ base64 = "0.21.7"
 num-bigint = "0.4.4"
 python3-dll-a = "0.2.7"
 uuid = "1.7.0"
-jiter = { version = "0.1.0", features = ["python"] }
+jiter = { version = "0.1.1", features = ["python"] }
 
 [lib]
 name = "_pydantic_core"
diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index 334334087..d7e1dd5bb 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -390,17 +390,26 @@ def to_json(
        JSON bytes.
     """
 
-def from_json(data: str | bytes | bytearray, *, allow_inf_nan: bool = True, cache_strings: bool = True) -> Any:
+def from_json(
+    data: str | bytes | bytearray,
+    *,
+    allow_inf_nan: bool = True,
+    cache_strings: bool | Literal['all', 'keys', 'none'] = True,
+    allow_partial: bool = False,
+) -> Any:
     """
     Deserialize JSON data to a Python object.
 
-    This is effectively a faster version of `json.loads()`.
+    This is effectively a faster version of `json.loads()`, with some extra functionality.
 
     Arguments:
         data: The JSON data to deserialize.
         allow_inf_nan: Whether to allow `Infinity`, `-Infinity` and `NaN` values as `json.loads()` does by default.
         cache_strings: Whether to cache strings to avoid constructing new Python objects,
-            this should have a significant impact on performance while increasing memory usage slightly.
+            this should have a significant impact on performance while increasing memory usage slightly,
+            `all/True` means cache all strings, `keys` means cache only dict keys, `none/False` means no caching.
+        allow_partial: Whether to allow partial deserialization, if `True` JSON data is returned if the end of the
+            input is reached before the full object is deserialized, e.g. `["aa", "bb", "c` would return `['aa', 'bb']`.
 
     Raises:
         ValueError: If deserialization fails.
diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index b5c4ae203..a2f4b4f0c 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -75,6 +75,8 @@ class CoreConfig(TypedDict, total=False):
             Requires exceptiongroup backport pre Python 3.11.
         coerce_numbers_to_str: Whether to enable coercion of any `Number` type to `str` (not applicable in `strict` mode).
         regex_engine: The regex engine to use for regex pattern validation. Default is 'rust-regex'. See `StringSchema`.
+        cache_strings: Whether to cache strings. Default is `True`, `True` or `'all'` is required to cache strings
+            during general validation since validators don't know if they're in a key or a value.
     """
 
     title: str
@@ -110,6 +112,7 @@ class CoreConfig(TypedDict, total=False):
     validation_error_cause: bool  # default: False
     coerce_numbers_to_str: bool  # default: False
     regex_engine: Literal['rust-regex', 'python-re']  # default: 'rust-regex'
+    cache_strings: Union[bool, Literal['all', 'keys', 'none']]  # default: 'True'
 
 
 IncExCall: TypeAlias = 'set[int | str] | dict[int | str, IncExCall] | None'
diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index 753ace478..5d1019f05 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -3,7 +3,7 @@ use std::cmp::Ordering;
 use std::ops::Rem;
 use std::str::FromStr;
 
-use jiter::{JsonArray, JsonValue};
+use jiter::{JsonArray, JsonValue, StringCacheMode};
 use num_bigint::BigInt;
 
 use pyo3::exceptions::PyTypeError;
@@ -435,9 +435,15 @@ impl<'a> EitherString<'a> {
         }
     }
 
-    pub fn as_py_string(&'a self, py: Python<'a>) -> Bound<'a, PyString> {
+    pub fn as_py_string(&'a self, py: Python<'a>, cache_str: StringCacheMode) -> Bound<'a, PyString> {
         match self {
-            Self::Cow(cow) => PyString::new_bound(py, cow),
+            Self::Cow(cow) => {
+                if matches!(cache_str, StringCacheMode::All) {
+                    jiter::cached_py_string(py, cow.as_ref())
+                } else {
+                    PyString::new_bound(py, cow.as_ref())
+                }
+            }
             Self::Py(py_string) => py_string.clone(),
         }
     }
@@ -461,12 +467,6 @@ impl<'a> From<Bound<'a, PyString>> for EitherString<'a> {
     }
 }
 
-impl<'a> IntoPy<PyObject> for EitherString<'a> {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        self.as_py_string(py).into_py(py)
-    }
-}
-
 pub fn py_string_str<'a>(py_str: &'a Bound<'_, PyString>) -> ValResult<&'a str> {
     py_str.to_str().map_err(|_| {
         ValError::new_custom_input(
diff --git a/src/lib.rs b/src/lib.rs
index 93fd91252..82f941f20 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -4,6 +4,7 @@ extern crate core;
 
 use std::sync::OnceLock;
 
+use jiter::StringCacheMode;
 use pyo3::exceptions::PyTypeError;
 use pyo3::{prelude::*, sync::GILOnceCell};
 
@@ -38,19 +39,31 @@ pub use validators::{validate_core_schema, PySome, SchemaValidator};
 
 use crate::input::Input;
 
-#[pyfunction(signature = (data, *, allow_inf_nan=true, cache_strings=true))]
+#[derive(FromPyObject)]
+pub enum CacheStringsArg {
+    Bool(bool),
+    Literal(StringCacheMode),
+}
+
+#[pyfunction(signature = (data, *, allow_inf_nan=true, cache_strings=CacheStringsArg::Bool(true), allow_partial=false))]
 pub fn from_json<'py>(
     py: Python<'py>,
     data: &Bound<'_, PyAny>,
     allow_inf_nan: bool,
-    cache_strings: bool,
+    cache_strings: CacheStringsArg,
+    allow_partial: bool,
 ) -> PyResult<Bound<'py, PyAny>> {
     let v_match = data
         .validate_bytes(false)
         .map_err(|_| PyTypeError::new_err("Expected bytes, bytearray or str"))?;
     let json_either_bytes = v_match.into_inner();
     let json_bytes = json_either_bytes.as_slice();
-    jiter::python_parse(py, json_bytes, allow_inf_nan, cache_strings).map_err(|e| jiter::map_json_error(json_bytes, &e))
+    let cache_mode = match cache_strings {
+        CacheStringsArg::Bool(b) => b.into(),
+        CacheStringsArg::Literal(mode) => mode,
+    };
+    jiter::python_parse(py, json_bytes, allow_inf_nan, cache_mode, allow_partial)
+        .map_err(|e| jiter::map_json_error(json_bytes, &e))
 }
 
 pub fn get_pydantic_core_version() -> &'static str {
diff --git a/src/validators/arguments.rs b/src/validators/arguments.rs
index 024348527..457474d65 100644
--- a/src/validators/arguments.rs
+++ b/src/validators/arguments.rs
@@ -55,7 +55,8 @@ impl BuildValidator for ArgumentsValidator {
         for (arg_index, arg) in arguments_schema.iter().enumerate() {
             let arg = arg.downcast::<PyDict>()?;
 
-            let name: String = arg.get_as_req(intern!(py, "name"))?;
+            let py_name: Bound<PyString> = arg.get_as_req(intern!(py, "name"))?;
+            let name = py_name.to_string();
             let mode = arg.get_as::<Bound<'_, PyString>>(intern!(py, "mode"))?;
             let mode = mode
                 .as_ref()
@@ -77,7 +78,7 @@ impl BuildValidator for ArgumentsValidator {
                     }
                     None => Some(LookupKey::from_string(py, &name)),
                 };
-                kwarg_key = Some(PyString::new_bound(py, &name).into());
+                kwarg_key = Some(py_name.into_py(py));
             }
 
             let schema = arg.get_as_req(intern!(py, "schema"))?;
@@ -274,7 +275,9 @@ impl Validator for ArgumentsValidator {
                     if !used_kwargs.contains(either_str.as_cow()?.as_ref()) {
                         match self.var_kwargs_validator {
                             Some(ref validator) => match validator.validate(py, value.borrow_input(), state) {
-                                Ok(value) => output_kwargs.set_item(either_str.as_py_string(py), value)?,
+                                Ok(value) => {
+                                    output_kwargs.set_item(either_str.as_py_string(py, state.cache_str()), value)?;
+                                }
                                 Err(ValError::LineErrors(line_errors)) => {
                                     for err in line_errors {
                                         errors.push(err.with_outer_location(raw_key.clone()));
diff --git a/src/validators/dataclass.rs b/src/validators/dataclass.rs
index 907e1511e..4e98538a8 100644
--- a/src/validators/dataclass.rs
+++ b/src/validators/dataclass.rs
@@ -302,7 +302,10 @@ impl Validator for DataclassArgsValidator {
                                         if let Some(ref validator) = self.extras_validator {
                                             match validator.validate(py, value.borrow_input(), state) {
                                                 Ok(value) => {
-                                                    output_dict.set_item(either_str.as_py_string(py), value)?;
+                                                    output_dict.set_item(
+                                                        either_str.as_py_string(py, state.cache_str()),
+                                                        value,
+                                                    )?;
                                                 }
                                                 Err(ValError::LineErrors(line_errors)) => {
                                                     for err in line_errors {
@@ -312,7 +315,8 @@ impl Validator for DataclassArgsValidator {
                                                 Err(err) => return Err(err),
                                             }
                                         } else {
-                                            output_dict.set_item(either_str.as_py_string(py), value)?;
+                                            output_dict
+                                                .set_item(either_str.as_py_string(py, state.cache_str()), value)?;
                                         }
                                     }
                                 }
@@ -455,7 +459,7 @@ impl BuildValidator for DataclassValidator {
         let validator = build_validator(&sub_schema, config, definitions)?;
 
         let post_init = if schema.get_as::<bool>(intern!(py, "post_init"))?.unwrap_or(false) {
-            Some(PyString::new_bound(py, "__post_init__").into())
+            Some(intern!(py, "__post_init__").into_py(py))
         } else {
             None
         };
diff --git a/src/validators/generator.rs b/src/validators/generator.rs
index f7c932397..904f4a0ef 100644
--- a/src/validators/generator.rs
+++ b/src/validators/generator.rs
@@ -219,6 +219,7 @@ pub struct InternalValidator {
     validation_mode: InputType,
     hide_input_in_errors: bool,
     validation_error_cause: bool,
+    cache_str: jiter::StringCacheMode,
 }
 
 impl fmt::Debug for InternalValidator {
@@ -250,6 +251,7 @@ impl InternalValidator {
             validation_mode: extra.input_type,
             hide_input_in_errors,
             validation_error_cause,
+            cache_str: extra.cache_str,
         }
     }
 
@@ -268,6 +270,7 @@ impl InternalValidator {
             from_attributes: self.from_attributes,
             context: self.context.as_ref().map(|data| data.bind(py)),
             self_instance: self.self_instance.as_ref().map(|data| data.bind(py)),
+            cache_str: self.cache_str,
         };
         let mut state = ValidationState::new(extra, &mut self.recursion_guard);
         state.exactness = self.exactness;
@@ -302,6 +305,7 @@ impl InternalValidator {
             from_attributes: self.from_attributes,
             context: self.context.as_ref().map(|data| data.bind(py)),
             self_instance: self.self_instance.as_ref().map(|data| data.bind(py)),
+            cache_str: self.cache_str,
         };
         let mut state = ValidationState::new(extra, &mut self.recursion_guard);
         state.exactness = self.exactness;
diff --git a/src/validators/json.rs b/src/validators/json.rs
index 62a23f0e6..5a5927058 100644
--- a/src/validators/json.rs
+++ b/src/validators/json.rs
@@ -64,8 +64,8 @@ impl Validator for JsonValidator {
                 validator.validate(py, &json_value, &mut json_state)
             }
             None => {
-                let obj =
-                    jiter::python_parse(py, json_bytes, true, true).map_err(|e| map_json_err(input, e, json_bytes))?;
+                let obj = jiter::python_parse(py, json_bytes, true, state.cache_str(), false)
+                    .map_err(|e| map_json_err(input, e, json_bytes))?;
                 Ok(obj.unbind())
             }
         }
diff --git a/src/validators/mod.rs b/src/validators/mod.rs
index ac5d6d63c..ede6489ab 100644
--- a/src/validators/mod.rs
+++ b/src/validators/mod.rs
@@ -1,6 +1,7 @@
 use std::fmt::Debug;
 
 use enum_dispatch::enum_dispatch;
+use jiter::StringCacheMode;
 
 use pyo3::exceptions::PyTypeError;
 use pyo3::prelude::*;
@@ -110,6 +111,7 @@ pub struct SchemaValidator {
     title: PyObject,
     hide_input_in_errors: bool,
     validation_error_cause: bool,
+    cache_str: StringCacheMode,
 }
 
 #[pymethods]
@@ -135,6 +137,9 @@ impl SchemaValidator {
         };
         let hide_input_in_errors: bool = config.get_as(intern!(py, "hide_input_in_errors"))?.unwrap_or(false);
         let validation_error_cause: bool = config.get_as(intern!(py, "validation_error_cause"))?.unwrap_or(false);
+        let cache_str: StringCacheMode = config
+            .get_as(intern!(py, "cache_strings"))?
+            .unwrap_or(StringCacheMode::All);
         Ok(Self {
             validator,
             definitions,
@@ -143,6 +148,7 @@ impl SchemaValidator {
             title,
             hide_input_in_errors,
             validation_error_cause,
+            cache_str,
         })
     }
 
@@ -262,6 +268,7 @@ impl SchemaValidator {
             from_attributes,
             context,
             self_instance: None,
+            cache_str: self.cache_str,
         };
 
         let guard = &mut RecursionState::default();
@@ -285,6 +292,7 @@ impl SchemaValidator {
             from_attributes: None,
             context,
             self_instance: None,
+            cache_str: self.cache_str,
         };
         let recursion_guard = &mut RecursionState::default();
         let mut state = ValidationState::new(extra, recursion_guard);
@@ -300,10 +308,15 @@ impl SchemaValidator {
 
     pub fn __repr__(&self, py: Python) -> String {
         format!(
-            "SchemaValidator(title={:?}, validator={:#?}, definitions={:#?})",
+            "SchemaValidator(title={:?}, validator={:#?}, definitions={:#?}, cache_strings={})",
             self.title.extract::<&str>(py).unwrap(),
             self.validator,
             self.definitions,
+            match self.cache_str {
+                StringCacheMode::All => "True",
+                StringCacheMode::Keys => "'keys'",
+                StringCacheMode::None => "False",
+            }
         )
     }
 
@@ -331,7 +344,14 @@ impl SchemaValidator {
     ) -> ValResult<PyObject> {
         let mut recursion_guard = RecursionState::default();
         let mut state = ValidationState::new(
-            Extra::new(strict, from_attributes, context, self_instance, input_type),
+            Extra::new(
+                strict,
+                from_attributes,
+                context,
+                self_instance,
+                input_type,
+                self.cache_str,
+            ),
             &mut recursion_guard,
         );
         self.validator.validate(py, input, &mut state)
@@ -384,7 +404,7 @@ impl<'py> SelfValidator<'py> {
         let py = schema.py();
         let mut recursion_guard = RecursionState::default();
         let mut state = ValidationState::new(
-            Extra::new(strict, None, None, None, InputType::Python),
+            Extra::new(strict, None, None, None, InputType::Python, true.into()),
             &mut recursion_guard,
         );
         match self.validator.validator.validate(py, schema, &mut state) {
@@ -414,6 +434,7 @@ impl<'py> SelfValidator<'py> {
             title: "Self Schema".into_py(py),
             hide_input_in_errors: false,
             validation_error_cause: false,
+            cache_str: true.into(),
         })
     }
 }
@@ -577,6 +598,8 @@ pub struct Extra<'a, 'py> {
     pub context: Option<&'a Bound<'py, PyAny>>,
     /// This is an instance of the model or dataclass being validated, when validation is performed from `__init__`
     self_instance: Option<&'a Bound<'py, PyAny>>,
+    /// Whether to use a cache of short strings to accelerate python string construction
+    cache_str: StringCacheMode,
 }
 
 impl<'a, 'py> Extra<'a, 'py> {
@@ -586,6 +609,7 @@ impl<'a, 'py> Extra<'a, 'py> {
         context: Option<&'a Bound<'py, PyAny>>,
         self_instance: Option<&'a Bound<'py, PyAny>>,
         input_type: InputType,
+        cache_str: StringCacheMode,
     ) -> Self {
         Extra {
             input_type,
@@ -594,6 +618,7 @@ impl<'a, 'py> Extra<'a, 'py> {
             from_attributes,
             context,
             self_instance,
+            cache_str,
         }
     }
 }
@@ -607,6 +632,7 @@ impl Extra<'_, '_> {
             from_attributes: self.from_attributes,
             context: self.context,
             self_instance: self.self_instance,
+            cache_str: self.cache_str,
         }
     }
 }
diff --git a/src/validators/model_fields.rs b/src/validators/model_fields.rs
index f470557dd..eda76056a 100644
--- a/src/validators/model_fields.rs
+++ b/src/validators/model_fields.rs
@@ -283,7 +283,7 @@ impl Validator for ModelFieldsValidator {
                             }
                             ExtraBehavior::Ignore => {}
                             ExtraBehavior::Allow => {
-                                let py_key = either_str.as_py_string(self.py);
+                                let py_key = either_str.as_py_string(self.py, self.state.cache_str());
                                 if let Some(validator) = self.extras_validator {
                                     match validator.validate(self.py, value, self.state) {
                                         Ok(value) => {
diff --git a/src/validators/string.rs b/src/validators/string.rs
index 6b7b01d24..ab6671c9c 100644
--- a/src/validators/string.rs
+++ b/src/validators/string.rs
@@ -49,7 +49,7 @@ impl Validator for StrValidator {
     ) -> ValResult<PyObject> {
         input
             .validate_str(state.strict_or(self.strict), self.coerce_numbers_to_str)
-            .map(|val_match| val_match.unpack(state).into_py(py))
+            .map(|val_match| val_match.unpack(state).as_py_string(py, state.cache_str()).into_py(py))
     }
 
     fn get_name(&self) -> &str {
@@ -129,14 +129,14 @@ impl Validator for StrConstrainedValidator {
         }
 
         let py_string = if self.to_lower {
-            PyString::new_bound(py, &str.to_lowercase())
+            state.maybe_cached_str(py, &str.to_lowercase())
         } else if self.to_upper {
-            PyString::new_bound(py, &str.to_uppercase())
+            state.maybe_cached_str(py, &str.to_uppercase())
         } else if self.strip_whitespace {
-            PyString::new_bound(py, str)
+            state.maybe_cached_str(py, str)
         } else {
             // we haven't modified the string, return the original as it might be a PyString
-            either_str.as_py_string(py)
+            either_str.as_py_string(py, state.cache_str())
         };
         Ok(py_string.into_py(py))
     }
diff --git a/src/validators/typed_dict.rs b/src/validators/typed_dict.rs
index 956ebac31..c90196c7c 100644
--- a/src/validators/typed_dict.rs
+++ b/src/validators/typed_dict.rs
@@ -281,7 +281,7 @@ impl Validator for TypedDictValidator {
                             }
                             ExtraBehavior::Ignore => {}
                             ExtraBehavior::Allow => {
-                                let py_key = either_str.as_py_string(self.py);
+                                let py_key = either_str.as_py_string(self.py, self.state.cache_str());
                                 if let Some(validator) = self.extras_validator {
                                     match validator.validate(self.py, value, self.state) {
                                         Ok(value) => {
diff --git a/src/validators/union.rs b/src/validators/union.rs
index 874da49af..8a33870ec 100644
--- a/src/validators/union.rs
+++ b/src/validators/union.rs
@@ -417,7 +417,7 @@ impl Validator for TaggedUnionValidator {
                 }
             }
             Discriminator::SelfSchema => {
-                self.find_call_validator(py, self.self_schema_tag(py, input)?.as_any(), input, state)
+                self.find_call_validator(py, self.self_schema_tag(py, input, state)?.as_any(), input, state)
             }
         }
     }
@@ -432,6 +432,7 @@ impl TaggedUnionValidator {
         &self,
         py: Python<'py>,
         input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<Bound<'py, PyString>> {
         let dict = input.strict_dict()?;
         let dict = dict.as_py_dict().expect("self schema is always a Python dictionary");
@@ -452,7 +453,7 @@ impl TaggedUnionValidator {
             };
             tag
         } else {
-            Ok(PyString::new_bound(py, tag))
+            Ok(state.maybe_cached_str(py, tag))
         }
     }
 
diff --git a/src/validators/validation_state.rs b/src/validators/validation_state.rs
index 1de2d75bd..8e68cd8d9 100644
--- a/src/validators/validation_state.rs
+++ b/src/validators/validation_state.rs
@@ -1,3 +1,8 @@
+use pyo3::prelude::*;
+use pyo3::types::PyString;
+
+use jiter::StringCacheMode;
+
 use crate::recursion_guard::{ContainsRecursionState, RecursionState};
 
 use super::Extra;
@@ -61,6 +66,18 @@ impl<'a, 'py> ValidationState<'a, 'py> {
             Some(Exactness::Exact) => self.exactness = Some(exactness),
         }
     }
+
+    pub fn cache_str(&self) -> StringCacheMode {
+        self.extra.cache_str
+    }
+
+    pub fn maybe_cached_str(&self, py: Python<'py>, s: &str) -> Bound<'py, PyString> {
+        if matches!(self.extra.cache_str, StringCacheMode::All) {
+            jiter::cached_py_string(py, s)
+        } else {
+            PyString::new_bound(py, s)
+        }
+    }
 }
 
 impl ContainsRecursionState for ValidationState<'_, '_> {
diff --git a/tests/benchmarks/test_micro_benchmarks.py b/tests/benchmarks/test_micro_benchmarks.py
index da7868c69..a86f698c1 100644
--- a/tests/benchmarks/test_micro_benchmarks.py
+++ b/tests/benchmarks/test_micro_benchmarks.py
@@ -366,6 +366,32 @@ def t():
         v.validate_json(json_data[1])
 
 
+list_of_strs_data = [str(i) for i in range(1000)]
+
+
+@pytest.mark.benchmark(group='list[str]')
+def test_list_of_strs_py_cached(benchmark):
+    v = SchemaValidator(core_schema.list_schema(core_schema.str_schema()))
+
+    benchmark(v.validate_python, list_of_strs_data)
+
+
+@pytest.mark.benchmark(group='list[str]')
+def test_list_of_strs_json_cached(benchmark):
+    v = SchemaValidator(core_schema.list_schema(core_schema.str_schema()))
+
+    json_data = json.dumps(list_of_strs_data)
+    benchmark(v.validate_json, json_data)
+
+
+@pytest.mark.benchmark(group='list[str]')
+def test_list_of_strs_json_uncached(benchmark):
+    v = SchemaValidator(core_schema.list_schema(core_schema.str_schema()), {'cache_strings': False})
+
+    json_data = json.dumps(list_of_strs_data)
+    benchmark(v.validate_json, json_data)
+
+
 @pytest.mark.benchmark(group='List[Any]')
 def test_list_of_any_core_py(benchmark):
     v = SchemaValidator({'type': 'list'})
diff --git a/tests/test_config.py b/tests/test_config.py
index 656918f82..8f552c20b 100644
--- a/tests/test_config.py
+++ b/tests/test_config.py
@@ -137,3 +137,17 @@ def test_hide_input_in_errors(config, input_str):
 
     with pytest.raises(ValidationError, match=re.escape(f'Input should be a valid string [{input_str}]')):
         assert v.validate_python({'f': 123})
+
+
+def test_cache_strings():
+    v = SchemaValidator({'type': 'str'})
+    assert 'cache_strings=True' in plain_repr(v)
+
+    v = SchemaValidator({'type': 'str'}, {'cache_strings': True})
+    assert 'cache_strings=True' in plain_repr(v)
+
+    v = SchemaValidator({'type': 'str'}, {'cache_strings': False})
+    assert 'cache_strings=False' in plain_repr(v)
+
+    v = SchemaValidator({'type': 'str'}, {'cache_strings': 'keys'})
+    assert "cache_strings='keys'" in plain_repr(v)
diff --git a/tests/test_json.py b/tests/test_json.py
index 4ef8a1d40..0f599cee1 100644
--- a/tests/test_json.py
+++ b/tests/test_json.py
@@ -13,6 +13,7 @@
     SchemaValidator,
     ValidationError,
     core_schema,
+    from_json,
     to_json,
     to_jsonable_python,
 )
@@ -365,3 +366,13 @@ def test_inf_nan_allow():
     assert v.validate_json('Infinity') == float('inf')
     assert v.validate_json('-Infinity') == float('-inf')
     assert v.validate_json('NaN') == IsFloatNan()
+
+
+def test_partial_parse():
+    with pytest.raises(ValueError, match='EOF while parsing a string at line 1 column 15'):
+        from_json('["aa", "bb", "c')
+    assert from_json('["aa", "bb", "c', allow_partial=True) == ['aa', 'bb']
+
+    with pytest.raises(ValueError, match='EOF while parsing a string at line 1 column 15'):
+        from_json(b'["aa", "bb", "c')
+    assert from_json(b'["aa", "bb", "c', allow_partial=True) == ['aa', 'bb']
diff --git a/tests/validators/test_bool.py b/tests/validators/test_bool.py
index 3ac900701..88f30add4 100644
--- a/tests/validators/test_bool.py
+++ b/tests/validators/test_bool.py
@@ -77,9 +77,15 @@ def test_bool_error(pydantic_version):
 
 def test_bool_repr():
     v = SchemaValidator({'type': 'bool'})
-    assert plain_repr(v) == 'SchemaValidator(title="bool",validator=Bool(BoolValidator{strict:false}),definitions=[])'
+    assert (
+        plain_repr(v)
+        == 'SchemaValidator(title="bool",validator=Bool(BoolValidator{strict:false}),definitions=[],cache_strings=True)'
+    )
     v = SchemaValidator({'type': 'bool', 'strict': True})
-    assert plain_repr(v) == 'SchemaValidator(title="bool",validator=Bool(BoolValidator{strict:true}),definitions=[])'
+    assert (
+        plain_repr(v)
+        == 'SchemaValidator(title="bool",validator=Bool(BoolValidator{strict:true}),definitions=[],cache_strings=True)'
+    )
 
 
 def test_bool_key(py_and_json: PyAndJson):
diff --git a/tests/validators/test_definitions.py b/tests/validators/test_definitions.py
index 606c8a6d9..18101fa93 100644
--- a/tests/validators/test_definitions.py
+++ b/tests/validators/test_definitions.py
@@ -32,7 +32,7 @@ def test_ignored_def():
 def test_extract_used_refs_ignores_metadata():
     v = SchemaValidator(core_schema.any_schema(metadata={'type': 'definition-ref'}))
     assert v.validate_python([1, 2, 3]) == [1, 2, 3]
-    assert plain_repr(v).endswith('definitions=[])')
+    assert plain_repr(v).endswith('definitions=[],cache_strings=True)')
 
 
 def test_check_ref_used_ignores_metadata():
diff --git a/tests/validators/test_float.py b/tests/validators/test_float.py
index 5af0d4adb..88966261a 100644
--- a/tests/validators/test_float.py
+++ b/tests/validators/test_float.py
@@ -183,12 +183,12 @@ def test_float_repr():
     v = SchemaValidator({'type': 'float'})
     assert (
         plain_repr(v)
-        == 'SchemaValidator(title="float",validator=Float(FloatValidator{strict:false,allow_inf_nan:true}),definitions=[])'
+        == 'SchemaValidator(title="float",validator=Float(FloatValidator{strict:false,allow_inf_nan:true}),definitions=[],cache_strings=True)'
     )
     v = SchemaValidator({'type': 'float', 'strict': True})
     assert (
         plain_repr(v)
-        == 'SchemaValidator(title="float",validator=Float(FloatValidator{strict:true,allow_inf_nan:true}),definitions=[])'
+        == 'SchemaValidator(title="float",validator=Float(FloatValidator{strict:true,allow_inf_nan:true}),definitions=[],cache_strings=True)'
     )
     v = SchemaValidator({'type': 'float', 'multiple_of': 7})
     assert plain_repr(v).startswith('SchemaValidator(title="constrained-float",validator=ConstrainedFloat(')
diff --git a/tests/validators/test_frozenset.py b/tests/validators/test_frozenset.py
index 6ee297b22..407e0a579 100644
--- a/tests/validators/test_frozenset.py
+++ b/tests/validators/test_frozenset.py
@@ -249,7 +249,9 @@ def test_repr():
         'validator=FrozenSet(FrozenSetValidator{'
         'strict:true,item_validator:Any(AnyValidator),min_length:Some(42),max_length:None,'
         'name:"frozenset[any]"'
-        '}),definitions=[])'
+        '}),'
+        'definitions=[],'
+        'cache_strings=True)'
     )
 
 
diff --git a/tests/validators/test_int.py b/tests/validators/test_int.py
index c5ccd7957..baddb6289 100644
--- a/tests/validators/test_int.py
+++ b/tests/validators/test_int.py
@@ -342,9 +342,15 @@ def test_union_int_simple(py_and_json: PyAndJson):
 
 def test_int_repr():
     v = SchemaValidator({'type': 'int'})
-    assert plain_repr(v) == 'SchemaValidator(title="int",validator=Int(IntValidator{strict:false}),definitions=[])'
+    assert (
+        plain_repr(v)
+        == 'SchemaValidator(title="int",validator=Int(IntValidator{strict:false}),definitions=[],cache_strings=True)'
+    )
     v = SchemaValidator({'type': 'int', 'strict': True})
-    assert plain_repr(v) == 'SchemaValidator(title="int",validator=Int(IntValidator{strict:true}),definitions=[])'
+    assert (
+        plain_repr(v)
+        == 'SchemaValidator(title="int",validator=Int(IntValidator{strict:true}),definitions=[],cache_strings=True)'
+    )
     v = SchemaValidator({'type': 'int', 'multiple_of': 7})
     assert plain_repr(v).startswith('SchemaValidator(title="constrained-int",validator=ConstrainedInt(')
 
diff --git a/tests/validators/test_string.py b/tests/validators/test_string.py
index 203c17b1e..f4f5f3888 100644
--- a/tests/validators/test_string.py
+++ b/tests/validators/test_string.py
@@ -212,7 +212,7 @@ def test_default_validator():
     v = SchemaValidator(core_schema.str_schema(strict=True, to_lower=False), {'str_strip_whitespace': False})
     assert (
         plain_repr(v)
-        == 'SchemaValidator(title="str",validator=Str(StrValidator{strict:true,coerce_numbers_to_str:false}),definitions=[])'
+        == 'SchemaValidator(title="str",validator=Str(StrValidator{strict:true,coerce_numbers_to_str:false}),definitions=[],cache_strings=True)'
     )
 
 
diff --git a/tests/validators/test_union.py b/tests/validators/test_union.py
index 42c542000..332b23257 100644
--- a/tests/validators/test_union.py
+++ b/tests/validators/test_union.py
@@ -264,7 +264,7 @@ def test_one_choice():
     v = SchemaValidator({'type': 'union', 'choices': [{'type': 'str'}]})
     assert (
         plain_repr(v)
-        == 'SchemaValidator(title="str",validator=Str(StrValidator{strict:false,coerce_numbers_to_str:false}),definitions=[])'
+        == 'SchemaValidator(title="str",validator=Str(StrValidator{strict:false,coerce_numbers_to_str:false}),definitions=[],cache_strings=True)'
     )
     assert v.validate_python('hello') == 'hello'
 

From 94739757194bc364ac30a09004eefa32457e6256 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 2 Apr 2024 09:23:30 +0100
Subject: [PATCH 250/550] Bump the python-packages group with 10 updates
 (#1257)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt |  8 ++++----
 tests/requirements.txt         | 12 ++++++------
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index 8e3ea74da..782eda79b 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,4 +1,4 @@
-griffe==0.41.0
-pyright==1.1.352
-ruff==0.3.0
-mypy==1.8.0
+griffe==0.42.1
+pyright==1.1.356
+ruff==0.3.4
+mypy==1.9.0
diff --git a/tests/requirements.txt b/tests/requirements.txt
index b2c8dba6b..eff02f91d 100644
--- a/tests/requirements.txt
+++ b/tests/requirements.txt
@@ -1,21 +1,21 @@
-coverage==7.4.3
+coverage==7.4.4
 dirty-equals==0.7.1.post0
-hypothesis==6.98.15
+hypothesis==6.100.0
 # TODO: remove manual override for dateutil once a version newer than 2.8.2 is
 # released which removes use of deprecated utcfromtimestamp
 git+https://github.com/dateutil/dateutil.git@f2293200747fb03d56c6c5997bfebeabe703576f
 # pandas doesn't offer prebuilt wheels for all versions and platforms we test in CI e.g. aarch64 musllinux
 pandas==2.1.3; python_version >= "3.9" and python_version < "3.13" and implementation_name == "cpython" and platform_machine == 'x86_64'
-pytest==8.0.2
+pytest==8.1.1
 # we run codspeed benchmarks on x86_64 CPython (i.e. native github actions architecture)
-pytest-codspeed~=2.2.0; implementation_name == "cpython" and platform_machine == 'x86_64'
+pytest-codspeed~=2.2.1; implementation_name == "cpython" and platform_machine == 'x86_64'
 # pytest-examples currently depends on aiohttp via black; we don't want to build
 # it on platforms like aarch64 musllinux in CI
 pytest-examples==0.0.10; implementation_name == "cpython" and platform_machine == 'x86_64'
 pytest-speed==0.3.5
-pytest-mock==3.11.1
+pytest-mock==3.14.0
 pytest-pretty==1.2.0
-pytest-timeout==2.2.0
+pytest-timeout==2.3.1
 pytz==2024.1
 # numpy doesn't offer prebuilt wheels for all versions and platforms we test in CI e.g. aarch64 musllinux
 numpy==1.26.2; python_version >= "3.9" and python_version < "3.13" and implementation_name == "cpython" and platform_machine == 'x86_64'

From d49ab496ebf9d9d15bfc673cfcea8b389c3487a6 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 2 Apr 2024 09:23:52 +0100
Subject: [PATCH 251/550] Bump softprops/action-gh-release from 1 to 2 (#1256)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index e0a7cb9b3..9af70cf31 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -738,7 +738,7 @@ jobs:
           path: wasm
 
       - name: upload to github release
-        uses: softprops/action-gh-release@v1
+        uses: softprops/action-gh-release@v2
         with:
           files: |
             wasm/*.whl

From 4ca7f55494c19e86348cbc681c73c80b8b6f3e5e Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 2 Apr 2024 09:24:12 +0100
Subject: [PATCH 252/550] Bump serde from 1.0.196 to 1.0.197 (#1255)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 8 ++++----
 Cargo.toml | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index e120e74c4..81997faa6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -457,18 +457,18 @@ checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
 
 [[package]]
 name = "serde"
-version = "1.0.196"
+version = "1.0.197"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "870026e60fa08c69f064aa766c10f10b1d62db9ccd4d0abb206472bee0ce3b32"
+checksum = "3fb1c873e1b9b056a4dc4c0c198b24c3ffa059243875552b2bd0933b1aee4ce2"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.196"
+version = "1.0.197"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "33c85360c95e7d137454dc81d9a4ed2b8efd8fbe19cee57357b32b9771fccb67"
+checksum = "7eb0b34b42edc17f6b7cac84a52a1c5f0e1bb2227e997ca9011ea3dd34e8610b"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/Cargo.toml b/Cargo.toml
index 420509290..8195edd6a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -33,7 +33,7 @@ strum = { version = "0.25.0", features = ["derive"] }
 strum_macros = "0.26.1"
 serde_json = {version = "1.0.114", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.8"
-serde = { version = "1.0.196", features = ["derive"] }
+serde = { version = "1.0.197", features = ["derive"] }
 speedate = "0.14.0"
 smallvec = "1.13.1"
 ahash = "0.8.10"

From 517cc0bfcd9dd026d946d31cfcb01dfd8bb1fd94 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 2 Apr 2024 09:24:23 +0100
Subject: [PATCH 253/550] Bump smallvec from 1.13.1 to 1.13.2 (#1253)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 81997faa6..f73416e5b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -489,9 +489,9 @@ dependencies = [
 
 [[package]]
 name = "smallvec"
-version = "1.13.1"
+version = "1.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e6ecd384b10a64542d77071bd64bd7b231f4ed5940fba55e98c3de13824cf3d7"
+checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
 
 [[package]]
 name = "speedate"
diff --git a/Cargo.toml b/Cargo.toml
index 8195edd6a..486b92b8f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -35,7 +35,7 @@ serde_json = {version = "1.0.114", features = ["arbitrary_precision", "preserve_
 enum_dispatch = "0.3.8"
 serde = { version = "1.0.197", features = ["derive"] }
 speedate = "0.14.0"
-smallvec = "1.13.1"
+smallvec = "1.13.2"
 ahash = "0.8.10"
 url = "2.5.0"
 # idna is already required by url, added here to be explicit

From 970c6e53a0b715247244fe02f78192abe4128c58 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 2 Apr 2024 08:31:26 +0000
Subject: [PATCH 254/550] Bump enum_dispatch from 0.3.12 to 0.3.13 (#1252)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index f73416e5b..4eea5796c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -56,9 +56,9 @@ checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
 [[package]]
 name = "enum_dispatch"
-version = "0.3.12"
+version = "0.3.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f33313078bb8d4d05a2733a94ac4c2d8a0df9a2b84424ebf4f33bfc224a890e"
+checksum = "aa18ce2bc66555b3218614519ac839ddb759a7d6720732f979ef8d13be147ecd"
 dependencies = [
  "once_cell",
  "proc-macro2",
diff --git a/Cargo.toml b/Cargo.toml
index 486b92b8f..80dc3634d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -32,7 +32,7 @@ regex = "1.10.3"
 strum = { version = "0.25.0", features = ["derive"] }
 strum_macros = "0.26.1"
 serde_json = {version = "1.0.114", features = ["arbitrary_precision", "preserve_order"]}
-enum_dispatch = "0.3.8"
+enum_dispatch = "0.3.13"
 serde = { version = "1.0.197", features = ["derive"] }
 speedate = "0.14.0"
 smallvec = "1.13.2"

From e26e8575f725fb769875ffed9d41c5629180011a Mon Sep 17 00:00:00 2001
From: Samuel Colvin <s@muelcolvin.com>
Date: Tue, 2 Apr 2024 15:00:16 +0100
Subject: [PATCH 255/550] fix build warnings on python <3.11 (#1259)

---
 src/errors/validation_exception.rs | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/errors/validation_exception.rs b/src/errors/validation_exception.rs
index 3a4c3f0c2..d41a10e65 100644
--- a/src/errors/validation_exception.rs
+++ b/src/errors/validation_exception.rs
@@ -145,7 +145,7 @@ impl ValidationError {
                     use pyo3::exceptions::PyUserWarning;
 
                     let wrapped = PyUserWarning::new_err((note,));
-                    wrapped.set_cause(py, Some(PyErr::from_value(err.as_ref(py))));
+                    wrapped.set_cause(py, Some(PyErr::from_value_bound(err.clone_ref(py).into_bound(py))));
                     user_py_errs.push(wrapped);
                 }
             }
@@ -167,16 +167,16 @@ impl ValidationError {
             #[cfg(not(Py_3_11))]
             let cause = {
                 use pyo3::exceptions::PyImportError;
-                match py.import("exceptiongroup") {
-                Ok(py_mod) => match py_mod.getattr("ExceptionGroup") {
-                    Ok(group_cls) => match group_cls.call1((title, user_py_errs)) {
-                        Ok(group_instance) => Some(group_instance.into_py(py)),
+                match py.import_bound("exceptiongroup") {
+                    Ok(py_mod) => match py_mod.getattr("ExceptionGroup") {
+                        Ok(group_cls) => match group_cls.call1((title, user_py_errs)) {
+                            Ok(group_instance) => Some(group_instance.into_py(py)),
+                            Err(_) => None,
+                        },
                         Err(_) => None,
                     },
-                    Err(_) => None,
-                },
-                Err(_) => return Some(PyImportError::new_err("validation_error_cause flag requires the exceptiongroup module backport to be installed when used on Python <3.11.")),
-            }
+                    Err(_) => return Some(PyImportError::new_err("validation_error_cause flag requires the exceptiongroup module backport to be installed when used on Python <3.11.")),
+                }
             };
 
             // Set the cause to the ValidationError:

From 1c4baacac107920110168ce07b63a674d4689d2d Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Tue, 2 Apr 2024 13:33:48 -0500
Subject: [PATCH 256/550] Fixes for `ser_json_inf_nan` inference (#1251)

---
 src/serializers/infer.rs      | 19 +++++++++++++---
 tests/serializers/test_any.py | 41 +++++++++++++++++++++++++++++++++++
 2 files changed, 57 insertions(+), 3 deletions(-)

diff --git a/src/serializers/infer.rs b/src/serializers/infer.rs
index 5c6abd7e8..2384e8691 100644
--- a/src/serializers/infer.rs
+++ b/src/serializers/infer.rs
@@ -401,7 +401,14 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
         ObType::None => serializer.serialize_none(),
         ObType::Int | ObType::IntSubclass => serialize!(Int),
         ObType::Bool => serialize!(bool),
-        ObType::Float | ObType::FloatSubclass => serialize!(f64),
+        ObType::Float | ObType::FloatSubclass => {
+            let v = value.extract::<f64>().map_err(py_err_se_err)?;
+            if (v.is_nan() || v.is_infinite()) && extra.config.inf_nan_mode == InfNanMode::Null {
+                serializer.serialize_none()
+            } else {
+                serializer.serialize_f64(v)
+            }
+        }
         ObType::Decimal => value.to_string().serialize(serializer),
         ObType::Str | ObType::StrSubclass => {
             let py_str = value.downcast::<PyString>().map_err(py_err_se_err)?;
@@ -575,8 +582,14 @@ pub(crate) fn infer_json_key_known<'a>(
 ) -> PyResult<Cow<'a, str>> {
     match ob_type {
         ObType::None => super::type_serializers::simple::none_json_key(),
-        ObType::Int | ObType::IntSubclass | ObType::Float | ObType::FloatSubclass => {
-            super::type_serializers::simple::to_str_json_key(key)
+        ObType::Int | ObType::IntSubclass => super::type_serializers::simple::to_str_json_key(key),
+        ObType::Float | ObType::FloatSubclass => {
+            let v = key.extract::<f64>()?;
+            if (v.is_nan() || v.is_infinite()) && extra.config.inf_nan_mode == InfNanMode::Null {
+                super::type_serializers::simple::none_json_key()
+            } else {
+                super::type_serializers::simple::to_str_json_key(key)
+            }
         }
         ObType::Decimal => Ok(Cow::Owned(key.to_string())),
         ObType::Bool => super::type_serializers::simple::bool_json_key(key),
diff --git a/tests/serializers/test_any.py b/tests/serializers/test_any.py
index 281c96970..b6eedafe0 100644
--- a/tests/serializers/test_any.py
+++ b/tests/serializers/test_any.py
@@ -7,6 +7,7 @@
 from datetime import date, datetime, time, timedelta, timezone
 from decimal import Decimal
 from enum import Enum
+from math import inf, isinf, isnan, nan
 from pathlib import Path
 from typing import ClassVar
 
@@ -603,3 +604,43 @@ def test_numpy_float(any_serializer):
         any_serializer.to_python(numpy.float16(1.0), mode='json')
     with pytest.raises(PydanticSerializationError, match=r"Unable to serialize unknown type: <class 'numpy\.float16'>"):
         any_serializer.to_json(numpy.float16(1.0))
+
+
+def test_ser_json_inf_nan_with_any() -> None:
+    s = SchemaSerializer(core_schema.any_schema(), core_schema.CoreConfig(ser_json_inf_nan='constants'))
+    assert isinf(s.to_python(inf))
+    assert isinf(s.to_python(inf, mode='json'))
+    assert s.to_json(inf) == b'Infinity'
+    assert isnan(s.to_python(nan))
+    assert isnan(s.to_python(nan, mode='json'))
+    assert s.to_json(nan) == b'NaN'
+
+    s = SchemaSerializer(core_schema.any_schema(), core_schema.CoreConfig(ser_json_inf_nan='null'))
+    assert isinf(s.to_python(inf))
+    assert s.to_python(inf, mode='json') is None
+    assert s.to_json(inf) == b'null'
+    assert isnan(s.to_python(nan))
+    assert s.to_python(nan, mode='json') is None
+    assert s.to_json(nan) == b'null'
+
+
+def test_ser_json_inf_nan_with_list_of_any() -> None:
+    s = SchemaSerializer(
+        core_schema.list_schema(core_schema.any_schema()), core_schema.CoreConfig(ser_json_inf_nan='constants')
+    )
+    assert isinf(s.to_python([inf])[0])
+    assert isinf(s.to_python([inf], mode='json')[0])
+    assert s.to_json([inf]) == b'[Infinity]'
+    assert isnan(s.to_python([nan])[0])
+    assert isnan(s.to_python([nan], mode='json')[0])
+    assert s.to_json([nan]) == b'[NaN]'
+
+    s = SchemaSerializer(
+        core_schema.list_schema(core_schema.any_schema()), core_schema.CoreConfig(ser_json_inf_nan='null')
+    )
+    assert isinf(s.to_python([inf])[0])
+    assert s.to_python([inf], mode='json')[0] is None
+    assert s.to_json([inf]) == b'[null]'
+    assert isnan(s.to_python([nan])[0])
+    assert s.to_python([nan], mode='json')[0] is None
+    assert s.to_json([nan]) == b'[null]'

From e73b2d1edc5c3c062f1e0b381cda29d6ed6e5901 Mon Sep 17 00:00:00 2001
From: Samuel Colvin <s@muelcolvin.com>
Date: Tue, 2 Apr 2024 19:37:34 +0100
Subject: [PATCH 257/550] Adopt jiter `0.2.0` (#1250)

Co-authored-by: David Hewitt <mail@davidhewitt.dev>
---
 Cargo.lock                         |  5 +--
 Cargo.toml                         |  2 +-
 src/input/return_enums.rs          | 10 ++----
 src/input/shared.rs                | 55 ++++++++++++++----------------
 src/tools.rs                       | 12 +++++++
 src/validators/validation_state.rs |  7 ++--
 6 files changed, 46 insertions(+), 45 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 4eea5796c..2c50f1444 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -138,15 +138,16 @@ checksum = "62b02a5381cc465bd3041d84623d0fa3b66738b52b8e2fc3bab8ad63ab032f4a"
 
 [[package]]
 name = "jiter"
-version = "0.1.1"
+version = "0.2.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2c0b7c896d2b1da897be13affb0bbf7bff95437e9c50823ede962addadae58d8"
+checksum = "8e1177860adcf80c1ae7d7c1d41561f008c7530664caebbfa5ddd8a7f7316b98"
 dependencies = [
  "ahash",
  "lexical-parse-float",
  "num-bigint",
  "num-traits",
  "pyo3",
+ "pyo3-build-config",
  "smallvec",
 ]
 
diff --git a/Cargo.toml b/Cargo.toml
index 80dc3634d..e6b40dc37 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -44,7 +44,7 @@ base64 = "0.21.7"
 num-bigint = "0.4.4"
 python3-dll-a = "0.2.7"
 uuid = "1.7.0"
-jiter = { version = "0.1.1", features = ["python"] }
+jiter = { version = "0.2.1", features = ["python"] }
 
 [lib]
 name = "_pydantic_core"
diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index 5d1019f05..d28bac2ec 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -19,7 +19,7 @@ use serde::{ser::Error, Serialize, Serializer};
 use crate::errors::{
     py_err_string, ErrorType, ErrorTypeDefaults, InputValue, ToErrorValue, ValError, ValLineError, ValResult,
 };
-use crate::tools::{extract_i64, py_err};
+use crate::tools::{extract_i64, new_py_string, py_err};
 use crate::validators::{CombinedValidator, Exactness, ValidationState, Validator};
 
 use super::{py_error_on_minusone, BorrowInput, Input};
@@ -437,13 +437,7 @@ impl<'a> EitherString<'a> {
 
     pub fn as_py_string(&'a self, py: Python<'a>, cache_str: StringCacheMode) -> Bound<'a, PyString> {
         match self {
-            Self::Cow(cow) => {
-                if matches!(cache_str, StringCacheMode::All) {
-                    jiter::cached_py_string(py, cow.as_ref())
-                } else {
-                    PyString::new_bound(py, cow.as_ref())
-                }
-            }
+            Self::Cow(cow) => new_py_string(py, cow.as_ref(), cache_str),
             Self::Py(py_string) => py_string.clone(),
         }
     }
diff --git a/src/input/shared.rs b/src/input/shared.rs
index 5f0040e3e..e99bfabcf 100644
--- a/src/input/shared.rs
+++ b/src/input/shared.rs
@@ -2,7 +2,7 @@ use pyo3::prelude::*;
 use pyo3::sync::GILOnceCell;
 use pyo3::{intern, Py, PyAny, Python};
 
-use num_bigint::BigInt;
+use jiter::{JsonErrorType, NumberInt};
 
 use crate::errors::{ErrorTypeDefaults, ValError, ValResult};
 
@@ -68,29 +68,24 @@ fn strip_underscores(s: &str) -> Option<String> {
 }
 
 /// parse a string as an int
-///
-/// max length of the input is 4300, see
-/// https://docs.python.org/3/whatsnew/3.11.html#other-cpython-implementation-changes and
-/// https://github.com/python/cpython/issues/95778 for more info in that length bound
 pub fn str_as_int<'py>(input: &(impl Input<'py> + ?Sized), str: &str) -> ValResult<EitherInt<'py>> {
     let str = str.trim();
-    let len = str.len();
-    if len > 4300 {
-        Err(ValError::new(ErrorTypeDefaults::IntParsingSize, input))
-    } else if let Some(int) = _parse_str(input, str, len) {
-        Ok(int)
-    } else if let Some(str_stripped) = strip_decimal_zeros(str) {
-        if let Some(int) = _parse_str(input, str_stripped, len) {
-            Ok(int)
-        } else {
-            Err(ValError::new(ErrorTypeDefaults::IntParsing, input))
+
+    // we have to call `NumberInt::try_from` directly first so we fail fast if the string is too long
+    match NumberInt::try_from(str.as_bytes()) {
+        Ok(NumberInt::Int(i)) => return Ok(EitherInt::I64(i)),
+        Ok(NumberInt::BigInt(i)) => return Ok(EitherInt::BigInt(i)),
+        Err(e) => {
+            if e.error_type == JsonErrorType::NumberOutOfRange {
+                return Err(ValError::new(ErrorTypeDefaults::IntParsingSize, input));
+            }
         }
+    }
+
+    if let Some(str_stripped) = strip_decimal_zeros(str) {
+        _parse_str(input, str_stripped)
     } else if let Some(str_stripped) = strip_underscores(str) {
-        if let Some(int) = _parse_str(input, &str_stripped, len) {
-            Ok(int)
-        } else {
-            Err(ValError::new(ErrorTypeDefaults::IntParsing, input))
-        }
+        _parse_str(input, &str_stripped)
     } else {
         Err(ValError::new(ErrorTypeDefaults::IntParsing, input))
     }
@@ -108,16 +103,18 @@ pub fn str_as_float<'py>(input: &(impl Input<'py> + ?Sized), str: &str) -> ValRe
 }
 
 /// parse a string as an int, `input` is required here to get lifetimes to match up
-///
-fn _parse_str<'py>(_input: &(impl Input<'py> + ?Sized), str: &str, len: usize) -> Option<EitherInt<'py>> {
-    if len < 19 {
-        if let Ok(i) = str.parse::<i64>() {
-            return Some(EitherInt::I64(i));
-        }
-    } else if let Ok(i) = str.parse::<BigInt>() {
-        return Some(EitherInt::BigInt(i));
+/// max length of the input is 4300 which is checked by jiter, see
+/// https://docs.python.org/3/whatsnew/3.11.html#other-cpython-implementation-changes and
+/// https://github.com/python/cpython/issues/95778 for more info in that length bound
+fn _parse_str<'py>(input: &(impl Input<'py> + ?Sized), str: &str) -> ValResult<EitherInt<'py>> {
+    match NumberInt::try_from(str.as_bytes()) {
+        Ok(jiter::NumberInt::Int(i)) => Ok(EitherInt::I64(i)),
+        Ok(jiter::NumberInt::BigInt(i)) => Ok(EitherInt::BigInt(i)),
+        Err(e) => match e.error_type {
+            JsonErrorType::NumberOutOfRange => Err(ValError::new(ErrorTypeDefaults::IntParsingSize, input)),
+            _ => Err(ValError::new(ErrorTypeDefaults::IntParsing, input)),
+        },
     }
-    None
 }
 
 /// we don't want to parse as f64 then call `float_as_int` as it can loose precision for large ints, therefore
diff --git a/src/tools.rs b/src/tools.rs
index a823311a0..28c661d8f 100644
--- a/src/tools.rs
+++ b/src/tools.rs
@@ -5,6 +5,8 @@ use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyString};
 use pyo3::{ffi, intern, FromPyObject};
 
+use jiter::{cached_py_string, pystring_fast_new, StringCacheMode};
+
 pub trait SchemaDict<'py> {
     fn get_as<T>(&self, key: &Bound<'_, PyString>) -> PyResult<Option<T>>
     where
@@ -143,3 +145,13 @@ pub fn extract_i64(v: &Bound<'_, PyAny>) -> Option<i64> {
         None
     }
 }
+
+pub(crate) fn new_py_string<'py>(py: Python<'py>, s: &str, cache_str: StringCacheMode) -> Bound<'py, PyString> {
+    // we could use `bytecount::num_chars(s.as_bytes()) == s.len()` as orjson does, but it doesn't appear to be faster
+    let ascii_only = false;
+    if matches!(cache_str, StringCacheMode::All) {
+        cached_py_string(py, s, ascii_only)
+    } else {
+        pystring_fast_new(py, s, ascii_only)
+    }
+}
diff --git a/src/validators/validation_state.rs b/src/validators/validation_state.rs
index 8e68cd8d9..ef6954618 100644
--- a/src/validators/validation_state.rs
+++ b/src/validators/validation_state.rs
@@ -4,6 +4,7 @@ use pyo3::types::PyString;
 use jiter::StringCacheMode;
 
 use crate::recursion_guard::{ContainsRecursionState, RecursionState};
+use crate::tools::new_py_string;
 
 use super::Extra;
 
@@ -72,11 +73,7 @@ impl<'a, 'py> ValidationState<'a, 'py> {
     }
 
     pub fn maybe_cached_str(&self, py: Python<'py>, s: &str) -> Bound<'py, PyString> {
-        if matches!(self.extra.cache_str, StringCacheMode::All) {
-            jiter::cached_py_string(py, s)
-        } else {
-            PyString::new_bound(py, s)
-        }
+        new_py_string(py, s, self.extra.cache_str)
     }
 }
 

From ee0633509d481617710c11f8a2eb00998437c2c1 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Tue, 2 Apr 2024 20:17:42 +0100
Subject: [PATCH 258/550] update to PyO3 0.21.1, bump version to 2.18 (#1261)

---
 Cargo.lock | 22 +++++++++++-----------
 Cargo.toml |  4 ++--
 2 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 2c50f1444..664672e27 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -294,7 +294,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.17.0"
+version = "2.18.0"
 dependencies = [
  "ahash",
  "base64",
@@ -319,9 +319,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.21.0"
+version = "0.21.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a02a88a17e74cadbc8ce77855e1d6c8ad0ab82901a4a9b5046bd01c1c0bd95cd"
+checksum = "a7a8b1990bd018761768d5e608a13df8bd1ac5f678456e0f301bb93e5f3ea16b"
 dependencies = [
  "cfg-if",
  "indoc",
@@ -338,9 +338,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.21.0"
+version = "0.21.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5eb0b6ecba38961f6f4bd6cd5906dfab3cd426ff37b2eed5771006aa31656f1"
+checksum = "650dca34d463b6cdbdb02b1d71bfd6eb6b6816afc708faebb3bac1380ff4aef7"
 dependencies = [
  "once_cell",
  "python3-dll-a",
@@ -349,9 +349,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.21.0"
+version = "0.21.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ba8a6e48a29b5d22e4fdaf132d8ba8d3203ee9f06362d48f244346902a594ec3"
+checksum = "09a7da8fc04a8a2084909b59f29e1b8474decac98b951d77b80b26dc45f046ad"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -359,9 +359,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.21.0"
+version = "0.21.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4e80493c5965f94a747d0782a607b2328a4eea5391327b152b00e2f3b001cede"
+checksum = "4b8a199fce11ebb28e3569387228836ea98110e43a804a530a9fd83ade36d513"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -371,9 +371,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.21.0"
+version = "0.21.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fcd7d86f42004025200e12a6a8119bd878329e6fddef8178eaafa4e4b5906c5b"
+checksum = "93fbbfd7eb553d10036513cb122b888dcd362a945a00b06c165f2ab480d4cc3b"
 dependencies = [
  "heck",
  "proc-macro2",
diff --git a/Cargo.toml b/Cargo.toml
index e6b40dc37..acfaf1145 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.17.0"
+version = "2.18.0"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"
@@ -27,7 +27,7 @@ include = [
 rust-version = "1.76"
 
 [dependencies]
-pyo3 = { version = "0.21.0", features = ["generate-import-lib", "num-bigint"] }
+pyo3 = { version = "0.21.1", features = ["generate-import-lib", "num-bigint"] }
 regex = "1.10.3"
 strum = { version = "0.25.0", features = ["derive"] }
 strum_macros = "0.26.1"

From 683c5a31a8ec04bb0959b71f2e44a7ab92de1e2f Mon Sep 17 00:00:00 2001
From: Lance-Drane <35977511+Lance-Drane@users.noreply.github.com>
Date: Wed, 3 Apr 2024 05:20:57 -0400
Subject: [PATCH 259/550] allow serialization functions to upgrade warnings to
 exceptions (#1258)

Signed-off-by: Lance Drane <dranelt@ornl.gov>
Signed-off-by: Lance-Drane <ldraneutk@gmail.com>
---
 .mypy-stubtest-allowlist                |  3 ++
 python/pydantic_core/_pydantic_core.pyi | 10 ++--
 src/lib.rs                              |  1 +
 src/serializers/extra.rs                | 71 ++++++++++++++++++++-----
 src/serializers/mod.rs                  | 28 +++++++---
 tests/serializers/test_list_tuple.py    | 12 ++++-
 tests/serializers/test_string.py        | 33 +++++++++++-
 tests/test.rs                           | 21 ++++++--
 8 files changed, 148 insertions(+), 31 deletions(-)

diff --git a/.mypy-stubtest-allowlist b/.mypy-stubtest-allowlist
index 0f9ad4418..9c6f4bb3d 100644
--- a/.mypy-stubtest-allowlist
+++ b/.mypy-stubtest-allowlist
@@ -2,3 +2,6 @@
 pydantic_core._pydantic_core.PydanticUndefinedType.new
 # As per #1240, from_json has custom logic to coverage the `cache_strings` kwarg
 pydantic_core._pydantic_core.from_json
+# the `warnings` kwarg for SchemaSerializer functions has custom logic
+pydantic_core._pydantic_core.SchemaSerializer.to_python
+pydantic_core._pydantic_core.SchemaSerializer.to_json
diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index d7e1dd5bb..b86b7aad0 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -264,7 +264,7 @@ class SchemaSerializer:
         exclude_defaults: bool = False,
         exclude_none: bool = False,
         round_trip: bool = False,
-        warnings: bool = True,
+        warnings: bool | Literal['none', 'warn', 'error'] = True,
         fallback: Callable[[Any], Any] | None = None,
         serialize_as_any: bool = False,
         context: dict[str, Any] | None = None,
@@ -284,7 +284,8 @@ class SchemaSerializer:
             exclude_defaults: Whether to exclude fields that are equal to their default value.
             exclude_none: Whether to exclude fields that have a value of `None`.
             round_trip: Whether to enable serialization and validation round-trip support.
-            warnings: Whether to log warnings when invalid fields are encountered.
+            warnings: How to handle invalid fields. False/"none" ignores them, True/"warn" logs errors,
+                "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
             fallback: A function to call when an unknown value is encountered,
                 if `None` a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
             serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
@@ -309,7 +310,7 @@ class SchemaSerializer:
         exclude_defaults: bool = False,
         exclude_none: bool = False,
         round_trip: bool = False,
-        warnings: bool = True,
+        warnings: bool | Literal['none', 'warn', 'error'] = True,
         fallback: Callable[[Any], Any] | None = None,
         serialize_as_any: bool = False,
         context: dict[str, Any] | None = None,
@@ -328,7 +329,8 @@ class SchemaSerializer:
             exclude_defaults: Whether to exclude fields that are equal to their default value.
             exclude_none: Whether to exclude fields that have a value of `None`.
             round_trip: Whether to enable serialization and validation round-trip support.
-            warnings: Whether to log warnings when invalid fields are encountered.
+            warnings: How to handle invalid fields. False/"none" ignores them, True/"warn" logs errors,
+                "error" raises a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError].
             fallback: A function to call when an unknown value is encountered,
                 if `None` a [`PydanticSerializationError`][pydantic_core.PydanticSerializationError] error is raised.
             serialize_as_any: Whether to serialize fields with duck-typing serialization behavior.
diff --git a/src/lib.rs b/src/lib.rs
index 82f941f20..067c8e08a 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -34,6 +34,7 @@ pub use errors::{
 };
 pub use serializers::{
     to_json, to_jsonable_python, PydanticSerializationError, PydanticSerializationUnexpectedValue, SchemaSerializer,
+    WarningsArg,
 };
 pub use validators::{validate_core_schema, PySome, SchemaValidator};
 
diff --git a/src/serializers/extra.rs b/src/serializers/extra.rs
index ca1eda11f..88185ad6c 100644
--- a/src/serializers/extra.rs
+++ b/src/serializers/extra.rs
@@ -1,9 +1,10 @@
 use std::cell::RefCell;
 use std::fmt;
 
-use pyo3::exceptions::PyValueError;
+use pyo3::exceptions::{PyTypeError, PyValueError};
 use pyo3::intern;
 use pyo3::prelude::*;
+use pyo3::types::PyBool;
 
 use serde::ser::Error;
 
@@ -14,6 +15,7 @@ use crate::recursion_guard::ContainsRecursionState;
 use crate::recursion_guard::RecursionError;
 use crate::recursion_guard::RecursionGuard;
 use crate::recursion_guard::RecursionState;
+use crate::PydanticSerializationError;
 
 /// this is ugly, would be much better if extra could be stored in `SerializationState`
 /// then `SerializationState` got a `serialize_infer` method, but I couldn't get it to work
@@ -64,7 +66,7 @@ impl DuckTypingSerMode {
 
 impl SerializationState {
     pub fn new(timedelta_mode: &str, bytes_mode: &str, inf_nan_mode: &str) -> PyResult<Self> {
-        let warnings = CollectWarnings::new(false);
+        let warnings = CollectWarnings::new(WarningsMode::None);
         let rec_guard = SerRecursionState::default();
         let config = SerializationConfig::from_args(timedelta_mode, bytes_mode, inf_nan_mode)?;
         Ok(Self {
@@ -325,23 +327,61 @@ impl ToPyObject for SerMode {
     }
 }
 
+#[derive(Debug, Clone, Copy, Eq, PartialEq)]
+pub enum WarningsMode {
+    None,
+    Warn,
+    Error,
+}
+
+impl<'py> FromPyObject<'py> for WarningsMode {
+    fn extract_bound(ob: &Bound<'py, PyAny>) -> PyResult<WarningsMode> {
+        if let Ok(bool_mode) = ob.downcast::<PyBool>() {
+            Ok(bool_mode.is_true().into())
+        } else if let Ok(str_mode) = ob.extract::<&str>() {
+            match str_mode {
+                "none" => Ok(Self::None),
+                "warn" => Ok(Self::Warn),
+                "error" => Ok(Self::Error),
+                _ => Err(PyValueError::new_err(
+                    "Invalid warnings parameter, should be `'none'`, `'warn'`, `'error'` or a `bool`",
+                )),
+            }
+        } else {
+            Err(PyTypeError::new_err(
+                "Invalid warnings parameter, should be `'none'`, `'warn'`, `'error'` or a `bool`",
+            ))
+        }
+    }
+}
+
+impl From<bool> for WarningsMode {
+    fn from(mode: bool) -> Self {
+        if mode {
+            Self::Warn
+        } else {
+            Self::None
+        }
+    }
+}
+
 #[derive(Clone)]
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub(crate) struct CollectWarnings {
-    active: bool,
+    mode: WarningsMode,
     warnings: RefCell<Option<Vec<String>>>,
 }
 
 impl CollectWarnings {
-    pub(crate) fn new(active: bool) -> Self {
+    pub(crate) fn new(mode: WarningsMode) -> Self {
         Self {
-            active,
+            mode,
             warnings: RefCell::new(None),
         }
     }
 
     pub fn custom_warning(&self, warning: String) {
-        if self.active {
+        if self.mode != WarningsMode::None {
             self.add_warning(warning);
         }
     }
@@ -379,7 +419,7 @@ impl CollectWarnings {
     }
 
     fn fallback_warning(&self, field_type: &str, value: &Bound<'_, PyAny>) {
-        if self.active {
+        if self.mode != WarningsMode::None {
             let type_name = value
                 .get_type()
                 .qualname()
@@ -400,17 +440,20 @@ impl CollectWarnings {
     }
 
     pub fn final_check(&self, py: Python) -> PyResult<()> {
-        if self.active {
-            match *self.warnings.borrow() {
-                Some(ref warnings) => {
-                    let message = format!("Pydantic serializer warnings:\n  {}", warnings.join("\n  "));
+        if self.mode == WarningsMode::None {
+            return Ok(());
+        }
+        match *self.warnings.borrow() {
+            Some(ref warnings) => {
+                let message = format!("Pydantic serializer warnings:\n  {}", warnings.join("\n  "));
+                if self.mode == WarningsMode::Warn {
                     let user_warning_type = py.import_bound("builtins")?.getattr("UserWarning")?;
                     PyErr::warn_bound(py, &user_warning_type, &message, 0)
+                } else {
+                    Err(PydanticSerializationError::new_err(message))
                 }
-                _ => Ok(()),
             }
-        } else {
-            Ok(())
+            _ => Ok(()),
         }
     }
 }
diff --git a/src/serializers/mod.rs b/src/serializers/mod.rs
index 14650a9df..02ec71fd6 100644
--- a/src/serializers/mod.rs
+++ b/src/serializers/mod.rs
@@ -10,7 +10,7 @@ use crate::py_gc::PyGcTraverse;
 
 use config::SerializationConfig;
 pub use errors::{PydanticSerializationError, PydanticSerializationUnexpectedValue};
-use extra::{CollectWarnings, SerRecursionState};
+use extra::{CollectWarnings, SerRecursionState, WarningsMode};
 pub(crate) use extra::{DuckTypingSerMode, Extra, SerMode, SerializationState};
 pub use shared::CombinedSerializer;
 use shared::{to_json_bytes, BuildSerializer, TypeSerializer};
@@ -27,6 +27,12 @@ pub mod ser;
 mod shared;
 mod type_serializers;
 
+#[derive(FromPyObject)]
+pub enum WarningsArg {
+    Bool(bool),
+    Literal(WarningsMode),
+}
+
 #[pyclass(module = "pydantic_core._pydantic_core", frozen)]
 #[derive(Debug)]
 pub struct SchemaSerializer {
@@ -98,7 +104,7 @@ impl SchemaSerializer {
 
     #[allow(clippy::too_many_arguments)]
     #[pyo3(signature = (value, *, mode = None, include = None, exclude = None, by_alias = true,
-        exclude_unset = false, exclude_defaults = false, exclude_none = false, round_trip = false, warnings = true,
+        exclude_unset = false, exclude_defaults = false, exclude_none = false, round_trip = false, warnings = WarningsArg::Bool(true),
         fallback = None, serialize_as_any = false, context = None))]
     pub fn to_python(
         &self,
@@ -112,13 +118,17 @@ impl SchemaSerializer {
         exclude_defaults: bool,
         exclude_none: bool,
         round_trip: bool,
-        warnings: bool,
+        warnings: WarningsArg,
         fallback: Option<&Bound<'_, PyAny>>,
         serialize_as_any: bool,
         context: Option<&Bound<'_, PyAny>>,
     ) -> PyResult<PyObject> {
         let mode: SerMode = mode.into();
-        let warnings = CollectWarnings::new(warnings);
+        let warnings_mode = match warnings {
+            WarningsArg::Bool(b) => b.into(),
+            WarningsArg::Literal(mode) => mode,
+        };
+        let warnings = CollectWarnings::new(warnings_mode);
         let rec_guard = SerRecursionState::default();
         let duck_typing_ser_mode = DuckTypingSerMode::from_bool(serialize_as_any);
         let extra = self.build_extra(
@@ -143,7 +153,7 @@ impl SchemaSerializer {
 
     #[allow(clippy::too_many_arguments)]
     #[pyo3(signature = (value, *, indent = None, include = None, exclude = None, by_alias = true,
-        exclude_unset = false, exclude_defaults = false, exclude_none = false, round_trip = false, warnings = true,
+        exclude_unset = false, exclude_defaults = false, exclude_none = false, round_trip = false, warnings = WarningsArg::Bool(true),
         fallback = None, serialize_as_any = false, context = None))]
     pub fn to_json(
         &self,
@@ -157,12 +167,16 @@ impl SchemaSerializer {
         exclude_defaults: bool,
         exclude_none: bool,
         round_trip: bool,
-        warnings: bool,
+        warnings: WarningsArg,
         fallback: Option<&Bound<'_, PyAny>>,
         serialize_as_any: bool,
         context: Option<&Bound<'_, PyAny>>,
     ) -> PyResult<PyObject> {
-        let warnings = CollectWarnings::new(warnings);
+        let warnings_mode = match warnings {
+            WarningsArg::Bool(b) => b.into(),
+            WarningsArg::Literal(mode) => mode,
+        };
+        let warnings = CollectWarnings::new(warnings_mode);
         let rec_guard = SerRecursionState::default();
         let duck_typing_ser_mode = DuckTypingSerMode::from_bool(serialize_as_any);
         let extra = self.build_extra(
diff --git a/tests/serializers/test_list_tuple.py b/tests/serializers/test_list_tuple.py
index 256a342fe..3591ffc9d 100644
--- a/tests/serializers/test_list_tuple.py
+++ b/tests/serializers/test_list_tuple.py
@@ -4,7 +4,7 @@
 
 import pytest
 
-from pydantic_core import SchemaError, SchemaSerializer, core_schema, validate_core_schema
+from pydantic_core import PydanticSerializationError, SchemaError, SchemaSerializer, core_schema, validate_core_schema
 
 
 def test_list_any():
@@ -52,6 +52,16 @@ def test_list_str_fallback():
         '  Expected `str` but got `int` - serialized value may not be as expected\n'
         '  Expected `str` but got `int` - serialized value may not be as expected'
     ]
+    with pytest.raises(PydanticSerializationError) as warning_ex:
+        v.to_json([1, 2, 3], warnings='error')
+    assert str(warning_ex.value) == ''.join(
+        [
+            'Pydantic serializer warnings:\n'
+            '  Expected `str` but got `int` - serialized value may not be as expected\n'
+            '  Expected `str` but got `int` - serialized value may not be as expected\n'
+            '  Expected `str` but got `int` - serialized value may not be as expected'
+        ]
+    )
 
 
 def test_tuple_any():
diff --git a/tests/serializers/test_string.py b/tests/serializers/test_string.py
index 495fb429a..6038b6a67 100644
--- a/tests/serializers/test_string.py
+++ b/tests/serializers/test_string.py
@@ -3,7 +3,7 @@
 
 import pytest
 
-from pydantic_core import SchemaSerializer, core_schema
+from pydantic_core import PydanticSerializationError, SchemaSerializer, core_schema
 
 
 def test_str():
@@ -34,13 +34,44 @@ def test_str_fallback():
         assert s.to_python(123, mode='json') == 123
     with pytest.warns(UserWarning, match='Expected `str` but got `int` - serialized value may not be as expected'):
         assert s.to_json(123) == b'123'
+    with pytest.warns(UserWarning, match='Expected `str` but got `int` - serialized value may not be as expected'):
+        assert s.to_python(123, warnings='warn') == 123
+    with pytest.warns(UserWarning, match='Expected `str` but got `int` - serialized value may not be as expected'):
+        assert s.to_python(123, mode='json', warnings='warn') == 123
+    with pytest.warns(UserWarning, match='Expected `str` but got `int` - serialized value may not be as expected'):
+        assert s.to_json(123, warnings='warn') == b'123'
+    with pytest.warns(UserWarning, match='Expected `str` but got `int` - serialized value may not be as expected'):
+        assert s.to_python(123, warnings=True) == 123
+    with pytest.warns(UserWarning, match='Expected `str` but got `int` - serialized value may not be as expected'):
+        assert s.to_python(123, mode='json', warnings=True) == 123
+    with pytest.warns(UserWarning, match='Expected `str` but got `int` - serialized value may not be as expected'):
+        assert s.to_json(123, warnings=True) == b'123'
 
 
 def test_str_no_warnings():
     s = SchemaSerializer(core_schema.str_schema())
     assert s.to_python(123, warnings=False) == 123
+    assert s.to_python(123, warnings='none') == 123
     assert s.to_python(123, mode='json', warnings=False) == 123
+    assert s.to_python(123, mode='json', warnings='none') == 123
     assert s.to_json(123, warnings=False) == b'123'
+    assert s.to_json(123, warnings='none') == b'123'
+
+
+def test_str_errors():
+    s = SchemaSerializer(core_schema.str_schema())
+    with pytest.raises(
+        PydanticSerializationError, match='Expected `str` but got `int` - serialized value may not be as expected'
+    ):
+        assert s.to_python(123, warnings='error') == 123
+    with pytest.raises(
+        PydanticSerializationError, match='Expected `str` but got `int` - serialized value may not be as expected'
+    ):
+        assert s.to_python(123, mode='json', warnings='error') == 123
+    with pytest.raises(
+        PydanticSerializationError, match='Expected `str` but got `int` - serialized value may not be as expected'
+    ):
+        assert s.to_json(123, warnings='error') == b'123'
 
 
 class StrSubclass(str):
diff --git a/tests/test.rs b/tests/test.rs
index 53c99daf6..1a4a87ef3 100644
--- a/tests/test.rs
+++ b/tests/test.rs
@@ -1,6 +1,6 @@
 #[cfg(test)]
 mod tests {
-    use _pydantic_core::{SchemaSerializer, SchemaValidator};
+    use _pydantic_core::{SchemaSerializer, SchemaValidator, WarningsArg};
     use pyo3::prelude::*;
     use pyo3::types::PyDict;
 
@@ -85,7 +85,20 @@ a = A()
             let serialized = SchemaSerializer::py_new(schema, None)
                 .unwrap()
                 .to_json(
-                    py, &a, None, None, None, true, false, false, false, false, true, None, false, None,
+                    py,
+                    &a,
+                    None,
+                    None,
+                    None,
+                    true,
+                    false,
+                    false,
+                    false,
+                    false,
+                    WarningsArg::Bool(true),
+                    None,
+                    false,
+                    None,
                 )
                 .unwrap();
             let serialized: &[u8] = serialized.extract(py).unwrap();
@@ -186,7 +199,7 @@ dump_json_input_2 = {'a': 'something'}
                     false,
                     false,
                     false,
-                    false,
+                    WarningsArg::Bool(false),
                     None,
                     false,
                     None,
@@ -207,7 +220,7 @@ dump_json_input_2 = {'a': 'something'}
                     false,
                     false,
                     false,
-                    false,
+                    WarningsArg::Bool(false),
                     None,
                     false,
                     None,

From 4b82169f21e6160fcfaba575a002c2af6a916a3f Mon Sep 17 00:00:00 2001
From: Neev Cohen <70970900+NeevCohen@users.noreply.github.com>
Date: Thu, 4 Apr 2024 18:37:08 +0300
Subject: [PATCH 260/550] Add coerce_numbers_to_str option in StringSchema
 (#1262)

---
 python/pydantic_core/core_schema.py | 1 +
 src/validators/string.rs            | 1 +
 2 files changed, 2 insertions(+)

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index a2f4b4f0c..2cb875b23 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -752,6 +752,7 @@ class StringSchema(TypedDict, total=False):
     to_upper: bool
     regex_engine: Literal['rust-regex', 'python-re']  # default: 'rust-regex'
     strict: bool
+    coerce_numbers_to_str: bool
     ref: str
     metadata: Any
     serialization: SerSchema
diff --git a/src/validators/string.rs b/src/validators/string.rs
index ab6671c9c..a7becf6bb 100644
--- a/src/validators/string.rs
+++ b/src/validators/string.rs
@@ -208,6 +208,7 @@ impl StrConstrainedValidator {
             || self.strip_whitespace
             || self.to_lower
             || self.to_upper
+            || self.coerce_numbers_to_str
     }
 }
 

From e23d7eb2f742324a5f41b6305e9a12b557376dca Mon Sep 17 00:00:00 2001
From: Samuel Colvin <s@muelcolvin.com>
Date: Sat, 6 Apr 2024 12:26:11 +0100
Subject: [PATCH 261/550] remove old profiling directory (#1265)

---
 Makefile                | 15 -------------
 profiling/dict_model.py | 47 -----------------------------------------
 2 files changed, 62 deletions(-)
 delete mode 100755 profiling/dict_model.py

diff --git a/Makefile b/Makefile
index 0b361de63..f860ae6aa 100644
--- a/Makefile
+++ b/Makefile
@@ -131,20 +131,6 @@ testcov: build-coverage
 .PHONY: all
 all: format build-dev lint test
 
-.PHONY: flame
-flame:
-	@rm -rf perf.data*
-	@rm -rf flame
-	@mkdir -p flame
-	perf record -g profiling/dict_model.py
-	perf script --max-stack 20 | stackcollapse-perf.pl | flamegraph.pl > flame/python.svg
-	perf script --max-stack 20 | stackcollapse-perf.pl > flame/python.txt
-	@rm perf.data
-	JSON=1 perf record -g profiling/dict_model.py
-	perf script --max-stack 20 | stackcollapse-perf.pl | flamegraph.pl > flame/json.svg
-	perf script --max-stack 20 | stackcollapse-perf.pl > flame/json.txt
-	@rm perf.data
-
 .PHONY: clean
 clean:
 	rm -rf `find . -name __pycache__`
@@ -153,7 +139,6 @@ clean:
 	rm -f `find . -type f -name '.*~' `
 	rm -rf src/self_schema.py
 	rm -rf .cache
-	rm -rf flame
 	rm -rf htmlcov
 	rm -rf .pytest_cache
 	rm -rf *.egg-info
diff --git a/profiling/dict_model.py b/profiling/dict_model.py
deleted file mode 100755
index 9c22e622b..000000000
--- a/profiling/dict_model.py
+++ /dev/null
@@ -1,47 +0,0 @@
-#!/usr/bin/env python3
-"""
-This is used to generate flamegraphs, usage:
-
-    perf record -g benchmarks/minimal.py
-
-Then:
-
-    perf script | stackcollapse-perf.pl | flamegraph.pl > flame.svg
-
-Or just
-
-    make flame
-
-As per https://gist.github.com/KodrAus/97c92c07a90b1fdd6853654357fd557a
-"""
-import os
-from pydantic_core import SchemaValidator, ValidationError
-import json
-
-size = 5
-v = SchemaValidator(
-    {
-        'title': 'MyTestModel',
-        'type': 'list',
-        'items': {'type': 'model', 'fields': {f'f_{i}': {'type': 'str'} for i in range(size)}},
-    }
-)
-# print(repr(v))
-
-d = [{f'f_{i}': f'foobar_{i}' for i in range(size)} for _ in range(50)]
-if os.getenv('JSON'):
-    print('running validate_json...')
-    j = json.dumps(d)
-    for i in range(100_000):
-        r = v.validate_json(j)
-else:
-    print('running validate_python...')
-    for i in range(100_000):
-        r = v.validate_python(d)
-# debug(r)
-
-try:
-    r = v.validate_python({'name': 'John', 'age': 16, 'friends': [-1, 2, 3, -1], 'settings': {'a': 1.0, 'b': 2.0}})
-except ValidationError as e:
-    # print(e)
-    pass

From f636403c2e8169bcbb94aa71a0727d76076f7e6e Mon Sep 17 00:00:00 2001
From: Samuel Colvin <s@muelcolvin.com>
Date: Sat, 6 Apr 2024 13:28:40 +0100
Subject: [PATCH 262/550] trim leading zeros before parsing `str` -> `int`
 (#1266)

---
 src/input/shared.rs          | 66 ++++++++++++++++++++----------------
 tests/validators/test_int.py |  5 +++
 2 files changed, 42 insertions(+), 29 deletions(-)

diff --git a/src/input/shared.rs b/src/input/shared.rs
index e99bfabcf..f4251a11d 100644
--- a/src/input/shared.rs
+++ b/src/input/shared.rs
@@ -1,3 +1,5 @@
+use std::borrow::Cow;
+
 use pyo3::prelude::*;
 use pyo3::sync::GILOnceCell;
 use pyo3::{intern, Py, PyAny, Python};
@@ -61,17 +63,19 @@ fn strip_underscores(s: &str) -> Option<String> {
     // Double consecutive underscores are also not valid
     // If there are no underscores at all, no need to replace anything
     if s.starts_with('_') || s.ends_with('_') || !s.contains('_') || s.contains("__") {
-        // no underscores to strip
-        return None;
+        // no underscores to strip, or underscores in the wrong place
+        None
+    } else {
+        Some(s.replace('_', ""))
     }
-    Some(s.replace('_', ""))
 }
 
 /// parse a string as an int
+/// max length of the input is 4300 which is checked by jiter, see
+/// https://docs.python.org/3/whatsnew/3.11.html#other-cpython-implementation-changes and
+/// https://github.com/python/cpython/issues/95778 for more info in that length bound
 pub fn str_as_int<'py>(input: &(impl Input<'py> + ?Sized), str: &str) -> ValResult<EitherInt<'py>> {
-    let str = str.trim();
-
-    // we have to call `NumberInt::try_from` directly first so we fail fast if the string is too long
+    // we can't move `NumberInt::try_from` into its own function we fail fast if the string is too long
     match NumberInt::try_from(str.as_bytes()) {
         Ok(NumberInt::Int(i)) => return Ok(EitherInt::I64(i)),
         Ok(NumberInt::BigInt(i)) => return Ok(EitherInt::BigInt(i)),
@@ -82,10 +86,12 @@ pub fn str_as_int<'py>(input: &(impl Input<'py> + ?Sized), str: &str) -> ValResu
         }
     }
 
-    if let Some(str_stripped) = strip_decimal_zeros(str) {
-        _parse_str(input, str_stripped)
-    } else if let Some(str_stripped) = strip_underscores(str) {
-        _parse_str(input, &str_stripped)
+    if let Some(cleaned_str) = clean_int_str(str) {
+        match NumberInt::try_from(cleaned_str.as_ref().as_bytes()) {
+            Ok(NumberInt::Int(i)) => Ok(EitherInt::I64(i)),
+            Ok(NumberInt::BigInt(i)) => Ok(EitherInt::BigInt(i)),
+            Err(_) => Err(ValError::new(ErrorTypeDefaults::IntParsing, input)),
+        }
     } else {
         Err(ValError::new(ErrorTypeDefaults::IntParsing, input))
     }
@@ -102,30 +108,32 @@ pub fn str_as_float<'py>(input: &(impl Input<'py> + ?Sized), str: &str) -> ValRe
     }
 }
 
-/// parse a string as an int, `input` is required here to get lifetimes to match up
-/// max length of the input is 4300 which is checked by jiter, see
-/// https://docs.python.org/3/whatsnew/3.11.html#other-cpython-implementation-changes and
-/// https://github.com/python/cpython/issues/95778 for more info in that length bound
-fn _parse_str<'py>(input: &(impl Input<'py> + ?Sized), str: &str) -> ValResult<EitherInt<'py>> {
-    match NumberInt::try_from(str.as_bytes()) {
-        Ok(jiter::NumberInt::Int(i)) => Ok(EitherInt::I64(i)),
-        Ok(jiter::NumberInt::BigInt(i)) => Ok(EitherInt::BigInt(i)),
-        Err(e) => match e.error_type {
-            JsonErrorType::NumberOutOfRange => Err(ValError::new(ErrorTypeDefaults::IntParsingSize, input)),
-            _ => Err(ValError::new(ErrorTypeDefaults::IntParsing, input)),
-        },
-    }
-}
+fn clean_int_str(mut s: &str) -> Option<Cow<str>> {
+    let len_before = s.len();
+
+    // strip leading and trailing whitespace
+    s = s.trim();
 
-/// we don't want to parse as f64 then call `float_as_int` as it can loose precision for large ints, therefore
-/// we strip `.0+` manually instead, then parse as i64
-fn strip_decimal_zeros(s: &str) -> Option<&str> {
+    // strip loading zeros
+    s = s.trim_start_matches('0');
+
+    // we don't want to parse as f64 then call `float_as_int` as it can lose precision for large ints, therefore
+    // we strip `.0+` manually instead
     if let Some(i) = s.find('.') {
         if s[i + 1..].chars().all(|c| c == '0') {
-            return Some(&s[..i]);
+            s = &s[..i];
+        }
+    }
+
+    // remove underscores
+    if let Some(str_stripped) = strip_underscores(s) {
+        Some(str_stripped.into())
+    } else {
+        match len_before == s.len() {
+            true => None,
+            false => Some(s.into()),
         }
     }
-    None
 }
 
 pub fn float_as_int<'py>(input: &(impl Input<'py> + ?Sized), float: f64) -> ValResult<EitherInt<'py>> {
diff --git a/tests/validators/test_int.py b/tests/validators/test_int.py
index baddb6289..775c65cc3 100644
--- a/tests/validators/test_int.py
+++ b/tests/validators/test_int.py
@@ -26,6 +26,11 @@
         ('42', 42),
         (42.0, 42),
         ('42.0', 42),
+        ('042', 42),
+        ('4_2', 42),
+        ('4_2.0', 42),
+        ('04_2.0', 42),
+        ('000001', 1),
         ('123456789.0', 123_456_789),
         ('123456789123456.00001', Err('Input should be a valid integer, unable to parse string as an integer')),
         (int(1e10), int(1e10)),

From b945bcb985dac95a3d9619aede954f78ad13a2bb Mon Sep 17 00:00:00 2001
From: Samuel Colvin <s@muelcolvin.com>
Date: Mon, 8 Apr 2024 15:05:27 +0100
Subject: [PATCH 263/550] prevent trailing dots in integers (#1267)

---
 src/input/shared.rs          | 3 ++-
 tests/validators/test_int.py | 6 ++++++
 2 files changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/input/shared.rs b/src/input/shared.rs
index f4251a11d..33e007a30 100644
--- a/src/input/shared.rs
+++ b/src/input/shared.rs
@@ -120,7 +120,8 @@ fn clean_int_str(mut s: &str) -> Option<Cow<str>> {
     // we don't want to parse as f64 then call `float_as_int` as it can lose precision for large ints, therefore
     // we strip `.0+` manually instead
     if let Some(i) = s.find('.') {
-        if s[i + 1..].chars().all(|c| c == '0') {
+        let decimal_part = &s[i + 1..];
+        if !decimal_part.is_empty() && decimal_part.chars().all(|c| c == '0') {
             s = &s[..i];
         }
     }
diff --git a/tests/validators/test_int.py b/tests/validators/test_int.py
index 775c65cc3..640234754 100644
--- a/tests/validators/test_int.py
+++ b/tests/validators/test_int.py
@@ -26,12 +26,18 @@
         ('42', 42),
         (42.0, 42),
         ('42.0', 42),
+        ('42.00', 42),
         ('042', 42),
         ('4_2', 42),
         ('4_2.0', 42),
         ('04_2.0', 42),
+        ('  04_2.0 ', 42),
+        # because zeros are striped before underscores this is not allowed
+        ('  0_42.0 ', Err('Input should be a valid integer, unable to parse string as an integer')),
         ('000001', 1),
         ('123456789.0', 123_456_789),
+        ('1.', Err('Input should be a valid integer, unable to parse string as an integer')),
+        ('42.', Err('Input should be a valid integer, unable to parse string as an integer')),
         ('123456789123456.00001', Err('Input should be a valid integer, unable to parse string as an integer')),
         (int(1e10), int(1e10)),
         (i64_max, i64_max),

From 031fc93b422ed83d7bcfe8d4beae93e6d6886a4f Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Thu, 11 Apr 2024 08:18:24 -0500
Subject: [PATCH 264/550] Bump to 2.18.1 (#1268)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 664672e27..29203dc84 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -294,7 +294,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.18.0"
+version = "2.18.1"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index acfaf1145..88470c543 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.18.0"
+version = "2.18.1"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From 4adf47f10cc30eaba3a48242216e2920e71fb600 Mon Sep 17 00:00:00 2001
From: Samuel Colvin <s@muelcolvin.com>
Date: Tue, 16 Apr 2024 15:49:59 +0100
Subject: [PATCH 265/550] support multiple zeros as an int (#1269)

---
 src/input/shared.rs          | 33 ++++++++++++++++++++++++++++++++-
 tests/validators/test_int.py | 19 +++++++++++++++++--
 2 files changed, 49 insertions(+), 3 deletions(-)

diff --git a/src/input/shared.rs b/src/input/shared.rs
index 33e007a30..771f16ed9 100644
--- a/src/input/shared.rs
+++ b/src/input/shared.rs
@@ -115,7 +115,7 @@ fn clean_int_str(mut s: &str) -> Option<Cow<str>> {
     s = s.trim();
 
     // strip loading zeros
-    s = s.trim_start_matches('0');
+    s = strip_leading_zeros(s)?;
 
     // we don't want to parse as f64 then call `float_as_int` as it can lose precision for large ints, therefore
     // we strip `.0+` manually instead
@@ -137,6 +137,37 @@ fn clean_int_str(mut s: &str) -> Option<Cow<str>> {
     }
 }
 
+/// strip leading zeros from a string, we can't simple use `s.trim_start_matches('0')`, because:
+/// - we need to keep one zero if the string is only zeros e.g. `000` -> `0`
+/// - we need to keep one zero if the string is a float which is an exact int e.g. `00.0` -> `0.0`
+/// - underscores within leading zeros should also be stripped e.g. `0_000` -> `0`, but not `_000`
+fn strip_leading_zeros(s: &str) -> Option<&str> {
+    let mut char_iter = s.char_indices();
+    match char_iter.next() {
+        // if we get a leading zero we continue
+        Some((_, '0')) => (),
+        // if we get another digit we return the whole string
+        Some((_, c)) if ('1'..='9').contains(&c) => return Some(s),
+        // anything else is invalid, we return None
+        _ => return None,
+    };
+    for (i, c) in char_iter {
+        match c {
+            // continue on more leading zeros or if we get an underscore we continue - we're "within the number"
+            '0' | '_' => (),
+            // any other digit we return the rest of the string
+            '1'..='9' => return Some(&s[i..]),
+            // if we get a dot we return the rest of the string but include the last zero
+            '.' => return Some(&s[(i - 1)..]),
+            // anything else is invalid, we return None
+            _ => return None,
+        }
+    }
+    // if the string is all zeros (or underscores), we return the last character
+    // generally this will be zero, but could be an underscore, which will fail
+    Some(&s[s.len() - 1..])
+}
+
 pub fn float_as_int<'py>(input: &(impl Input<'py> + ?Sized), float: f64) -> ValResult<EitherInt<'py>> {
     if float.is_infinite() || float.is_nan() {
         Err(ValError::new(ErrorTypeDefaults::FiniteNumber, input))
diff --git a/tests/validators/test_int.py b/tests/validators/test_int.py
index 640234754..83e527514 100644
--- a/tests/validators/test_int.py
+++ b/tests/validators/test_int.py
@@ -20,22 +20,37 @@
         (True, 1),
         (0, 0),
         ('0', 0),
+        ('00', 0),
+        ('000', 0),
+        ('0_000', 0),
         (1, 1),
         ('  1  ', 1),
         (42, 42),
         ('42', 42),
         (42.0, 42),
+        ('0.0', 0),
+        ('00.0', 0),
+        ('00.00', 0),
         ('42.0', 42),
         ('42.00', 42),
         ('042', 42),
+        ('01', 1),
+        ('09', 9),
+        ('00_', Err('Input should be a valid integer, unable to parse string as an integer')),
+        # next character after 9 is not valid
+        ('0:', Err('Input should be a valid integer, unable to parse string as an integer')),
         ('4_2', 42),
+        ('0_42', 42),
         ('4_2.0', 42),
         ('04_2.0', 42),
         ('  04_2.0 ', 42),
-        # because zeros are striped before underscores this is not allowed
-        ('  0_42.0 ', Err('Input should be a valid integer, unable to parse string as an integer')),
+        ('  0_42.0 ', 42),
+        ('  _042.0 ', Err('Input should be a valid integer, unable to parse string as an integer')),
+        ('42_', Err('Input should be a valid integer, unable to parse string as an integer')),
+        ('42_.0', Err('Input should be a valid integer, unable to parse string as an integer')),
         ('000001', 1),
         ('123456789.0', 123_456_789),
+        (' ', Err('Input should be a valid integer, unable to parse string as an integer')),
         ('1.', Err('Input should be a valid integer, unable to parse string as an integer')),
         ('42.', Err('Input should be a valid integer, unable to parse string as an integer')),
         ('123456789123456.00001', Err('Input should be a valid integer, unable to parse string as an integer')),

From 91c354182d631b9845cc37a3ed3f7177c27ec1c4 Mon Sep 17 00:00:00 2001
From: Esben Sonne <esbensonne@gmail.com>
Date: Thu, 18 Apr 2024 19:07:34 +0200
Subject: [PATCH 266/550] fix validation of ints with leading unary plus
 (#1272)

---
 src/input/shared.rs          |  3 +++
 tests/validators/test_int.py | 10 ++++++++++
 2 files changed, 13 insertions(+)

diff --git a/src/input/shared.rs b/src/input/shared.rs
index 771f16ed9..fe26c503d 100644
--- a/src/input/shared.rs
+++ b/src/input/shared.rs
@@ -114,6 +114,9 @@ fn clean_int_str(mut s: &str) -> Option<Cow<str>> {
     // strip leading and trailing whitespace
     s = s.trim();
 
+    // strip leading unary plus
+    s = s.strip_prefix('+').unwrap_or(s);
+
     // strip loading zeros
     s = strip_leading_zeros(s)?;
 
diff --git a/tests/validators/test_int.py b/tests/validators/test_int.py
index 83e527514..5732fe181 100644
--- a/tests/validators/test_int.py
+++ b/tests/validators/test_int.py
@@ -23,6 +23,10 @@
         ('00', 0),
         ('000', 0),
         ('0_000', 0),
+        ('+0', 0),
+        ('+00', 0),
+        ('+000', 0),
+        ('+0_000', 0),
         (1, 1),
         ('  1  ', 1),
         (42, 42),
@@ -39,6 +43,12 @@
         ('00_', Err('Input should be a valid integer, unable to parse string as an integer')),
         # next character after 9 is not valid
         ('0:', Err('Input should be a valid integer, unable to parse string as an integer')),
+        ('+4_2', 42),
+        ('+0_42', 42),
+        ('+4_2.0', 42),
+        ('+04_2.0', 42),
+        ('++4_2', Err('Input should be a valid integer, unable to parse string as an integer')),
+        ('+-1', Err('Input should be a valid integer, unable to parse string as an integer')),
         ('4_2', 42),
         ('0_42', 42),
         ('4_2.0', 42),

From 3240277ed9368abb67d9323369079f73d94062e5 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Mon, 22 Apr 2024 14:13:11 +0100
Subject: [PATCH 267/550] fix interaction between `extra != 'ignore'` and
 `from_attributes=True` (#1275)

---
 src/input/input_python.rs      |  6 ++-
 src/validators/typed_dict.rs   | 10 ++--
 tests/validators/test_model.py | 93 ++++++++++++++++++++++++++++++++++
 3 files changed, 104 insertions(+), 5 deletions(-)

diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index 0c9a807b1..b2284efb5 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -622,7 +622,7 @@ fn from_attributes_applicable(obj: &Bound<'_, PyAny>) -> bool {
     // I don't think it's a very good list at all! But it doesn't have to be at perfect, it just needs to avoid
     // the most egregious foot guns, it's mostly just to catch "builtins"
     // still happy to add more or do something completely different if anyone has a better idea???
-    // dbg!(obj, module_name);
+    // dbg!(obj, &module_name);
     !matches!(module_name.to_str(), Ok("builtins" | "datetime" | "collections"))
 }
 
@@ -808,6 +808,10 @@ impl<'py> ValidatedDict<'py> for GenericPyMapping<'_, 'py> {
         }
     }
 
+    fn is_py_get_attr(&self) -> bool {
+        matches!(self, Self::GetAttr(..))
+    }
+
     fn as_py_dict(&self) -> Option<&Bound<'py, PyDict>> {
         match self {
             Self::Dict(dict) => Some(dict),
diff --git a/src/validators/typed_dict.rs b/src/validators/typed_dict.rs
index c90196c7c..5aa8a5f00 100644
--- a/src/validators/typed_dict.rs
+++ b/src/validators/typed_dict.rs
@@ -156,10 +156,12 @@ impl Validator for TypedDictValidator {
 
         // we only care about which keys have been used if we're iterating over the object for extra after
         // the first pass
-        let mut used_keys: Option<AHashSet<&str>> = match self.extra_behavior {
-            ExtraBehavior::Allow | ExtraBehavior::Forbid => Some(AHashSet::with_capacity(self.fields.len())),
-            ExtraBehavior::Ignore => None,
-        };
+        let mut used_keys: Option<AHashSet<&str>> =
+            if self.extra_behavior == ExtraBehavior::Ignore || dict.is_py_get_attr() {
+                None
+            } else {
+                Some(AHashSet::with_capacity(self.fields.len()))
+            };
 
         {
             let state = &mut state.rebind_extra(|extra| extra.data = Some(output_dict.clone()));
diff --git a/tests/validators/test_model.py b/tests/validators/test_model.py
index 69b6a06ec..bdcfbb2e9 100644
--- a/tests/validators/test_model.py
+++ b/tests/validators/test_model.py
@@ -72,6 +72,99 @@ class MyModel:
     assert m.__dict__ == {'field_a': 'test', 'field_b': 12}
 
 
+def test_model_class_extra_forbid():
+    class MyModel:
+        class Meta:
+            pass
+
+        # this is not required, but it avoids `__pydantic_fields_set__` being included in `__dict__`
+        __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__'
+        field_a: str
+        field_b: int
+
+    class Wrapper:
+        def __init__(self, inner):
+            self._inner = inner
+
+        def __dir__(self):
+            return dir(self._inner)
+
+        def __getattr__(self, key):
+            return getattr(self._inner, key)
+
+    v = SchemaValidator(
+        core_schema.model_schema(
+            MyModel,
+            core_schema.model_fields_schema(
+                {
+                    'field_a': core_schema.model_field(core_schema.str_schema()),
+                    'field_b': core_schema.model_field(core_schema.int_schema()),
+                },
+                extra_behavior='forbid',
+            ),
+        )
+    )
+    m = v.validate_python({'field_a': 'test', 'field_b': 12})
+    assert isinstance(m, MyModel)
+    assert m.field_a == 'test'
+    assert m.field_b == 12
+
+    # try revalidating from the model's attributes
+    m = v.validate_python(Wrapper(m), from_attributes=True)
+
+    with pytest.raises(ValidationError) as exc_info:
+        m = v.validate_python({'field_a': 'test', 'field_b': 12, 'field_c': 'extra'})
+
+    assert exc_info.value.errors(include_url=False) == [
+        {'type': 'extra_forbidden', 'loc': ('field_c',), 'msg': 'Extra inputs are not permitted', 'input': 'extra'}
+    ]
+
+
+@pytest.mark.parametrize('extra_behavior', ['allow', 'ignore', 'forbid'])
+def test_model_class_extra_forbid_from_attributes(extra_behavior: str):
+    # iterating attributes includes much more than just __dict__, so need
+    # careful interaction with __extra__
+
+    class MyModel:
+        # this is not required, but it avoids `__pydantic_fields_set__` being included in `__dict__`
+        __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__'
+        field_a: str
+        field_b: int
+
+    class Data:
+        # https://github.com/pydantic/pydantic/issues/9242
+        class Meta:
+            pass
+
+        def __init__(self, **values):
+            self.__dict__.update(values)
+
+    v = SchemaValidator(
+        core_schema.model_schema(
+            MyModel,
+            core_schema.model_fields_schema(
+                {
+                    'field_a': core_schema.model_field(core_schema.str_schema()),
+                    'field_b': core_schema.model_field(core_schema.int_schema()),
+                },
+                extra_behavior=extra_behavior,
+                from_attributes=True,
+            ),
+        )
+    )
+    m = v.validate_python(Data(field_a='test', field_b=12))
+    assert isinstance(m, MyModel)
+    assert m.field_a == 'test'
+    assert m.field_b == 12
+
+    # with from_attributes, extra is basically ignored
+    m = v.validate_python(Data(field_a='test', field_b=12, field_c='extra'))
+    assert isinstance(m, MyModel)
+    assert m.field_a == 'test'
+    assert m.field_b == 12
+    assert not hasattr(m, 'field_c')
+
+
 def test_model_class_setattr():
     setattr_calls = []
 

From f537a03fad095e4e04c465fcfe29036bb2b2fe67 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Mon, 22 Apr 2024 08:31:19 -0500
Subject: [PATCH 268/550] Handle error from `Enum`'s `missing` function as
 `ValidationError` (#1274)

---
 src/validators/enum_.rs        | 10 +++++++++-
 tests/validators/test_enums.py | 20 +++++++++++++++++++-
 2 files changed, 28 insertions(+), 2 deletions(-)

diff --git a/src/validators/enum_.rs b/src/validators/enum_.rs
index cf65c2f96..2c9ae4b28 100644
--- a/src/validators/enum_.rs
+++ b/src/validators/enum_.rs
@@ -121,7 +121,15 @@ impl<T: EnumValidateValue> Validator for EnumValidator<T> {
             return Ok(v);
         } else if let Some(ref missing) = self.missing {
             state.floor_exactness(Exactness::Lax);
-            let enum_value = missing.bind(py).call1((input.to_object(py),))?;
+            let enum_value = missing.bind(py).call1((input.to_object(py),)).map_err(|_| {
+                ValError::new(
+                    ErrorType::Enum {
+                        expected: self.expected_repr.clone(),
+                        context: None,
+                    },
+                    input,
+                )
+            })?;
             // check enum_value is an instance of the class like
             // https://github.com/python/cpython/blob/v3.12.2/Lib/enum.py#L1148
             if enum_value.is_instance(class)? {
diff --git a/tests/validators/test_enums.py b/tests/validators/test_enums.py
index 89db8aa21..49abc415b 100644
--- a/tests/validators/test_enums.py
+++ b/tests/validators/test_enums.py
@@ -1,6 +1,6 @@
 import re
 import sys
-from enum import Enum
+from enum import Enum, IntFlag
 
 import pytest
 
@@ -267,3 +267,21 @@ class MyEnum(Enum):
 
     with pytest.raises(SchemaError, match='`members` should have length > 0'):
         SchemaValidator(core_schema.enum_schema(MyEnum, []))
+
+
+def test_missing_error_converted_to_val_error() -> None:
+    class MyFlags(IntFlag):
+        OFF = 0
+        ON = 1
+
+    v = SchemaValidator(
+        core_schema.with_default_schema(
+            schema=core_schema.enum_schema(MyFlags, list(MyFlags.__members__.values())), default=MyFlags.OFF
+        )
+    )
+
+    assert v.validate_python(MyFlags.OFF) is MyFlags.OFF
+    assert v.validate_python(0) is MyFlags.OFF
+
+    with pytest.raises(ValidationError):
+        v.validate_python(None)

From a99729a324540693fefacfa42b398796fc2544b0 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Mon, 22 Apr 2024 16:49:08 +0100
Subject: [PATCH 269/550] fix memory leak with iterable validation (#1271)

---
 src/input/return_enums.rs        | 12 ++++++++++
 src/validators/generator.rs      |  9 ++++++-
 tests/test_garbage_collection.py | 41 +++++++++++++++++++++++++++++++-
 3 files changed, 60 insertions(+), 2 deletions(-)

diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index d28bac2ec..9722669cc 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -19,6 +19,7 @@ use serde::{ser::Error, Serialize, Serializer};
 use crate::errors::{
     py_err_string, ErrorType, ErrorTypeDefaults, InputValue, ToErrorValue, ValError, ValLineError, ValResult,
 };
+use crate::py_gc::PyGcTraverse;
 use crate::tools::{extract_i64, new_py_string, py_err};
 use crate::validators::{CombinedValidator, Exactness, ValidationState, Validator};
 
@@ -327,6 +328,15 @@ pub enum GenericIterator<'data> {
     JsonArray(GenericJsonIterator<'data>),
 }
 
+impl PyGcTraverse for GenericIterator<'_> {
+    fn py_gc_traverse(&self, visit: &pyo3::PyVisit<'_>) -> Result<(), pyo3::PyTraverseError> {
+        if let Self::PyIterator(iter) = self {
+            iter.py_gc_traverse(visit)?;
+        }
+        Ok(())
+    }
+}
+
 impl GenericIterator<'_> {
     pub(crate) fn into_static(self) -> GenericIterator<'static> {
         match self {
@@ -385,6 +395,8 @@ impl GenericPyIterator {
     }
 }
 
+impl_py_gc_traverse!(GenericPyIterator { obj, iter });
+
 #[derive(Debug, Clone)]
 pub struct GenericJsonIterator<'data> {
     array: JsonArray<'data>,
diff --git a/src/validators/generator.rs b/src/validators/generator.rs
index 904f4a0ef..de9949a8c 100644
--- a/src/validators/generator.rs
+++ b/src/validators/generator.rs
@@ -1,11 +1,12 @@
 use std::fmt;
 use std::sync::Arc;
 
-use pyo3::prelude::*;
 use pyo3::types::PyDict;
+use pyo3::{prelude::*, PyTraverseError, PyVisit};
 
 use crate::errors::{ErrorType, LocItem, ValError, ValResult};
 use crate::input::{BorrowInput, GenericIterator, Input};
+use crate::py_gc::PyGcTraverse;
 use crate::recursion_guard::RecursionState;
 use crate::tools::SchemaDict;
 use crate::ValidationError;
@@ -201,6 +202,12 @@ impl ValidatorIterator {
     fn __str__(&self) -> String {
         self.__repr__()
     }
+
+    fn __traverse__(&self, visit: PyVisit<'_>) -> Result<(), PyTraverseError> {
+        self.iterator.py_gc_traverse(&visit)?;
+        self.validator.py_gc_traverse(&visit)?;
+        Ok(())
+    }
 }
 
 /// Owned validator wrapper for use in generators in functions, this can be passed back to python
diff --git a/tests/test_garbage_collection.py b/tests/test_garbage_collection.py
index 97107e61b..f4e178f26 100644
--- a/tests/test_garbage_collection.py
+++ b/tests/test_garbage_collection.py
@@ -1,6 +1,6 @@
 import gc
 import platform
-from typing import Any
+from typing import Any, Iterable
 from weakref import WeakValueDictionary
 
 import pytest
@@ -79,3 +79,42 @@ class MyModel(BaseModel):
     gc.collect(2)
 
     assert len(cache) == 0
+
+
+@pytest.mark.xfail(
+    condition=platform.python_implementation() == 'PyPy', reason='https://foss.heptapod.net/pypy/pypy/-/issues/3899'
+)
+def test_gc_validator_iterator() -> None:
+    # test for https://github.com/pydantic/pydantic/issues/9243
+    class MyModel:
+        iter: Iterable[int]
+
+    v = SchemaValidator(
+        core_schema.model_schema(
+            MyModel,
+            core_schema.model_fields_schema(
+                {'iter': core_schema.model_field(core_schema.generator_schema(core_schema.int_schema()))}
+            ),
+        ),
+    )
+
+    class MyIterable:
+        def __iter__(self):
+            return self
+
+        def __next__(self):
+            raise StopIteration()
+
+    cache: 'WeakValueDictionary[int, Any]' = WeakValueDictionary()
+
+    for _ in range(10_000):
+        iterable = MyIterable()
+        cache[id(iterable)] = iterable
+        v.validate_python({'iter': iterable})
+        del iterable
+
+    gc.collect(0)
+    gc.collect(1)
+    gc.collect(2)
+
+    assert len(cache) == 0

From 1cefeae57609a876842b29c3ccba9df14aeae9ad Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Mon, 22 Apr 2024 10:56:51 -0500
Subject: [PATCH 270/550] version bump (#1277)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 29203dc84..8bd6576d1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -294,7 +294,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.18.1"
+version = "2.18.2"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index 88470c543..a52d37c6f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.18.1"
+version = "2.18.2"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From c67e48c6fb0a712be1d3025cc752f8177139dff3 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 1 May 2024 12:20:05 +0100
Subject: [PATCH 271/550] Bump serde_json from 1.0.114 to 1.0.116 (#1281)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 8bd6576d1..55d448a50 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -478,9 +478,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.114"
+version = "1.0.116"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c5f09b1bd632ef549eaa9f60a1f8de742bdbc698e6cee2095fc84dde5f549ae0"
+checksum = "3e17db7126d17feb94eb3fad46bf1a96b034e8aacbc2e775fe81505f8b0b2813"
 dependencies = [
  "indexmap",
  "itoa",
diff --git a/Cargo.toml b/Cargo.toml
index a52d37c6f..70ea099bf 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -31,7 +31,7 @@ pyo3 = { version = "0.21.1", features = ["generate-import-lib", "num-bigint"] }
 regex = "1.10.3"
 strum = { version = "0.25.0", features = ["derive"] }
 strum_macros = "0.26.1"
-serde_json = {version = "1.0.114", features = ["arbitrary_precision", "preserve_order"]}
+serde_json = {version = "1.0.116", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.13"
 serde = { version = "1.0.197", features = ["derive"] }
 speedate = "0.14.0"

From 3c3391de2610166bf9e9c28c8ea37bec1b54b9a6 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 1 May 2024 12:20:21 +0100
Subject: [PATCH 272/550] Bump the python-packages group with 7 updates (#1280)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 8 ++++----
 tests/requirements.txt         | 6 +++---
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index 782eda79b..6f7696bf3 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,4 +1,4 @@
-griffe==0.42.1
-pyright==1.1.356
-ruff==0.3.4
-mypy==1.9.0
+griffe==0.44.0
+pyright==1.1.360
+ruff==0.4.2
+mypy==1.10.0
diff --git a/tests/requirements.txt b/tests/requirements.txt
index eff02f91d..1a6c3c1d5 100644
--- a/tests/requirements.txt
+++ b/tests/requirements.txt
@@ -1,12 +1,12 @@
-coverage==7.4.4
+coverage==7.5.0
 dirty-equals==0.7.1.post0
-hypothesis==6.100.0
+hypothesis==6.100.2
 # TODO: remove manual override for dateutil once a version newer than 2.8.2 is
 # released which removes use of deprecated utcfromtimestamp
 git+https://github.com/dateutil/dateutil.git@f2293200747fb03d56c6c5997bfebeabe703576f
 # pandas doesn't offer prebuilt wheels for all versions and platforms we test in CI e.g. aarch64 musllinux
 pandas==2.1.3; python_version >= "3.9" and python_version < "3.13" and implementation_name == "cpython" and platform_machine == 'x86_64'
-pytest==8.1.1
+pytest==8.2.0
 # we run codspeed benchmarks on x86_64 CPython (i.e. native github actions architecture)
 pytest-codspeed~=2.2.1; implementation_name == "cpython" and platform_machine == 'x86_64'
 # pytest-examples currently depends on aiohttp via black; we don't want to build

From 8abdfdc6dc18d2b5a442d3287b40984d6d07aa2c Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 1 May 2024 12:21:05 +0100
Subject: [PATCH 273/550] Bump regex from 1.10.3 to 1.10.4 (#1282)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 55d448a50..b931edfe0 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -411,9 +411,9 @@ dependencies = [
 
 [[package]]
 name = "regex"
-version = "1.10.3"
+version = "1.10.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b62dbe01f0b06f9d8dc7d49e05a0785f153b00b2c227856282f671e0318c9b15"
+checksum = "c117dbdfde9c8308975b6a18d71f3f385c89461f7b3fb054288ecf2a2058ba4c"
 dependencies = [
  "aho-corasick",
  "memchr",
diff --git a/Cargo.toml b/Cargo.toml
index 70ea099bf..09aa0682d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -28,7 +28,7 @@ rust-version = "1.76"
 
 [dependencies]
 pyo3 = { version = "0.21.1", features = ["generate-import-lib", "num-bigint"] }
-regex = "1.10.3"
+regex = "1.10.4"
 strum = { version = "0.25.0", features = ["derive"] }
 strum_macros = "0.26.1"
 serde_json = {version = "1.0.116", features = ["arbitrary_precision", "preserve_order"]}

From 505a199f4c0c1702e9ea6c6079eaffe1ef81b3a6 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 1 May 2024 11:27:55 +0000
Subject: [PATCH 274/550] Bump pyo3 from 0.21.1 to 0.21.2 (#1283)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 20 ++++++++++----------
 Cargo.toml |  4 ++--
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index b931edfe0..aa7228295 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -319,9 +319,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.21.1"
+version = "0.21.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a7a8b1990bd018761768d5e608a13df8bd1ac5f678456e0f301bb93e5f3ea16b"
+checksum = "a5e00b96a521718e08e03b1a622f01c8a8deb50719335de3f60b3b3950f069d8"
 dependencies = [
  "cfg-if",
  "indoc",
@@ -338,9 +338,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.21.1"
+version = "0.21.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "650dca34d463b6cdbdb02b1d71bfd6eb6b6816afc708faebb3bac1380ff4aef7"
+checksum = "7883df5835fafdad87c0d888b266c8ec0f4c9ca48a5bed6bbb592e8dedee1b50"
 dependencies = [
  "once_cell",
  "python3-dll-a",
@@ -349,9 +349,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.21.1"
+version = "0.21.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "09a7da8fc04a8a2084909b59f29e1b8474decac98b951d77b80b26dc45f046ad"
+checksum = "01be5843dc60b916ab4dad1dca6d20b9b4e6ddc8e15f50c47fe6d85f1fb97403"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -359,9 +359,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.21.1"
+version = "0.21.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4b8a199fce11ebb28e3569387228836ea98110e43a804a530a9fd83ade36d513"
+checksum = "77b34069fc0682e11b31dbd10321cbf94808394c56fd996796ce45217dfac53c"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -371,9 +371,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.21.1"
+version = "0.21.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93fbbfd7eb553d10036513cb122b888dcd362a945a00b06c165f2ab480d4cc3b"
+checksum = "08260721f32db5e1a5beae69a55553f56b99bd0e1c3e6e0a5e8851a9d0f5a85c"
 dependencies = [
  "heck",
  "proc-macro2",
diff --git a/Cargo.toml b/Cargo.toml
index 09aa0682d..0682583b0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -27,7 +27,7 @@ include = [
 rust-version = "1.76"
 
 [dependencies]
-pyo3 = { version = "0.21.1", features = ["generate-import-lib", "num-bigint"] }
+pyo3 = { version = "0.21.2", features = ["generate-import-lib", "num-bigint"] }
 regex = "1.10.4"
 strum = { version = "0.25.0", features = ["derive"] }
 strum_macros = "0.26.1"
@@ -71,7 +71,7 @@ debug = true
 strip = false
 
 [dev-dependencies]
-pyo3 = { version = "0.21.0", features = ["auto-initialize"] }
+pyo3 = { version = "0.21.2", features = ["auto-initialize"] }
 
 [build-dependencies]
 version_check = "0.9.4"

From e1fc99dd3207157aad77defc20ab6873fd268b5b Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 1 May 2024 13:37:58 +0100
Subject: [PATCH 275/550] Bump uraimo/run-on-arch-action from 2.7.1 to 2.7.2
 (#1284)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 9af70cf31..ba195b0c0 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -640,7 +640,7 @@ jobs:
           merge-multiple: true
           path: dist
 
-      - uses: uraimo/run-on-arch-action@v2.7.1
+      - uses: uraimo/run-on-arch-action@v2.7.2
         name: install & test
         with:
           arch: ${{ matrix.target }}

From aed68446d61594ead7920cff3dcd478093626c8e Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Tue, 14 May 2024 16:08:24 +0100
Subject: [PATCH 276/550] ci: lint fixes for rust 1.78 (#1289)

---
 src/errors/types.rs    |  7 ++-----
 src/serializers/ser.rs | 12 +++---------
 2 files changed, 5 insertions(+), 14 deletions(-)

diff --git a/src/errors/types.rs b/src/errors/types.rs
index d3a6cdebb..57025f9b5 100644
--- a/src/errors/types.rs
+++ b/src/errors/types.rs
@@ -56,15 +56,12 @@ fn field_from_context<'py, T: FromPyObject<'py>>(
         .map_err(|_| py_error_type!(PyTypeError; "{}: '{}' context value must be a {}", enum_name, field_name, type_name_fn()))
 }
 
-fn cow_field_from_context<'py, T: FromPyObject<'py>, B: ?Sized + 'static>(
+fn cow_field_from_context<'py, T: FromPyObject<'py>, B: ToOwned<Owned = T> + ?Sized + 'static>(
     context: Option<&Bound<'py, PyDict>>,
     field_name: &str,
     enum_name: &str,
     _type_name_fn: fn() -> &'static str,
-) -> PyResult<Cow<'static, B>>
-where
-    B: ToOwned<Owned = T>,
-{
+) -> PyResult<Cow<'static, B>> {
     let res: T = field_from_context(context, field_name, enum_name, || {
         type_name::<T>().split("::").last().unwrap()
     })?;
diff --git a/src/serializers/ser.rs b/src/serializers/ser.rs
index 170cd1849..50f006e7b 100644
--- a/src/serializers/ser.rs
+++ b/src/serializers/ser.rs
@@ -236,23 +236,17 @@ where
         self.serialize_str(variant)
     }
 
-    fn serialize_newtype_struct<T: ?Sized>(self, _name: &'static str, value: &T) -> Result<Self::Ok>
-    where
-        T: Serialize,
-    {
+    fn serialize_newtype_struct<T: Serialize + ?Sized>(self, _name: &'static str, value: &T) -> Result<Self::Ok> {
         value.serialize(self)
     }
 
-    fn serialize_newtype_variant<T: ?Sized>(
+    fn serialize_newtype_variant<T: Serialize + ?Sized>(
         self,
         _name: &'static str,
         _variant_index: u32,
         variant: &'static str,
         value: &T,
-    ) -> Result<Self::Ok>
-    where
-        T: Serialize,
-    {
+    ) -> Result<Self::Ok> {
         tri!(self
             .formatter
             .begin_object(&mut self.writer)

From 8f5f91acacae03edbbeee5a1b9ca8f0709faf4b1 Mon Sep 17 00:00:00 2001
From: Rajat Rajdeep <46029666+RajatRajdeep@users.noreply.github.com>
Date: Thu, 16 May 2024 23:50:04 +0530
Subject: [PATCH 277/550] fix validation of ints with leading unary minus
 (#1291)

---
 src/input/shared.rs          | 17 +++++++++++------
 tests/validators/test_int.py |  3 +++
 2 files changed, 14 insertions(+), 6 deletions(-)

diff --git a/src/input/shared.rs b/src/input/shared.rs
index fe26c503d..95b9912a5 100644
--- a/src/input/shared.rs
+++ b/src/input/shared.rs
@@ -114,8 +114,13 @@ fn clean_int_str(mut s: &str) -> Option<Cow<str>> {
     // strip leading and trailing whitespace
     s = s.trim();
 
-    // strip leading unary plus
-    s = s.strip_prefix('+').unwrap_or(s);
+    // Check for and remove a leading unary plus and ensure the next character is not a unary minus. e.g.: '+-1'.
+    if let Some(suffix) = s.strip_prefix('+') {
+        if suffix.starts_with('-') {
+            return None;
+        }
+        s = suffix;
+    }
 
     // strip loading zeros
     s = strip_leading_zeros(s)?;
@@ -149,8 +154,8 @@ fn strip_leading_zeros(s: &str) -> Option<&str> {
     match char_iter.next() {
         // if we get a leading zero we continue
         Some((_, '0')) => (),
-        // if we get another digit we return the whole string
-        Some((_, c)) if ('1'..='9').contains(&c) => return Some(s),
+        // if we get another digit or unary minus we return the whole string
+        Some((_, c)) if ('1'..='9').contains(&c) || c == '-' => return Some(s),
         // anything else is invalid, we return None
         _ => return None,
     };
@@ -158,8 +163,8 @@ fn strip_leading_zeros(s: &str) -> Option<&str> {
         match c {
             // continue on more leading zeros or if we get an underscore we continue - we're "within the number"
             '0' | '_' => (),
-            // any other digit we return the rest of the string
-            '1'..='9' => return Some(&s[i..]),
+            // any other digit or unary minus we return the rest of the string
+            '1'..='9' | '-' => return Some(&s[i..]),
             // if we get a dot we return the rest of the string but include the last zero
             '.' => return Some(&s[(i - 1)..]),
             // anything else is invalid, we return None
diff --git a/tests/validators/test_int.py b/tests/validators/test_int.py
index 5732fe181..f93919f17 100644
--- a/tests/validators/test_int.py
+++ b/tests/validators/test_int.py
@@ -29,6 +29,8 @@
         ('+0_000', 0),
         (1, 1),
         ('  1  ', 1),
+        ('-1', -1),
+        ('-1.0', -1),
         (42, 42),
         ('42', 42),
         (42.0, 42),
@@ -48,6 +50,7 @@
         ('+4_2.0', 42),
         ('+04_2.0', 42),
         ('++4_2', Err('Input should be a valid integer, unable to parse string as an integer')),
+        ('-+1', Err('Input should be a valid integer, unable to parse string as an integer')),
         ('+-1', Err('Input should be a valid integer, unable to parse string as an integer')),
         ('4_2', 42),
         ('0_42', 42),

From 0f8445ebd4c63c8e340f16404c58149210dde7c4 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Thu, 16 May 2024 14:28:13 -0400
Subject: [PATCH 278/550] defer to PyO3 i64 extraction to avoid implicit
 integer casts (#1288)

---
 pyproject.toml |  7 +++----
 src/tools.rs   | 29 ++++++++++-------------------
 2 files changed, 13 insertions(+), 23 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index d56dc1255..e1edd165f 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -73,10 +73,9 @@ testpaths = 'tests'
 log_format = '%(name)s %(levelname)s: %(message)s'
 filterwarnings = [
     'error',
-    # Work around https://github.com/pytest-dev/pytest/issues/10977 for Python 3.12
-    'ignore:(ast\.Str|ast\.NameConstant|ast\.Num|Attribute s) is deprecated and will be removed.*:DeprecationWarning:',
-    # issue with pytz - https://github.com/stub42/pytz/issues/105 for Python 3.12
-    'ignore:datetime\.utcfromtimestamp\(\) is deprecated.*:DeprecationWarning:',
+    # Python 3.9 and below allowed truncation of float to integers in some
+    # cases, by not making this an error we can test for this behaviour
+    'ignore:(.+)Implicit conversion to integers using __int__ is deprecated',
 ]
 timeout = 30
 xfail_strict = true
diff --git a/src/tools.rs b/src/tools.rs
index 28c661d8f..adf64c91a 100644
--- a/src/tools.rs
+++ b/src/tools.rs
@@ -3,7 +3,7 @@ use std::borrow::Cow;
 use pyo3::exceptions::PyKeyError;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyString};
-use pyo3::{ffi, intern, FromPyObject};
+use pyo3::{intern, FromPyObject};
 
 use jiter::{cached_py_string, pystring_fast_new, StringCacheMode};
 
@@ -124,26 +124,17 @@ pub fn safe_repr<'py>(v: &Bound<'py, PyAny>) -> ReprOutput<'py> {
     }
 }
 
-/// Extract an i64 from a python object more quickly, see
-/// https://github.com/PyO3/pyo3/pull/3742#discussion_r1451763928
-#[cfg(not(any(target_pointer_width = "32", windows, PyPy)))]
-pub fn extract_i64(obj: &Bound<'_, PyAny>) -> Option<i64> {
-    let val = unsafe { ffi::PyLong_AsLong(obj.as_ptr()) };
-    if val == -1 && PyErr::occurred(obj.py()) {
-        unsafe { ffi::PyErr_Clear() };
-        None
-    } else {
-        Some(val)
-    }
-}
-
-#[cfg(any(target_pointer_width = "32", windows, PyPy))]
 pub fn extract_i64(v: &Bound<'_, PyAny>) -> Option<i64> {
-    if v.is_instance_of::<pyo3::types::PyInt>() {
-        v.extract().ok()
-    } else {
-        None
+    #[cfg(PyPy)]
+    if !v.is_instance_of::<pyo3::types::PyInt>() {
+        // PyPy used __int__ to cast floats to ints after CPython removed it,
+        // see https://github.com/pypy/pypy/issues/4949
+        //
+        // Can remove this after PyPy 7.3.17 is released
+        return None;
     }
+
+    v.extract().ok()
 }
 
 pub(crate) fn new_py_string<'py>(py: Python<'py>, s: &str, cache_str: StringCacheMode) -> Bound<'py, PyString> {

From b777774d0fa73a400152c31c33c85fb824e59d7e Mon Sep 17 00:00:00 2001
From: Jean Arhancet <jean.arhancetebehere@gmail.com>
Date: Sun, 19 May 2024 00:33:49 +0200
Subject: [PATCH 279/550] fix: keyword only non default argument (#1290)

---
 src/validators/arguments.rs        |  7 ++-
 tests/validators/test_arguments.py | 77 ++++++++++++++++++++++++++++++
 2 files changed, 83 insertions(+), 1 deletion(-)

diff --git a/src/validators/arguments.rs b/src/validators/arguments.rs
index 457474d65..075bc009e 100644
--- a/src/validators/arguments.rs
+++ b/src/validators/arguments.rs
@@ -51,6 +51,7 @@ impl BuildValidator for ArgumentsValidator {
 
         let mut positional_params_count = 0;
         let mut had_default_arg = false;
+        let mut had_keyword_only = false;
 
         for (arg_index, arg) in arguments_schema.iter().enumerate() {
             let arg = arg.downcast::<PyDict>()?;
@@ -68,6 +69,10 @@ impl BuildValidator for ArgumentsValidator {
                 positional_params_count = arg_index + 1;
             }
 
+            if mode == "keyword_only" {
+                had_keyword_only = true;
+            }
+
             let mut kw_lookup_key = None;
             let mut kwarg_key = None;
             if mode == "keyword_only" || mode == "positional_or_keyword" {
@@ -98,7 +103,7 @@ impl BuildValidator for ArgumentsValidator {
                 _ => false,
             };
 
-            if had_default_arg && !has_default {
+            if had_default_arg && !has_default && !had_keyword_only {
                 return py_schema_err!("Non-default argument '{}' follows default argument", name);
             } else if has_default {
                 had_default_arg = true;
diff --git a/tests/validators/test_arguments.py b/tests/validators/test_arguments.py
index 45ade32e6..915f05878 100644
--- a/tests/validators/test_arguments.py
+++ b/tests/validators/test_arguments.py
@@ -371,6 +371,83 @@ def test_positional_or_keyword(py_and_json: PyAndJson, input_value, expected):
         assert v.validate_test(input_value) == expected
 
 
+@pytest.mark.parametrize(
+    'input_value,expected,arguments_schema',
+    [
+        (
+            {'a': 1, 'b': 2, 'e': 3.14},
+            ((), {'a': 1, 'b': 2, 'c': 5, 'd': 'default', 'e': 3.14}),
+            [
+                {'name': 'a', 'mode': 'positional_or_keyword', 'schema': {'type': 'int'}},
+                {'name': 'b', 'mode': 'positional_or_keyword', 'schema': {'type': 'int'}},
+                {
+                    'name': 'c',
+                    'mode': 'keyword_only',
+                    'schema': {'type': 'default', 'schema': {'type': 'int'}, 'default': 5},
+                },
+                {
+                    'name': 'd',
+                    'mode': 'keyword_only',
+                    'schema': {'type': 'default', 'schema': {'type': 'str'}, 'default': 'default'},
+                },
+                {'name': 'e', 'mode': 'keyword_only', 'schema': {'type': 'float'}},
+            ],
+        ),
+        (
+            {'y': 'test'},
+            ((), {'x': 1, 'y': 'test'}),
+            [
+                {
+                    'name': 'x',
+                    'mode': 'keyword_only',
+                    'schema': {'type': 'default', 'schema': {'type': 'int'}, 'default': 1},
+                },
+                {'name': 'y', 'mode': 'keyword_only', 'schema': {'type': 'str'}},
+            ],
+        ),
+        (
+            {'a': 1, 'd': 3.14},
+            ((), {'a': 1, 'b': 10, 'c': 'hello', 'd': 3.14}),
+            [
+                {'name': 'a', 'mode': 'positional_or_keyword', 'schema': {'type': 'int'}},
+                {
+                    'name': 'b',
+                    'mode': 'positional_or_keyword',
+                    'schema': {'type': 'default', 'schema': {'type': 'int'}, 'default': 10},
+                },
+                {
+                    'name': 'c',
+                    'mode': 'keyword_only',
+                    'schema': {'type': 'default', 'schema': {'type': 'str'}, 'default': 'hello'},
+                },
+                {'name': 'd', 'mode': 'keyword_only', 'schema': {'type': 'float'}},
+            ],
+        ),
+        (
+            {'x': 3, 'y': 'custom', 'z': 4},
+            ((), {'x': 3, 'y': 'custom', 'z': 4}),
+            [
+                {'name': 'x', 'mode': 'positional_or_keyword', 'schema': {'type': 'int'}},
+                {
+                    'name': 'y',
+                    'mode': 'keyword_only',
+                    'schema': {'type': 'default', 'schema': {'type': 'str'}, 'default': 'default'},
+                },
+                {'name': 'z', 'mode': 'keyword_only', 'schema': {'type': 'int'}},
+            ],
+        ),
+    ],
+)
+def test_keyword_only_non_default(py_and_json: PyAndJson, input_value, expected, arguments_schema):
+    v = py_and_json(
+        {
+            'type': 'arguments',
+            'arguments_schema': arguments_schema,
+        }
+    )
+    assert v.validate_test(input_value) == expected
+
+
 @pytest.mark.parametrize('input_value,expected', [[(1,), ((1,), {})], [(), ((42,), {})]], ids=repr)
 def test_positional_optional(py_and_json: PyAndJson, input_value, expected):
     v = py_and_json(

From 727deee70f7ebbd4ed48fc665be1ccf1f354abd0 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Tue, 21 May 2024 09:19:44 -0500
Subject: [PATCH 280/550] Fix str subclass validation for enums (#1273)

Co-authored-by: David Hewitt <david.hewitt@pydantic.dev>
---
 src/validators/enum_.rs        | 24 +++++++++++++++---
 tests/validators/test_enums.py | 46 ++++++++++++++++++++++++++++++++++
 2 files changed, 67 insertions(+), 3 deletions(-)

diff --git a/src/validators/enum_.rs b/src/validators/enum_.rs
index 2c9ae4b28..087d0ca5f 100644
--- a/src/validators/enum_.rs
+++ b/src/validators/enum_.rs
@@ -4,7 +4,7 @@ use std::marker::PhantomData;
 use pyo3::exceptions::PyTypeError;
 use pyo3::intern;
 use pyo3::prelude::*;
-use pyo3::types::{PyDict, PyList, PyType};
+use pyo3::types::{PyDict, PyFloat, PyInt, PyList, PyString, PyType};
 
 use crate::build_tools::{is_strict, py_schema_err};
 use crate::errors::{ErrorType, ValError, ValResult};
@@ -167,9 +167,27 @@ impl EnumValidateValue for PlainEnumValidator {
         py: Python<'py>,
         input: &I,
         lookup: &LiteralLookup<PyObject>,
-        _strict: bool,
+        strict: bool,
     ) -> ValResult<Option<PyObject>> {
-        Ok(lookup.validate(py, input)?.map(|(_, v)| v.clone_ref(py)))
+        match lookup.validate(py, input)? {
+            Some((_, v)) => Ok(Some(v.clone_ref(py))),
+            None => {
+                if !strict {
+                    if let Some(py_input) = input.as_python() {
+                        // necessary for compatibility with 2.6, where str and int subclasses are allowed
+                        if py_input.is_instance_of::<PyString>() {
+                            return Ok(lookup.validate_str(input, false)?.map(|v| v.clone_ref(py)));
+                        } else if py_input.is_instance_of::<PyInt>() {
+                            return Ok(lookup.validate_int(py, input, false)?.map(|v| v.clone_ref(py)));
+                        // necessary for compatibility with 2.6, where float values are allowed for int enums in lax mode
+                        } else if py_input.is_instance_of::<PyFloat>() {
+                            return Ok(lookup.validate_int(py, input, false)?.map(|v| v.clone_ref(py)));
+                        }
+                    }
+                }
+                Ok(None)
+            }
+        }
     }
 }
 
diff --git a/tests/validators/test_enums.py b/tests/validators/test_enums.py
index 49abc415b..91701ce74 100644
--- a/tests/validators/test_enums.py
+++ b/tests/validators/test_enums.py
@@ -269,6 +269,52 @@ class MyEnum(Enum):
         SchemaValidator(core_schema.enum_schema(MyEnum, []))
 
 
+def test_enum_with_str_subclass() -> None:
+    class MyEnum(Enum):
+        a = 'a'
+        b = 'b'
+
+    v = SchemaValidator(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values())))
+
+    assert v.validate_python(MyEnum.a) is MyEnum.a
+    assert v.validate_python('a') is MyEnum.a
+
+    class MyStr(str):
+        pass
+
+    assert v.validate_python(MyStr('a')) is MyEnum.a
+    with pytest.raises(ValidationError):
+        v.validate_python(MyStr('a'), strict=True)
+
+
+def test_enum_with_int_subclass() -> None:
+    class MyEnum(Enum):
+        a = 1
+        b = 2
+
+    v = SchemaValidator(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values())))
+
+    assert v.validate_python(MyEnum.a) is MyEnum.a
+    assert v.validate_python(1) is MyEnum.a
+
+    class MyInt(int):
+        pass
+
+    assert v.validate_python(MyInt(1)) is MyEnum.a
+    with pytest.raises(ValidationError):
+        v.validate_python(MyInt(1), strict=True)
+
+
+def test_validate_float_for_int_enum() -> None:
+    class MyEnum(int, Enum):
+        a = 1
+        b = 2
+
+    v = SchemaValidator(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values())))
+
+    assert v.validate_python(1.0) is MyEnum.a
+
+
 def test_missing_error_converted_to_val_error() -> None:
     class MyFlags(IntFlag):
         OFF = 0

From f04418b2a3282db72e4cfba4b842debac8747c91 Mon Sep 17 00:00:00 2001
From: Samuel Colvin <s@muelcolvin.com>
Date: Tue, 21 May 2024 11:41:02 -0400
Subject: [PATCH 281/550] support big ints in literals and enums (#1297)

---
 src/input/return_enums.rs        |  1 +
 src/validators/literal.rs        | 14 ++++++++------
 tests/validators/test_enums.py   | 15 ++++++++++++++-
 tests/validators/test_literal.py | 11 +++++++++++
 4 files changed, 34 insertions(+), 7 deletions(-)

diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index 9722669cc..22faaba71 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -549,6 +549,7 @@ impl<'a> EitherInt<'a> {
             Ok(Self::BigInt(big_int))
         }
     }
+
     pub fn into_i64(self, py: Python<'a>) -> ValResult<i64> {
         match self {
             EitherInt::I64(i) => Ok(i),
diff --git a/src/validators/literal.rs b/src/validators/literal.rs
index 9c4eb7292..16eef090d 100644
--- a/src/validators/literal.rs
+++ b/src/validators/literal.rs
@@ -4,7 +4,7 @@ use core::fmt::Debug;
 use std::cmp::Ordering;
 
 use pyo3::prelude::*;
-use pyo3::types::{PyDict, PyList};
+use pyo3::types::{PyDict, PyInt, PyList};
 use pyo3::{intern, PyTraverseError, PyVisit};
 
 use ahash::AHashMap;
@@ -58,11 +58,13 @@ impl<T: Debug> LiteralLookup<T> {
                     expected_bool.false_id = Some(id);
                 }
             }
-            if let Ok(either_int) = k.exact_int() {
-                let int = either_int
-                    .into_i64(py)
-                    .map_err(|_| py_schema_error_type!("error extracting int {:?}", k))?;
-                expected_int.insert(int, id);
+            if k.is_exact_instance_of::<PyInt>() {
+                if let Ok(int_64) = k.extract::<i64>() {
+                    expected_int.insert(int_64, id);
+                } else {
+                    // cover the case of an int that's > i64::MAX etc.
+                    expected_py_dict.set_item(k, id)?;
+                }
             } else if let Ok(either_str) = k.exact_str() {
                 let str = either_str
                     .as_cow()
diff --git a/tests/validators/test_enums.py b/tests/validators/test_enums.py
index 91701ce74..a4fb3c5c2 100644
--- a/tests/validators/test_enums.py
+++ b/tests/validators/test_enums.py
@@ -1,6 +1,6 @@
 import re
 import sys
-from enum import Enum, IntFlag
+from enum import Enum, IntEnum, IntFlag
 
 import pytest
 
@@ -331,3 +331,16 @@ class MyFlags(IntFlag):
 
     with pytest.raises(ValidationError):
         v.validate_python(None)
+
+
+def test_big_int():
+    class ColorEnum(IntEnum):
+        GREEN = 1 << 63
+        BLUE = 1 << 64
+
+    v = SchemaValidator(
+        core_schema.with_default_schema(schema=core_schema.enum_schema(ColorEnum, list(ColorEnum.__members__.values())))
+    )
+
+    assert v.validate_python(ColorEnum.GREEN) is ColorEnum.GREEN
+    assert v.validate_python(1 << 63) is ColorEnum.GREEN
diff --git a/tests/validators/test_literal.py b/tests/validators/test_literal.py
index d294f866c..5f9f942e2 100644
--- a/tests/validators/test_literal.py
+++ b/tests/validators/test_literal.py
@@ -378,3 +378,14 @@ class Foo(str, Enum):
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python('bar_val')
     assert exc_info.value.errors(include_url=False) == err
+
+
+def test_big_int():
+    big_int = 2**64 + 1
+    massive_int = 2**128 + 1
+    v = SchemaValidator(core_schema.literal_schema([big_int, massive_int]))
+    assert v.validate_python(big_int) == big_int
+    assert v.validate_python(massive_int) == massive_int
+    m = r'Input should be 18446744073709551617 or 340282366920938463463374607431768211457 \[type=literal_error'
+    with pytest.raises(ValidationError, match=m):
+        v.validate_python(37)

From 2415f423e227b108ed709149a5a523e9463f834a Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Tue, 21 May 2024 14:14:56 -0400
Subject: [PATCH 282/550] uuid: allow str subclass as input (#1296)

---
 src/validators/uuid.rs        | 3 ++-
 tests/validators/test_uuid.py | 4 ++++
 2 files changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/validators/uuid.rs b/src/validators/uuid.rs
index f5d713aa2..1fad8f8ed 100644
--- a/src/validators/uuid.rs
+++ b/src/validators/uuid.rs
@@ -12,6 +12,7 @@ use crate::errors::{ErrorType, ErrorTypeDefaults, ValError, ValResult};
 use crate::input::input_as_python_instance;
 use crate::input::Input;
 use crate::input::InputType;
+use crate::input::ValidationMatch;
 use crate::tools::SchemaDict;
 
 use super::model::create_class;
@@ -152,7 +153,7 @@ impl Validator for UuidValidator {
 
 impl UuidValidator {
     fn get_uuid<'py>(&self, input: &(impl Input<'py> + ?Sized)) -> ValResult<Uuid> {
-        let uuid = match input.exact_str().ok() {
+        let uuid = match input.validate_str(true, false).ok().map(ValidationMatch::into_inner) {
             Some(either_string) => {
                 let cow = either_string.as_cow()?;
                 let uuid_str = cow.as_ref();
diff --git a/tests/validators/test_uuid.py b/tests/validators/test_uuid.py
index eae950a63..d1475f38e 100644
--- a/tests/validators/test_uuid.py
+++ b/tests/validators/test_uuid.py
@@ -9,6 +9,9 @@
 from ..conftest import Err, PyAndJson
 
 
+class MyStr(str): ...
+
+
 @pytest.mark.parametrize(
     'input_value,expected',
     [
@@ -25,6 +28,7 @@
         ('c0a8f9a8-aa5e-482b-a067-9cb3a51f5c11', UUID('c0a8f9a8-aa5e-482b-a067-9cb3a51f5c11')),
         ('00000000-8000-4000-8000-000000000000', UUID('00000000-8000-4000-8000-000000000000')),
         ('00000000-0000-4000-0000-000000000000', UUID('00000000-0000-4000-0000-000000000000')),
+        (MyStr('00000000-0000-4000-0000-000000000000'), UUID('00000000-0000-4000-0000-000000000000')),
         (b'\x12\x34\x56\x78' * 4, UUID('12345678-1234-5678-1234-567812345678')),
         (b'\x00\x00\x00\x00' * 4, UUID('00000000-0000-0000-0000-000000000000')),
         (b'ebcdab58-6eb8-46fb-a190-d07a33e9eac8', UUID('ebcdab58-6eb8-46fb-a190-d07a33e9eac8')),

From 88a8a302bc0dc35f1baf179597722d469840fe77 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Wed, 22 May 2024 14:40:03 +0100
Subject: [PATCH 283/550] fix case of checking truthiness of `NotImplemented`
 (#1298)

---
 src/serializers/filter.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/serializers/filter.rs b/src/serializers/filter.rs
index 8ba4a3bc2..efeba7d25 100644
--- a/src/serializers/filter.rs
+++ b/src/serializers/filter.rs
@@ -23,8 +23,7 @@ fn map_negative_index<'py>(value: &Bound<'py, PyAny>, len: Option<usize>) -> PyR
             .unwrap_or_else(|_| value.clone())),
         None => {
             // check that it's not negative
-            let negative = value.call_method1(intern!(py, "__lt__"), (0,))?.is_truthy()?;
-            if negative {
+            if value.lt(0).unwrap_or(false) {
                 Err(PyValueError::new_err(
                     "Negative indices cannot be used to exclude items on unsized iterables",
                 ))

From 0dcf82af48eac07798f4885b067be7adc25bf4db Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Wed, 22 May 2024 15:39:26 +0100
Subject: [PATCH 284/550] add test for 1298 (#1300)

---
 tests/serializers/test_generator.py | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/tests/serializers/test_generator.py b/tests/serializers/test_generator.py
index 29e9eeb6b..89b6b0350 100644
--- a/tests/serializers/test_generator.py
+++ b/tests/serializers/test_generator.py
@@ -122,6 +122,8 @@ def test_include():
     ]
     with pytest.raises(ValueError, match='Negative indices cannot be used to exclude items on unsized iterables'):
         v.to_python(gen_ok('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'), include={-1: None, -2: None}, mode='json')
+    # Non-integer keys are ignored
+    v.to_python(gen_ok('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h'), include={'__all__': None}, mode='json')
 
 
 def test_custom_serializer():

From a7620419383a69bd2b28ab953c9a17f6ed35bb9a Mon Sep 17 00:00:00 2001
From: Jelle Zijlstra <jelle.zijlstra@gmail.com>
Date: Wed, 22 May 2024 07:44:10 -0700
Subject: [PATCH 285/550] Fix generate_self_schema for Python 3.12+ (#1299)

---
 generate_self_schema.py | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/generate_self_schema.py b/generate_self_schema.py
index 3aef99b18..acecf19d8 100644
--- a/generate_self_schema.py
+++ b/generate_self_schema.py
@@ -190,7 +190,12 @@ def all_literal_values(type_: type[core_schema.Literal]) -> list[any]:
 
 def eval_forward_ref(type_: Any) -> Any:
     try:
-        return type_._evaluate(core_schema.__dict__, None, set())
+        try:
+            # Python 3.12+
+            return type_._evaluate(core_schema.__dict__, None, type_params=set(), recursive_guard=set())
+        except TypeError:
+            # Python 3.9+
+            return type_._evaluate(core_schema.__dict__, None, set())
     except TypeError:
         # for Python 3.8
         return type_._evaluate(core_schema.__dict__, None)

From 52287213a5d76028d151c4fe3db89cd08e7bf124 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Wed, 22 May 2024 16:13:21 -0500
Subject: [PATCH 286/550] Prep for 2.18.3 Release (#1301)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index aa7228295..7e1e4a7b0 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -294,7 +294,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.18.2"
+version = "2.18.3"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index 0682583b0..04b2b2783 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.18.2"
+version = "2.18.3"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From fd262933683fad0a9706e63298065f0d6ab9905d Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Tue, 28 May 2024 14:09:12 +0100
Subject: [PATCH 287/550] tests: use zoneinfo instead of pytz (#1304)

---
 tests/emscripten_runner.js        |  3 ++-
 tests/requirements.txt            |  3 ++-
 tests/validators/test_datetime.py | 41 +++++++++++++++++--------------
 wasm-preview/run_tests.py         |  2 +-
 wasm-preview/worker.js            |  2 +-
 5 files changed, 29 insertions(+), 22 deletions(-)

diff --git a/tests/emscripten_runner.js b/tests/emscripten_runner.js
index 054a88380..c3c53834e 100644
--- a/tests/emscripten_runner.js
+++ b/tests/emscripten_runner.js
@@ -86,7 +86,7 @@ async function main() {
     FS.mkdir('/test_dir');
     FS.mount(FS.filesystems.NODEFS, {root: path.join(root_dir, 'tests')}, '/test_dir');
     FS.chdir('/test_dir');
-    await pyodide.loadPackage(['micropip', 'pytest', 'pytz']);
+    await pyodide.loadPackage(['micropip', 'pytest']);
     // language=python
     errcode = await pyodide.runPythonAsync(`
 import micropip
@@ -101,6 +101,7 @@ await micropip.install([
     'hypothesis',
     'pytest-speed',
     'pytest-mock',
+    'tzdata',
     'file:${wheel_path}',
     'typing-extensions',
 ])
diff --git a/tests/requirements.txt b/tests/requirements.txt
index 1a6c3c1d5..6fa5882c4 100644
--- a/tests/requirements.txt
+++ b/tests/requirements.txt
@@ -1,3 +1,4 @@
+backports.zoneinfo==0.2.1;python_version<"3.9"
 coverage==7.5.0
 dirty-equals==0.7.1.post0
 hypothesis==6.100.2
@@ -16,7 +17,7 @@ pytest-speed==0.3.5
 pytest-mock==3.14.0
 pytest-pretty==1.2.0
 pytest-timeout==2.3.1
-pytz==2024.1
 # numpy doesn't offer prebuilt wheels for all versions and platforms we test in CI e.g. aarch64 musllinux
 numpy==1.26.2; python_version >= "3.9" and python_version < "3.13" and implementation_name == "cpython" and platform_machine == 'x86_64'
 exceptiongroup==1.1; python_version < "3.11"
+tzdata==2024.1
diff --git a/tests/validators/test_datetime.py b/tests/validators/test_datetime.py
index 33ebb1250..9e1eef086 100644
--- a/tests/validators/test_datetime.py
+++ b/tests/validators/test_datetime.py
@@ -7,7 +7,12 @@
 from typing import Dict
 
 import pytest
-import pytz
+
+try:
+    import zoneinfo
+except ImportError:
+    # TODO: can remove this once we drop support for python 3.8
+    from backports import zoneinfo
 
 from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema, validate_core_schema
 
@@ -81,8 +86,8 @@ def test_datetime_strict(input_value, expected):
 
 
 def test_keep_tz():
-    tz = pytz.timezone('Europe/London')
-    dt = tz.localize(datetime(2022, 6, 14, 12, 13, 14))
+    tz = zoneinfo.ZoneInfo('Europe/London')
+    dt = datetime(2022, 6, 14, 12, 13, 14, tzinfo=tz)
     v = SchemaValidator({'type': 'datetime'})
 
     output = v.validate_python(dt)
@@ -94,8 +99,8 @@ def test_keep_tz():
 
 
 def test_keep_tz_bound():
-    tz = pytz.timezone('Europe/London')
-    dt = tz.localize(datetime(2022, 6, 14, 12, 13, 14))
+    tz = zoneinfo.ZoneInfo('Europe/London')
+    dt = datetime(2022, 6, 14, 12, 13, 14, tzinfo=tz)
     v = SchemaValidator({'type': 'datetime', 'gt': datetime(2022, 1, 1)})
 
     output = v.validate_python(dt)
@@ -106,7 +111,7 @@ def test_keep_tz_bound():
     assert output.tzinfo.dst(datetime(2022, 1, 1)) == timedelta(0)
 
     with pytest.raises(ValidationError, match=r'Input should be greater than 2022-01-01T00:00:00 \[type=greater_than'):
-        v.validate_python(tz.localize(datetime(2021, 6, 14)))
+        v.validate_python(datetime(2021, 6, 14, tzinfo=tz))
 
 
 @pytest.mark.parametrize(
@@ -186,8 +191,8 @@ def test_custom_timezone_utc_repr():
 
 
 def test_tz_comparison():
-    tz = pytz.timezone('Europe/London')
-    uk_3pm = tz.localize(datetime(2022, 1, 1, 15, 0, 0))
+    tz = zoneinfo.ZoneInfo('Europe/London')
+    uk_3pm = datetime(2022, 1, 1, 15, 0, 0, tzinfo=tz)
 
     # two times are the same instant, therefore le and ge are both ok
     v = SchemaValidator({'type': 'datetime', 'le': uk_3pm}).validate_python('2022-01-01T16:00:00+01:00')
@@ -322,22 +327,22 @@ def test_datetime_past_timezone():
     now_utc = datetime.now(timezone.utc) - timedelta(seconds=1)
     assert v.isinstance_python(now_utc)
     # "later" in the day
-    assert v.isinstance_python(now_utc.astimezone(pytz.timezone('Europe/Istanbul')))
+    assert v.isinstance_python(now_utc.astimezone(zoneinfo.ZoneInfo('Europe/Istanbul')))
     # "earlier" in the day
-    assert v.isinstance_python(now_utc.astimezone(pytz.timezone('America/Los_Angeles')))
+    assert v.isinstance_python(now_utc.astimezone(zoneinfo.ZoneInfo('America/Los_Angeles')))
 
     soon_utc = now_utc + timedelta(minutes=1)
     assert not v.isinstance_python(soon_utc)
 
     # "later" in the day
-    assert not v.isinstance_python(soon_utc.astimezone(pytz.timezone('Europe/Istanbul')))
+    assert not v.isinstance_python(soon_utc.astimezone(zoneinfo.ZoneInfo('Europe/Istanbul')))
     # "earlier" in the day
-    assert not v.isinstance_python(soon_utc.astimezone(pytz.timezone('America/Los_Angeles')))
+    assert not v.isinstance_python(soon_utc.astimezone(zoneinfo.ZoneInfo('America/Los_Angeles')))
 
     # input value is timezone naive, so we do a dumb comparison in these terms the istanbul time is later so fails
     # wile the LA time is earlier so passes
-    assert not v.isinstance_python(soon_utc.astimezone(pytz.timezone('Europe/Istanbul')).replace(tzinfo=None))
-    assert v.isinstance_python(soon_utc.astimezone(pytz.timezone('America/Los_Angeles')).replace(tzinfo=None))
+    assert not v.isinstance_python(soon_utc.astimezone(zoneinfo.ZoneInfo('Europe/Istanbul')).replace(tzinfo=None))
+    assert v.isinstance_python(soon_utc.astimezone(zoneinfo.ZoneInfo('America/Los_Angeles')).replace(tzinfo=None))
 
 
 @pytest.mark.parametrize(
@@ -368,17 +373,17 @@ def test_datetime_future_timezone():
     assert v.isinstance_python(soon_utc)
 
     # "later" in the day
-    assert v.isinstance_python(soon_utc.astimezone(pytz.timezone('Europe/Istanbul')))
+    assert v.isinstance_python(soon_utc.astimezone(zoneinfo.ZoneInfo('Europe/Istanbul')))
     # "earlier" in the day
-    assert v.isinstance_python(soon_utc.astimezone(pytz.timezone('America/Los_Angeles')))
+    assert v.isinstance_python(soon_utc.astimezone(zoneinfo.ZoneInfo('America/Los_Angeles')))
 
     past_utc = now_utc - timedelta(minutes=1)
     assert not v.isinstance_python(past_utc)
 
     # "later" in the day
-    assert not v.isinstance_python(past_utc.astimezone(pytz.timezone('Europe/Istanbul')))
+    assert not v.isinstance_python(past_utc.astimezone(zoneinfo.ZoneInfo('Europe/Istanbul')))
     # "earlier" in the day
-    assert not v.isinstance_python(past_utc.astimezone(pytz.timezone('America/Los_Angeles')))
+    assert not v.isinstance_python(past_utc.astimezone(zoneinfo.ZoneInfo('America/Los_Angeles')))
 
 
 def test_mock_utc_offset_8_hours(mocker):
diff --git a/wasm-preview/run_tests.py b/wasm-preview/run_tests.py
index 538c10e49..776f7a8e2 100644
--- a/wasm-preview/run_tests.py
+++ b/wasm-preview/run_tests.py
@@ -37,7 +37,7 @@ async def main(tests_zip: str, tag_name: str):
 
     print(f'Mounted {count} test files, installing dependencies...')
 
-    await micropip.install(['dirty-equals', 'hypothesis', 'pytest-speed', 'pytest-mock', pydantic_core_wheel])
+    await micropip.install(['dirty-equals', 'hypothesis', 'pytest-speed', 'pytest-mock', pydantic_core_wheel, 'tzdata'])
     importlib.invalidate_caches()
 
     # print('installed packages:')
diff --git a/wasm-preview/worker.js b/wasm-preview/worker.js
index b769281ef..c6223ecbd 100644
--- a/wasm-preview/worker.js
+++ b/wasm-preview/worker.js
@@ -97,7 +97,7 @@ async function main() {
     setupStreams(FS, pyodide._module.TTY);
     FS.mkdir('/test_dir');
     FS.chdir('/test_dir');
-    await pyodide.loadPackage(['micropip', 'pytest', 'pytz', 'numpy']);
+    await pyodide.loadPackage(['micropip', 'pytest', 'numpy']);
     if (pydantic_core_version < '2.0.0') await pyodide.loadPackage(['typing-extensions']);
     await pyodide.runPythonAsync(python_code, {globals: pyodide.toPy({pydantic_core_version, tests_zip})});
     post();

From 0c7c2e567b7117628461ab844d864c42cafbe43d Mon Sep 17 00:00:00 2001
From: OhioDschungel6 <39698795+OhioDschungel6@users.noreply.github.com>
Date: Sun, 2 Jun 2024 20:20:25 +0200
Subject: [PATCH 288/550] Fix context type hints (#1303)

Co-authored-by: OhioDschungel6 <OhioDschungel6@users.noreply.github.com>
---
 python/pydantic_core/_pydantic_core.pyi | 20 +++++++++-----------
 1 file changed, 9 insertions(+), 11 deletions(-)

diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index b86b7aad0..d785d1531 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -89,7 +89,7 @@ class SchemaValidator:
         *,
         strict: bool | None = None,
         from_attributes: bool | None = None,
-        context: dict[str, Any] | None = None,
+        context: Any | None = None,
         self_instance: Any | None = None,
     ) -> Any:
         """
@@ -119,7 +119,7 @@ class SchemaValidator:
         *,
         strict: bool | None = None,
         from_attributes: bool | None = None,
-        context: dict[str, Any] | None = None,
+        context: Any | None = None,
         self_instance: Any | None = None,
     ) -> bool:
         """
@@ -136,7 +136,7 @@ class SchemaValidator:
         input: str | bytes | bytearray,
         *,
         strict: bool | None = None,
-        context: dict[str, Any] | None = None,
+        context: Any | None = None,
         self_instance: Any | None = None,
     ) -> Any:
         """
@@ -163,9 +163,7 @@ class SchemaValidator:
         Returns:
             The validated Python object.
         """
-    def validate_strings(
-        self, input: _StringInput, *, strict: bool | None = None, context: dict[str, Any] | None = None
-    ) -> Any:
+    def validate_strings(self, input: _StringInput, *, strict: bool | None = None, context: Any | None = None) -> Any:
         """
         Validate a string against the schema and return the validated Python object.
 
@@ -194,7 +192,7 @@ class SchemaValidator:
         *,
         strict: bool | None = None,
         from_attributes: bool | None = None,
-        context: dict[str, Any] | None = None,
+        context: Any | None = None,
     ) -> dict[str, Any] | tuple[dict[str, Any], dict[str, Any] | None, set[str]]:
         """
         Validate an assignment to a field on a model.
@@ -267,7 +265,7 @@ class SchemaSerializer:
         warnings: bool | Literal['none', 'warn', 'error'] = True,
         fallback: Callable[[Any], Any] | None = None,
         serialize_as_any: bool = False,
-        context: dict[str, Any] | None = None,
+        context: Any | None = None,
     ) -> Any:
         """
         Serialize/marshal a Python object to a Python object including transforming and filtering data.
@@ -313,7 +311,7 @@ class SchemaSerializer:
         warnings: bool | Literal['none', 'warn', 'error'] = True,
         fallback: Callable[[Any], Any] | None = None,
         serialize_as_any: bool = False,
-        context: dict[str, Any] | None = None,
+        context: Any | None = None,
     ) -> bytes:
         """
         Serialize a Python object to JSON including transforming and filtering data.
@@ -359,7 +357,7 @@ def to_json(
     serialize_unknown: bool = False,
     fallback: Callable[[Any], Any] | None = None,
     serialize_as_any: bool = False,
-    context: dict[str, Any] | None = None,
+    context: Any | None = None,
 ) -> bytes:
     """
     Serialize a Python object to JSON including transforming and filtering data.
@@ -434,7 +432,7 @@ def to_jsonable_python(
     serialize_unknown: bool = False,
     fallback: Callable[[Any], Any] | None = None,
     serialize_as_any: bool = False,
-    context: dict[str, Any] | None = None,
+    context: Any | None = None,
 ) -> Any:
     """
     Serialize/marshal a Python object to a JSON-serializable Python object including transforming and filtering data.

From 87438f98b3915d872107955eec3d013b7860f6b1 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 3 Jun 2024 11:41:13 +0100
Subject: [PATCH 289/550] Bump uuid from 1.7.0 to 1.8.0 (#1311)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 7e1e4a7b0..dea7c7861 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -617,9 +617,9 @@ dependencies = [
 
 [[package]]
 name = "uuid"
-version = "1.7.0"
+version = "1.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f00cc9702ca12d3c81455259621e676d0f7251cec66a21e98fe2e9a37db93b2a"
+checksum = "a183cf7feeba97b4dd1c0d46788634f6221d87fa961b305bed08c851829efcc0"
 
 [[package]]
 name = "version_check"
diff --git a/Cargo.toml b/Cargo.toml
index 04b2b2783..b9038a050 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -43,7 +43,7 @@ idna = "0.5.0"
 base64 = "0.21.7"
 num-bigint = "0.4.4"
 python3-dll-a = "0.2.7"
-uuid = "1.7.0"
+uuid = "1.8.0"
 jiter = { version = "0.2.1", features = ["python"] }
 
 [lib]

From 2a5f464542ad8d4b180fca935fd89c0c9eb92324 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 3 Jun 2024 11:41:29 +0100
Subject: [PATCH 290/550] Bump serde from 1.0.197 to 1.0.203 (#1310)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 8 ++++----
 Cargo.toml | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index dea7c7861..f40fada62 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -458,18 +458,18 @@ checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
 
 [[package]]
 name = "serde"
-version = "1.0.197"
+version = "1.0.203"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3fb1c873e1b9b056a4dc4c0c198b24c3ffa059243875552b2bd0933b1aee4ce2"
+checksum = "7253ab4de971e72fb7be983802300c30b5a7f0c2e56fab8abfc6a214307c0094"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.197"
+version = "1.0.203"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7eb0b34b42edc17f6b7cac84a52a1c5f0e1bb2227e997ca9011ea3dd34e8610b"
+checksum = "500cbc0ebeb6f46627f50f3f5811ccf6bf00643be300b4c3eabc0ef55dc5b5ba"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/Cargo.toml b/Cargo.toml
index b9038a050..ca3997686 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -33,7 +33,7 @@ strum = { version = "0.25.0", features = ["derive"] }
 strum_macros = "0.26.1"
 serde_json = {version = "1.0.116", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.13"
-serde = { version = "1.0.197", features = ["derive"] }
+serde = { version = "1.0.203", features = ["derive"] }
 speedate = "0.14.0"
 smallvec = "1.13.2"
 ahash = "0.8.10"

From 81e3bd3a635f1c5942af2baef8c3c23e6f5b42aa Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 3 Jun 2024 11:41:58 +0100
Subject: [PATCH 291/550] Bump the python-packages group with 6 updates (#1312)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 6 +++---
 tests/requirements.txt         | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index 6f7696bf3..e5bac5207 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,4 +1,4 @@
-griffe==0.44.0
-pyright==1.1.360
-ruff==0.4.2
+griffe==0.45.2
+pyright==1.1.365
+ruff==0.4.7
 mypy==1.10.0
diff --git a/tests/requirements.txt b/tests/requirements.txt
index 6fa5882c4..7d8e2de3d 100644
--- a/tests/requirements.txt
+++ b/tests/requirements.txt
@@ -1,13 +1,13 @@
 backports.zoneinfo==0.2.1;python_version<"3.9"
-coverage==7.5.0
+coverage==7.5.3
 dirty-equals==0.7.1.post0
-hypothesis==6.100.2
+hypothesis==6.103.0
 # TODO: remove manual override for dateutil once a version newer than 2.8.2 is
 # released which removes use of deprecated utcfromtimestamp
 git+https://github.com/dateutil/dateutil.git@f2293200747fb03d56c6c5997bfebeabe703576f
 # pandas doesn't offer prebuilt wheels for all versions and platforms we test in CI e.g. aarch64 musllinux
 pandas==2.1.3; python_version >= "3.9" and python_version < "3.13" and implementation_name == "cpython" and platform_machine == 'x86_64'
-pytest==8.2.0
+pytest==8.2.1
 # we run codspeed benchmarks on x86_64 CPython (i.e. native github actions architecture)
 pytest-codspeed~=2.2.1; implementation_name == "cpython" and platform_machine == 'x86_64'
 # pytest-examples currently depends on aiohttp via black; we don't want to build

From 37ad925981226755410e8a952b92ee8838b4e732 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Mon, 3 Jun 2024 10:21:44 -0500
Subject: [PATCH 292/550] Uprev `jiter` to v0.4.1 and `pydantic-core` to
 v2.18.4 (#1306)

Co-authored-by: David Hewitt <david.hewitt@pydantic.dev>
---
 .github/workflows/ci.yml |  3 +++
 Cargo.lock               | 46 +++++++++++++++++++++++++++++++++++++---
 Cargo.toml               |  4 ++--
 src/lib.rs               | 19 ++++++++++++++---
 src/validators/json.rs   | 12 +++++++++--
 5 files changed, 74 insertions(+), 10 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index ba195b0c0..5aacc579d 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -90,6 +90,9 @@ jobs:
           python-version: ${{ matrix.python-version }}
 
       - run: pip install -r tests/requirements.txt
+      # TODO: remove this after the the next release of typing-extensions (v4.12.3 or v.4.13.0)
+      - run: pip uninstall -y typing-extensions
+      - run: pip install -U git+https://github.com/python/typing_extensions@main
 
       - run: pip install -e .
         env:
diff --git a/Cargo.lock b/Cargo.lock
index f40fada62..a2ccbbbab 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -42,6 +42,18 @@ version = "1.3.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
 
+[[package]]
+name = "bitvec"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
+dependencies = [
+ "funty",
+ "radium",
+ "tap",
+ "wyz",
+]
+
 [[package]]
 name = "cc"
 version = "1.0.79"
@@ -81,6 +93,12 @@ dependencies = [
  "percent-encoding",
 ]
 
+[[package]]
+name = "funty"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
+
 [[package]]
 name = "getrandom"
 version = "0.2.10"
@@ -138,11 +156,12 @@ checksum = "62b02a5381cc465bd3041d84623d0fa3b66738b52b8e2fc3bab8ad63ab032f4a"
 
 [[package]]
 name = "jiter"
-version = "0.2.1"
+version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8e1177860adcf80c1ae7d7c1d41561f008c7530664caebbfa5ddd8a7f7316b98"
+checksum = "abbbbe1bad457e3cd5503af716aedc735e849505a0d2172c55a753ae1b127458"
 dependencies = [
  "ahash",
+ "bitvec",
  "lexical-parse-float",
  "num-bigint",
  "num-traits",
@@ -294,7 +313,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.18.3"
+version = "2.18.4"
 dependencies = [
  "ahash",
  "base64",
@@ -400,6 +419,12 @@ dependencies = [
  "proc-macro2",
 ]
 
+[[package]]
+name = "radium"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
+
 [[package]]
 name = "redox_syscall"
 version = "0.3.5"
@@ -556,6 +581,12 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "tap"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
+
 [[package]]
 name = "target-lexicon"
 version = "0.12.9"
@@ -690,6 +721,15 @@ version = "0.48.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "1a515f5799fe4961cb532f983ce2b23082366b898e52ffbce459c86f67c8378a"
 
+[[package]]
+name = "wyz"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
+dependencies = [
+ "tap",
+]
+
 [[package]]
 name = "zerocopy"
 version = "0.7.32"
diff --git a/Cargo.toml b/Cargo.toml
index ca3997686..8f0ea441c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.18.3"
+version = "2.18.4"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"
@@ -44,7 +44,7 @@ base64 = "0.21.7"
 num-bigint = "0.4.4"
 python3-dll-a = "0.2.7"
 uuid = "1.8.0"
-jiter = { version = "0.2.1", features = ["python"] }
+jiter = { version = "0.4.1", features = ["python"] }
 
 [lib]
 name = "_pydantic_core"
diff --git a/src/lib.rs b/src/lib.rs
index 067c8e08a..d55e83645 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -4,7 +4,7 @@ extern crate core;
 
 use std::sync::OnceLock;
 
-use jiter::StringCacheMode;
+use jiter::{map_json_error, PartialMode, PythonParse, StringCacheMode};
 use pyo3::exceptions::PyTypeError;
 use pyo3::{prelude::*, sync::GILOnceCell};
 
@@ -63,8 +63,21 @@ pub fn from_json<'py>(
         CacheStringsArg::Bool(b) => b.into(),
         CacheStringsArg::Literal(mode) => mode,
     };
-    jiter::python_parse(py, json_bytes, allow_inf_nan, cache_mode, allow_partial)
-        .map_err(|e| jiter::map_json_error(json_bytes, &e))
+    let partial_mode = if allow_partial {
+        PartialMode::On
+    } else {
+        PartialMode::Off
+    };
+    let parse_builder = PythonParse {
+        allow_inf_nan,
+        cache_mode,
+        partial_mode,
+        catch_duplicate_keys: false,
+        lossless_floats: false,
+    };
+    parse_builder
+        .python_parse(py, json_bytes)
+        .map_err(|e| map_json_error(json_bytes, &e))
 }
 
 pub fn get_pydantic_core_version() -> &'static str {
diff --git a/src/validators/json.rs b/src/validators/json.rs
index 5a5927058..3e35a640b 100644
--- a/src/validators/json.rs
+++ b/src/validators/json.rs
@@ -2,7 +2,7 @@ use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
 
-use jiter::JsonValue;
+use jiter::{JsonValue, PartialMode, PythonParse};
 
 use crate::errors::{ErrorType, ErrorTypeDefaults, ValError, ValLineError, ValResult};
 use crate::input::{EitherBytes, Input, InputType, ValidationMatch};
@@ -64,7 +64,15 @@ impl Validator for JsonValidator {
                 validator.validate(py, &json_value, &mut json_state)
             }
             None => {
-                let obj = jiter::python_parse(py, json_bytes, true, state.cache_str(), false)
+                let parse_builder = PythonParse {
+                    allow_inf_nan: true,
+                    cache_mode: state.cache_str(),
+                    partial_mode: PartialMode::Off,
+                    catch_duplicate_keys: false,
+                    lossless_floats: false,
+                };
+                let obj = parse_builder
+                    .python_parse(py, json_bytes)
                     .map_err(|e| map_json_err(input, e, json_bytes))?;
                 Ok(obj.unbind())
             }

From 51ac71abfd066145d2e12ddc4547d8210a3aa58f Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Mon, 3 Jun 2024 11:34:06 -0500
Subject: [PATCH 293/550] Attempt fix - release build failed, need to install
 `typing-extensions` from main until a version after v4.12.1 (#1313)

---
 .github/workflows/ci.yml | 6 ------
 tests/requirements.txt   | 2 ++
 2 files changed, 2 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 5aacc579d..156ab6519 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -90,9 +90,6 @@ jobs:
           python-version: ${{ matrix.python-version }}
 
       - run: pip install -r tests/requirements.txt
-      # TODO: remove this after the the next release of typing-extensions (v4.12.3 or v.4.13.0)
-      - run: pip uninstall -y typing-extensions
-      - run: pip install -U git+https://github.com/python/typing_extensions@main
 
       - run: pip install -e .
         env:
@@ -662,10 +659,8 @@ jobs:
             fi
           run: |
             set -x
-            # typing-extensions isn't automatically installed because of `--no-index --no-deps`
             python3 -m venv venv
             source venv/bin/activate
-            python3 -m pip install -U pip typing-extensions
             python3 -m pip install -r tests/requirements.txt
             python3 -m pip install pydantic-core --no-index --no-deps --find-links dist --force-reinstall
             python3 -m pytest --ignore=tests/test_docstrings.py
@@ -696,7 +691,6 @@ jobs:
           merge-multiple: true
           path: dist
 
-      - run: pip install typing-extensions
       - run: pip install -r tests/requirements.txt
       - run: pip install pydantic-core --no-index --no-deps --find-links dist --force-reinstall
       - run: pytest --ignore=tests/test_docstrings.py
diff --git a/tests/requirements.txt b/tests/requirements.txt
index 7d8e2de3d..85bfca252 100644
--- a/tests/requirements.txt
+++ b/tests/requirements.txt
@@ -21,3 +21,5 @@ pytest-timeout==2.3.1
 numpy==1.26.2; python_version >= "3.9" and python_version < "3.13" and implementation_name == "cpython" and platform_machine == 'x86_64'
 exceptiongroup==1.1; python_version < "3.11"
 tzdata==2024.1
+# TODO: remove manual override for typing_extensions once a version newer than 4.12.1 is released
+git+https://github.com/python/typing_extensions@main

From 77f2b6957a7279d91773cc2eb30a21c0cba2ae41 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Mon, 3 Jun 2024 11:55:35 -0500
Subject: [PATCH 294/550] Ugh, another `typing-extensions` fix (#1314)

---
 .github/workflows/ci.yml | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 156ab6519..69b0133a7 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -467,7 +467,9 @@ jobs:
           python-version: '3.11'
           architecture: ${{ matrix.python-architecture || 'x64' }}
 
-      - run: pip install -U twine 'ruff==0.1.3' typing_extensions
+      - run: pip install -U twine 'ruff==0.1.3'
+      # TODO: remove manual override for typing_extensions once a version newer than 4.12.1 is released
+      - run: pip install -U git+https://github.com/python/typing_extensions@main
 
       # generate self-schema now, so we don't have to do so inside docker in maturin build
       - run: python generate_self_schema.py
@@ -530,7 +532,9 @@ jobs:
         with:
           components: llvm-tools
 
-      - run: pip install -U 'ruff==0.1.3' typing_extensions
+      - run: pip install -U 'ruff==0.1.3'
+      # TODO: remove manual override for typing_extensions once a version newer than 4.12.1 is released
+      - run: pip install -U git+https://github.com/python/typing_extensions@main
 
       # generate self-schema now, so we don't have to do so inside docker in maturin build
       - run: python generate_self_schema.py

From ebef5bdf92707f5e1739931150893ae6c7ccc531 Mon Sep 17 00:00:00 2001
From: Christian Heimes <christian@python.org>
Date: Wed, 5 Jun 2024 11:34:52 +0200
Subject: [PATCH 295/550] Lower MSRV to 1.75 (#1316)

Signed-off-by: Christian Heimes <christian@python.org>
---
 Cargo.toml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/Cargo.toml b/Cargo.toml
index 8f0ea441c..10b277cdb 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -24,7 +24,7 @@ include = [
     "!tests/.pytest_cache",
     "!*.so",
 ]
-rust-version = "1.76"
+rust-version = "1.75"
 
 [dependencies]
 pyo3 = { version = "0.21.2", features = ["generate-import-lib", "num-bigint"] }

From 34d789fc510810eee507347d5e0897d8fb9045bb Mon Sep 17 00:00:00 2001
From: wangweijie <51752888+wxpppp@users.noreply.github.com>
Date: Wed, 5 Jun 2024 21:12:36 +0800
Subject: [PATCH 296/550] deps: bump libc from 0.2.147 to 0.2.155 (#1317)

Signed-off-by: wangweijie <wangweijie@loongson.cn>
---
 Cargo.lock | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index a2ccbbbab..be73ee8ca 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -202,9 +202,9 @@ dependencies = [
 
 [[package]]
 name = "libc"
-version = "0.2.147"
+version = "0.2.155"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4668fb0ea861c1df094127ac5f1da3409a82116a4ba74fca2e58ef927159bb3"
+checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"
 
 [[package]]
 name = "lock_api"

From 1f8b30bddac794b08ed92aeb3dcfa1b43f1f8816 Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Fri, 7 Jun 2024 15:36:02 +0200
Subject: [PATCH 297/550] Make `ValidatorFunctionWrapHandler` positional only
 (#1323)

---
 python/pydantic_core/core_schema.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index 2cb875b23..2cc1a6c11 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -2062,7 +2062,7 @@ def fn(v: str, info: core_schema.ValidationInfo) -> str:
 
 
 class ValidatorFunctionWrapHandler(Protocol):
-    def __call__(self, input_value: Any, outer_location: str | int | None = None) -> Any:  # pragma: no cover
+    def __call__(self, input_value: Any, outer_location: str | int | None = None, /) -> Any:  # pragma: no cover
         ...
 
 

From 96aca52448d0d70e06651f09cdb5e9258d11cfc7 Mon Sep 17 00:00:00 2001
From: Josh Newman <src@joshn.dev>
Date: Mon, 10 Jun 2024 04:31:40 -0700
Subject: [PATCH 298/550] Add ser_json_inf_nan='strings' mode to produce valid
 JSON (#1307)

---
 python/pydantic_core/_pydantic_core.pyi   |  8 +++----
 python/pydantic_core/core_schema.py       |  2 +-
 src/serializers/config.rs                 |  1 +
 src/serializers/infer.rs                  |  7 ++----
 src/serializers/type_serializers/float.rs | 27 +++++++++++++++++------
 tests/serializers/test_any.py             |  8 +++++++
 tests/serializers/test_simple.py          |  3 +++
 tests/validators/test_float.py            |  4 ++++
 8 files changed, 43 insertions(+), 17 deletions(-)

diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index d785d1531..05fe48e40 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -353,7 +353,7 @@ def to_json(
     round_trip: bool = False,
     timedelta_mode: Literal['iso8601', 'float'] = 'iso8601',
     bytes_mode: Literal['utf8', 'base64'] = 'utf8',
-    inf_nan_mode: Literal['null', 'constants'] = 'constants',
+    inf_nan_mode: Literal['null', 'constants', 'strings'] = 'constants',
     serialize_unknown: bool = False,
     fallback: Callable[[Any], Any] | None = None,
     serialize_as_any: bool = False,
@@ -374,7 +374,7 @@ def to_json(
         round_trip: Whether to enable serialization and validation round-trip support.
         timedelta_mode: How to serialize `timedelta` objects, either `'iso8601'` or `'float'`.
         bytes_mode: How to serialize `bytes` objects, either `'utf8'` or `'base64'`.
-        inf_nan_mode: How to serialize `Infinity`, `-Infinity` and `NaN` values, either `'null'` or `'constants'`.
+        inf_nan_mode: How to serialize `Infinity`, `-Infinity` and `NaN` values, either `'null'`, `'constants'`, or `'strings'`.
         serialize_unknown: Attempt to serialize unknown types, `str(value)` will be used, if that fails
             `"<Unserializable {value_type} object>"` will be used.
         fallback: A function to call when an unknown value is encountered,
@@ -428,7 +428,7 @@ def to_jsonable_python(
     round_trip: bool = False,
     timedelta_mode: Literal['iso8601', 'float'] = 'iso8601',
     bytes_mode: Literal['utf8', 'base64'] = 'utf8',
-    inf_nan_mode: Literal['null', 'constants'] = 'constants',
+    inf_nan_mode: Literal['null', 'constants', 'strings'] = 'constants',
     serialize_unknown: bool = False,
     fallback: Callable[[Any], Any] | None = None,
     serialize_as_any: bool = False,
@@ -449,7 +449,7 @@ def to_jsonable_python(
         round_trip: Whether to enable serialization and validation round-trip support.
         timedelta_mode: How to serialize `timedelta` objects, either `'iso8601'` or `'float'`.
         bytes_mode: How to serialize `bytes` objects, either `'utf8'` or `'base64'`.
-        inf_nan_mode: How to serialize `Infinity`, `-Infinity` and `NaN` values, either `'null'` or `'constants'`.
+        inf_nan_mode: How to serialize `Infinity`, `-Infinity` and `NaN` values, either `'null'`, `'constants'`, or `'strings'`.
         serialize_unknown: Attempt to serialize unknown types, `str(value)` will be used, if that fails
             `"<Unserializable {value_type} object>"` will be used.
         fallback: A function to call when an unknown value is encountered,
diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index 2cc1a6c11..13dc26317 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -106,7 +106,7 @@ class CoreConfig(TypedDict, total=False):
     # the config options are used to customise serialization to JSON
     ser_json_timedelta: Literal['iso8601', 'float']  # default: 'iso8601'
     ser_json_bytes: Literal['utf8', 'base64', 'hex']  # default: 'utf8'
-    ser_json_inf_nan: Literal['null', 'constants']  # default: 'null'
+    ser_json_inf_nan: Literal['null', 'constants', 'strings']  # default: 'null'
     # used to hide input data from ValidationError repr
     hide_input_in_errors: bool
     validation_error_cause: bool  # default: False
diff --git a/src/serializers/config.rs b/src/serializers/config.rs
index 2863d68d9..0aca33de5 100644
--- a/src/serializers/config.rs
+++ b/src/serializers/config.rs
@@ -104,6 +104,7 @@ serialization_mode! {
     "ser_json_inf_nan",
     Null => "null",
     Constants => "constants",
+    Strings => "strings",
 }
 
 impl TimedeltaMode {
diff --git a/src/serializers/infer.rs b/src/serializers/infer.rs
index 2384e8691..c4cb8e9d9 100644
--- a/src/serializers/infer.rs
+++ b/src/serializers/infer.rs
@@ -9,6 +9,7 @@ use pyo3::types::{PyByteArray, PyBytes, PyDict, PyFrozenSet, PyIterator, PyList,
 use serde::ser::{Error, Serialize, SerializeMap, SerializeSeq, Serializer};
 
 use crate::input::{EitherTimedelta, Int};
+use crate::serializers::type_serializers;
 use crate::tools::{extract_i64, py_err, safe_repr};
 use crate::url::{PyMultiHostUrl, PyUrl};
 
@@ -403,11 +404,7 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
         ObType::Bool => serialize!(bool),
         ObType::Float | ObType::FloatSubclass => {
             let v = value.extract::<f64>().map_err(py_err_se_err)?;
-            if (v.is_nan() || v.is_infinite()) && extra.config.inf_nan_mode == InfNanMode::Null {
-                serializer.serialize_none()
-            } else {
-                serializer.serialize_f64(v)
-            }
+            type_serializers::float::serialize_f64(v, serializer, extra.config.inf_nan_mode.clone())
         }
         ObType::Decimal => value.to_string().serialize(serializer),
         ObType::Str | ObType::StrSubclass => {
diff --git a/src/serializers/type_serializers/float.rs b/src/serializers/type_serializers/float.rs
index f3cb81380..84eae4ba0 100644
--- a/src/serializers/type_serializers/float.rs
+++ b/src/serializers/type_serializers/float.rs
@@ -30,6 +30,24 @@ impl FloatSerializer {
     }
 }
 
+pub fn serialize_f64<S: Serializer>(v: f64, serializer: S, inf_nan_mode: InfNanMode) -> Result<S::Ok, S::Error> {
+    if v.is_nan() || v.is_infinite() {
+        match inf_nan_mode {
+            InfNanMode::Null => serializer.serialize_none(),
+            InfNanMode::Constants => serializer.serialize_f64(v),
+            InfNanMode::Strings => {
+                if v.is_nan() {
+                    serializer.serialize_str("NaN")
+                } else {
+                    serializer.serialize_str(if v.is_sign_positive() { "Infinity" } else { "-Infinity" })
+                }
+            }
+        }
+    } else {
+        serializer.serialize_f64(v)
+    }
+}
+
 impl BuildSerializer for FloatSerializer {
     const EXPECTED_TYPE: &'static str = "float";
 
@@ -85,16 +103,11 @@ impl TypeSerializer for FloatSerializer {
         serializer: S,
         include: Option<&Bound<'_, PyAny>>,
         exclude: Option<&Bound<'_, PyAny>>,
+        // TODO: Merge extra.config into self.inf_nan_mode?
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         match value.extract::<f64>() {
-            Ok(v) => {
-                if (v.is_nan() || v.is_infinite()) && self.inf_nan_mode == InfNanMode::Null {
-                    serializer.serialize_none()
-                } else {
-                    serializer.serialize_f64(v)
-                }
-            }
+            Ok(v) => serialize_f64(v, serializer, self.inf_nan_mode.clone()),
             Err(_) => {
                 extra.warnings.on_fallback_ser::<S>(self.get_name(), value, extra)?;
                 infer_serialize(value, serializer, include, exclude, extra)
diff --git a/tests/serializers/test_any.py b/tests/serializers/test_any.py
index b6eedafe0..4c3cd9eff 100644
--- a/tests/serializers/test_any.py
+++ b/tests/serializers/test_any.py
@@ -623,6 +623,14 @@ def test_ser_json_inf_nan_with_any() -> None:
     assert s.to_python(nan, mode='json') is None
     assert s.to_json(nan) == b'null'
 
+    s = SchemaSerializer(core_schema.any_schema(), core_schema.CoreConfig(ser_json_inf_nan='strings'))
+    assert isinf(s.to_python(inf))
+    assert isinf(s.to_python(inf, mode='json'))
+    assert s.to_json(inf) == b'"Infinity"'
+    assert isnan(s.to_python(nan))
+    assert isnan(s.to_python(nan, mode='json'))
+    assert s.to_json(nan) == b'"NaN"'
+
 
 def test_ser_json_inf_nan_with_list_of_any() -> None:
     s = SchemaSerializer(
diff --git a/tests/serializers/test_simple.py b/tests/serializers/test_simple.py
index b63208c07..b0fe7b836 100644
--- a/tests/serializers/test_simple.py
+++ b/tests/serializers/test_simple.py
@@ -152,6 +152,9 @@ def test_numpy():
         (float('inf'), 'Infinity', {'ser_json_inf_nan': 'constants'}),
         (float('-inf'), '-Infinity', {'ser_json_inf_nan': 'constants'}),
         (float('nan'), 'NaN', {'ser_json_inf_nan': 'constants'}),
+        (float('inf'), '"Infinity"', {'ser_json_inf_nan': 'strings'}),
+        (float('-inf'), '"-Infinity"', {'ser_json_inf_nan': 'strings'}),
+        (float('nan'), '"NaN"', {'ser_json_inf_nan': 'strings'}),
     ],
 )
 def test_float_inf_and_nan_serializers(value, expected_json, config):
diff --git a/tests/validators/test_float.py b/tests/validators/test_float.py
index 88966261a..c397f453c 100644
--- a/tests/validators/test_float.py
+++ b/tests/validators/test_float.py
@@ -387,6 +387,10 @@ def test_allow_inf_nan_true_json() -> None:
     assert v.validate_json('Infinity') == float('inf')
     assert v.validate_json('-Infinity') == float('-inf')
 
+    assert v.validate_json('"NaN"') == IsFloatNan()
+    assert v.validate_json('"Infinity"') == float('inf')
+    assert v.validate_json('"-Infinity"') == float('-inf')
+
 
 def test_allow_inf_nan_false_json() -> None:
     v = SchemaValidator(core_schema.float_schema(), core_schema.CoreConfig(allow_inf_nan=False))

From 8afaa45190d4fb63d9b6d442944a02b06df09e5a Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Mon, 10 Jun 2024 13:53:55 +0100
Subject: [PATCH 299/550] impl `Copy` for simple config enums (#1325)

---
 src/serializers/config.rs                 | 12 ++++++------
 src/serializers/infer.rs                  |  2 +-
 src/serializers/type_serializers/float.rs |  2 +-
 3 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/serializers/config.rs b/src/serializers/config.rs
index 0aca33de5..5421ed920 100644
--- a/src/serializers/config.rs
+++ b/src/serializers/config.rs
@@ -51,7 +51,7 @@ pub trait FromConfig {
 
 macro_rules! serialization_mode {
     ($name:ident, $config_key:expr, $($variant:ident => $value:expr),* $(,)?) => {
-        #[derive(Default, Debug, Clone, PartialEq, Eq)]
+        #[derive(Default, Debug, Clone, Copy, PartialEq, Eq)]
         pub(crate) enum $name {
             #[default]
             $($variant,)*
@@ -112,7 +112,7 @@ impl TimedeltaMode {
         py_timedelta.call_method0(intern!(py_timedelta.py(), "total_seconds"))
     }
 
-    pub fn either_delta_to_json(&self, py: Python, either_delta: &EitherTimedelta) -> PyResult<PyObject> {
+    pub fn either_delta_to_json(self, py: Python, either_delta: &EitherTimedelta) -> PyResult<PyObject> {
         match self {
             Self::Iso8601 => {
                 let d = either_delta.to_duration()?;
@@ -128,7 +128,7 @@ impl TimedeltaMode {
         }
     }
 
-    pub fn json_key<'py>(&self, py: Python, either_delta: &EitherTimedelta) -> PyResult<Cow<'py, str>> {
+    pub fn json_key<'py>(self, py: Python, either_delta: &EitherTimedelta) -> PyResult<Cow<'py, str>> {
         match self {
             Self::Iso8601 => {
                 let d = either_delta.to_duration()?;
@@ -143,7 +143,7 @@ impl TimedeltaMode {
     }
 
     pub fn timedelta_serialize<S: serde::ser::Serializer>(
-        &self,
+        self,
         py: Python,
         either_delta: &EitherTimedelta,
         serializer: S,
@@ -164,7 +164,7 @@ impl TimedeltaMode {
 }
 
 impl BytesMode {
-    pub fn bytes_to_string<'a>(&self, py: Python, bytes: &'a [u8]) -> PyResult<Cow<'a, str>> {
+    pub fn bytes_to_string<'a>(self, py: Python, bytes: &'a [u8]) -> PyResult<Cow<'a, str>> {
         match self {
             Self::Utf8 => from_utf8(bytes)
                 .map_err(|err| utf8_py_error(py, err, bytes))
@@ -176,7 +176,7 @@ impl BytesMode {
         }
     }
 
-    pub fn serialize_bytes<S: serde::ser::Serializer>(&self, bytes: &[u8], serializer: S) -> Result<S::Ok, S::Error> {
+    pub fn serialize_bytes<S: serde::ser::Serializer>(self, bytes: &[u8], serializer: S) -> Result<S::Ok, S::Error> {
         match self {
             Self::Utf8 => match from_utf8(bytes) {
                 Ok(s) => serializer.serialize_str(s),
diff --git a/src/serializers/infer.rs b/src/serializers/infer.rs
index c4cb8e9d9..45d8957bb 100644
--- a/src/serializers/infer.rs
+++ b/src/serializers/infer.rs
@@ -404,7 +404,7 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
         ObType::Bool => serialize!(bool),
         ObType::Float | ObType::FloatSubclass => {
             let v = value.extract::<f64>().map_err(py_err_se_err)?;
-            type_serializers::float::serialize_f64(v, serializer, extra.config.inf_nan_mode.clone())
+            type_serializers::float::serialize_f64(v, serializer, extra.config.inf_nan_mode)
         }
         ObType::Decimal => value.to_string().serialize(serializer),
         ObType::Str | ObType::StrSubclass => {
diff --git a/src/serializers/type_serializers/float.rs b/src/serializers/type_serializers/float.rs
index 84eae4ba0..13af9294c 100644
--- a/src/serializers/type_serializers/float.rs
+++ b/src/serializers/type_serializers/float.rs
@@ -107,7 +107,7 @@ impl TypeSerializer for FloatSerializer {
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         match value.extract::<f64>() {
-            Ok(v) => serialize_f64(v, serializer, self.inf_nan_mode.clone()),
+            Ok(v) => serialize_f64(v, serializer, self.inf_nan_mode),
             Err(_) => {
                 extra.warnings.on_fallback_ser::<S>(self.get_name(), value, extra)?;
                 infer_serialize(value, serializer, include, exclude, extra)

From d7946da7455fc269f69d6ae01abe2ba61266a0f2 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Tue, 11 Jun 2024 07:16:39 -0500
Subject: [PATCH 300/550] Reuse `re.Pattern` object in regex patterns (#1318)

---
 generate_self_schema.py             | 22 ++++++------
 python/pydantic_core/core_schema.py |  6 ++--
 src/validators/string.rs            | 55 ++++++++++++++++++++++-------
 tests/validators/test_string.py     |  7 ++++
 4 files changed, 63 insertions(+), 27 deletions(-)

diff --git a/generate_self_schema.py b/generate_self_schema.py
index acecf19d8..ac12062f3 100644
--- a/generate_self_schema.py
+++ b/generate_self_schema.py
@@ -10,10 +10,11 @@
 import decimal
 import importlib.util
 import re
+import sys
 from collections.abc import Callable
 from datetime import date, datetime, time, timedelta
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Dict, ForwardRef, List, Set, Type, Union
+from typing import TYPE_CHECKING, Any, Dict, ForwardRef, List, Pattern, Set, Type, Union
 
 from typing_extensions import TypedDict, get_args, get_origin, is_typeddict
 
@@ -46,7 +47,7 @@
 schema_ref_validator = {'type': 'definition-ref', 'schema_ref': 'root-schema'}
 
 
-def get_schema(obj: Any, definitions: dict[str, core_schema.CoreSchema]) -> core_schema.CoreSchema:
+def get_schema(obj: Any, definitions: dict[str, core_schema.CoreSchema]) -> core_schema.CoreSchema:  # noqa: C901
     if isinstance(obj, str):
         return {'type': obj}
     elif obj in (datetime, timedelta, date, time, bool, int, float, str, decimal.Decimal):
@@ -81,6 +82,9 @@ def get_schema(obj: Any, definitions: dict[str, core_schema.CoreSchema]) -> core
     elif issubclass(origin, Type):
         # can't really use 'is-instance' since this is used for the class_ parameter of 'is-instance' validators
         return {'type': 'any'}
+    elif origin in (Pattern, re.Pattern):
+        # can't really use 'is-instance' easily with Pattern, so we use `any` as a placeholder for now
+        return {'type': 'any'}
     else:
         # debug(obj)
         raise TypeError(f'Unknown type: {obj!r}')
@@ -189,16 +193,12 @@ def all_literal_values(type_: type[core_schema.Literal]) -> list[any]:
 
 
 def eval_forward_ref(type_: Any) -> Any:
-    try:
-        try:
-            # Python 3.12+
-            return type_._evaluate(core_schema.__dict__, None, type_params=set(), recursive_guard=set())
-        except TypeError:
-            # Python 3.9+
-            return type_._evaluate(core_schema.__dict__, None, set())
-    except TypeError:
-        # for Python 3.8
+    if sys.version_info < (3, 9):
         return type_._evaluate(core_schema.__dict__, None)
+    elif sys.version_info < (3, 12, 4):
+        return type_._evaluate(core_schema.__dict__, None, recursive_guard=set())
+    else:
+        return type_._evaluate(core_schema.__dict__, None, type_params=set(), recursive_guard=set())
 
 
 def main() -> None:
diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index 13dc26317..6644c7fc8 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -10,7 +10,7 @@
 from collections.abc import Mapping
 from datetime import date, datetime, time, timedelta
 from decimal import Decimal
-from typing import TYPE_CHECKING, Any, Callable, Dict, Hashable, List, Set, Tuple, Type, Union
+from typing import TYPE_CHECKING, Any, Callable, Dict, Hashable, List, Pattern, Set, Tuple, Type, Union
 
 from typing_extensions import deprecated
 
@@ -744,7 +744,7 @@ def decimal_schema(
 
 class StringSchema(TypedDict, total=False):
     type: Required[Literal['str']]
-    pattern: str
+    pattern: Union[str, Pattern[str]]
     max_length: int
     min_length: int
     strip_whitespace: bool
@@ -760,7 +760,7 @@ class StringSchema(TypedDict, total=False):
 
 def str_schema(
     *,
-    pattern: str | None = None,
+    pattern: str | Pattern[str] | None = None,
     max_length: int | None = None,
     min_length: int | None = None,
     strip_whitespace: bool | None = None,
diff --git a/src/validators/string.rs b/src/validators/string.rs
index a7becf6bb..672bc64f5 100644
--- a/src/validators/string.rs
+++ b/src/validators/string.rs
@@ -164,7 +164,7 @@ impl StrConstrainedValidator {
                     .map(|s| s.to_str())
                     .transpose()?
                     .unwrap_or(RegexEngine::RUST_REGEX);
-                Pattern::compile(py, s, regex_engine)
+                Pattern::compile(s, regex_engine)
             })
             .transpose()?;
         let min_length: Option<usize> =
@@ -230,18 +230,47 @@ impl RegexEngine {
 }
 
 impl Pattern {
-    fn compile(py: Python<'_>, pattern: String, engine: &str) -> PyResult<Self> {
-        let engine = match engine {
-            RegexEngine::RUST_REGEX => {
-                RegexEngine::RustRegex(Regex::new(&pattern).map_err(|e| py_schema_error_type!("{}", e))?)
-            }
-            RegexEngine::PYTHON_RE => {
-                let re_compile = py.import_bound(intern!(py, "re"))?.getattr(intern!(py, "compile"))?;
-                RegexEngine::PythonRe(re_compile.call1((&pattern,))?.into())
-            }
-            _ => return Err(py_schema_error_type!("Invalid regex engine: {}", engine)),
-        };
-        Ok(Self { pattern, engine })
+    fn extract_pattern_str(pattern: &Bound<'_, PyAny>) -> PyResult<String> {
+        if pattern.is_instance_of::<PyString>() {
+            Ok(pattern.to_string())
+        } else {
+            pattern
+                .getattr("pattern")
+                .and_then(|attr| attr.extract::<String>())
+                .map_err(|_| py_schema_error_type!("Invalid pattern, must be str or re.Pattern: {}", pattern))
+        }
+    }
+
+    fn compile(pattern: Bound<'_, PyAny>, engine: &str) -> PyResult<Self> {
+        let pattern_str = Self::extract_pattern_str(&pattern)?;
+
+        let py = pattern.py();
+
+        let re_module = py.import_bound(intern!(py, "re"))?;
+        let re_compile = re_module.getattr(intern!(py, "compile"))?;
+        let re_pattern = re_module.getattr(intern!(py, "Pattern"))?;
+
+        if pattern.is_instance(&re_pattern)? {
+            // if the pattern is already a compiled regex object, we default to using the python re engine
+            // so that any flags, etc. are preserved
+            Ok(Self {
+                pattern: pattern_str,
+                engine: RegexEngine::PythonRe(pattern.to_object(py)),
+            })
+        } else {
+            let engine = match engine {
+                RegexEngine::RUST_REGEX => {
+                    RegexEngine::RustRegex(Regex::new(&pattern_str).map_err(|e| py_schema_error_type!("{}", e))?)
+                }
+                RegexEngine::PYTHON_RE => RegexEngine::PythonRe(re_compile.call1((pattern,))?.into()),
+                _ => return Err(py_schema_error_type!("Invalid regex engine: {}", engine)),
+            };
+
+            Ok(Self {
+                pattern: pattern_str,
+                engine,
+            })
+        }
     }
 
     fn is_match(&self, py: Python<'_>, target: &str) -> PyResult<bool> {
diff --git a/tests/validators/test_string.py b/tests/validators/test_string.py
index f4f5f3888..75edcc1b0 100644
--- a/tests/validators/test_string.py
+++ b/tests/validators/test_string.py
@@ -398,3 +398,10 @@ def test_coerce_numbers_to_str_schema_with_strict_mode(number: int):
         v.validate_python(number)
     with pytest.raises(ValidationError):
         v.validate_json(str(number))
+
+
+@pytest.mark.parametrize('engine', [None, 'rust-regex', 'python-re'])
+def test_compiled_regex(engine) -> None:
+    v = SchemaValidator(core_schema.str_schema(pattern=re.compile('abc', re.IGNORECASE), regex_engine=engine))
+    assert v.validate_python('abc') == 'abc'
+    assert v.validate_python('ABC') == 'ABC'

From 66331bb1a4977d3d927fd26c6929dd6532d586ef Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Tue, 11 Jun 2024 13:38:12 -0500
Subject: [PATCH 301/550] Prep for 2.19.0 (#1326)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index be73ee8ca..c4f6d67e0 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -313,7 +313,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.18.4"
+version = "2.19.0"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index 10b277cdb..7c4614f3c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.18.4"
+version = "2.19.0"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From 4d20a1da5a0dee634e86e63d8a25c46432a80c46 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Wed, 12 Jun 2024 17:28:44 +0100
Subject: [PATCH 302/550] ci: stop building on windows aarch64 pending fix
 (#1328)

---
 .github/workflows/ci.yml | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 69b0133a7..550a73345 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -453,9 +453,15 @@ jobs:
             target: i686
             python-architecture: x86
             interpreter: 3.8 3.9 3.10 3.11 3.12
+          # FIXME aarch64 builds broken, see https://github.com/PyO3/maturin/issues/2110
+          # - os: windows
+          #   target: aarch64
+          #   interpreter: 3.11 3.12
+
+        exclude:
+          # See above; disabled for now.
           - os: windows
             target: aarch64
-            interpreter: 3.11 3.12
 
     runs-on: ${{ (matrix.os == 'linux' && 'ubuntu') || matrix.os }}-latest
     steps:

From 03f1aa87fa1b29628b81e5730adb7763718f83a0 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Wed, 12 Jun 2024 17:43:45 +0100
Subject: [PATCH 303/550] remove some dead PyPy-specific code (#1329)

---
 src/input/input_python.rs | 54 ---------------------------------------
 1 file changed, 54 deletions(-)

diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index b2284efb5..2a06228e1 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -653,60 +653,6 @@ fn maybe_as_enum<'py>(v: &Bound<'py, PyAny>) -> Option<Bound<'py, PyAny>> {
     }
 }
 
-#[cfg(PyPy)]
-static DICT_KEYS_TYPE: pyo3::sync::GILOnceCell<Py<PyType>> = pyo3::sync::GILOnceCell::new();
-
-#[cfg(PyPy)]
-fn is_dict_keys_type(v: &Bound<'_, PyAny>) -> bool {
-    let py = v.py();
-    let keys_type = DICT_KEYS_TYPE
-        .get_or_init(py, || {
-            py.eval("type({}.keys())", None, None)
-                .unwrap()
-                .downcast::<PyType>()
-                .unwrap()
-                .into()
-        })
-        .bind(py);
-    v.is_instance(keys_type).unwrap_or(false)
-}
-
-#[cfg(PyPy)]
-static DICT_VALUES_TYPE: pyo3::sync::GILOnceCell<Py<PyType>> = pyo3::sync::GILOnceCell::new();
-
-#[cfg(PyPy)]
-fn is_dict_values_type(v: &Bound<'_, PyAny>) -> bool {
-    let py = v.py();
-    let values_type = DICT_VALUES_TYPE
-        .get_or_init(py, || {
-            py.eval("type({}.values())", None, None)
-                .unwrap()
-                .downcast::<PyType>()
-                .unwrap()
-                .into()
-        })
-        .bind(py);
-    v.is_instance(values_type).unwrap_or(false)
-}
-
-#[cfg(PyPy)]
-static DICT_ITEMS_TYPE: pyo3::sync::GILOnceCell<Py<PyType>> = pyo3::sync::GILOnceCell::new();
-
-#[cfg(PyPy)]
-fn is_dict_items_type(v: &Bound<'_, PyAny>) -> bool {
-    let py = v.py();
-    let items_type = DICT_ITEMS_TYPE
-        .get_or_init(py, || {
-            py.eval("type({}.items())", None, None)
-                .unwrap()
-                .downcast::<PyType>()
-                .unwrap()
-                .into()
-        })
-        .bind(py);
-    v.is_instance(items_type).unwrap_or(false)
-}
-
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub struct PyArgs<'py> {
     pub args: Option<PyPosArgs<'py>>,

From 9507a28f93da317dbfd90a32ec9e66b1c3c0b964 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Wed, 12 Jun 2024 17:49:01 +0100
Subject: [PATCH 304/550] ci: remove pins on git dependencies of packages
 (#1330)

---
 .github/workflows/ci.yml | 8 ++------
 tests/requirements.txt   | 7 ++-----
 2 files changed, 4 insertions(+), 11 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 550a73345..c8bb82805 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -473,9 +473,7 @@ jobs:
           python-version: '3.11'
           architecture: ${{ matrix.python-architecture || 'x64' }}
 
-      - run: pip install -U twine 'ruff==0.1.3'
-      # TODO: remove manual override for typing_extensions once a version newer than 4.12.1 is released
-      - run: pip install -U git+https://github.com/python/typing_extensions@main
+      - run: pip install -U twine 'ruff==0.1.3' typing_extensions
 
       # generate self-schema now, so we don't have to do so inside docker in maturin build
       - run: python generate_self_schema.py
@@ -538,9 +536,7 @@ jobs:
         with:
           components: llvm-tools
 
-      - run: pip install -U 'ruff==0.1.3'
-      # TODO: remove manual override for typing_extensions once a version newer than 4.12.1 is released
-      - run: pip install -U git+https://github.com/python/typing_extensions@main
+      - run: pip install -U 'ruff==0.1.3' typing_extensions
 
       # generate self-schema now, so we don't have to do so inside docker in maturin build
       - run: python generate_self_schema.py
diff --git a/tests/requirements.txt b/tests/requirements.txt
index 85bfca252..cdb222bf8 100644
--- a/tests/requirements.txt
+++ b/tests/requirements.txt
@@ -2,9 +2,6 @@ backports.zoneinfo==0.2.1;python_version<"3.9"
 coverage==7.5.3
 dirty-equals==0.7.1.post0
 hypothesis==6.103.0
-# TODO: remove manual override for dateutil once a version newer than 2.8.2 is
-# released which removes use of deprecated utcfromtimestamp
-git+https://github.com/dateutil/dateutil.git@f2293200747fb03d56c6c5997bfebeabe703576f
 # pandas doesn't offer prebuilt wheels for all versions and platforms we test in CI e.g. aarch64 musllinux
 pandas==2.1.3; python_version >= "3.9" and python_version < "3.13" and implementation_name == "cpython" and platform_machine == 'x86_64'
 pytest==8.2.1
@@ -17,9 +14,9 @@ pytest-speed==0.3.5
 pytest-mock==3.14.0
 pytest-pretty==1.2.0
 pytest-timeout==2.3.1
+python-dateutil==2.9.0.post0
 # numpy doesn't offer prebuilt wheels for all versions and platforms we test in CI e.g. aarch64 musllinux
 numpy==1.26.2; python_version >= "3.9" and python_version < "3.13" and implementation_name == "cpython" and platform_machine == 'x86_64'
 exceptiongroup==1.1; python_version < "3.11"
 tzdata==2024.1
-# TODO: remove manual override for typing_extensions once a version newer than 4.12.1 is released
-git+https://github.com/python/typing_extensions@main
+typing_extensions==4.12.2

From 46379acc7f9b9cf2137bbc4623cc7484abe57474 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Mon, 17 Jun 2024 17:01:12 +0100
Subject: [PATCH 305/550] tidy up `tagged_union_schema` (#1333)

---
 python/pydantic_core/core_schema.py |  4 ++--
 src/validators/literal.rs           | 29 ++++++++++++++---------------
 src/validators/union.rs             |  2 --
 3 files changed, 16 insertions(+), 19 deletions(-)

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index 6644c7fc8..2c66f8702 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -2466,8 +2466,8 @@ class TaggedUnionSchema(TypedDict, total=False):
 
 
 def tagged_union_schema(
-    choices: Dict[Hashable, CoreSchema],
-    discriminator: str | list[str | int] | list[list[str | int]] | Callable[[Any], Hashable],
+    choices: Dict[Any, CoreSchema],
+    discriminator: str | list[str | int] | list[list[str | int]] | Callable[[Any], Any],
     *,
     custom_error_type: str | None = None,
     custom_error_message: str | None = None,
diff --git a/src/validators/literal.rs b/src/validators/literal.rs
index 16eef090d..5e09c97dc 100644
--- a/src/validators/literal.rs
+++ b/src/validators/literal.rs
@@ -1,7 +1,6 @@
 // Validator for things inside of a typing.Literal[]
 // which can be an int, a string, bytes or an Enum value (including `class Foo(str, Enum)` type enums)
 use core::fmt::Debug;
-use std::cmp::Ordering;
 
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyInt, PyList};
@@ -35,7 +34,7 @@ pub struct LiteralLookup<T: Debug> {
     // Catch all for hashable types like Enum and bytes (the latter only because it is seldom used)
     expected_py_dict: Option<Py<PyDict>>,
     // Catch all for unhashable types like list
-    expected_py_list: Option<Py<PyList>>,
+    expected_py_values: Option<Vec<(Py<PyAny>, usize)>>,
 
     pub values: Vec<T>,
 }
@@ -46,7 +45,7 @@ impl<T: Debug> LiteralLookup<T> {
         let mut expected_int = AHashMap::new();
         let mut expected_str: AHashMap<String, usize> = AHashMap::new();
         let expected_py_dict = PyDict::new_bound(py);
-        let expected_py_list = PyList::empty_bound(py);
+        let mut expected_py_values = Vec::new();
         let mut values = Vec::new();
         for (k, v) in expected {
             let id = values.len();
@@ -71,7 +70,7 @@ impl<T: Debug> LiteralLookup<T> {
                     .map_err(|_| py_schema_error_type!("error extracting str {:?}", k))?;
                 expected_str.insert(str.to_string(), id);
             } else if expected_py_dict.set_item(&k, id).is_err() {
-                expected_py_list.append((&k, id))?;
+                expected_py_values.push((k.as_unbound().clone_ref(py), id));
             }
         }
 
@@ -92,9 +91,9 @@ impl<T: Debug> LiteralLookup<T> {
                 true => None,
                 false => Some(expected_py_dict.into()),
             },
-            expected_py_list: match expected_py_list.is_empty() {
+            expected_py_values: match expected_py_values.is_empty() {
                 true => None,
-                false => Some(expected_py_list.into()),
+                false => Some(expected_py_values),
             },
             values,
         })
@@ -143,23 +142,23 @@ impl<T: Debug> LiteralLookup<T> {
                 }
             }
         }
+        // cache py_input if needed, since we might need it for multiple lookups
+        let mut py_input = None;
         if let Some(expected_py_dict) = &self.expected_py_dict {
+            let py_input = py_input.get_or_insert_with(|| input.to_object(py));
             // We don't use ? to unpack the result of `get_item` in the next line because unhashable
             // inputs will produce a TypeError, which in this case we just want to treat equivalently
             // to a failed lookup
-            if let Ok(Some(v)) = expected_py_dict.bind(py).get_item(input) {
+            if let Ok(Some(v)) = expected_py_dict.bind(py).get_item(&*py_input) {
                 let id: usize = v.extract().unwrap();
                 return Ok(Some((input, &self.values[id])));
             }
         };
-        if let Some(expected_py_list) = &self.expected_py_list {
-            for item in expected_py_list.bind(py) {
-                let (k, id): (Bound<PyAny>, usize) = item.extract()?;
-                if k.compare(input.to_object(py).bind(py))
-                    .unwrap_or(Ordering::Less)
-                    .is_eq()
-                {
-                    return Ok(Some((input, &self.values[id])));
+        if let Some(expected_py_values) = &self.expected_py_values {
+            let py_input = py_input.get_or_insert_with(|| input.to_object(py));
+            for (k, id) in expected_py_values {
+                if k.bind(py).eq(&*py_input).unwrap_or(false) {
+                    return Ok(Some((input, &self.values[*id])));
                 }
             }
         };
diff --git a/src/validators/union.rs b/src/validators/union.rs
index 8a33870ec..21ebe89e7 100644
--- a/src/validators/union.rs
+++ b/src/validators/union.rs
@@ -344,11 +344,9 @@ impl BuildValidator for TaggedUnionValidator {
         let mut tags_repr = String::with_capacity(50);
         let mut descr = String::with_capacity(50);
         let mut first = true;
-        let mut discriminators = Vec::with_capacity(choices.len());
         let schema_choices: Bound<PyDict> = schema.get_as_req(intern!(py, "choices"))?;
         let mut lookup_map = Vec::with_capacity(choices.len());
         for (choice_key, choice_schema) in schema_choices {
-            discriminators.push(choice_key.clone());
             let validator = build_validator(&choice_schema, config, definitions)?;
             let tag_repr = choice_key.repr()?.to_string();
             if first {

From fcc77f88dc00a3475f05b5573a3ee844989464c6 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Wed, 19 Jun 2024 11:10:55 -0500
Subject: [PATCH 306/550] Improvements in union matching logic during
 validation (#1332)

---
 src/validators/dataclass.rs        |  14 +-
 src/validators/model.rs            |  12 +-
 src/validators/typed_dict.rs       |   4 +
 src/validators/union.rs            |  54 +++-
 src/validators/validation_state.rs |   6 +
 tests/validators/test_union.py     | 487 ++++++++++++++++++++++++++++-
 6 files changed, 551 insertions(+), 26 deletions(-)

diff --git a/src/validators/dataclass.rs b/src/validators/dataclass.rs
index 4e98538a8..72d738440 100644
--- a/src/validators/dataclass.rs
+++ b/src/validators/dataclass.rs
@@ -154,6 +154,7 @@ impl Validator for DataclassArgsValidator {
         let mut used_keys: AHashSet<&str> = AHashSet::with_capacity(self.fields.len());
 
         let state = &mut state.rebind_extra(|extra| extra.data = Some(output_dict.clone()));
+        let mut fields_set_count: usize = 0;
 
         macro_rules! set_item {
             ($field:ident, $value:expr) => {{
@@ -175,6 +176,7 @@ impl Validator for DataclassArgsValidator {
                     Ok(Some(value)) => {
                         // Default value exists, and passed validation if required
                         set_item!(field, value);
+                        fields_set_count += 1;
                     }
                     Ok(None) | Err(ValError::Omit) => continue,
                     // Note: this will always use the field name even if there is an alias
@@ -214,7 +216,10 @@ impl Validator for DataclassArgsValidator {
                 }
                 // found a positional argument, validate it
                 (Some(pos_value), None) => match field.validator.validate(py, pos_value.borrow_input(), state) {
-                    Ok(value) => set_item!(field, value),
+                    Ok(value) => {
+                        set_item!(field, value);
+                        fields_set_count += 1;
+                    }
                     Err(ValError::LineErrors(line_errors)) => {
                         errors.extend(line_errors.into_iter().map(|err| err.with_outer_location(index)));
                     }
@@ -222,7 +227,10 @@ impl Validator for DataclassArgsValidator {
                 },
                 // found a keyword argument, validate it
                 (None, Some((lookup_path, kw_value))) => match field.validator.validate(py, kw_value, state) {
-                    Ok(value) => set_item!(field, value),
+                    Ok(value) => {
+                        set_item!(field, value);
+                        fields_set_count += 1;
+                    }
                     Err(ValError::LineErrors(line_errors)) => {
                         errors.extend(
                             line_errors
@@ -336,6 +344,8 @@ impl Validator for DataclassArgsValidator {
             }
         }
 
+        state.add_fields_set(fields_set_count);
+
         if errors.is_empty() {
             if let Some(init_only_args) = init_only_args {
                 Ok((output_dict, PyTuple::new_bound(py, init_only_args)).to_object(py))
diff --git a/src/validators/model.rs b/src/validators/model.rs
index 741b6f9f0..fc4ca75d3 100644
--- a/src/validators/model.rs
+++ b/src/validators/model.rs
@@ -204,6 +204,7 @@ impl Validator for ModelValidator {
             for field_name in validated_fields_set {
                 fields_set.add(field_name)?;
             }
+            state.add_fields_set(fields_set.len());
         }
 
         force_setattr(py, model, intern!(py, DUNDER_DICT), validated_dict.to_object(py))?;
@@ -241,10 +242,13 @@ impl ModelValidator {
             } else {
                 PySet::new_bound(py, [&String::from(ROOT_FIELD)])?
             };
-            force_setattr(py, self_instance, intern!(py, DUNDER_FIELDS_SET_KEY), fields_set)?;
+            force_setattr(py, self_instance, intern!(py, DUNDER_FIELDS_SET_KEY), &fields_set)?;
             force_setattr(py, self_instance, intern!(py, ROOT_FIELD), &output)?;
+            state.add_fields_set(fields_set.len());
         } else {
-            let (model_dict, model_extra, fields_set) = output.extract(py)?;
+            let (model_dict, model_extra, fields_set): (Bound<PyAny>, Bound<PyAny>, Bound<PyAny>) =
+                output.extract(py)?;
+            state.add_fields_set(fields_set.len().unwrap_or(0));
             set_model_attrs(self_instance, &model_dict, &model_extra, &fields_set)?;
         }
         self.call_post_init(py, self_instance.clone(), input, state.extra())
@@ -281,11 +285,13 @@ impl ModelValidator {
             } else {
                 PySet::new_bound(py, [&String::from(ROOT_FIELD)])?
             };
-            force_setattr(py, &instance, intern!(py, DUNDER_FIELDS_SET_KEY), fields_set)?;
+            force_setattr(py, &instance, intern!(py, DUNDER_FIELDS_SET_KEY), &fields_set)?;
             force_setattr(py, &instance, intern!(py, ROOT_FIELD), output)?;
+            state.add_fields_set(fields_set.len());
         } else {
             let (model_dict, model_extra, val_fields_set) = output.extract(py)?;
             let fields_set = existing_fields_set.unwrap_or(&val_fields_set);
+            state.add_fields_set(fields_set.len().unwrap_or(0));
             set_model_attrs(&instance, &model_dict, &model_extra, fields_set)?;
         }
         self.call_post_init(py, instance, input, state.extra())
diff --git a/src/validators/typed_dict.rs b/src/validators/typed_dict.rs
index 5aa8a5f00..f72d969a8 100644
--- a/src/validators/typed_dict.rs
+++ b/src/validators/typed_dict.rs
@@ -165,6 +165,7 @@ impl Validator for TypedDictValidator {
 
         {
             let state = &mut state.rebind_extra(|extra| extra.data = Some(output_dict.clone()));
+            let mut fields_set_count: usize = 0;
 
             for field in &self.fields {
                 let op_key_value = match dict.get_item(&field.lookup_key) {
@@ -186,6 +187,7 @@ impl Validator for TypedDictValidator {
                     match field.validator.validate(py, value.borrow_input(), state) {
                         Ok(value) => {
                             output_dict.set_item(&field.name_py, value)?;
+                            fields_set_count += 1;
                         }
                         Err(ValError::Omit) => continue,
                         Err(ValError::LineErrors(line_errors)) => {
@@ -227,6 +229,8 @@ impl Validator for TypedDictValidator {
                     Err(err) => return Err(err),
                 }
             }
+
+            state.add_fields_set(fields_set_count);
         }
 
         if let Some(used_keys) = used_keys {
diff --git a/src/validators/union.rs b/src/validators/union.rs
index 21ebe89e7..6fb9fb070 100644
--- a/src/validators/union.rs
+++ b/src/validators/union.rs
@@ -108,10 +108,12 @@ impl UnionValidator {
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let old_exactness = state.exactness;
+        let old_fields_set_count = state.fields_set_count;
+
         let strict = state.strict_or(self.strict);
         let mut errors = MaybeErrors::new(self.custom_error.as_ref());
 
-        let mut success = None;
+        let mut best_match: Option<(Py<PyAny>, Exactness, Option<usize>)> = None;
 
         for (choice, label) in &self.choices {
             let state = &mut state.rebind_extra(|extra| {
@@ -120,47 +122,67 @@ impl UnionValidator {
                 }
             });
             state.exactness = Some(Exactness::Exact);
+            state.fields_set_count = None;
             let result = choice.validate(py, input, state);
             match result {
-                Ok(new_success) => match state.exactness {
-                    // exact match, return
-                    Some(Exactness::Exact) => {
+                Ok(new_success) => match (state.exactness, state.fields_set_count) {
+                    (Some(Exactness::Exact), None) => {
+                        // exact match with no fields set data, return immediately
                         return {
                             // exact match, return, restore any previous exactness
                             state.exactness = old_exactness;
+                            state.fields_set_count = old_fields_set_count;
                             Ok(new_success)
                         };
                     }
                     _ => {
                         // success should always have an exactness
                         debug_assert_ne!(state.exactness, None);
+
                         let new_exactness = state.exactness.unwrap_or(Exactness::Lax);
-                        // if the new result has higher exactness than the current success, replace it
-                        if success
-                            .as_ref()
-                            .map_or(true, |(_, current_exactness)| *current_exactness < new_exactness)
-                        {
-                            // TODO: is there a possible optimization here, where once there has
-                            // been one success, we turn on strict mode, to avoid unnecessary
-                            // coercions for further validation?
-                            success = Some((new_success, new_exactness));
+                        let new_fields_set_count = state.fields_set_count;
+
+                        // we use both the exactness and the fields_set_count to determine the best union member match
+                        // if fields_set_count is available for the current best match and the new candidate, we use this
+                        // as the primary metric. If the new fields_set_count is greater, the new candidate is better.
+                        // if the fields_set_count is the same, we use the exactness as a tie breaker to determine the best match.
+                        // if the fields_set_count is not available for either the current best match or the new candidate,
+                        // we use the exactness to determine the best match.
+                        let new_success_is_best_match: bool =
+                            best_match
+                                .as_ref()
+                                .map_or(true, |(_, cur_exactness, cur_fields_set_count)| {
+                                    match (*cur_fields_set_count, new_fields_set_count) {
+                                        (Some(cur), Some(new)) if cur != new => cur < new,
+                                        _ => *cur_exactness < new_exactness,
+                                    }
+                                });
+
+                        if new_success_is_best_match {
+                            best_match = Some((new_success, new_exactness, new_fields_set_count));
                         }
                     }
                 },
                 Err(ValError::LineErrors(lines)) => {
                     // if we don't yet know this validation will succeed, record the error
-                    if success.is_none() {
+                    if best_match.is_none() {
                         errors.push(choice, label.as_deref(), lines);
                     }
                 }
                 otherwise => return otherwise,
             }
         }
+
+        // restore previous validation state to prepare for any future validations
         state.exactness = old_exactness;
+        state.fields_set_count = old_fields_set_count;
 
-        if let Some((success, exactness)) = success {
+        if let Some((best_match, exactness, fields_set_count)) = best_match {
             state.floor_exactness(exactness);
-            return Ok(success);
+            if let Some(count) = fields_set_count {
+                state.add_fields_set(count);
+            }
+            return Ok(best_match);
         }
 
         // no matches, build errors
diff --git a/src/validators/validation_state.rs b/src/validators/validation_state.rs
index ef6954618..92edfbbe9 100644
--- a/src/validators/validation_state.rs
+++ b/src/validators/validation_state.rs
@@ -18,6 +18,7 @@ pub enum Exactness {
 pub struct ValidationState<'a, 'py> {
     pub recursion_guard: &'a mut RecursionState,
     pub exactness: Option<Exactness>,
+    pub fields_set_count: Option<usize>,
     // deliberately make Extra readonly
     extra: Extra<'a, 'py>,
 }
@@ -27,6 +28,7 @@ impl<'a, 'py> ValidationState<'a, 'py> {
         Self {
             recursion_guard, // Don't care about exactness unless doing union validation
             exactness: None,
+            fields_set_count: None,
             extra,
         }
     }
@@ -68,6 +70,10 @@ impl<'a, 'py> ValidationState<'a, 'py> {
         }
     }
 
+    pub fn add_fields_set(&mut self, fields_set_count: usize) {
+        *self.fields_set_count.get_or_insert(0) += fields_set_count;
+    }
+
     pub fn cache_str(&self) -> StringCacheMode {
         self.extra.cache_str
     }
diff --git a/tests/validators/test_union.py b/tests/validators/test_union.py
index 332b23257..f2d10f36b 100644
--- a/tests/validators/test_union.py
+++ b/tests/validators/test_union.py
@@ -1,7 +1,8 @@
 from dataclasses import dataclass
 from datetime import date, time
 from enum import Enum, IntEnum
-from typing import Any
+from itertools import permutations
+from typing import Any, List, Optional, Union
 from uuid import UUID
 
 import pytest
@@ -170,13 +171,15 @@ def test_model_a(self, schema_validator: SchemaValidator):
         assert m.b == 'hello'
         assert not hasattr(m, 'c')
 
-    def test_model_b_ignored(self, schema_validator: SchemaValidator):
-        # first choice works, so second choice is not used
+    def test_model_b_preferred(self, schema_validator: SchemaValidator):
+        # Note, this is a different behavior to previous smart union behavior,
+        # where the first match would be preferred. However, we believe is it better
+        # to prefer the match with the greatest number of valid fields set.
         m = schema_validator.validate_python({'a': 1, 'b': 'hello', 'c': 2.0})
-        assert isinstance(m, self.ModelA)
+        assert isinstance(m, self.ModelB)
         assert m.a == 1
         assert m.b == 'hello'
-        assert not hasattr(m, 'c')
+        assert m.c == 2.0
 
     def test_model_b_not_ignored(self, schema_validator: SchemaValidator):
         m1 = self.ModelB()
@@ -803,3 +806,477 @@ class ModelA:
     assert isinstance(m, ModelA)
     assert m.a == 42
     assert validator.validate_python(True) is True
+
+
+def permute_choices(choices: List[core_schema.CoreSchema]) -> List[List[core_schema.CoreSchema]]:
+    return [list(p) for p in permutations(choices)]
+
+
+class TestSmartUnionWithSubclass:
+    class ModelA:
+        a: int
+
+    class ModelB(ModelA):
+        b: int
+
+    model_a_schema = core_schema.model_schema(
+        ModelA, core_schema.model_fields_schema(fields={'a': core_schema.model_field(core_schema.int_schema())})
+    )
+    model_b_schema = core_schema.model_schema(
+        ModelB,
+        core_schema.model_fields_schema(
+            fields={
+                'a': core_schema.model_field(core_schema.int_schema()),
+                'b': core_schema.model_field(core_schema.int_schema()),
+            }
+        ),
+    )
+
+    @pytest.mark.parametrize('choices', permute_choices([model_a_schema, model_b_schema]))
+    def test_more_specific_data_matches_subclass(self, choices) -> None:
+        validator = SchemaValidator(schema=core_schema.union_schema(choices))
+        assert isinstance(validator.validate_python({'a': 1}), self.ModelA)
+        assert isinstance(validator.validate_python({'a': 1, 'b': 2}), self.ModelB)
+
+        assert isinstance(validator.validate_python({'a': 1, 'b': 2}), self.ModelB)
+
+        # confirm that a model that matches in lax mode with 2 fields
+        # is preferred over a model that matches in strict mode with 1 field
+        assert isinstance(validator.validate_python({'a': '1', 'b': '2'}), self.ModelB)
+        assert isinstance(validator.validate_python({'a': '1', 'b': 2}), self.ModelB)
+        assert isinstance(validator.validate_python({'a': 1, 'b': '2'}), self.ModelB)
+
+
+class TestSmartUnionWithDefaults:
+    class ModelA:
+        a: int = 0
+
+    class ModelB:
+        b: int = 0
+
+    model_a_schema = core_schema.model_schema(
+        ModelA,
+        core_schema.model_fields_schema(
+            fields={'a': core_schema.model_field(core_schema.with_default_schema(core_schema.int_schema(), default=0))}
+        ),
+    )
+    model_b_schema = core_schema.model_schema(
+        ModelB,
+        core_schema.model_fields_schema(
+            fields={'b': core_schema.model_field(core_schema.with_default_schema(core_schema.int_schema(), default=0))}
+        ),
+    )
+
+    @pytest.mark.parametrize('choices', permute_choices([model_a_schema, model_b_schema]))
+    def test_fields_set_ensures_best_match(self, choices) -> None:
+        validator = SchemaValidator(schema=core_schema.union_schema(choices))
+        assert isinstance(validator.validate_python({'a': 1}), self.ModelA)
+        assert isinstance(validator.validate_python({'b': 1}), self.ModelB)
+
+        # defaults to leftmost choice if there's a tie
+        assert isinstance(validator.validate_python({}), choices[0]['cls'])
+
+    @pytest.mark.parametrize('choices', permute_choices([model_a_schema, model_b_schema]))
+    def test_optional_union_with_members_having_defaults(self, choices) -> None:
+        class WrapModel:
+            val: Optional[Union[self.ModelA, self.ModelB]] = None
+
+        val = SchemaValidator(
+            core_schema.model_schema(
+                WrapModel,
+                core_schema.model_fields_schema(
+                    fields={
+                        'val': core_schema.model_field(
+                            core_schema.with_default_schema(
+                                core_schema.union_schema(choices),
+                                default=None,
+                            )
+                        )
+                    }
+                ),
+            )
+        )
+
+        assert isinstance(val.validate_python({'val': {'a': 1}}).val, self.ModelA)
+        assert isinstance(val.validate_python({'val': {'b': 1}}).val, self.ModelB)
+        assert val.validate_python({}).val is None
+
+
+def test_dc_smart_union_by_fields_set() -> None:
+    @dataclass
+    class ModelA:
+        x: int
+
+    @dataclass
+    class ModelB(ModelA):
+        y: int
+
+    dc_a_schema = core_schema.dataclass_schema(
+        ModelA,
+        core_schema.dataclass_args_schema('ModelA', [core_schema.dataclass_field('x', core_schema.int_schema())]),
+        ['x'],
+    )
+
+    dc_b_schema = core_schema.dataclass_schema(
+        ModelB,
+        core_schema.dataclass_args_schema(
+            'ModelB',
+            [
+                core_schema.dataclass_field('x', core_schema.int_schema()),
+                core_schema.dataclass_field('y', core_schema.int_schema()),
+            ],
+        ),
+        ['x', 'y'],
+    )
+
+    for choices in permute_choices([dc_a_schema, dc_b_schema]):
+        validator = SchemaValidator(core_schema.union_schema(choices=choices))
+
+        assert isinstance(validator.validate_python({'x': 1}), ModelA)
+        assert isinstance(validator.validate_python({'x': '1'}), ModelA)
+
+        assert isinstance(validator.validate_python({'x': 1, 'y': 2}), ModelB)
+        assert isinstance(validator.validate_python({'x': 1, 'y': '2'}), ModelB)
+        assert isinstance(validator.validate_python({'x': '1', 'y': 2}), ModelB)
+        assert isinstance(validator.validate_python({'x': '1', 'y': '2'}), ModelB)
+
+
+def test_dc_smart_union_with_defaults() -> None:
+    @dataclass
+    class ModelA:
+        a: int = 0
+
+    @dataclass
+    class ModelB:
+        b: int = 0
+
+    dc_a_schema = core_schema.dataclass_schema(
+        ModelA,
+        core_schema.dataclass_args_schema(
+            'ModelA',
+            [
+                core_schema.dataclass_field(
+                    'a', core_schema.with_default_schema(schema=core_schema.int_schema(), default=0)
+                )
+            ],
+        ),
+        ['a'],
+    )
+
+    dc_b_schema = core_schema.dataclass_schema(
+        ModelB,
+        core_schema.dataclass_args_schema(
+            'ModelB',
+            [
+                core_schema.dataclass_field(
+                    'b', core_schema.with_default_schema(schema=core_schema.int_schema(), default=0)
+                )
+            ],
+        ),
+        ['b'],
+    )
+
+    for choices in permute_choices([dc_a_schema, dc_b_schema]):
+        validator = SchemaValidator(core_schema.union_schema(choices=choices))
+
+        assert isinstance(validator.validate_python({'a': 1}), ModelA)
+        assert isinstance(validator.validate_python({'b': 1}), ModelB)
+
+
+def test_td_smart_union_by_fields_set() -> None:
+    td_a_schema = core_schema.typed_dict_schema(
+        fields={'x': core_schema.typed_dict_field(core_schema.int_schema())},
+    )
+
+    td_b_schema = core_schema.typed_dict_schema(
+        fields={
+            'x': core_schema.typed_dict_field(core_schema.int_schema()),
+            'y': core_schema.typed_dict_field(core_schema.int_schema()),
+        },
+    )
+
+    for choices in permute_choices([td_a_schema, td_b_schema]):
+        validator = SchemaValidator(core_schema.union_schema(choices=choices))
+
+        assert set(validator.validate_python({'x': 1}).keys()) == {'x'}
+        assert set(validator.validate_python({'x': '1'}).keys()) == {'x'}
+
+        assert set(validator.validate_python({'x': 1, 'y': 2}).keys()) == {'x', 'y'}
+        assert set(validator.validate_python({'x': 1, 'y': '2'}).keys()) == {'x', 'y'}
+        assert set(validator.validate_python({'x': '1', 'y': 2}).keys()) == {'x', 'y'}
+        assert set(validator.validate_python({'x': '1', 'y': '2'}).keys()) == {'x', 'y'}
+
+
+def test_smart_union_does_nested_model_field_counting() -> None:
+    class SubModelA:
+        x: int = 1
+
+    class SubModelB:
+        y: int = 2
+
+    class ModelA:
+        sub: SubModelA
+
+    class ModelB:
+        sub: SubModelB
+
+    model_a_schema = core_schema.model_schema(
+        ModelA,
+        core_schema.model_fields_schema(
+            fields={
+                'sub': core_schema.model_field(
+                    core_schema.model_schema(
+                        SubModelA,
+                        core_schema.model_fields_schema(
+                            fields={
+                                'x': core_schema.model_field(
+                                    core_schema.with_default_schema(core_schema.int_schema(), default=1)
+                                )
+                            }
+                        ),
+                    )
+                )
+            }
+        ),
+    )
+
+    model_b_schema = core_schema.model_schema(
+        ModelB,
+        core_schema.model_fields_schema(
+            fields={
+                'sub': core_schema.model_field(
+                    core_schema.model_schema(
+                        SubModelB,
+                        core_schema.model_fields_schema(
+                            fields={
+                                'y': core_schema.model_field(
+                                    core_schema.with_default_schema(core_schema.int_schema(), default=2)
+                                )
+                            }
+                        ),
+                    )
+                )
+            }
+        ),
+    )
+
+    for choices in permute_choices([model_a_schema, model_b_schema]):
+        validator = SchemaValidator(core_schema.union_schema(choices=choices))
+
+        assert isinstance(validator.validate_python({'sub': {'x': 1}}), ModelA)
+        assert isinstance(validator.validate_python({'sub': {'y': 3}}), ModelB)
+
+        # defaults to leftmost choice if there's a tie
+        assert isinstance(validator.validate_python({'sub': {}}), choices[0]['cls'])
+
+
+def test_smart_union_does_nested_dataclass_field_counting() -> None:
+    @dataclass
+    class SubModelA:
+        x: int = 1
+
+    @dataclass
+    class SubModelB:
+        y: int = 2
+
+    @dataclass
+    class ModelA:
+        sub: SubModelA
+
+    @dataclass
+    class ModelB:
+        sub: SubModelB
+
+    dc_a_schema = core_schema.dataclass_schema(
+        ModelA,
+        core_schema.dataclass_args_schema(
+            'ModelA',
+            [
+                core_schema.dataclass_field(
+                    'sub',
+                    core_schema.with_default_schema(
+                        core_schema.dataclass_schema(
+                            SubModelA,
+                            core_schema.dataclass_args_schema(
+                                'SubModelA',
+                                [
+                                    core_schema.dataclass_field(
+                                        'x', core_schema.with_default_schema(core_schema.int_schema(), default=1)
+                                    )
+                                ],
+                            ),
+                            ['x'],
+                        ),
+                        default=SubModelA(),
+                    ),
+                )
+            ],
+        ),
+        ['sub'],
+    )
+
+    dc_b_schema = core_schema.dataclass_schema(
+        ModelB,
+        core_schema.dataclass_args_schema(
+            'ModelB',
+            [
+                core_schema.dataclass_field(
+                    'sub',
+                    core_schema.with_default_schema(
+                        core_schema.dataclass_schema(
+                            SubModelB,
+                            core_schema.dataclass_args_schema(
+                                'SubModelB',
+                                [
+                                    core_schema.dataclass_field(
+                                        'y', core_schema.with_default_schema(core_schema.int_schema(), default=2)
+                                    )
+                                ],
+                            ),
+                            ['y'],
+                        ),
+                        default=SubModelB(),
+                    ),
+                )
+            ],
+        ),
+        ['sub'],
+    )
+
+    for choices in permute_choices([dc_a_schema, dc_b_schema]):
+        validator = SchemaValidator(core_schema.union_schema(choices=choices))
+
+        assert isinstance(validator.validate_python({'sub': {'x': 1}}), ModelA)
+        assert isinstance(validator.validate_python({'sub': {'y': 3}}), ModelB)
+
+        # defaults to leftmost choice if there's a tie
+        assert isinstance(validator.validate_python({'sub': {}}), choices[0]['cls'])
+
+
+def test_smart_union_does_nested_typed_dict_field_counting() -> None:
+    td_a_schema = core_schema.typed_dict_schema(
+        fields={
+            'sub': core_schema.typed_dict_field(
+                core_schema.typed_dict_schema(fields={'x': core_schema.typed_dict_field(core_schema.int_schema())})
+            )
+        }
+    )
+
+    td_b_schema = core_schema.typed_dict_schema(
+        fields={
+            'sub': core_schema.typed_dict_field(
+                core_schema.typed_dict_schema(fields={'y': core_schema.typed_dict_field(core_schema.int_schema())})
+            )
+        }
+    )
+
+    for choices in permute_choices([td_a_schema, td_b_schema]):
+        validator = SchemaValidator(core_schema.union_schema(choices=choices))
+
+        assert set(validator.validate_python({'sub': {'x': 1}})['sub'].keys()) == {'x'}
+        assert set(validator.validate_python({'sub': {'y': 2}})['sub'].keys()) == {'y'}
+
+
+def test_nested_unions_bubble_up_field_count() -> None:
+    class SubModelX:
+        x1: int = 0
+        x2: int = 0
+        x3: int = 0
+
+    class SubModelY:
+        x1: int = 0
+        x2: int = 0
+        x3: int = 0
+
+    class SubModelZ:
+        z1: int = 0
+        z2: int = 0
+        z3: int = 0
+
+    class SubModelW:
+        w1: int = 0
+        w2: int = 0
+        w3: int = 0
+
+    class ModelA:
+        a: Union[SubModelX, SubModelY]
+
+    class ModelB:
+        b: Union[SubModelZ, SubModelW]
+
+    model_x_schema = core_schema.model_schema(
+        SubModelX,
+        core_schema.model_fields_schema(
+            fields={
+                'x1': core_schema.model_field(core_schema.with_default_schema(core_schema.int_schema(), default=0)),
+                'x2': core_schema.model_field(core_schema.with_default_schema(core_schema.int_schema(), default=0)),
+                'x3': core_schema.model_field(core_schema.with_default_schema(core_schema.int_schema(), default=0)),
+            }
+        ),
+    )
+
+    model_y_schema = core_schema.model_schema(
+        SubModelY,
+        core_schema.model_fields_schema(
+            fields={
+                'x1': core_schema.model_field(core_schema.with_default_schema(core_schema.int_schema(), default=0)),
+                'x2': core_schema.model_field(core_schema.with_default_schema(core_schema.int_schema(), default=0)),
+                'x3': core_schema.model_field(core_schema.with_default_schema(core_schema.int_schema(), default=0)),
+            }
+        ),
+    )
+
+    model_z_schema = core_schema.model_schema(
+        SubModelZ,
+        core_schema.model_fields_schema(
+            fields={
+                'z1': core_schema.model_field(core_schema.with_default_schema(core_schema.int_schema(), default=0)),
+                'z2': core_schema.model_field(core_schema.with_default_schema(core_schema.int_schema(), default=0)),
+                'z3': core_schema.model_field(core_schema.with_default_schema(core_schema.int_schema(), default=0)),
+            }
+        ),
+    )
+
+    model_w_schema = core_schema.model_schema(
+        SubModelW,
+        core_schema.model_fields_schema(
+            fields={
+                'w1': core_schema.model_field(core_schema.with_default_schema(core_schema.int_schema(), default=0)),
+                'w2': core_schema.model_field(core_schema.with_default_schema(core_schema.int_schema(), default=0)),
+                'w3': core_schema.model_field(core_schema.with_default_schema(core_schema.int_schema(), default=0)),
+            }
+        ),
+    )
+
+    model_a_schema_options = [
+        core_schema.union_schema([model_x_schema, model_y_schema]),
+        core_schema.union_schema([model_y_schema, model_x_schema]),
+    ]
+
+    model_b_schema_options = [
+        core_schema.union_schema([model_z_schema, model_w_schema]),
+        core_schema.union_schema([model_w_schema, model_z_schema]),
+    ]
+
+    for model_a_schema in model_a_schema_options:
+        for model_b_schema in model_b_schema_options:
+            validator = SchemaValidator(
+                core_schema.union_schema(
+                    [
+                        core_schema.model_schema(
+                            ModelA,
+                            core_schema.model_fields_schema(fields={'a': core_schema.model_field(model_a_schema)}),
+                        ),
+                        core_schema.model_schema(
+                            ModelB,
+                            core_schema.model_fields_schema(fields={'b': core_schema.model_field(model_b_schema)}),
+                        ),
+                    ]
+                )
+            )
+
+            result = validator.validate_python(
+                {'a': {'x1': 1, 'x2': 2, 'y1': 1, 'y2': 2}, 'b': {'w1': 1, 'w2': 2, 'w3': 3}}
+            )
+            assert isinstance(result, ModelB)
+            assert isinstance(result.b, SubModelW)

From a65f3272f002c7663c368aa4708ca706547e3bdb Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Thu, 20 Jun 2024 07:12:24 -0500
Subject: [PATCH 307/550] Fix union validation logic when `extra='allow'`
 (#1334)

---
 src/validators/model.rs            |  8 ++---
 src/validators/model_fields.rs     |  3 ++
 src/validators/validation_state.rs |  4 +++
 tests/validators/test_union.py     | 53 ++++++++++++++++++++++++++++++
 4 files changed, 62 insertions(+), 6 deletions(-)

diff --git a/src/validators/model.rs b/src/validators/model.rs
index fc4ca75d3..2c0cef6fd 100644
--- a/src/validators/model.rs
+++ b/src/validators/model.rs
@@ -204,7 +204,6 @@ impl Validator for ModelValidator {
             for field_name in validated_fields_set {
                 fields_set.add(field_name)?;
             }
-            state.add_fields_set(fields_set.len());
         }
 
         force_setattr(py, model, intern!(py, DUNDER_DICT), validated_dict.to_object(py))?;
@@ -244,11 +243,9 @@ impl ModelValidator {
             };
             force_setattr(py, self_instance, intern!(py, DUNDER_FIELDS_SET_KEY), &fields_set)?;
             force_setattr(py, self_instance, intern!(py, ROOT_FIELD), &output)?;
-            state.add_fields_set(fields_set.len());
         } else {
             let (model_dict, model_extra, fields_set): (Bound<PyAny>, Bound<PyAny>, Bound<PyAny>) =
                 output.extract(py)?;
-            state.add_fields_set(fields_set.len().unwrap_or(0));
             set_model_attrs(self_instance, &model_dict, &model_extra, &fields_set)?;
         }
         self.call_post_init(py, self_instance.clone(), input, state.extra())
@@ -287,11 +284,10 @@ impl ModelValidator {
             };
             force_setattr(py, &instance, intern!(py, DUNDER_FIELDS_SET_KEY), &fields_set)?;
             force_setattr(py, &instance, intern!(py, ROOT_FIELD), output)?;
-            state.add_fields_set(fields_set.len());
         } else {
-            let (model_dict, model_extra, val_fields_set) = output.extract(py)?;
+            let (model_dict, model_extra, val_fields_set): (Bound<PyAny>, Bound<PyAny>, Bound<PyAny>) =
+                output.extract(py)?;
             let fields_set = existing_fields_set.unwrap_or(&val_fields_set);
-            state.add_fields_set(fields_set.len().unwrap_or(0));
             set_model_attrs(&instance, &model_dict, &model_extra, fields_set)?;
         }
         self.call_post_init(py, instance, input, state.extra())
diff --git a/src/validators/model_fields.rs b/src/validators/model_fields.rs
index eda76056a..7ecd1d353 100644
--- a/src/validators/model_fields.rs
+++ b/src/validators/model_fields.rs
@@ -150,6 +150,7 @@ impl Validator for ModelFieldsValidator {
         let mut model_extra_dict_op: Option<Bound<PyDict>> = None;
         let mut errors: Vec<ValLineError> = Vec::with_capacity(self.fields.len());
         let mut fields_set_vec: Vec<Py<PyString>> = Vec::with_capacity(self.fields.len());
+        let mut fields_set_count: usize = 0;
 
         // we only care about which keys have been used if we're iterating over the object for extra after
         // the first pass
@@ -184,6 +185,7 @@ impl Validator for ModelFieldsValidator {
                         Ok(value) => {
                             model_dict.set_item(&field.name_py, value)?;
                             fields_set_vec.push(field.name_py.clone_ref(py));
+                            fields_set_count += 1;
                         }
                         Err(ValError::Omit) => continue,
                         Err(ValError::LineErrors(line_errors)) => {
@@ -327,6 +329,7 @@ impl Validator for ModelFieldsValidator {
             Err(ValError::LineErrors(errors))
         } else {
             let fields_set = PySet::new_bound(py, &fields_set_vec)?;
+            state.add_fields_set(fields_set_count);
 
             // if we have extra=allow, but we didn't create a dict because we were validating
             // from attributes, set it now so __pydantic_extra__ is always a dict if extra=allow
diff --git a/src/validators/validation_state.rs b/src/validators/validation_state.rs
index 92edfbbe9..b125cd316 100644
--- a/src/validators/validation_state.rs
+++ b/src/validators/validation_state.rs
@@ -18,6 +18,10 @@ pub enum Exactness {
 pub struct ValidationState<'a, 'py> {
     pub recursion_guard: &'a mut RecursionState,
     pub exactness: Option<Exactness>,
+    // This is used as a tie-breaking mechanism for union validation.
+    // Note: the count of the fields set is not always equivalent to the length of the
+    // `model_fields_set` attached to a model. `model_fields_set` includes extra fields
+    // when extra='allow', whereas this tally does not.
     pub fields_set_count: Option<usize>,
     // deliberately make Extra readonly
     extra: Extra<'a, 'py>,
diff --git a/tests/validators/test_union.py b/tests/validators/test_union.py
index f2d10f36b..7f9b4b424 100644
--- a/tests/validators/test_union.py
+++ b/tests/validators/test_union.py
@@ -1280,3 +1280,56 @@ class ModelB:
             )
             assert isinstance(result, ModelB)
             assert isinstance(result.b, SubModelW)
+
+
+@pytest.mark.parametrize('extra_behavior', ['forbid', 'ignore', 'allow'])
+def test_smart_union_extra_behavior(extra_behavior) -> None:
+    class Foo:
+        foo: str = 'foo'
+
+    class Bar:
+        bar: str = 'bar'
+
+    class Model:
+        x: Union[Foo, Bar]
+
+    validator = SchemaValidator(
+        core_schema.model_schema(
+            Model,
+            core_schema.model_fields_schema(
+                fields={
+                    'x': core_schema.model_field(
+                        core_schema.union_schema(
+                            [
+                                core_schema.model_schema(
+                                    Foo,
+                                    core_schema.model_fields_schema(
+                                        fields={
+                                            'foo': core_schema.model_field(
+                                                core_schema.with_default_schema(core_schema.str_schema(), default='foo')
+                                            )
+                                        }
+                                    ),
+                                    extra_behavior=extra_behavior,
+                                ),
+                                core_schema.model_schema(
+                                    Bar,
+                                    core_schema.model_fields_schema(
+                                        fields={
+                                            'bar': core_schema.model_field(
+                                                core_schema.with_default_schema(core_schema.str_schema(), default='bar')
+                                            )
+                                        }
+                                    ),
+                                    extra_behavior=extra_behavior,
+                                ),
+                            ]
+                        )
+                    )
+                }
+            ),
+        )
+    )
+
+    assert isinstance(validator.validate_python({'x': {'foo': 'foo'}}).x, Foo)
+    assert isinstance(validator.validate_python({'x': {'bar': 'bar'}}).x, Bar)

From aba682ee7a60f377fa79215744c153e155f57fa9 Mon Sep 17 00:00:00 2001
From: Yurii Karabas <1998uriyyo@gmail.com>
Date: Mon, 24 Jun 2024 17:59:35 +0300
Subject: [PATCH 308/550] Add list fail-fast config option (#1322)

---
 python/pydantic_core/core_schema.py | 16 ++++++++
 src/input/return_enums.rs           |  8 ++++
 src/validators/frozenset.rs         |  4 ++
 src/validators/list.rs              |  5 +++
 src/validators/set.rs               |  5 +++
 src/validators/tuple.rs             | 25 +++++++++++++
 tests/validators/test_frozenset.py  | 47 ++++++++++++++++++++++-
 tests/validators/test_list.py       | 45 ++++++++++++++++++++++
 tests/validators/test_set.py        | 44 ++++++++++++++++++++++
 tests/validators/test_tuple.py      | 58 ++++++++++++++++++++++++++++-
 10 files changed, 254 insertions(+), 3 deletions(-)

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index 2c66f8702..5405d96b2 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -1399,6 +1399,7 @@ class ListSchema(TypedDict, total=False):
     items_schema: CoreSchema
     min_length: int
     max_length: int
+    fail_fast: bool
     strict: bool
     ref: str
     metadata: Any
@@ -1410,6 +1411,7 @@ def list_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: Any = None,
@@ -1430,6 +1432,7 @@ def list_schema(
         items_schema: The value must be a list of items that match this schema
         min_length: The value must be a list with at least this many items
         max_length: The value must be a list with at most this many items
+        fail_fast: Stop validation on the first error
         strict: The value must be a list with exactly this many items
         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
@@ -1440,6 +1443,7 @@ def list_schema(
         items_schema=items_schema,
         min_length=min_length,
         max_length=max_length,
+        fail_fast=fail_fast,
         strict=strict,
         ref=ref,
         metadata=metadata,
@@ -1547,6 +1551,7 @@ class TupleSchema(TypedDict, total=False):
     variadic_item_index: int
     min_length: int
     max_length: int
+    fail_fast: bool
     strict: bool
     ref: str
     metadata: Any
@@ -1559,6 +1564,7 @@ def tuple_schema(
     variadic_item_index: int | None = None,
     min_length: int | None = None,
     max_length: int | None = None,
+    fail_fast: bool | None = None,
     strict: bool | None = None,
     ref: str | None = None,
     metadata: Any = None,
@@ -1583,6 +1589,7 @@ def tuple_schema(
         variadic_item_index: The index of the schema in `items_schema` to be treated as variadic (following PEP 646)
         min_length: The value must be a tuple with at least this many items
         max_length: The value must be a tuple with at most this many items
+        fail_fast: Stop validation on the first error
         strict: The value must be a tuple with exactly this many items
         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
@@ -1594,6 +1601,7 @@ def tuple_schema(
         variadic_item_index=variadic_item_index,
         min_length=min_length,
         max_length=max_length,
+        fail_fast=fail_fast,
         strict=strict,
         ref=ref,
         metadata=metadata,
@@ -1606,6 +1614,7 @@ class SetSchema(TypedDict, total=False):
     items_schema: CoreSchema
     min_length: int
     max_length: int
+    fail_fast: bool
     strict: bool
     ref: str
     metadata: Any
@@ -1617,6 +1626,7 @@ def set_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: Any = None,
@@ -1639,6 +1649,7 @@ def set_schema(
         items_schema: The value must be a set with items that match this schema
         min_length: The value must be a set with at least this many items
         max_length: The value must be a set with at most this many items
+        fail_fast: Stop validation on the first error
         strict: The value must be a set with exactly this many items
         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
@@ -1649,6 +1660,7 @@ def set_schema(
         items_schema=items_schema,
         min_length=min_length,
         max_length=max_length,
+        fail_fast=fail_fast,
         strict=strict,
         ref=ref,
         metadata=metadata,
@@ -1661,6 +1673,7 @@ class FrozenSetSchema(TypedDict, total=False):
     items_schema: CoreSchema
     min_length: int
     max_length: int
+    fail_fast: bool
     strict: bool
     ref: str
     metadata: Any
@@ -1672,6 +1685,7 @@ def frozenset_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: Any = None,
@@ -1694,6 +1708,7 @@ def frozenset_schema(
         items_schema: The value must be a frozenset with items that match this schema
         min_length: The value must be a frozenset with at least this many items
         max_length: The value must be a frozenset with at most this many items
+        fail_fast: Stop validation on the first error
         strict: The value must be a frozenset with exactly this many items
         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
@@ -1704,6 +1719,7 @@ def frozenset_schema(
         items_schema=items_schema,
         min_length=min_length,
         max_length=max_length,
+        fail_fast=fail_fast,
         strict=strict,
         ref=ref,
         metadata=metadata,
diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index 22faaba71..bbd1b6404 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -124,6 +124,7 @@ pub(crate) fn validate_iter_to_vec<'py>(
     mut max_length_check: MaxLengthCheck<'_, impl Input<'py> + ?Sized>,
     validator: &CombinedValidator,
     state: &mut ValidationState<'_, 'py>,
+    fail_fast: bool,
 ) -> ValResult<Vec<PyObject>> {
     let mut output: Vec<PyObject> = Vec::with_capacity(capacity);
     let mut errors: Vec<ValLineError> = Vec::new();
@@ -137,6 +138,9 @@ pub(crate) fn validate_iter_to_vec<'py>(
             Err(ValError::LineErrors(line_errors)) => {
                 max_length_check.incr()?;
                 errors.extend(line_errors.into_iter().map(|err| err.with_outer_location(index)));
+                if fail_fast {
+                    break;
+                }
             }
             Err(ValError::Omit) => (),
             Err(err) => return Err(err),
@@ -190,6 +194,7 @@ pub(crate) fn validate_iter_to_set<'py>(
     max_length: Option<usize>,
     validator: &CombinedValidator,
     state: &mut ValidationState<'_, 'py>,
+    fail_fast: bool,
 ) -> ValResult<()> {
     let mut errors: Vec<ValLineError> = Vec::new();
     for (index, item_result) in iter.enumerate() {
@@ -220,6 +225,9 @@ pub(crate) fn validate_iter_to_set<'py>(
             Err(ValError::Omit) => (),
             Err(err) => return Err(err),
         }
+        if fail_fast && !errors.is_empty() {
+            break;
+        }
     }
 
     if errors.is_empty() {
diff --git a/src/validators/frozenset.rs b/src/validators/frozenset.rs
index fcb7ffe7c..60fe451a7 100644
--- a/src/validators/frozenset.rs
+++ b/src/validators/frozenset.rs
@@ -17,6 +17,7 @@ pub struct FrozenSetValidator {
     min_length: Option<usize>,
     max_length: Option<usize>,
     name: String,
+    fail_fast: bool,
 }
 
 impl BuildValidator for FrozenSetValidator {
@@ -42,6 +43,7 @@ impl Validator for FrozenSetValidator {
             max_length: self.max_length,
             item_validator: &self.item_validator,
             state,
+            fail_fast: self.fail_fast,
         })??;
         min_length_check!(input, "Frozenset", self.min_length, f_set);
         Ok(f_set.into_py(py))
@@ -59,6 +61,7 @@ struct ValidateToFrozenSet<'a, 's, 'py, I: Input<'py> + ?Sized> {
     max_length: Option<usize>,
     item_validator: &'a CombinedValidator,
     state: &'a mut ValidationState<'s, 'py>,
+    fail_fast: bool,
 }
 
 impl<'py, T, I> ConsumeIterator<PyResult<T>> for ValidateToFrozenSet<'_, '_, 'py, I>
@@ -77,6 +80,7 @@ where
             self.max_length,
             self.item_validator,
             self.state,
+            self.fail_fast,
         )
     }
 }
diff --git a/src/validators/list.rs b/src/validators/list.rs
index 21825ca54..87600fb81 100644
--- a/src/validators/list.rs
+++ b/src/validators/list.rs
@@ -18,6 +18,7 @@ pub struct ListValidator {
     min_length: Option<usize>,
     max_length: Option<usize>,
     name: OnceLock<String>,
+    fail_fast: bool,
 }
 
 pub fn get_items_schema(
@@ -109,6 +110,7 @@ impl BuildValidator for ListValidator {
             min_length: schema.get_as(pyo3::intern!(py, "min_length"))?,
             max_length: schema.get_as(pyo3::intern!(py, "max_length"))?,
             name: OnceLock::new(),
+            fail_fast: schema.get_as(pyo3::intern!(py, "fail_fast"))?.unwrap_or(false),
         }
         .into())
     }
@@ -135,6 +137,7 @@ impl Validator for ListValidator {
                 field_type: "List",
                 item_validator: v,
                 state,
+                fail_fast: self.fail_fast,
             })??,
             None => {
                 if let Some(py_list) = seq.as_py_list() {
@@ -184,6 +187,7 @@ struct ValidateToVec<'a, 's, 'py, I: Input<'py> + ?Sized> {
     field_type: &'static str,
     item_validator: &'a CombinedValidator,
     state: &'a mut ValidationState<'s, 'py>,
+    fail_fast: bool,
 }
 
 // pretty arbitrary default capacity when creating vecs from iteration
@@ -204,6 +208,7 @@ where
             max_length_check,
             self.item_validator,
             self.state,
+            self.fail_fast,
         )
     }
 }
diff --git a/src/validators/set.rs b/src/validators/set.rs
index 3ebd2e40b..281cfc37d 100644
--- a/src/validators/set.rs
+++ b/src/validators/set.rs
@@ -15,6 +15,7 @@ pub struct SetValidator {
     min_length: Option<usize>,
     max_length: Option<usize>,
     name: String,
+    fail_fast: bool,
 }
 
 macro_rules! set_build {
@@ -42,6 +43,7 @@ macro_rules! set_build {
                 min_length: schema.get_as(pyo3::intern!(py, "min_length"))?,
                 max_length,
                 name,
+                fail_fast: schema.get_as(pyo3::intern!(py, "fail_fast"))?.unwrap_or(false),
             }
             .into())
         }
@@ -72,6 +74,7 @@ impl Validator for SetValidator {
             max_length: self.max_length,
             item_validator: &self.item_validator,
             state,
+            fail_fast: self.fail_fast,
         })??;
         min_length_check!(input, "Set", self.min_length, set);
         Ok(set.into_py(py))
@@ -89,6 +92,7 @@ struct ValidateToSet<'a, 's, 'py, I: Input<'py> + ?Sized> {
     max_length: Option<usize>,
     item_validator: &'a CombinedValidator,
     state: &'a mut ValidationState<'s, 'py>,
+    fail_fast: bool,
 }
 
 impl<'py, T, I> ConsumeIterator<PyResult<T>> for ValidateToSet<'_, '_, 'py, I>
@@ -107,6 +111,7 @@ where
             self.max_length,
             self.item_validator,
             self.state,
+            self.fail_fast,
         )
     }
 }
diff --git a/src/validators/tuple.rs b/src/validators/tuple.rs
index 3c5adb186..8acbf2beb 100644
--- a/src/validators/tuple.rs
+++ b/src/validators/tuple.rs
@@ -19,6 +19,7 @@ pub struct TupleValidator {
     min_length: Option<usize>,
     max_length: Option<usize>,
     name: String,
+    fail_fast: bool,
 }
 
 impl BuildValidator for TupleValidator {
@@ -50,6 +51,7 @@ impl BuildValidator for TupleValidator {
             min_length: schema.get_as(intern!(py, "min_length"))?,
             max_length: schema.get_as(intern!(py, "max_length"))?,
             name,
+            fail_fast: schema.get_as(intern!(py, "fail_fast"))?.unwrap_or(false),
         }
         .into())
     }
@@ -69,6 +71,7 @@ impl TupleValidator {
         item_validators: &[CombinedValidator],
         collection_iter: &mut NextCountingIterator<impl Iterator<Item = I>>,
         actual_length: Option<usize>,
+        fail_fast: bool,
     ) -> ValResult<()> {
         // Validate the head:
         for validator in item_validators {
@@ -90,6 +93,9 @@ impl TupleValidator {
                     }
                 }
             }
+            if fail_fast && !errors.is_empty() {
+                return Ok(());
+            }
         }
 
         Ok(())
@@ -128,8 +134,13 @@ impl TupleValidator {
                 head_validators,
                 collection_iter,
                 actual_length,
+                self.fail_fast,
             )?;
 
+            if self.fail_fast && !errors.is_empty() {
+                return Ok(output);
+            }
+
             let n_tail_validators = tail_validators.len();
             if n_tail_validators == 0 {
                 for (index, input_item) in collection_iter {
@@ -141,6 +152,10 @@ impl TupleValidator {
                         Err(ValError::Omit) => (),
                         Err(err) => return Err(err),
                     }
+
+                    if self.fail_fast && !errors.is_empty() {
+                        return Ok(output);
+                    }
                 }
             } else {
                 // Populate a buffer with the first n_tail_validators items
@@ -172,6 +187,10 @@ impl TupleValidator {
                         Err(ValError::Omit) => (),
                         Err(err) => return Err(err),
                     }
+
+                    if self.fail_fast && !errors.is_empty() {
+                        return Ok(output);
+                    }
                 }
 
                 // Validate the buffered items using the tail validators
@@ -184,6 +203,7 @@ impl TupleValidator {
                     tail_validators,
                     &mut NextCountingIterator::new(tail_buffer.into_iter(), index),
                     actual_length,
+                    self.fail_fast,
                 )?;
             }
         } else {
@@ -197,8 +217,13 @@ impl TupleValidator {
                 &self.validators,
                 collection_iter,
                 actual_length,
+                self.fail_fast,
             )?;
 
+            if self.fail_fast && !errors.is_empty() {
+                return Ok(output);
+            }
+
             // Generate an error if there are any extra items:
             if collection_iter.next().is_some() {
                 return Err(ValError::new(
diff --git a/tests/validators/test_frozenset.py b/tests/validators/test_frozenset.py
index 407e0a579..e8ddbfc3b 100644
--- a/tests/validators/test_frozenset.py
+++ b/tests/validators/test_frozenset.py
@@ -248,7 +248,8 @@ def test_repr():
         'title="frozenset[any]",'
         'validator=FrozenSet(FrozenSetValidator{'
         'strict:true,item_validator:Any(AnyValidator),min_length:Some(42),max_length:None,'
-        'name:"frozenset[any]"'
+        'name:"frozenset[any]",'
+        'fail_fast:false'
         '}),'
         'definitions=[],'
         'cache_strings=True)'
@@ -296,3 +297,47 @@ def test_frozenset_from_dict_items(input_value, items_schema, expected):
     output = v.validate_python(input_value)
     assert isinstance(output, frozenset)
     assert output == expected
+
+
+@pytest.mark.parametrize(
+    'fail_fast,expected',
+    [
+        pytest.param(
+            True,
+            [
+                {
+                    'type': 'int_parsing',
+                    'loc': (1,),
+                    'msg': 'Input should be a valid integer, unable to parse string as an integer',
+                    'input': 'not-num',
+                },
+            ],
+            id='fail_fast',
+        ),
+        pytest.param(
+            False,
+            [
+                {
+                    'type': 'int_parsing',
+                    'loc': (1,),
+                    'msg': 'Input should be a valid integer, unable to parse string as an integer',
+                    'input': 'not-num',
+                },
+                {
+                    'type': 'int_parsing',
+                    'loc': (2,),
+                    'msg': 'Input should be a valid integer, unable to parse string as an integer',
+                    'input': 'again',
+                },
+            ],
+            id='not_fail_fast',
+        ),
+    ],
+)
+def test_frozenset_fail_fast(fail_fast, expected):
+    v = SchemaValidator({'type': 'frozenset', 'items_schema': {'type': 'int'}, 'fail_fast': fail_fast})
+
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_python([1, 'not-num', 'again'])
+
+    assert exc_info.value.errors(include_url=False) == expected
diff --git a/tests/validators/test_list.py b/tests/validators/test_list.py
index 9f7d8738f..b8bcee8ec 100644
--- a/tests/validators/test_list.py
+++ b/tests/validators/test_list.py
@@ -397,6 +397,51 @@ def f(v: int) -> int:
     )
 
 
+@pytest.mark.parametrize(
+    'fail_fast,expected',
+    [
+        pytest.param(
+            True,
+            [
+                {
+                    'type': 'int_parsing',
+                    'loc': (1,),
+                    'msg': 'Input should be a valid integer, unable to parse string as an integer',
+                    'input': 'not-num',
+                }
+            ],
+            id='fail_fast',
+        ),
+        pytest.param(
+            False,
+            [
+                {
+                    'type': 'int_parsing',
+                    'loc': (1,),
+                    'msg': 'Input should be a valid integer, unable to parse string as an integer',
+                    'input': 'not-num',
+                },
+                {
+                    'type': 'int_parsing',
+                    'loc': (2,),
+                    'msg': 'Input should be a valid integer, unable to parse string as an integer',
+                    'input': 'again',
+                },
+            ],
+            id='not_fail_fast',
+        ),
+    ],
+)
+def test_list_fail_fast(fail_fast, expected):
+    s = core_schema.list_schema(core_schema.int_schema(), fail_fast=fail_fast)
+    v = SchemaValidator(s)
+
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_python([1, 'not-num', 'again'])
+
+    assert exc_info.value.errors(include_url=False) == expected
+
+
 class MySequence(collections.abc.Sequence):
     def __init__(self, data: List[Any]):
         self._data = data
diff --git a/tests/validators/test_set.py b/tests/validators/test_set.py
index e58cedff8..3c044658c 100644
--- a/tests/validators/test_set.py
+++ b/tests/validators/test_set.py
@@ -277,3 +277,47 @@ def test_set_any(input_value, expected):
     output = v.validate_python(input_value)
     assert output == expected
     assert isinstance(output, set)
+
+
+@pytest.mark.parametrize(
+    'fail_fast,expected',
+    [
+        pytest.param(
+            True,
+            [
+                {
+                    'type': 'int_parsing',
+                    'loc': (1,),
+                    'msg': 'Input should be a valid integer, unable to parse string as an integer',
+                    'input': 'not-num',
+                },
+            ],
+            id='fail_fast',
+        ),
+        pytest.param(
+            False,
+            [
+                {
+                    'type': 'int_parsing',
+                    'loc': (1,),
+                    'msg': 'Input should be a valid integer, unable to parse string as an integer',
+                    'input': 'not-num',
+                },
+                {
+                    'type': 'int_parsing',
+                    'loc': (2,),
+                    'msg': 'Input should be a valid integer, unable to parse string as an integer',
+                    'input': 'again',
+                },
+            ],
+            id='not_fail_fast',
+        ),
+    ],
+)
+def test_set_fail_fast(fail_fast, expected):
+    v = SchemaValidator({'type': 'set', 'items_schema': {'type': 'int'}, 'fail_fast': fail_fast})
+
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_python([1, 'not-num', 'again'])
+
+    assert exc_info.value.errors(include_url=False) == expected
diff --git a/tests/validators/test_tuple.py b/tests/validators/test_tuple.py
index a3d548ced..d25ef9547 100644
--- a/tests/validators/test_tuple.py
+++ b/tests/validators/test_tuple.py
@@ -58,8 +58,9 @@ def test_tuple_strict_passes_with_tuple(variadic_item_index, items, input_value,
     assert v.validate_python(input_value) == expected
 
 
-def test_empty_positional_tuple():
-    v = SchemaValidator({'type': 'tuple', 'items_schema': []})
+@pytest.mark.parametrize('fail_fast', [True, False])
+def test_empty_positional_tuple(fail_fast):
+    v = SchemaValidator({'type': 'tuple', 'items_schema': [], 'fail_fast': fail_fast})
     assert v.validate_python(()) == ()
     assert v.validate_python([]) == ()
     with pytest.raises(ValidationError) as exc_info:
@@ -493,3 +494,56 @@ def test_length_constraints_omit(input_value, expected):
             v.validate_python(input_value)
     else:
         assert v.validate_python(input_value) == expected
+
+
+@pytest.mark.parametrize(
+    'fail_fast,expected',
+    [
+        pytest.param(
+            True,
+            [
+                {
+                    'type': 'int_parsing',
+                    'loc': (1,),
+                    'msg': 'Input should be a valid integer, unable to parse string as an integer',
+                    'input': 'not-num',
+                }
+            ],
+            id='fail_fast',
+        ),
+        pytest.param(
+            False,
+            [
+                {
+                    'type': 'int_parsing',
+                    'loc': (1,),
+                    'msg': 'Input should be a valid integer, unable to parse string as an integer',
+                    'input': 'not-num',
+                },
+                {
+                    'type': 'float_parsing',
+                    'loc': (2,),
+                    'msg': 'Input should be a valid number, unable to parse string as a number',
+                    'input': 'again',
+                },
+            ],
+            id='not_fail_fast',
+        ),
+    ],
+)
+def test_tuple_fail_fast(fail_fast, expected):
+    s = core_schema.tuple_schema(
+        [
+            core_schema.str_schema(),
+            core_schema.int_schema(),
+            core_schema.float_schema(),
+        ],
+        variadic_item_index=None,
+        fail_fast=fail_fast,
+    )
+    v = SchemaValidator(s)
+
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_python(['str', 'not-num', 'again'])
+
+    assert exc_info.value.errors(include_url=False) == expected

From ef7f81c63dc8dbca0b18689787bd67c553d316bd Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Mon, 24 Jun 2024 23:31:57 +0100
Subject: [PATCH 309/550] update to PyO3 0.22, add 3.13 support (#1340)

---
 .github/workflows/ci.yml                      |  33 +-
 Cargo.lock                                    | 289 ++++++------------
 Cargo.toml                                    |  12 +-
 pyproject.toml                                |   1 +
 src/argument_markers.rs                       |   1 +
 src/errors/types.rs                           |   4 +-
 src/errors/value_exception.rs                 |  10 +-
 src/input/input_python.rs                     |   7 +-
 src/input/return_enums.rs                     |   8 +-
 src/lookup_key.rs                             |   2 +-
 src/serializers/errors.rs                     |   1 +
 src/serializers/extra.rs                      |   4 +-
 src/serializers/mod.rs                        |   1 +
 src/serializers/type_serializers/dataclass.rs |   6 +-
 src/serializers/type_serializers/function.rs  |   1 +
 src/validators/dataclass.rs                   |  10 +-
 src/validators/datetime.rs                    |   4 +-
 src/validators/decimal.rs                     |   3 +-
 src/validators/enum_.rs                       |   5 +-
 src/validators/function.rs                    |   6 +-
 src/validators/is_instance.rs                 |   2 +-
 src/validators/is_subclass.rs                 |   2 +-
 src/validators/mod.rs                         |   1 +
 src/validators/url.rs                         |   2 +-
 src/validators/uuid.rs                        |   5 +-
 tests/validators/test_string.py               |   4 +-
 26 files changed, 173 insertions(+), 251 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index c8bb82805..6b7be62c7 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -68,6 +68,7 @@ jobs:
           - '3.10'
           - '3.11'
           - '3.12'
+          - '3.13'
           - 'pypy3.9'
           - 'pypy3.10'
 
@@ -88,6 +89,7 @@ jobs:
         uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.python-version }}
+          allow-prereleases: true
 
       - run: pip install -r tests/requirements.txt
 
@@ -411,15 +413,15 @@ jobs:
           - os: linux
             manylinux: auto
             target: armv7
-            interpreter: 3.8 3.9 3.10 3.11 3.12
+            interpreter: 3.8 3.9 3.10 3.11 3.12 3.13
           - os: linux
             manylinux: auto
             target: ppc64le
-            interpreter: 3.8 3.9 3.10 3.11 3.12
+            interpreter: 3.8 3.9 3.10 3.11 3.12 3.13
           - os: linux
             manylinux: auto
             target: s390x
-            interpreter: 3.8 3.9 3.10 3.11 3.12
+            interpreter: 3.8 3.9 3.10 3.11 3.12 3.13
           - os: linux
             manylinux: auto
             target: x86_64
@@ -436,27 +438,33 @@ jobs:
           # macos;
           # all versions x86_64
           # arm pypy and older pythons which can't be run on the arm hardware for PGO
+          #
+          # FIXME https://github.com/PyO3/maturin-action/issues/275
+          # cffi prevents `maturin-action` working on macOS 3.13 for now for the optimized build
           - os: macos
             target: x86_64
           - os: macos
             target: aarch64
-            interpreter: 3.8 3.9 pypy3.9 pypy3.10
+            interpreter: 3.8 3.9 pypy3.9 pypy3.10 # 3.13
 
           # windows;
           # x86_64 pypy builds are not PGO optimized
           # i686 not supported by pypy
           # aarch64 only 3.11 and up, also not PGO optimized
+          #
+          # FIXME https://github.com/PyO3/maturin-action/issues/275
+          # cffi prevents `maturin-action` working on Windows 3.13 for now for the optimized build
           - os: windows
             target: x86_64
-            interpreter: pypy3.9 pypy3.10
+            interpreter: pypy3.9 pypy3.10 3.13
           - os: windows
             target: i686
             python-architecture: x86
-            interpreter: 3.8 3.9 3.10 3.11 3.12
+            interpreter: 3.8 3.9 3.10 3.11 3.12 3.13
           # FIXME aarch64 builds broken, see https://github.com/PyO3/maturin/issues/2110
           # - os: windows
           #   target: aarch64
-          #   interpreter: 3.11 3.12
+          #   interpreter: 3.11 3.12 3.13
 
         exclude:
           # See above; disabled for now.
@@ -483,7 +491,7 @@ jobs:
         with:
           target: ${{ matrix.target }}
           manylinux: ${{ matrix.manylinux }}
-          args: --release --out dist --interpreter ${{ matrix.interpreter || '3.8 3.9 3.10 3.11 3.12 pypy3.9 pypy3.10' }}
+          args: --release --out dist --interpreter ${{ matrix.interpreter || '3.8 3.9 3.10 3.11 3.12 3.13 pypy3.9 pypy3.10' }}
           rust-toolchain: stable
           docker-options: -e CI
 
@@ -504,7 +512,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [linux, windows, macos]
-        interpreter: ['3.8', '3.9', '3.10', '3.11', '3.12']
+        interpreter: ['3.8', '3.9', '3.10', '3.11', '3.12', '3.13']
         include:
           # standard runners with override for macos arm
           - os: linux
@@ -520,6 +528,12 @@ jobs:
             interpreter: '3.8'
           - os: macos
             interpreter: '3.9'
+          # https://github.com/PyO3/maturin-action/issues/275
+          # cffi prevents `maturin-action` working on Windows & macOS 3.13 for now
+          - os: windows
+            interpreter: '3.13'
+          - os: macos
+            interpreter: '3.13'
 
     runs-on: ${{ matrix.runs-on }}
     steps:
@@ -529,6 +543,7 @@ jobs:
         uses: actions/setup-python@v5
         with:
           python-version: ${{ matrix.interpreter }}
+          allow-prereleases: true
 
       - name: install rust stable
         id: rust-toolchain
diff --git a/Cargo.lock b/Cargo.lock
index c4f6d67e0..cdcde2cd6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -4,9 +4,9 @@ version = 3
 
 [[package]]
 name = "ahash"
-version = "0.8.10"
+version = "0.8.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8b79b82693f705137f8fb9b37871d99e4f9a7df12b917eed79c3d3954830a60b"
+checksum = "e89da841a80418a9b391ebaea17f5c112ffaaa96f621d2c285b5174da76b9011"
 dependencies = [
  "cfg-if",
  "getrandom",
@@ -17,18 +17,18 @@ dependencies = [
 
 [[package]]
 name = "aho-corasick"
-version = "1.0.2"
+version = "1.1.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43f6cb1bf222025340178f382c426f13757b2960e89779dfcb319c32542a5a41"
+checksum = "8e60d3430d3a69478ad0993f19238d2df97c507009a52b3c10addcd7f6bcb916"
 dependencies = [
  "memchr",
 ]
 
 [[package]]
 name = "autocfg"
-version = "1.1.0"
+version = "1.3.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d468802bab17cbc0cc575e9b053f41e72aa36bfa6b7f55e3529ffa43161b97fa"
+checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0"
 
 [[package]]
 name = "base64"
@@ -36,12 +36,6 @@ version = "0.21.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
 
-[[package]]
-name = "bitflags"
-version = "1.3.2"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bef38d45163c2f1dde094a7dfd33ccf595c92905c8f8f4fdc18d06fb1037718a"
-
 [[package]]
 name = "bitvec"
 version = "1.0.1"
@@ -56,9 +50,9 @@ dependencies = [
 
 [[package]]
 name = "cc"
-version = "1.0.79"
+version = "1.0.100"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "50d30906286121d95be3d479533b458f87493b30a4b5f79a607db8f5d11aa91f"
+checksum = "c891175c3fb232128f48de6590095e59198bbeb8620c310be349bfc3afd12c7b"
 
 [[package]]
 name = "cfg-if"
@@ -101,9 +95,9 @@ checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
 
 [[package]]
 name = "getrandom"
-version = "0.2.10"
+version = "0.2.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "be4136b2a15dd319360be1c07d9933517ccf0be8f16bf62a3bee4f0d618df427"
+checksum = "c4567c8db10ae91089c99af84c68c38da3ec2f087c3f82960bcdbf3656b6f4d7"
 dependencies = [
  "cfg-if",
  "libc",
@@ -112,9 +106,9 @@ dependencies = [
 
 [[package]]
 name = "hashbrown"
-version = "0.14.3"
+version = "0.14.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "290f1a1d9242c78d09ce40a5e87e7554ee637af1351968159f4952f028f75604"
+checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
 
 [[package]]
 name = "heck"
@@ -122,6 +116,12 @@ version = "0.4.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
 
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
 [[package]]
 name = "idna"
 version = "0.5.0"
@@ -134,9 +134,9 @@ dependencies = [
 
 [[package]]
 name = "indexmap"
-version = "2.2.2"
+version = "2.2.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "824b2ae422412366ba479e8111fd301f7b5faece8149317bb81925979a53f520"
+checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26"
 dependencies = [
  "equivalent",
  "hashbrown",
@@ -144,21 +144,21 @@ dependencies = [
 
 [[package]]
 name = "indoc"
-version = "2.0.4"
+version = "2.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e186cfbae8084e513daff4240b4797e342f988cecda4fb6c939150f96315fd8"
+checksum = "b248f5224d1d606005e02c97f5aa4e88eeb230488bcc03bc9ca4d7991399f2b5"
 
 [[package]]
 name = "itoa"
-version = "1.0.8"
+version = "1.0.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "62b02a5381cc465bd3041d84623d0fa3b66738b52b8e2fc3bab8ad63ab032f4a"
+checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
 
 [[package]]
 name = "jiter"
-version = "0.4.1"
+version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "abbbbe1bad457e3cd5503af716aedc735e849505a0d2172c55a753ae1b127458"
+checksum = "02e23549143ef50eddffd46ba8cd0229b0a4500aef7518cf2eb0f41c9a09d22b"
 dependencies = [
  "ahash",
  "bitvec",
@@ -206,89 +206,54 @@ version = "0.2.155"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"
 
-[[package]]
-name = "lock_api"
-version = "0.4.10"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c1cc9717a20b1bb222f333e6a92fd32f7d8a18ddc5a3191a11af45dcbf4dcd16"
-dependencies = [
- "autocfg",
- "scopeguard",
-]
-
 [[package]]
 name = "memchr"
-version = "2.6.3"
+version = "2.7.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8f232d6ef707e1956a43342693d2a31e72989554d58299d7a88738cc95b0d35c"
+checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
 
 [[package]]
 name = "memoffset"
-version = "0.9.0"
+version = "0.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a634b1c61a95585bd15607c6ab0c4e5b226e695ff2800ba0cdccddf208c406c"
+checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
 dependencies = [
  "autocfg",
 ]
 
 [[package]]
 name = "num-bigint"
-version = "0.4.4"
+version = "0.4.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "608e7659b5c3d7cba262d894801b9ec9d00de989e8a82bd4bef91d08da45cdc0"
+checksum = "c165a9ab64cf766f73521c0dd2cfdff64f488b8f0b3e621face3462d3db536d7"
 dependencies = [
- "autocfg",
  "num-integer",
  "num-traits",
 ]
 
 [[package]]
 name = "num-integer"
-version = "0.1.45"
+version = "0.1.46"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "225d3389fb3509a24c93f5c29eb6bde2586b98d9f016636dff58d7c6f7569cd9"
+checksum = "7969661fd2958a5cb096e56c8e1ad0444ac2bbcd0061bd28660485a44879858f"
 dependencies = [
- "autocfg",
  "num-traits",
 ]
 
 [[package]]
 name = "num-traits"
-version = "0.2.16"
+version = "0.2.19"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f30b0abd723be7e2ffca1272140fac1a2f084c77ec3e123c192b66af1ee9e6c2"
+checksum = "071dfc062690e90b734c0b2273ce72ad0ffa95f0c74596bc250dcfd960262841"
 dependencies = [
  "autocfg",
 ]
 
 [[package]]
 name = "once_cell"
-version = "1.18.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd8b5dd2ae5ed71462c540258bedcb51965123ad7e7ccf4b9a8cafaa4a63576d"
-
-[[package]]
-name = "parking_lot"
-version = "0.12.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3742b2c103b9f06bc9fff0a37ff4912935851bee6d36f3c02bcc755bcfec228f"
-dependencies = [
- "lock_api",
- "parking_lot_core",
-]
-
-[[package]]
-name = "parking_lot_core"
-version = "0.9.8"
+version = "1.19.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "93f00c865fe7cabf650081affecd3871070f26767e7b2070a3ffae14c654b447"
-dependencies = [
- "cfg-if",
- "libc",
- "redox_syscall",
- "smallvec",
- "windows-targets",
-]
+checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92"
 
 [[package]]
 name = "percent-encoding"
@@ -304,9 +269,9 @@ checksum = "7170ef9988bc169ba16dd36a7fa041e5c4cbeb6a35b76d4c03daded371eae7c0"
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.76"
+version = "1.0.86"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95fc56cda0b5c3325f5fbbd7ff9fda9e02bb00bb3dac51252d2f1bfa1cb8cc8c"
+checksum = "5e719e8df665df0d1c8fbfd238015744736151d4445ec0836b8e628aae103b77"
 dependencies = [
  "unicode-ident",
 ]
@@ -330,7 +295,7 @@ dependencies = [
  "smallvec",
  "speedate",
  "strum",
- "strum_macros 0.26.1",
+ "strum_macros 0.26.4",
  "url",
  "uuid",
  "version_check",
@@ -338,16 +303,16 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.21.2"
+version = "0.22.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5e00b96a521718e08e03b1a622f01c8a8deb50719335de3f60b3b3950f069d8"
+checksum = "1962a33ed2a201c637fc14a4e0fd4e06e6edfdeee6a5fede0dab55507ad74cf7"
 dependencies = [
  "cfg-if",
  "indoc",
  "libc",
  "memoffset",
  "num-bigint",
- "parking_lot",
+ "once_cell",
  "portable-atomic",
  "pyo3-build-config",
  "pyo3-ffi",
@@ -357,9 +322,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.21.2"
+version = "0.22.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7883df5835fafdad87c0d888b266c8ec0f4c9ca48a5bed6bbb592e8dedee1b50"
+checksum = "ab7164b2202753bd33afc7f90a10355a719aa973d1f94502c50d06f3488bc420"
 dependencies = [
  "once_cell",
  "python3-dll-a",
@@ -368,9 +333,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.21.2"
+version = "0.22.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "01be5843dc60b916ab4dad1dca6d20b9b4e6ddc8e15f50c47fe6d85f1fb97403"
+checksum = "c6424906ca49013c0829c5c1ed405e20e2da2dc78b82d198564880a704e6a7b7"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -378,9 +343,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.21.2"
+version = "0.22.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "77b34069fc0682e11b31dbd10321cbf94808394c56fd996796ce45217dfac53c"
+checksum = "82b2f19e153122d64afd8ce7aaa72f06a00f52e34e1d1e74b6d71baea396460a"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -390,11 +355,11 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.21.2"
+version = "0.22.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08260721f32db5e1a5beae69a55553f56b99bd0e1c3e6e0a5e8851a9d0f5a85c"
+checksum = "dd698c04cac17cf0fe63d47790ab311b8b25542f5cb976b65c374035c50f1eef"
 dependencies = [
- "heck",
+ "heck 0.5.0",
  "proc-macro2",
  "pyo3-build-config",
  "quote",
@@ -403,18 +368,18 @@ dependencies = [
 
 [[package]]
 name = "python3-dll-a"
-version = "0.2.9"
+version = "0.2.10"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d5f07cd4412be8fa09a721d40007c483981bbe072cd6a21f2e83e04ec8f8343f"
+checksum = "bd0b78171a90d808b319acfad166c4790d9e9759bbc14ac8273fe133673dd41b"
 dependencies = [
  "cc",
 ]
 
 [[package]]
 name = "quote"
-version = "1.0.35"
+version = "1.0.36"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "291ec9ab5efd934aaf503a6466c5d5251535d108ee747472c3977cc5acc868ef"
+checksum = "0fa76aaf39101c457836aec0ce2316dbdc3ab723cdda1c6bd4e6ad4208acaca7"
 dependencies = [
  "proc-macro2",
 ]
@@ -425,20 +390,11 @@ version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
 
-[[package]]
-name = "redox_syscall"
-version = "0.3.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "567664f262709473930a4bf9e51bf2ebf3348f2e748ccc50dea20646858f8f29"
-dependencies = [
- "bitflags",
-]
-
 [[package]]
 name = "regex"
-version = "1.10.4"
+version = "1.10.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c117dbdfde9c8308975b6a18d71f3f385c89461f7b3fb054288ecf2a2058ba4c"
+checksum = "b91213439dad192326a0d7c6ee3955910425f441d7038e0d6933b0aec5c4517f"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -448,9 +404,9 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.4.5"
+version = "0.4.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5bb987efffd3c6d0d8f5f89510bb458559eab11e4f869acb20bf845e016259cd"
+checksum = "38caf58cc5ef2fed281f89292ef23f6365465ed9a41b7a7754eb4e26496c92df"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -459,27 +415,21 @@ dependencies = [
 
 [[package]]
 name = "regex-syntax"
-version = "0.8.2"
+version = "0.8.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c08c74e62047bb2de4ff487b251e4a92e24f48745648451635cec7d591162d9f"
+checksum = "7a66a03ae7c801facd77a29370b4faec201768915ac14a721ba36f20bc9c209b"
 
 [[package]]
 name = "rustversion"
-version = "1.0.13"
+version = "1.0.17"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc31bd9b61a32c31f9650d18add92aa83a49ba979c143eefd27fe7177b05bd5f"
+checksum = "955d28af4278de8121b7ebeb796b6a45735dc01436d898801014aced2773a3d6"
 
 [[package]]
 name = "ryu"
-version = "1.0.14"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fe232bdf6be8c8de797b22184ee71118d63780ea42ac85b61d1baa6d3b782ae9"
-
-[[package]]
-name = "scopeguard"
-version = "1.1.0"
+version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d29ab0c6d3fc0ee92fe66e2d99f700eab17a8d57d1c1d3b748380fb20baa78cd"
+checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
 
 [[package]]
 name = "serde"
@@ -503,9 +453,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.116"
+version = "1.0.117"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3e17db7126d17feb94eb3fad46bf1a96b034e8aacbc2e775fe81505f8b0b2813"
+checksum = "455182ea6142b14f93f4bc5320a2b31c1f266b66a4a5c858b013302a5d8cbfc3"
 dependencies = [
  "indexmap",
  "itoa",
@@ -550,7 +500,7 @@ version = "0.25.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "23dc1fa9ac9c169a78ba62f0b841814b7abae11bdd047b9c58f893439e309ea0"
 dependencies = [
- "heck",
+ "heck 0.4.1",
  "proc-macro2",
  "quote",
  "rustversion",
@@ -559,11 +509,11 @@ dependencies = [
 
 [[package]]
 name = "strum_macros"
-version = "0.26.1"
+version = "0.26.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a3417fc93d76740d974a01654a09777cb500428cc874ca9f45edfe0c4d4cd18"
+checksum = "4c6bee85a5a24955dc440386795aa378cd9cf82acd5f764469152d2270e581be"
 dependencies = [
- "heck",
+ "heck 0.5.0",
  "proc-macro2",
  "quote",
  "rustversion",
@@ -572,9 +522,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.48"
+version = "2.0.68"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0f3531638e407dfc0814761abb7c00a5b54992b849452a0646b7f65c9f770f3f"
+checksum = "901fa70d88b9d6c98022e23b4136f9f3e54e4662c3bc1bd1d84a42a9a0f0c1e9"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -589,9 +539,9 @@ checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
 
 [[package]]
 name = "target-lexicon"
-version = "0.12.9"
+version = "0.12.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df8e77cb757a61f51b947ec4a7e3646efd825b73561db1c232a8ccb639e611a0"
+checksum = "e1fc403891a21bcfb7c37834ba66a547a8f402146eba7265b5a6d88059c9ff2f"
 
 [[package]]
 name = "tinyvec"
@@ -610,21 +560,21 @@ checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
 
 [[package]]
 name = "unicode-bidi"
-version = "0.3.13"
+version = "0.3.15"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "92888ba5573ff080736b3648696b70cafad7d250551175acbaa4e0385b3e1460"
+checksum = "08f95100a766bf4f8f28f90d77e0a5461bbdb219042e7679bebe79004fed8d75"
 
 [[package]]
 name = "unicode-ident"
-version = "1.0.10"
+version = "1.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22049a19f4a68748a168c0fc439f9516686aa045927ff767eca0a85101fb6e73"
+checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
 
 [[package]]
 name = "unicode-normalization"
-version = "0.1.22"
+version = "0.1.23"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c5713f0fc4b5db668a2ac63cdb7bb4469d8c9fed047b1d0292cc7b0ce2ba921"
+checksum = "a56d1686db2308d901306f92a263857ef59ea39678a5458e7cb17f01415101f5"
 dependencies = [
  "tinyvec",
 ]
@@ -637,9 +587,9 @@ checksum = "c7de7d73e1754487cb58364ee906a499937a0dfabd86bcb980fa99ec8c8fa2ce"
 
 [[package]]
 name = "url"
-version = "2.5.0"
+version = "2.5.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "31e6302e3bb753d46e83516cae55ae196fc0c309407cf11ab35cc51a4c2a4633"
+checksum = "22784dbdf76fdde8af1aeda5622b546b422b6fc585325248a2bf9f5e41e94d6c"
 dependencies = [
  "form_urlencoded",
  "idna",
@@ -648,9 +598,9 @@ dependencies = [
 
 [[package]]
 name = "uuid"
-version = "1.8.0"
+version = "1.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a183cf7feeba97b4dd1c0d46788634f6221d87fa961b305bed08c851829efcc0"
+checksum = "3ea73390fe27785838dcbf75b91b1d84799e28f1ce71e6f372a5dc2200c80de5"
 
 [[package]]
 name = "version_check"
@@ -664,63 +614,6 @@ version = "0.11.0+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
-[[package]]
-name = "windows-targets"
-version = "0.48.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05d4b17490f70499f20b9e791dcf6a299785ce8af4d709018206dc5b4953e95f"
-dependencies = [
- "windows_aarch64_gnullvm",
- "windows_aarch64_msvc",
- "windows_i686_gnu",
- "windows_i686_msvc",
- "windows_x86_64_gnu",
- "windows_x86_64_gnullvm",
- "windows_x86_64_msvc",
-]
-
-[[package]]
-name = "windows_aarch64_gnullvm"
-version = "0.48.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91ae572e1b79dba883e0d315474df7305d12f569b400fcf90581b06062f7e1bc"
-
-[[package]]
-name = "windows_aarch64_msvc"
-version = "0.48.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b2ef27e0d7bdfcfc7b868b317c1d32c641a6fe4629c171b8928c7b08d98d7cf3"
-
-[[package]]
-name = "windows_i686_gnu"
-version = "0.48.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "622a1962a7db830d6fd0a69683c80a18fda201879f0f447f065a3b7467daa241"
-
-[[package]]
-name = "windows_i686_msvc"
-version = "0.48.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4542c6e364ce21bf45d69fdd2a8e455fa38d316158cfd43b3ac1c5b1b19f8e00"
-
-[[package]]
-name = "windows_x86_64_gnu"
-version = "0.48.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ca2b8a661f7628cbd23440e50b05d705db3686f894fc9580820623656af974b1"
-
-[[package]]
-name = "windows_x86_64_gnullvm"
-version = "0.48.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7896dbc1f41e08872e9d5e8f8baa8fdd2677f29468c4e156210174edc7f7b953"
-
-[[package]]
-name = "windows_x86_64_msvc"
-version = "0.48.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1a515f5799fe4961cb532f983ce2b23082366b898e52ffbce459c86f67c8378a"
-
 [[package]]
 name = "wyz"
 version = "0.5.1"
@@ -732,18 +625,18 @@ dependencies = [
 
 [[package]]
 name = "zerocopy"
-version = "0.7.32"
+version = "0.7.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "74d4d3961e53fa4c9a25a8637fc2bfaf2595b3d3ae34875568a5cf64787716be"
+checksum = "ae87e3fcd617500e5d106f0380cf7b77f3c6092aae37191433159dda23cfb087"
 dependencies = [
  "zerocopy-derive",
 ]
 
 [[package]]
 name = "zerocopy-derive"
-version = "0.7.32"
+version = "0.7.34"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ce1b18ccd8e73a9321186f97e46f9f04b778851177567b1975109d26a08d2a6"
+checksum = "15e934569e47891f7d9411f1a451d947a60e000ab3bd24fbb970f000387d1b3b"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/Cargo.toml b/Cargo.toml
index 7c4614f3c..a268e0a69 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -27,7 +27,9 @@ include = [
 rust-version = "1.75"
 
 [dependencies]
-pyo3 = { version = "0.21.2", features = ["generate-import-lib", "num-bigint"] }
+# TODO it would be very nice to remove the "py-clone" feature as it can panic,
+# but needs a bit of work to make sure it's not used in the codebase
+pyo3 = { version = "0.22.0", features = ["generate-import-lib", "num-bigint", "py-clone"] }
 regex = "1.10.4"
 strum = { version = "0.25.0", features = ["derive"] }
 strum_macros = "0.26.1"
@@ -42,9 +44,9 @@ url = "2.5.0"
 idna = "0.5.0"
 base64 = "0.21.7"
 num-bigint = "0.4.4"
-python3-dll-a = "0.2.7"
+python3-dll-a = "0.2.10"
 uuid = "1.8.0"
-jiter = { version = "0.4.1", features = ["python"] }
+jiter = { version = "0.5", features = ["python"] }
 
 [lib]
 name = "_pydantic_core"
@@ -71,12 +73,12 @@ debug = true
 strip = false
 
 [dev-dependencies]
-pyo3 = { version = "0.21.2", features = ["auto-initialize"] }
+pyo3 = { version = "0.22.0", features = ["auto-initialize"] }
 
 [build-dependencies]
 version_check = "0.9.4"
 # used where logic has to be version/distribution specific, e.g. pypy
-pyo3-build-config = { version = "0.21.0" }
+pyo3-build-config = { version = "0.22.0" }
 
 [lints.clippy]
 dbg_macro = "warn"
diff --git a/pyproject.toml b/pyproject.toml
index e1edd165f..97ee3319f 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -22,6 +22,7 @@ classifiers = [
     'Programming Language :: Python :: 3.10',
     'Programming Language :: Python :: 3.11',
     'Programming Language :: Python :: 3.12',
+    'Programming Language :: Python :: 3.13',
     'Programming Language :: Rust',
     'Framework :: Pydantic',
     'Intended Audience :: Developers',
diff --git a/src/argument_markers.rs b/src/argument_markers.rs
index 4a9e80bbd..23cd74f41 100644
--- a/src/argument_markers.rs
+++ b/src/argument_markers.rs
@@ -30,6 +30,7 @@ impl ArgsKwargs {
 #[pymethods]
 impl ArgsKwargs {
     #[new]
+    #[pyo3(signature = (args, kwargs = None))]
     fn py_new(py: Python, args: &Bound<'_, PyTuple>, kwargs: Option<&Bound<'_, PyDict>>) -> Self {
         Self {
             args: args.into_py(py),
diff --git a/src/errors/types.rs b/src/errors/types.rs
index 57025f9b5..09ad47f38 100644
--- a/src/errors/types.rs
+++ b/src/errors/types.rs
@@ -459,8 +459,8 @@ static ERROR_TYPE_LOOKUP: GILOnceCell<AHashMap<String, ErrorType>> = GILOnceCell
 impl ErrorType {
     pub fn new_custom_error(py: Python, custom_error: PydanticCustomError) -> Self {
         Self::CustomError {
-            error_type: custom_error.error_type(),
-            message_template: custom_error.message_template(),
+            error_type: custom_error.error_type().to_owned(),
+            message_template: custom_error.message_template().to_owned(),
             context: custom_error.context(py),
         }
     }
diff --git a/src/errors/value_exception.rs b/src/errors/value_exception.rs
index 20ad6174a..793bcd0b5 100644
--- a/src/errors/value_exception.rs
+++ b/src/errors/value_exception.rs
@@ -65,6 +65,7 @@ pub struct PydanticCustomError {
 #[pymethods]
 impl PydanticCustomError {
     #[new]
+    #[pyo3(signature = (error_type, message_template, context = None))]
     pub fn py_new(error_type: String, message_template: String, context: Option<Bound<'_, PyDict>>) -> Self {
         Self {
             error_type,
@@ -74,13 +75,13 @@ impl PydanticCustomError {
     }
 
     #[getter(r#type)]
-    pub fn error_type(&self) -> String {
-        self.error_type.clone()
+    pub fn error_type(&self) -> &str {
+        &self.error_type
     }
 
     #[getter]
-    pub fn message_template(&self) -> String {
-        self.message_template.clone()
+    pub fn message_template(&self) -> &str {
+        &self.message_template
     }
 
     #[getter]
@@ -143,6 +144,7 @@ pub struct PydanticKnownError {
 #[pymethods]
 impl PydanticKnownError {
     #[new]
+    #[pyo3(signature = (error_type, context=None))]
     pub fn py_new(py: Python, error_type: &str, context: Option<Bound<'_, PyDict>>) -> PyResult<Self> {
         let error_type = ErrorType::new(py, error_type, context)?;
         Ok(Self { error_type })
diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index 2a06228e1..3de712272 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -318,7 +318,10 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
 
         Err(ValError::new(
             ErrorType::IsInstanceOf {
-                class: decimal_type.qualname().unwrap_or_else(|_| "Decimal".to_owned()),
+                class: decimal_type
+                    .qualname()
+                    .and_then(|name| name.extract())
+                    .unwrap_or_else(|_| "Decimal".to_owned()),
                 context: None,
             },
             self,
@@ -772,7 +775,7 @@ impl<'py> ValidatedDict<'py> for GenericPyMapping<'_, 'py> {
         match self {
             Self::Dict(dict) => Ok(consumer.consume_iterator(dict.iter().map(Ok))),
             Self::Mapping(mapping) => Ok(consumer.consume_iterator(iterate_mapping_items(mapping)?)),
-            Self::GetAttr(obj, _) => Ok(consumer.consume_iterator(iterate_attributes(obj))),
+            Self::GetAttr(obj, _) => Ok(consumer.consume_iterator(iterate_attributes(obj)?)),
         }
     }
 }
diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index bbd1b6404..6b62ac85a 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -292,10 +292,10 @@ const MAPPING_TUPLE_ERROR: &str = "Mapping items must be tuples of (key, value)
 /// Iterate over attributes of an object
 pub(crate) fn iterate_attributes<'a, 'py>(
     object: &'a Bound<'py, PyAny>,
-) -> impl Iterator<Item = ValResult<(Bound<'py, PyAny>, Bound<'py, PyAny>)>> + 'a {
-    let mut attributes_iterator = object.dir().into_iter();
+) -> PyResult<impl Iterator<Item = ValResult<(Bound<'py, PyAny>, Bound<'py, PyAny>)>> + 'a> {
+    let mut attributes_iterator = object.dir()?.into_iter();
 
-    std::iter::from_fn(move || {
+    Ok(std::iter::from_fn(move || {
         // loop until we find an attribute who's name does not start with underscore,
         // or we get to the end of the list of attributes
         let name = attributes_iterator.next()?;
@@ -327,7 +327,7 @@ pub(crate) fn iterate_attributes<'a, 'py>(
             }
         }
         None
-    })
+    }))
 }
 
 #[derive(Debug)]
diff --git a/src/lookup_key.rs b/src/lookup_key.rs
index bacdb5fd1..4cc131df8 100644
--- a/src/lookup_key.rs
+++ b/src/lookup_key.rs
@@ -504,7 +504,7 @@ impl PathItem {
 /// wrapper around `getattr` that returns `Ok(None)` for attribute errors, but returns other errors
 /// We don't check `try_from_attributes` because that check was performed on the top level object before we got here
 fn py_get_attrs<'py>(obj: &Bound<'py, PyAny>, attr_name: &Py<PyString>) -> PyResult<Option<Bound<'py, PyAny>>> {
-    match obj.getattr(attr_name.extract::<&PyString>(obj.py())?) {
+    match obj.getattr(attr_name) {
         Ok(attr) => Ok(Some(attr)),
         Err(err) => {
             if err.get_type_bound(obj.py()).is_subclass_of::<PyAttributeError>()? {
diff --git a/src/serializers/errors.rs b/src/serializers/errors.rs
index 71a0a024e..ffd43407f 100644
--- a/src/serializers/errors.rs
+++ b/src/serializers/errors.rs
@@ -105,6 +105,7 @@ impl PydanticSerializationUnexpectedValue {
 #[pymethods]
 impl PydanticSerializationUnexpectedValue {
     #[new]
+    #[pyo3(signature = (message=None))]
     fn py_new(message: Option<String>) -> Self {
         Self { message }
     }
diff --git a/src/serializers/extra.rs b/src/serializers/extra.rs
index 88185ad6c..dbf6f7b31 100644
--- a/src/serializers/extra.rs
+++ b/src/serializers/extra.rs
@@ -4,7 +4,7 @@ use std::fmt;
 use pyo3::exceptions::{PyTypeError, PyValueError};
 use pyo3::intern;
 use pyo3::prelude::*;
-use pyo3::types::PyBool;
+use pyo3::types::{PyBool, PyString};
 
 use serde::ser::Error;
 
@@ -423,7 +423,7 @@ impl CollectWarnings {
             let type_name = value
                 .get_type()
                 .qualname()
-                .unwrap_or_else(|_| "<unknown python object>".to_owned());
+                .unwrap_or_else(|_| PyString::new_bound(value.py(), "<unknown python object>"));
             self.add_warning(format!(
                 "Expected `{field_type}` but got `{type_name}` - serialized value may not be as expected"
             ));
diff --git a/src/serializers/mod.rs b/src/serializers/mod.rs
index 02ec71fd6..66b345530 100644
--- a/src/serializers/mod.rs
+++ b/src/serializers/mod.rs
@@ -86,6 +86,7 @@ impl SchemaSerializer {
 #[pymethods]
 impl SchemaSerializer {
     #[new]
+    #[pyo3(signature = (schema, config=None))]
     pub fn py_new(schema: Bound<'_, PyDict>, config: Option<&Bound<'_, PyDict>>) -> PyResult<Self> {
         let mut definitions_builder = DefinitionsBuilder::new();
         let serializer = CombinedSerializer::build(schema.downcast()?, config, &mut definitions_builder)?;
diff --git a/src/serializers/type_serializers/dataclass.rs b/src/serializers/type_serializers/dataclass.rs
index 193e75b66..ebcca0dec 100644
--- a/src/serializers/type_serializers/dataclass.rs
+++ b/src/serializers/type_serializers/dataclass.rs
@@ -82,18 +82,18 @@ impl BuildSerializer for DataclassSerializer {
         // models ignore the parent config and always use the config from this model
         let config = schema.get_as(intern!(py, "config"))?;
 
-        let class: &PyType = schema.get_as_req(intern!(py, "cls"))?;
+        let class: Bound<'_, PyType> = schema.get_as_req(intern!(py, "cls"))?;
         let sub_schema = schema.get_as_req(intern!(py, "schema"))?;
         let serializer = Box::new(CombinedSerializer::build(&sub_schema, config.as_ref(), definitions)?);
 
         let fields = schema
-            .get_as_req::<&PyList>(intern!(py, "fields"))?
+            .get_as_req::<Bound<'_, PyList>>(intern!(py, "fields"))?
             .iter()
             .map(|s| Ok(s.downcast::<PyString>()?.into_py(py)))
             .collect::<PyResult<Vec<_>>>()?;
 
         Ok(Self {
-            class: class.into(),
+            class: class.clone().unbind(),
             serializer,
             fields,
             name: class.getattr(intern!(py, "__name__"))?.extract()?,
diff --git a/src/serializers/type_serializers/function.rs b/src/serializers/type_serializers/function.rs
index 01bc6606a..856be6fb3 100644
--- a/src/serializers/type_serializers/function.rs
+++ b/src/serializers/type_serializers/function.rs
@@ -476,6 +476,7 @@ impl SerializationCallable {
 
 #[pymethods]
 impl SerializationCallable {
+    #[pyo3(signature = (value, index_key=None))]
     fn __call__(
         &mut self,
         py: Python,
diff --git a/src/validators/dataclass.rs b/src/validators/dataclass.rs
index 72d738440..4ff82a467 100644
--- a/src/validators/dataclass.rs
+++ b/src/validators/dataclass.rs
@@ -460,7 +460,7 @@ impl BuildValidator for DataclassValidator {
         let config = schema.get_as(intern!(py, "config"))?;
         let config = config.as_ref();
 
-        let class: &PyType = schema.get_as_req(intern!(py, "cls"))?;
+        let class = schema.get_as_req::<Bound<'_, PyType>>(intern!(py, "cls"))?;
         let name = match schema.get_as_req::<String>(intern!(py, "cls_name")) {
             Ok(name) => name,
             Err(_) => class.getattr(intern!(py, "__name__"))?.extract()?,
@@ -474,11 +474,7 @@ impl BuildValidator for DataclassValidator {
             None
         };
 
-        let fields = schema
-            .get_as_req::<&PyList>(intern!(py, "fields"))?
-            .iter()
-            .map(|s| Ok(s.downcast::<PyString>()?.into_py(py)))
-            .collect::<PyResult<Vec<_>>>()?;
+        let fields = schema.get_as_req(intern!(py, "fields"))?;
 
         Ok(Self {
             strict: is_strict(schema, config)?,
@@ -634,7 +630,7 @@ impl DataclassValidator {
                 dc.call_method0(post_init)
             } else {
                 let args = post_init_kwargs.downcast::<PyTuple>()?;
-                dc.call_method1(post_init, args.as_gil_ref())
+                dc.call_method1(post_init, args)
             };
             r.map_err(|e| convert_err(py, e, input))?;
         }
diff --git a/src/validators/datetime.rs b/src/validators/datetime.rs
index 4874e78a3..a6ccad328 100644
--- a/src/validators/datetime.rs
+++ b/src/validators/datetime.rs
@@ -31,9 +31,7 @@ pub(crate) fn extract_microseconds_precision(
     schema_or_config_same(schema, config, intern!(schema.py(), "microseconds_precision"))?
         .map_or(
             Ok(speedate::MicrosecondsPrecisionOverflowBehavior::Truncate),
-            |v: &PyString| {
-                speedate::MicrosecondsPrecisionOverflowBehavior::try_from(v.extract::<String>().unwrap().as_str())
-            },
+            |v: Bound<'_, PyString>| speedate::MicrosecondsPrecisionOverflowBehavior::try_from(v.to_str().unwrap()),
         )
         .map_err(|_| {
             py_schema_error_type!("Invalid `microseconds_precision`, must be one of \"truncate\" or \"error\"")
diff --git a/src/validators/decimal.rs b/src/validators/decimal.rs
index 38409c9d4..d1c15c299 100644
--- a/src/validators/decimal.rs
+++ b/src/validators/decimal.rs
@@ -22,9 +22,8 @@ pub fn get_decimal_type(py: Python) -> &Bound<'_, PyType> {
             py.import_bound("decimal")
                 .and_then(|decimal_module| decimal_module.getattr("Decimal"))
                 .unwrap()
-                .extract::<&PyType>()
+                .extract()
                 .unwrap()
-                .into()
         })
         .bind(py)
 }
diff --git a/src/validators/enum_.rs b/src/validators/enum_.rs
index 087d0ca5f..0449a95da 100644
--- a/src/validators/enum_.rs
+++ b/src/validators/enum_.rs
@@ -137,7 +137,10 @@ impl<T: EnumValidateValue> Validator for EnumValidator<T> {
             } else if !enum_value.is(&py.None()) {
                 let type_error = PyTypeError::new_err(format!(
                     "error in {}._missing_: returned {} instead of None or a valid member",
-                    class.name().unwrap_or_else(|_| "<Unknown>".into()),
+                    class
+                        .name()
+                        .and_then(|name| name.extract::<String>())
+                        .unwrap_or_else(|_| "<Unknown>".into()),
                     safe_repr(&enum_value)
                 ));
                 return Err(type_error.into());
diff --git a/src/validators/function.rs b/src/validators/function.rs
index 855337a01..286107c92 100644
--- a/src/validators/function.rs
+++ b/src/validators/function.rs
@@ -36,9 +36,7 @@ fn destructure_function_schema(schema: &Bound<'_, PyDict>) -> PyResult<FunctionI
         "no-info" => false,
         _ => unreachable!(),
     };
-    let field_name = func_dict
-        .get_as::<&PyString>(intern!(schema.py(), "field_name"))?
-        .map(Into::into);
+    let field_name = func_dict.get_as(intern!(schema.py(), "field_name"))?;
     Ok(FunctionInfo {
         function,
         field_name,
@@ -394,6 +392,7 @@ struct ValidatorCallable {
 
 #[pymethods]
 impl ValidatorCallable {
+    #[pyo3(signature = (input_value, outer_location=None))]
     fn __call__(
         &mut self,
         py: Python,
@@ -427,6 +426,7 @@ struct AssignmentValidatorCallable {
 
 #[pymethods]
 impl AssignmentValidatorCallable {
+    #[pyo3(signature = (input_value, outer_location=None))]
     fn __call__(
         &mut self,
         py: Python,
diff --git a/src/validators/is_instance.rs b/src/validators/is_instance.rs
index d904e82fb..d9190f33c 100644
--- a/src/validators/is_instance.rs
+++ b/src/validators/is_instance.rs
@@ -81,7 +81,7 @@ impl Validator for IsInstanceValidator {
 pub fn class_repr(schema: &Bound<'_, PyDict>, class: &Bound<'_, PyAny>) -> PyResult<String> {
     match schema.get_as(intern!(schema.py(), "cls_repr"))? {
         Some(s) => Ok(s),
-        None => match class.extract::<&PyType>() {
+        None => match class.downcast::<PyType>() {
             Ok(t) => Ok(t.qualname()?.to_string()),
             Err(_) => Ok(class.repr()?.extract()?),
         },
diff --git a/src/validators/is_subclass.rs b/src/validators/is_subclass.rs
index 50deb8ae3..fdfea5b75 100644
--- a/src/validators/is_subclass.rs
+++ b/src/validators/is_subclass.rs
@@ -25,7 +25,7 @@ impl BuildValidator for IsSubclassValidator {
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
-        let class: &PyType = schema.get_as_req(intern!(py, "cls"))?;
+        let class = schema.get_as_req::<Bound<'_, PyType>>(intern!(py, "cls"))?;
 
         let class_repr = match schema.get_as(intern!(py, "cls_repr"))? {
             Some(s) => s,
diff --git a/src/validators/mod.rs b/src/validators/mod.rs
index ede6489ab..02abda1fd 100644
--- a/src/validators/mod.rs
+++ b/src/validators/mod.rs
@@ -117,6 +117,7 @@ pub struct SchemaValidator {
 #[pymethods]
 impl SchemaValidator {
     #[new]
+    #[pyo3(signature = (schema, config=None))]
     pub fn py_new(py: Python, schema: &Bound<'_, PyAny>, config: Option<&Bound<'_, PyDict>>) -> PyResult<Self> {
         let mut definitions_builder = DefinitionsBuilder::new();
 
diff --git a/src/validators/url.rs b/src/validators/url.rs
index 5ec3a139f..634d1ce43 100644
--- a/src/validators/url.rs
+++ b/src/validators/url.rs
@@ -578,7 +578,7 @@ trait CopyFromPyUrl {
 }
 
 fn get_allowed_schemas(schema: &Bound<'_, PyDict>, name: &'static str) -> PyResult<(AllowedSchemas, String)> {
-    match schema.get_as::<&PyList>(intern!(schema.py(), "allowed_schemes"))? {
+    match schema.get_as::<Bound<'_, PyList>>(intern!(schema.py(), "allowed_schemes"))? {
         Some(list) => {
             if list.is_empty() {
                 return py_schema_err!("`allowed_schemes` should have length > 0");
diff --git a/src/validators/uuid.rs b/src/validators/uuid.rs
index 1fad8f8ed..44aa22003 100644
--- a/src/validators/uuid.rs
+++ b/src/validators/uuid.rs
@@ -115,7 +115,10 @@ impl Validator for UuidValidator {
         } else if state.strict_or(self.strict) && state.extra().input_type == InputType::Python {
             Err(ValError::new(
                 ErrorType::IsInstanceOf {
-                    class: class.qualname().unwrap_or_else(|_| "UUID".to_owned()),
+                    class: class
+                        .qualname()
+                        .and_then(|name| name.extract())
+                        .unwrap_or_else(|_| "UUID".to_owned()),
                     context: None,
                 },
                 input,
diff --git a/tests/validators/test_string.py b/tests/validators/test_string.py
index 75edcc1b0..df6bd7ad7 100644
--- a/tests/validators/test_string.py
+++ b/tests/validators/test_string.py
@@ -1,4 +1,5 @@
 import re
+import sys
 from decimal import Decimal
 from numbers import Number
 from typing import Any, Dict, Union
@@ -187,8 +188,9 @@ def test_invalid_regex(engine):
             'error: unclosed group'
         )
     elif engine == 'python-re':
+        prefix = 'PatternError' if sys.version_info >= (3, 13) else 'error'
         assert exc_info.value.args[0] == (
-            'Error building "str" validator:\n  error: missing ), unterminated subpattern at position 0'
+            f'Error building "str" validator:\n  {prefix}: missing ), unterminated subpattern at position 0'
         )
 
 

From 7b62646c361d8a2c8db9e4a581bd26c85c93a90f Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Mon, 24 Jun 2024 19:32:17 -0500
Subject: [PATCH 310/550] Prep for v2.20.0 release (#1343)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index cdcde2cd6..18c26427b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -278,7 +278,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.19.0"
+version = "2.20.0"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index a268e0a69..4950183d0 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.19.0"
+version = "2.20.0"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From a017bd9230561aab9868564045d3d37d30a3637a Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Tue, 25 Jun 2024 15:06:37 +0100
Subject: [PATCH 311/550] try restore 3.13 PGO builds (#1346)

---
 .github/workflows/ci.yml | 16 ++--------------
 1 file changed, 2 insertions(+), 14 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 6b7be62c7..6a12b0686 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -438,25 +438,19 @@ jobs:
           # macos;
           # all versions x86_64
           # arm pypy and older pythons which can't be run on the arm hardware for PGO
-          #
-          # FIXME https://github.com/PyO3/maturin-action/issues/275
-          # cffi prevents `maturin-action` working on macOS 3.13 for now for the optimized build
           - os: macos
             target: x86_64
           - os: macos
             target: aarch64
-            interpreter: 3.8 3.9 pypy3.9 pypy3.10 # 3.13
+            interpreter: 3.8 3.9 pypy3.9 pypy3.10
 
           # windows;
           # x86_64 pypy builds are not PGO optimized
           # i686 not supported by pypy
           # aarch64 only 3.11 and up, also not PGO optimized
-          #
-          # FIXME https://github.com/PyO3/maturin-action/issues/275
-          # cffi prevents `maturin-action` working on Windows 3.13 for now for the optimized build
           - os: windows
             target: x86_64
-            interpreter: pypy3.9 pypy3.10 3.13
+            interpreter: pypy3.9 pypy3.10
           - os: windows
             target: i686
             python-architecture: x86
@@ -528,12 +522,6 @@ jobs:
             interpreter: '3.8'
           - os: macos
             interpreter: '3.9'
-          # https://github.com/PyO3/maturin-action/issues/275
-          # cffi prevents `maturin-action` working on Windows & macOS 3.13 for now
-          - os: windows
-            interpreter: '3.13'
-          - os: macos
-            interpreter: '3.13'
 
     runs-on: ${{ matrix.runs-on }}
     steps:

From 510daf8f612df3a13c95f8434d12685d7d222e00 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Tue, 2 Jul 2024 13:16:13 -0500
Subject: [PATCH 312/550] Bump `pytest-examples` to get tests passing with ruff
 `v0.5.0` (#1360)

---
 .github/workflows/ci.yml       | 6 +++---
 tests/requirements-linting.txt | 2 +-
 tests/requirements.txt         | 2 +-
 tests/validators/test_list.py  | 2 +-
 4 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 6a12b0686..ae15660a2 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -343,7 +343,7 @@ jobs:
           version: '3.1.46'
           actions-cache-folder: emsdk-cache
 
-      - run: pip install 'maturin>=1,<2' 'ruff==0.1.3' typing_extensions
+      - run: pip install 'maturin>=1,<2' 'ruff==0.5.0' typing_extensions
 
       - name: build wheels
         run: make build-wasm
@@ -475,7 +475,7 @@ jobs:
           python-version: '3.11'
           architecture: ${{ matrix.python-architecture || 'x64' }}
 
-      - run: pip install -U twine 'ruff==0.1.3' typing_extensions
+      - run: pip install -U twine 'ruff==0.5.0' typing_extensions
 
       # generate self-schema now, so we don't have to do so inside docker in maturin build
       - run: python generate_self_schema.py
@@ -539,7 +539,7 @@ jobs:
         with:
           components: llvm-tools
 
-      - run: pip install -U 'ruff==0.1.3' typing_extensions
+      - run: pip install -U 'ruff==0.5.0' typing_extensions
 
       # generate self-schema now, so we don't have to do so inside docker in maturin build
       - run: python generate_self_schema.py
diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index e5bac5207..b1517394a 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,4 +1,4 @@
 griffe==0.45.2
 pyright==1.1.365
-ruff==0.4.7
+ruff==0.5.0
 mypy==1.10.0
diff --git a/tests/requirements.txt b/tests/requirements.txt
index cdb222bf8..09b1dd4b9 100644
--- a/tests/requirements.txt
+++ b/tests/requirements.txt
@@ -9,7 +9,7 @@ pytest==8.2.1
 pytest-codspeed~=2.2.1; implementation_name == "cpython" and platform_machine == 'x86_64'
 # pytest-examples currently depends on aiohttp via black; we don't want to build
 # it on platforms like aarch64 musllinux in CI
-pytest-examples==0.0.10; implementation_name == "cpython" and platform_machine == 'x86_64'
+pytest-examples==0.0.11; implementation_name == "cpython" and platform_machine == 'x86_64'
 pytest-speed==0.3.5
 pytest-mock==3.14.0
 pytest-pretty==1.2.0
diff --git a/tests/validators/test_list.py b/tests/validators/test_list.py
index b8bcee8ec..6914529f9 100644
--- a/tests/validators/test_list.py
+++ b/tests/validators/test_list.py
@@ -43,7 +43,7 @@ def test_list_strict():
 
 def test_list_no_copy():
     v = SchemaValidator({'type': 'list'})
-    assert v.validate_python([1, 2, 3]) is not [1, 2, 3]
+    assert v.validate_python([1, 2, 3]) is not [1, 2, 3]  # noqa: F632
 
 
 def gen_ints():

From 4519e9f4a978eec56e581bc693ef176a5a4ae727 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 2 Jul 2024 18:22:41 +0000
Subject: [PATCH 313/550] Bump uuid from 1.9.0 to 1.9.1 (#1356)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 18c26427b..14e6c19bc 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -598,9 +598,9 @@ dependencies = [
 
 [[package]]
 name = "uuid"
-version = "1.9.0"
+version = "1.9.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ea73390fe27785838dcbf75b91b1d84799e28f1ce71e6f372a5dc2200c80de5"
+checksum = "5de17fd2f7da591098415cff336e12965a28061ddace43b59cb3c430179c9439"
 
 [[package]]
 name = "version_check"
diff --git a/Cargo.toml b/Cargo.toml
index 4950183d0..274c338c5 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -45,7 +45,7 @@ idna = "0.5.0"
 base64 = "0.21.7"
 num-bigint = "0.4.4"
 python3-dll-a = "0.2.10"
-uuid = "1.8.0"
+uuid = "1.9.1"
 jiter = { version = "0.5", features = ["python"] }
 
 [lib]

From de196833fd8a650550b312c151d5d7285388fc80 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 2 Jul 2024 18:22:54 +0000
Subject: [PATCH 314/550] Bump num-bigint from 0.4.5 to 0.4.6 (#1357)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 14e6c19bc..9510eea24 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -223,9 +223,9 @@ dependencies = [
 
 [[package]]
 name = "num-bigint"
-version = "0.4.5"
+version = "0.4.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c165a9ab64cf766f73521c0dd2cfdff64f488b8f0b3e621face3462d3db536d7"
+checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
 dependencies = [
  "num-integer",
  "num-traits",
diff --git a/Cargo.toml b/Cargo.toml
index 274c338c5..cd76ac238 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -43,7 +43,7 @@ url = "2.5.0"
 # idna is already required by url, added here to be explicit
 idna = "0.5.0"
 base64 = "0.21.7"
-num-bigint = "0.4.4"
+num-bigint = "0.4.6"
 python3-dll-a = "0.2.10"
 uuid = "1.9.1"
 jiter = { version = "0.5", features = ["python"] }

From b7fa254143315ac27745ad703f87de7266fa8eac Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 2 Jul 2024 18:10:43 -0500
Subject: [PATCH 315/550] Bump the python-packages group across 1 directory
 with 7 updates (#1361)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 6 +++---
 tests/requirements.txt         | 8 ++++----
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index b1517394a..c125a229c 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,4 +1,4 @@
-griffe==0.45.2
-pyright==1.1.365
+griffe==0.47.0
+pyright==1.1.369
 ruff==0.5.0
-mypy==1.10.0
+mypy==1.10.1
diff --git a/tests/requirements.txt b/tests/requirements.txt
index 09b1dd4b9..fc107a45f 100644
--- a/tests/requirements.txt
+++ b/tests/requirements.txt
@@ -1,15 +1,15 @@
 backports.zoneinfo==0.2.1;python_version<"3.9"
-coverage==7.5.3
+coverage==7.5.4
 dirty-equals==0.7.1.post0
-hypothesis==6.103.0
+hypothesis==6.104.2
 # pandas doesn't offer prebuilt wheels for all versions and platforms we test in CI e.g. aarch64 musllinux
 pandas==2.1.3; python_version >= "3.9" and python_version < "3.13" and implementation_name == "cpython" and platform_machine == 'x86_64'
-pytest==8.2.1
+pytest==8.2.2
 # we run codspeed benchmarks on x86_64 CPython (i.e. native github actions architecture)
 pytest-codspeed~=2.2.1; implementation_name == "cpython" and platform_machine == 'x86_64'
 # pytest-examples currently depends on aiohttp via black; we don't want to build
 # it on platforms like aarch64 musllinux in CI
-pytest-examples==0.0.11; implementation_name == "cpython" and platform_machine == 'x86_64'
+pytest-examples==0.0.12; implementation_name == "cpython" and platform_machine == 'x86_64'
 pytest-speed==0.3.5
 pytest-mock==3.14.0
 pytest-pretty==1.2.0

From 0e6b377d2bef52e744deff22314269c8751f7b00 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Wed, 3 Jul 2024 11:09:57 -0500
Subject: [PATCH 316/550] Bump `speedate` to v0.14.1 and prep for v0.20.1
 (#1347)

---
 Cargo.lock                         | 51 +++++++++---------------------
 Cargo.toml                         |  8 ++---
 tests/validators/test_timedelta.py | 10 ++++--
 3 files changed, 27 insertions(+), 42 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 9510eea24..076cf3191 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -50,9 +50,9 @@ dependencies = [
 
 [[package]]
 name = "cc"
-version = "1.0.100"
+version = "1.0.101"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c891175c3fb232128f48de6590095e59198bbeb8620c310be349bfc3afd12c7b"
+checksum = "ac367972e516d45567c7eafc73d24e1c193dcf200a8d94e9db7b3d38b349572d"
 
 [[package]]
 name = "cfg-if"
@@ -110,12 +110,6 @@ version = "0.14.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
 
-[[package]]
-name = "heck"
-version = "0.4.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
-
 [[package]]
 name = "heck"
 version = "0.5.0"
@@ -278,7 +272,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.20.0"
+version = "2.20.1"
 dependencies = [
  "ahash",
  "base64",
@@ -295,7 +289,7 @@ dependencies = [
  "smallvec",
  "speedate",
  "strum",
- "strum_macros 0.26.4",
+ "strum_macros",
  "url",
  "uuid",
  "version_check",
@@ -359,7 +353,7 @@ version = "0.22.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "dd698c04cac17cf0fe63d47790ab311b8b25542f5cb976b65c374035c50f1eef"
 dependencies = [
- "heck 0.5.0",
+ "heck",
  "proc-macro2",
  "pyo3-build-config",
  "quote",
@@ -453,9 +447,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.117"
+version = "1.0.118"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "455182ea6142b14f93f4bc5320a2b31c1f266b66a4a5c858b013302a5d8cbfc3"
+checksum = "d947f6b3163d8857ea16c4fa0dd4840d52f3041039a85decd46867eb1abef2e4"
 dependencies = [
  "indexmap",
  "itoa",
@@ -471,12 +465,10 @@ checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
 
 [[package]]
 name = "speedate"
-version = "0.14.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c323c4e6fece5a5a1a2a7f726d243144cce9fbcfe3ce4d9f3c6ede726a2bc780"
+version = "0.14.4"
 dependencies = [
  "strum",
- "strum_macros 0.25.3",
+ "strum_macros",
 ]
 
 [[package]]
@@ -487,24 +479,11 @@ checksum = "a2eb9349b6444b326872e140eb1cf5e7c522154d69e7a0ffb0fb81c06b37543f"
 
 [[package]]
 name = "strum"
-version = "0.25.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "290d54ea6f91c969195bdbcd7442c8c2a2ba87da8bf60a7ee86a235d4bc1e125"
-dependencies = [
- "strum_macros 0.25.3",
-]
-
-[[package]]
-name = "strum_macros"
-version = "0.25.3"
+version = "0.26.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "23dc1fa9ac9c169a78ba62f0b841814b7abae11bdd047b9c58f893439e309ea0"
+checksum = "8fec0f0aef304996cf250b31b5a10dee7980c85da9d759361292b8bca5a18f06"
 dependencies = [
- "heck 0.4.1",
- "proc-macro2",
- "quote",
- "rustversion",
- "syn",
+ "strum_macros",
 ]
 
 [[package]]
@@ -513,7 +492,7 @@ version = "0.26.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "4c6bee85a5a24955dc440386795aa378cd9cf82acd5f764469152d2270e581be"
 dependencies = [
- "heck 0.5.0",
+ "heck",
  "proc-macro2",
  "quote",
  "rustversion",
@@ -545,9 +524,9 @@ checksum = "e1fc403891a21bcfb7c37834ba66a547a8f402146eba7265b5a6d88059c9ff2f"
 
 [[package]]
 name = "tinyvec"
-version = "1.6.0"
+version = "1.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "87cc5ceb3875bb20c2890005a4e226a4651264a5c75edb2421b52861a0a0cb50"
+checksum = "c55115c6fbe2d2bef26eb09ad74bde02d8255476fc0c7b515ef09fbb35742d82"
 dependencies = [
  "tinyvec_macros",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index cd76ac238..003f8865f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.20.0"
+version = "2.20.1"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"
@@ -31,12 +31,12 @@ rust-version = "1.75"
 # but needs a bit of work to make sure it's not used in the codebase
 pyo3 = { version = "0.22.0", features = ["generate-import-lib", "num-bigint", "py-clone"] }
 regex = "1.10.4"
-strum = { version = "0.25.0", features = ["derive"] }
-strum_macros = "0.26.1"
+strum = { version = "0.26.3", features = ["derive"] }
+strum_macros = "0.26.4"
 serde_json = {version = "1.0.116", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.13"
 serde = { version = "1.0.203", features = ["derive"] }
-speedate = "0.14.0"
+speedate = "0.14.4"
 smallvec = "1.13.2"
 ahash = "0.8.10"
 url = "2.5.0"
diff --git a/tests/validators/test_timedelta.py b/tests/validators/test_timedelta.py
index 3af2a0857..7ef45eaa0 100644
--- a/tests/validators/test_timedelta.py
+++ b/tests/validators/test_timedelta.py
@@ -195,10 +195,16 @@ def test_timedelta_kwargs_strict():
 
 
 def test_invalid_constraint():
-    with pytest.raises(SchemaError, match='timedelta.gt\n  Input should be a valid timedelta, invalid digit in'):
+    with pytest.raises(
+        SchemaError,
+        match='Invalid Schema:\ntimedelta.gt\n  Input should be a valid timedelta, invalid character in hour',
+    ):
         validate_core_schema({'type': 'timedelta', 'gt': 'foobar'})
 
-    with pytest.raises(SchemaError, match='timedelta.le\n  Input should be a valid timedelta, invalid digit in'):
+    with pytest.raises(
+        SchemaError,
+        match='Invalid Schema:\ntimedelta.le\n  Input should be a valid timedelta, invalid character in hour',
+    ):
         validate_core_schema({'type': 'timedelta', 'le': 'foobar'})
 
 

From e459d3c34eb13a9d815773cba36258186198c3b5 Mon Sep 17 00:00:00 2001
From: kfreezen <kfreezen@gmail.com>
Date: Wed, 17 Jul 2024 13:59:24 -0300
Subject: [PATCH 317/550] Fixes discriminated union bug regression when using
 enums (#1286)

---
 src/serializers/type_serializers/literal.rs |  2 +-
 tests/serializers/test_literal.py           | 76 +++++++++++++++++++++
 2 files changed, 77 insertions(+), 1 deletion(-)

diff --git a/src/serializers/type_serializers/literal.rs b/src/serializers/type_serializers/literal.rs
index d0b751e72..258f35ed9 100644
--- a/src/serializers/type_serializers/literal.rs
+++ b/src/serializers/type_serializers/literal.rs
@@ -89,7 +89,7 @@ impl LiteralSerializer {
                 if let Ok(py_str) = value.downcast::<PyString>() {
                     let s = py_str.to_str()?;
                     if self.expected_str.contains(s) {
-                        return Ok(OutputValue::OkStr(py_str.clone()));
+                        return Ok(OutputValue::OkStr(PyString::new_bound(value.py(), s)));
                     }
                 }
             }
diff --git a/tests/serializers/test_literal.py b/tests/serializers/test_literal.py
index d3cc9f262..6ce75ed96 100644
--- a/tests/serializers/test_literal.py
+++ b/tests/serializers/test_literal.py
@@ -1,3 +1,7 @@
+from dataclasses import dataclass
+from enum import Enum
+from typing import Literal, Union
+
 import pytest
 
 from pydantic_core import SchemaError, SchemaSerializer, core_schema
@@ -71,3 +75,75 @@ def test_bool_literal():
     assert s.to_python(False, mode='json') is False
     assert s.to_python(True) is True
     assert s.to_json(False) == b'false'
+
+
+def test_literal_with_enum() -> None:
+    class SomeEnum(str, Enum):
+        CAT = 'cat'
+        DOG = 'dog'
+
+    @dataclass
+    class Dog:
+        name: str
+        type: Literal[SomeEnum.DOG] = SomeEnum.DOG
+
+    @dataclass
+    class Cat:
+        name: str
+        type: Literal[SomeEnum.CAT] = SomeEnum.CAT
+
+    @dataclass
+    class Yard:
+        pet: Union[Dog, Cat]
+
+    serializer = SchemaSerializer(
+        core_schema.model_schema(
+            cls=Yard,
+            schema=core_schema.model_fields_schema(
+                fields={
+                    'pet': core_schema.model_field(
+                        schema=core_schema.tagged_union_schema(
+                            choices={
+                                SomeEnum.DOG: core_schema.model_schema(
+                                    cls=Dog,
+                                    schema=core_schema.model_fields_schema(
+                                        fields={
+                                            'type': core_schema.model_field(
+                                                schema=core_schema.with_default_schema(
+                                                    schema=core_schema.literal_schema([SomeEnum.DOG]),
+                                                    default=SomeEnum.DOG,
+                                                )
+                                            ),
+                                            'name': core_schema.model_field(schema=core_schema.str_schema()),
+                                        },
+                                        model_name='Dog',
+                                    ),
+                                ),
+                                SomeEnum.CAT: core_schema.model_schema(
+                                    cls=Cat,
+                                    schema=core_schema.model_fields_schema(
+                                        fields={
+                                            'type': core_schema.model_field(
+                                                schema=core_schema.with_default_schema(
+                                                    schema=core_schema.literal_schema([SomeEnum.CAT]),
+                                                    default=SomeEnum.CAT,
+                                                )
+                                            ),
+                                            'name': core_schema.model_field(schema=core_schema.str_schema()),
+                                        },
+                                        model_name='Cat',
+                                    ),
+                                ),
+                            },
+                            discriminator='type',
+                            strict=False,
+                            from_attributes=True,
+                        )
+                    )
+                }
+            ),
+        )
+    )
+
+    yard = Yard(pet=Dog(name='Rex'))
+    assert serializer.to_python(yard, mode='json') == {'pet': {'type': 'dog', 'name': 'Rex'}}

From 9f7bf4c0ecf145e47ea8b6af278ef0b4a0688708 Mon Sep 17 00:00:00 2001
From: Marcin Sobczyk <tinez@users.noreply.github.com>
Date: Thu, 18 Jul 2024 20:51:41 +0200
Subject: [PATCH 318/550] string: Use 're.Pattern.search' instead of
 're.Pattern.match' (#1368)

Signed-off-by: Marcin Sobczyk <msobczyk@redhat.com>
---
 src/validators/string.rs        | 2 +-
 tests/validators/test_string.py | 2 ++
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/validators/string.rs b/src/validators/string.rs
index 672bc64f5..a1f7765ad 100644
--- a/src/validators/string.rs
+++ b/src/validators/string.rs
@@ -277,7 +277,7 @@ impl Pattern {
         match &self.engine {
             RegexEngine::RustRegex(regex) => Ok(regex.is_match(target)),
             RegexEngine::PythonRe(py_regex) => {
-                Ok(!py_regex.call_method1(py, intern!(py, "match"), (target,))?.is_none(py))
+                Ok(!py_regex.call_method1(py, intern!(py, "search"), (target,))?.is_none(py))
             }
         }
     }
diff --git a/tests/validators/test_string.py b/tests/validators/test_string.py
index df6bd7ad7..50afc878a 100644
--- a/tests/validators/test_string.py
+++ b/tests/validators/test_string.py
@@ -80,6 +80,8 @@ def test_str_not_json(input_value, expected):
         ({'pattern': r'^\d+$'}, '12345', '12345'),
         ({'pattern': r'\d+$'}, 'foobar 123', 'foobar 123'),
         ({'pattern': r'^\d+$'}, '12345a', Err("String should match pattern '^\\d+$' [type=string_pattern_mismatch")),
+        ({'pattern': r'[a-z]'}, 'Abc', 'Abc'),
+        ({'pattern': re.compile(r'[a-z]')}, 'Abc', 'Abc'),
         # strip comes after length check
         ({'max_length': 5, 'strip_whitespace': True}, '1234  ', '1234'),
         # to_upper and strip comes after pattern check

From 61318d902d441959946fc8d9eb0a0ddc8b06648d Mon Sep 17 00:00:00 2001
From: Nicolas Wicht <niwicht@gmail.com>
Date: Thu, 18 Jul 2024 20:52:42 +0200
Subject: [PATCH 319/550] use Uuid:::from_u128 for uuid_to_string (#1362)

---
 src/serializers/type_serializers/uuid.rs | 8 ++++++--
 1 file changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/serializers/type_serializers/uuid.rs b/src/serializers/type_serializers/uuid.rs
index b2b6572a7..9609f11da 100644
--- a/src/serializers/type_serializers/uuid.rs
+++ b/src/serializers/type_serializers/uuid.rs
@@ -1,7 +1,8 @@
 use std::borrow::Cow;
 
-use pyo3::prelude::*;
 use pyo3::types::PyDict;
+use pyo3::{intern, prelude::*};
+use uuid::Uuid;
 
 use crate::definitions::DefinitionsBuilder;
 
@@ -11,7 +12,10 @@ use super::{
 };
 
 pub(crate) fn uuid_to_string(py_uuid: &Bound<'_, PyAny>) -> PyResult<String> {
-    Ok(py_uuid.str()?.to_string())
+    let py = py_uuid.py();
+    let uuid_int_val: u128 = py_uuid.getattr(intern!(py, "int"))?.extract()?;
+    let uuid = Uuid::from_u128(uuid_int_val);
+    Ok(uuid.to_string())
 }
 
 #[derive(Debug, Clone)]

From cd2521e332ee48e5282b14024d02ae104da31495 Mon Sep 17 00:00:00 2001
From: Nix <khiem3t@gmail.com>
Date: Fri, 19 Jul 2024 01:56:10 +0700
Subject: [PATCH 320/550] Fix model field serializer with computed field
 (#1349)

Co-authored-by: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
---
 src/serializers/computed_fields.rs | 14 +++++++++---
 tests/serializers/test_model.py    | 36 ++++++++++++++++++++++++++++++
 2 files changed, 47 insertions(+), 3 deletions(-)

diff --git a/src/serializers/computed_fields.rs b/src/serializers/computed_fields.rs
index 009f947dd..2d80d4f61 100644
--- a/src/serializers/computed_fields.rs
+++ b/src/serializers/computed_fields.rs
@@ -52,8 +52,12 @@ impl ComputedFields {
             // Do not serialize computed fields
             return Ok(());
         }
-        for computed_fields in &self.0 {
-            computed_fields.to_python(model, output_dict, filter, include, exclude, extra)?;
+        for computed_field in &self.0 {
+            let field_extra = Extra {
+                field_name: Some(computed_field.property_name.as_str()),
+                ..*extra
+            };
+            computed_field.to_python(model, output_dict, filter, include, exclude, &field_extra)?;
         }
         Ok(())
     }
@@ -83,12 +87,16 @@ impl ComputedFields {
                 if extra.exclude_none && value.is_none() {
                     continue;
                 }
+                let field_extra = Extra {
+                    field_name: Some(computed_field.property_name.as_str()),
+                    ..*extra
+                };
                 let cfs = ComputedFieldSerializer {
                     model,
                     computed_field,
                     include: next_include.as_ref(),
                     exclude: next_exclude.as_ref(),
-                    extra,
+                    extra: &field_extra,
                 };
                 let key = match extra.by_alias {
                     true => computed_field.alias.as_str(),
diff --git a/tests/serializers/test_model.py b/tests/serializers/test_model.py
index c93825839..ddf9e5f97 100644
--- a/tests/serializers/test_model.py
+++ b/tests/serializers/test_model.py
@@ -565,6 +565,42 @@ def ser_x(self, v: Any, _) -> str:
     assert json.loads(s.to_json(Model(x=1000))) == {'x': '1_000'}
 
 
+def test_function_plain_field_serializer_with_computed_field():
+    @dataclasses.dataclass
+    class Model:
+        x: int
+
+        @property
+        def computed_field_x(self) -> int:
+            return self.x + 200
+
+        def ser_func(self, v: Any, info: core_schema.FieldSerializationInfo) -> str:
+            return info.field_name + '_' + str(v * 2)
+
+    field_str_with_field_serializer = core_schema.str_schema(
+        serialization=core_schema.plain_serializer_function_ser_schema(
+            Model.ser_func,
+            is_field_serializer=True,
+            info_arg=True,
+            return_schema=core_schema.any_schema(),
+        )
+    )
+
+    s = SchemaSerializer(
+        core_schema.model_schema(
+            Model,
+            core_schema.model_fields_schema(
+                {'x': core_schema.model_field(field_str_with_field_serializer)},
+                computed_fields=[
+                    core_schema.computed_field('computed_field_x', field_str_with_field_serializer),
+                ],
+            ),
+        )
+    )
+    assert json.loads(s.to_json(Model(x=1000))) == {'x': 'x_2000', 'computed_field_x': 'computed_field_x_2400'}
+    assert s.to_python(Model(x=2000)) == {'x': 'x_4000', 'computed_field_x': 'computed_field_x_4400'}
+
+
 def test_function_wrap_field_serializer_to_json():
     @dataclasses.dataclass
     class Model:

From cb696e261a799333097d9674b9c55500eac54b74 Mon Sep 17 00:00:00 2001
From: Nicolas Wicht <niwicht@gmail.com>
Date: Mon, 22 Jul 2024 16:54:20 +0200
Subject: [PATCH 321/550] use little endian int (#1372)

Co-authored-by: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
---
 src/serializers/type_serializers/uuid.rs | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/serializers/type_serializers/uuid.rs b/src/serializers/type_serializers/uuid.rs
index 9609f11da..bb731e61b 100644
--- a/src/serializers/type_serializers/uuid.rs
+++ b/src/serializers/type_serializers/uuid.rs
@@ -14,7 +14,8 @@ use super::{
 pub(crate) fn uuid_to_string(py_uuid: &Bound<'_, PyAny>) -> PyResult<String> {
     let py = py_uuid.py();
     let uuid_int_val: u128 = py_uuid.getattr(intern!(py, "int"))?.extract()?;
-    let uuid = Uuid::from_u128(uuid_int_val);
+    // we use a little endian conversion for compatibility across platforms, see https://github.com/pydantic/pydantic-core/pull/1372
+    let uuid = Uuid::from_u128(uuid_int_val.to_le());
     Ok(uuid.to_string())
 }
 

From 06a834887de8a7fe318c50b51cc155dedb469267 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 25 Jul 2024 10:44:00 +0100
Subject: [PATCH 322/550] Bump idna from 0.5.0 to 1.0.1 (#1358)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
---
 Cargo.lock | 269 ++++++++++++++++++++++++++++++++++++++++++++++++++++-
 Cargo.toml |   2 +-
 2 files changed, 268 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 076cf3191..770f6d0b6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -60,6 +60,17 @@ version = "1.0.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
 
+[[package]]
+name = "displaydoc"
+version = "0.2.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "97369cbbc041bc366949bc74d34658d6cda5621039731c6310521892a3a20ae0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "enum_dispatch"
 version = "0.3.13"
@@ -116,6 +127,124 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
+[[package]]
+name = "icu_collections"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "db2fa452206ebee18c4b5c2274dbf1de17008e874b4dc4f0aea9d01ca79e4526"
+dependencies = [
+ "displaydoc",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locid"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "13acbb8371917fc971be86fc8057c41a64b521c184808a698c02acc242dbf637"
+dependencies = [
+ "displaydoc",
+ "litemap",
+ "tinystr",
+ "writeable",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locid_transform"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "01d11ac35de8e40fdeda00d9e1e9d92525f3f9d887cdd7aa81d727596788b54e"
+dependencies = [
+ "displaydoc",
+ "icu_locid",
+ "icu_locid_transform_data",
+ "icu_provider",
+ "tinystr",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_locid_transform_data"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fdc8ff3388f852bede6b579ad4e978ab004f139284d7b28715f773507b946f6e"
+
+[[package]]
+name = "icu_normalizer"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "19ce3e0da2ec68599d193c93d088142efd7f9c5d6fc9b803774855747dc6a84f"
+dependencies = [
+ "displaydoc",
+ "icu_collections",
+ "icu_normalizer_data",
+ "icu_properties",
+ "icu_provider",
+ "smallvec",
+ "utf16_iter",
+ "utf8_iter",
+ "write16",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_normalizer_data"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8cafbf7aa791e9b22bec55a167906f9e1215fd475cd22adfcf660e03e989516"
+
+[[package]]
+name = "icu_properties"
+version = "1.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "93d6020766cfc6302c15dbbc9c8778c37e62c14427cb7f6e601d849e092aeef5"
+dependencies = [
+ "displaydoc",
+ "icu_collections",
+ "icu_locid_transform",
+ "icu_properties_data",
+ "icu_provider",
+ "tinystr",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_properties_data"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "67a8effbc3dd3e4ba1afa8ad918d5684b8868b3b26500753effea8d2eed19569"
+
+[[package]]
+name = "icu_provider"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ed421c8a8ef78d3e2dbc98a973be2f3770cb42b606e3ab18d6237c4dfde68d9"
+dependencies = [
+ "displaydoc",
+ "icu_locid",
+ "icu_provider_macros",
+ "stable_deref_trait",
+ "tinystr",
+ "writeable",
+ "yoke",
+ "zerofrom",
+ "zerovec",
+]
+
+[[package]]
+name = "icu_provider_macros"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1ec89e9337638ecdc08744df490b221a7399bf8d164eb52a665454e60e075ad6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "idna"
 version = "0.5.0"
@@ -126,6 +255,18 @@ dependencies = [
  "unicode-normalization",
 ]
 
+[[package]]
+name = "idna"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "44a986806a1cc899952ba462bc1f28afbfd5850ab6cb030ccb20dd02cc527a24"
+dependencies = [
+ "icu_normalizer",
+ "icu_properties",
+ "smallvec",
+ "utf8_iter",
+]
+
 [[package]]
 name = "indexmap"
 version = "2.2.6"
@@ -200,6 +341,12 @@ version = "0.2.155"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "97b3888a4aecf77e811145cadf6eef5901f4782c53886191b2f693f24761847c"
 
+[[package]]
+name = "litemap"
+version = "0.7.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "643cb0b8d4fcc284004d5fd0d67ccf61dfffadb7f75e1e71bc420f4688a3a704"
+
 [[package]]
 name = "memchr"
 version = "2.7.4"
@@ -277,7 +424,7 @@ dependencies = [
  "ahash",
  "base64",
  "enum_dispatch",
- "idna",
+ "idna 1.0.1",
  "jiter",
  "num-bigint",
  "pyo3",
@@ -471,6 +618,12 @@ dependencies = [
  "strum_macros",
 ]
 
+[[package]]
+name = "stable_deref_trait"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a8f112729512f8e442d81f95a8a7ddf2b7c6b8a1a6f509a95864142b30cab2d3"
+
 [[package]]
 name = "static_assertions"
 version = "1.1.0"
@@ -510,6 +663,17 @@ dependencies = [
  "unicode-ident",
 ]
 
+[[package]]
+name = "synstructure"
+version = "0.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8af7666ab7b6390ab78131fb5b0fce11d6b7a6951602017c35fa82800708971"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "tap"
 version = "1.0.1"
@@ -522,6 +686,16 @@ version = "0.12.14"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "e1fc403891a21bcfb7c37834ba66a547a8f402146eba7265b5a6d88059c9ff2f"
 
+[[package]]
+name = "tinystr"
+version = "0.7.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9117f5d4db391c1cf6927e7bea3db74b9a1c1add8f7eda9ffd5364f40f57b82f"
+dependencies = [
+ "displaydoc",
+ "zerovec",
+]
+
 [[package]]
 name = "tinyvec"
 version = "1.6.1"
@@ -571,10 +745,22 @@ source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "22784dbdf76fdde8af1aeda5622b546b422b6fc585325248a2bf9f5e41e94d6c"
 dependencies = [
  "form_urlencoded",
- "idna",
+ "idna 0.5.0",
  "percent-encoding",
 ]
 
+[[package]]
+name = "utf16_iter"
+version = "1.0.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c8232dd3cdaed5356e0f716d285e4b40b932ac434100fe9b7e0e8e935b9e6246"
+
+[[package]]
+name = "utf8_iter"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
+
 [[package]]
 name = "uuid"
 version = "1.9.1"
@@ -593,6 +779,18 @@ version = "0.11.0+wasi-snapshot-preview1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "9c8d87e72b64a3b4db28d11ce29237c246188f4f51057d65a7eab63b7987e423"
 
+[[package]]
+name = "write16"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d1890f4022759daae28ed4fe62859b1236caebfc61ede2f63ed4e695f3f6d936"
+
+[[package]]
+name = "writeable"
+version = "0.5.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e9df38ee2d2c3c5948ea468a8406ff0db0b29ae1ffde1bcf20ef305bcc95c51"
+
 [[package]]
 name = "wyz"
 version = "0.5.1"
@@ -602,6 +800,30 @@ dependencies = [
  "tap",
 ]
 
+[[package]]
+name = "yoke"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6c5b1314b079b0930c31e3af543d8ee1757b1951ae1e1565ec704403a7240ca5"
+dependencies = [
+ "serde",
+ "stable_deref_trait",
+ "yoke-derive",
+ "zerofrom",
+]
+
+[[package]]
+name = "yoke-derive"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "28cc31741b18cb6f1d5ff12f5b7523e3d6eb0852bbbad19d73905511d9849b95"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
+
 [[package]]
 name = "zerocopy"
 version = "0.7.34"
@@ -621,3 +843,46 @@ dependencies = [
  "quote",
  "syn",
 ]
+
+[[package]]
+name = "zerofrom"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "91ec111ce797d0e0784a1116d0ddcdbea84322cd79e5d5ad173daeba4f93ab55"
+dependencies = [
+ "zerofrom-derive",
+]
+
+[[package]]
+name = "zerofrom-derive"
+version = "0.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0ea7b4a3637ea8669cedf0f1fd5c286a17f3de97b8dd5a70a6c167a1730e63a5"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+ "synstructure",
+]
+
+[[package]]
+name = "zerovec"
+version = "0.10.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "aa2b893d79df23bfb12d5461018d408ea19dfafe76c2c7ef6d4eba614f8ff079"
+dependencies = [
+ "yoke",
+ "zerofrom",
+ "zerovec-derive",
+]
+
+[[package]]
+name = "zerovec-derive"
+version = "0.10.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6eafa6dfb17584ea3e2bd6e76e0cc15ad7af12b09abdd1ca55961bed9b1063c6"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
diff --git a/Cargo.toml b/Cargo.toml
index 003f8865f..6832fc4e8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -41,7 +41,7 @@ smallvec = "1.13.2"
 ahash = "0.8.10"
 url = "2.5.0"
 # idna is already required by url, added here to be explicit
-idna = "0.5.0"
+idna = "1.0.1"
 base64 = "0.21.7"
 num-bigint = "0.4.6"
 python3-dll-a = "0.2.10"

From 40b8a947c4550d140adbe2b4a87466be21dbfff9 Mon Sep 17 00:00:00 2001
From: Boxy <rust@boxyuwu.dev>
Date: Tue, 30 Jul 2024 16:42:57 +0100
Subject: [PATCH 323/550] Fix lints firing since rust 1.80 (#1379)

---
 Cargo.lock                 | 2 ++
 build.rs                   | 1 +
 src/serializers/ob_type.rs | 3 ++-
 3 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/Cargo.lock b/Cargo.lock
index 770f6d0b6..3638f2629 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -613,6 +613,8 @@ checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
 [[package]]
 name = "speedate"
 version = "0.14.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "08a20480dbd4c693f0b0f3210f2cee5bfa21a176c1fa4df0e65cc0474e7fa557"
 dependencies = [
  "strum",
  "strum_macros",
diff --git a/build.rs b/build.rs
index 7f59e1f57..d1093c747 100644
--- a/build.rs
+++ b/build.rs
@@ -35,6 +35,7 @@ fn main() {
     if let Some(true) = version_check::supports_feature("coverage_attribute") {
         println!("cargo:rustc-cfg=has_coverage_attribute");
     }
+    println!("cargo:rustc-check-cfg=cfg(has_coverage_attribute)");
     generate_self_schema();
     println!("cargo:rustc-env=PROFILE={}", std::env::var("PROFILE").unwrap());
 }
diff --git a/src/serializers/ob_type.rs b/src/serializers/ob_type.rs
index 1eaa090a8..196cf27b7 100644
--- a/src/serializers/ob_type.rs
+++ b/src/serializers/ob_type.rs
@@ -290,7 +290,8 @@ impl ObTypeLookup {
     /// We care about order here since:
     /// 1. we pay a price for each `isinstance` call
     /// 2. some types are subclasses of others, e.g. `bool` is a subclass of `int`
-    /// hence we put common types first
+    ///    hence we put common types first
+    ///
     /// In addition, some types have inheritance set as a bitflag on the type object:
     /// https://github.com/python/cpython/blob/v3.12.0rc1/Include/object.h#L546-L553
     /// Hence they come first

From 57e69918670016c4cf00a844aabcf76bb0cd458f Mon Sep 17 00:00:00 2001
From: Josh Newman <josh@d8e.ai>
Date: Wed, 31 Jul 2024 22:53:46 -0700
Subject: [PATCH 324/550] Validate bytes based on ser_json_bytes (#1308)

---
 Cargo.lock                              |  7 +++
 Cargo.toml                              |  1 +
 python/pydantic_core/_pydantic_core.pyi |  8 +--
 python/pydantic_core/core_schema.py     |  3 +
 src/errors/types.rs                     | 10 ++++
 src/input/input_abstract.rs             |  3 +-
 src/input/input_json.rs                 | 23 ++++++--
 src/input/input_python.rs               | 12 +++-
 src/input/input_string.rs               | 12 +++-
 src/lib.rs                              |  4 +-
 src/serializers/config.rs               |  6 +-
 src/serializers/mod.rs                  |  1 +
 src/validators/bytes.rs                 | 11 +++-
 src/validators/config.rs                | 49 ++++++++++++++++
 src/validators/json.rs                  |  4 +-
 src/validators/mod.rs                   |  2 +
 src/validators/uuid.rs                  |  4 +-
 tests/test_errors.py                    | 10 ++++
 tests/test_json.py                      | 75 +++++++++++++++++++++++++
 19 files changed, 223 insertions(+), 22 deletions(-)
 create mode 100644 src/validators/config.rs

diff --git a/Cargo.lock b/Cargo.lock
index 3638f2629..c0ba1f49b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -127,6 +127,12 @@ version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
+[[package]]
+name = "hex"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7f24254aa9a54b5c858eaee2f5bccdb46aaf0e486a595ed5fd8f86ba55232a70"
+
 [[package]]
 name = "icu_collections"
 version = "1.5.0"
@@ -424,6 +430,7 @@ dependencies = [
  "ahash",
  "base64",
  "enum_dispatch",
+ "hex",
  "idna 1.0.1",
  "jiter",
  "num-bigint",
diff --git a/Cargo.toml b/Cargo.toml
index 6832fc4e8..04d22e02b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -47,6 +47,7 @@ num-bigint = "0.4.6"
 python3-dll-a = "0.2.10"
 uuid = "1.9.1"
 jiter = { version = "0.5", features = ["python"] }
+hex = "0.4.3"
 
 [lib]
 name = "_pydantic_core"
diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index 05fe48e40..34c70cd31 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -352,7 +352,7 @@ def to_json(
     exclude_none: bool = False,
     round_trip: bool = False,
     timedelta_mode: Literal['iso8601', 'float'] = 'iso8601',
-    bytes_mode: Literal['utf8', 'base64'] = 'utf8',
+    bytes_mode: Literal['utf8', 'base64', 'hex'] = 'utf8',
     inf_nan_mode: Literal['null', 'constants', 'strings'] = 'constants',
     serialize_unknown: bool = False,
     fallback: Callable[[Any], Any] | None = None,
@@ -373,7 +373,7 @@ def to_json(
         exclude_none: Whether to exclude fields that have a value of `None`.
         round_trip: Whether to enable serialization and validation round-trip support.
         timedelta_mode: How to serialize `timedelta` objects, either `'iso8601'` or `'float'`.
-        bytes_mode: How to serialize `bytes` objects, either `'utf8'` or `'base64'`.
+        bytes_mode: How to serialize `bytes` objects, either `'utf8'`, `'base64'`, or `'hex'`.
         inf_nan_mode: How to serialize `Infinity`, `-Infinity` and `NaN` values, either `'null'`, `'constants'`, or `'strings'`.
         serialize_unknown: Attempt to serialize unknown types, `str(value)` will be used, if that fails
             `"<Unserializable {value_type} object>"` will be used.
@@ -427,7 +427,7 @@ def to_jsonable_python(
     exclude_none: bool = False,
     round_trip: bool = False,
     timedelta_mode: Literal['iso8601', 'float'] = 'iso8601',
-    bytes_mode: Literal['utf8', 'base64'] = 'utf8',
+    bytes_mode: Literal['utf8', 'base64', 'hex'] = 'utf8',
     inf_nan_mode: Literal['null', 'constants', 'strings'] = 'constants',
     serialize_unknown: bool = False,
     fallback: Callable[[Any], Any] | None = None,
@@ -448,7 +448,7 @@ def to_jsonable_python(
         exclude_none: Whether to exclude fields that have a value of `None`.
         round_trip: Whether to enable serialization and validation round-trip support.
         timedelta_mode: How to serialize `timedelta` objects, either `'iso8601'` or `'float'`.
-        bytes_mode: How to serialize `bytes` objects, either `'utf8'` or `'base64'`.
+        bytes_mode: How to serialize `bytes` objects, either `'utf8'`, `'base64'`, or `'hex'`.
         inf_nan_mode: How to serialize `Infinity`, `-Infinity` and `NaN` values, either `'null'`, `'constants'`, or `'strings'`.
         serialize_unknown: Attempt to serialize unknown types, `str(value)` will be used, if that fails
             `"<Unserializable {value_type} object>"` will be used.
diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index 5405d96b2..c157a027b 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -70,6 +70,7 @@ class CoreConfig(TypedDict, total=False):
         ser_json_bytes: The serialization option for `bytes` values. Default is 'utf8'.
         ser_json_inf_nan: The serialization option for infinity and NaN values
             in float fields. Default is 'null'.
+        val_json_bytes: The validation option for `bytes` values, complementing ser_json_bytes. Default is 'utf8'.
         hide_input_in_errors: Whether to hide input data from `ValidationError` representation.
         validation_error_cause: Whether to add user-python excs to the __cause__ of a ValidationError.
             Requires exceptiongroup backport pre Python 3.11.
@@ -107,6 +108,7 @@ class CoreConfig(TypedDict, total=False):
     ser_json_timedelta: Literal['iso8601', 'float']  # default: 'iso8601'
     ser_json_bytes: Literal['utf8', 'base64', 'hex']  # default: 'utf8'
     ser_json_inf_nan: Literal['null', 'constants', 'strings']  # default: 'null'
+    val_json_bytes: Literal['utf8', 'base64', 'hex']  # default: 'utf8'
     # used to hide input data from ValidationError repr
     hide_input_in_errors: bool
     validation_error_cause: bool  # default: False
@@ -3904,6 +3906,7 @@ def definition_reference_schema(
     'bytes_type',
     'bytes_too_short',
     'bytes_too_long',
+    'bytes_invalid_encoding',
     'value_error',
     'assertion_error',
     'literal_error',
diff --git a/src/errors/types.rs b/src/errors/types.rs
index 09ad47f38..8807ba129 100644
--- a/src/errors/types.rs
+++ b/src/errors/types.rs
@@ -290,6 +290,10 @@ error_types! {
     BytesTooLong {
         max_length: {ctx_type: usize, ctx_fn: field_from_context},
     },
+    BytesInvalidEncoding {
+        encoding: {ctx_type: String, ctx_fn: field_from_context},
+        encoding_error: {ctx_type: String, ctx_fn: field_from_context},
+    },
     // ---------------------
     // python errors from functions
     ValueError {
@@ -515,6 +519,7 @@ impl ErrorType {
             Self::BytesType {..} => "Input should be a valid bytes",
             Self::BytesTooShort {..} => "Data should have at least {min_length} byte{expected_plural}",
             Self::BytesTooLong {..} => "Data should have at most {max_length} byte{expected_plural}",
+            Self::BytesInvalidEncoding { .. } => "Data should be valid {encoding}: {encoding_error}",
             Self::ValueError {..} => "Value error, {error}",
             Self::AssertionError {..} => "Assertion failed, {error}",
             Self::CustomError {..} => "",  // custom errors are handled separately
@@ -664,6 +669,11 @@ impl ErrorType {
                 let expected_plural = plural_s(*max_length);
                 to_string_render!(tmpl, max_length, expected_plural)
             }
+            Self::BytesInvalidEncoding {
+                encoding,
+                encoding_error,
+                ..
+            } => render!(tmpl, encoding, encoding_error),
             Self::ValueError { error, .. } => {
                 let error = &error
                     .as_ref()
diff --git a/src/input/input_abstract.rs b/src/input/input_abstract.rs
index 5e915c548..b0e058d9b 100644
--- a/src/input/input_abstract.rs
+++ b/src/input/input_abstract.rs
@@ -7,6 +7,7 @@ use pyo3::{intern, prelude::*};
 use crate::errors::{ErrorTypeDefaults, InputValue, LocItem, ValError, ValResult};
 use crate::lookup_key::{LookupKey, LookupPath};
 use crate::tools::py_err;
+use crate::validators::ValBytesMode;
 
 use super::datetime::{EitherDate, EitherDateTime, EitherTime, EitherTimedelta};
 use super::return_enums::{EitherBytes, EitherInt, EitherString};
@@ -71,7 +72,7 @@ pub trait Input<'py>: fmt::Debug + ToPyObject {
 
     fn validate_str(&self, strict: bool, coerce_numbers_to_str: bool) -> ValMatch<EitherString<'_>>;
 
-    fn validate_bytes<'a>(&'a self, strict: bool) -> ValMatch<EitherBytes<'a, 'py>>;
+    fn validate_bytes<'a>(&'a self, strict: bool, mode: ValBytesMode) -> ValMatch<EitherBytes<'a, 'py>>;
 
     fn validate_bool(&self, strict: bool) -> ValMatch<bool>;
 
diff --git a/src/input/input_json.rs b/src/input/input_json.rs
index f2bf74998..3adc36ba6 100644
--- a/src/input/input_json.rs
+++ b/src/input/input_json.rs
@@ -10,6 +10,7 @@ use strum::EnumMessage;
 use crate::errors::{ErrorType, ErrorTypeDefaults, InputValue, LocItem, ValError, ValResult};
 use crate::lookup_key::{LookupKey, LookupPath};
 use crate::validators::decimal::create_decimal;
+use crate::validators::ValBytesMode;
 
 use super::datetime::{
     bytes_as_date, bytes_as_datetime, bytes_as_time, bytes_as_timedelta, float_as_datetime, float_as_duration,
@@ -106,9 +107,16 @@ impl<'py, 'data> Input<'py> for JsonValue<'data> {
         }
     }
 
-    fn validate_bytes<'a>(&'a self, _strict: bool) -> ValResult<ValidationMatch<EitherBytes<'a, 'py>>> {
+    fn validate_bytes<'a>(
+        &'a self,
+        _strict: bool,
+        mode: ValBytesMode,
+    ) -> ValResult<ValidationMatch<EitherBytes<'a, 'py>>> {
         match self {
-            JsonValue::Str(s) => Ok(ValidationMatch::strict(s.as_bytes().into())),
+            JsonValue::Str(s) => match mode.deserialize_string(s) {
+                Ok(b) => Ok(ValidationMatch::strict(b)),
+                Err(e) => Err(ValError::new(e, self)),
+            },
             _ => Err(ValError::new(ErrorTypeDefaults::BytesType, self)),
         }
     }
@@ -342,8 +350,15 @@ impl<'py> Input<'py> for str {
         Ok(ValidationMatch::strict(self.into()))
     }
 
-    fn validate_bytes<'a>(&'a self, _strict: bool) -> ValResult<ValidationMatch<EitherBytes<'a, 'py>>> {
-        Ok(ValidationMatch::strict(self.as_bytes().into()))
+    fn validate_bytes<'a>(
+        &'a self,
+        _strict: bool,
+        mode: ValBytesMode,
+    ) -> ValResult<ValidationMatch<EitherBytes<'a, 'py>>> {
+        match mode.deserialize_string(self) {
+            Ok(b) => Ok(ValidationMatch::strict(b)),
+            Err(e) => Err(ValError::new(e, self)),
+        }
     }
 
     fn validate_bool(&self, _strict: bool) -> ValResult<ValidationMatch<bool>> {
diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index 3de712272..519a96f89 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -17,6 +17,7 @@ use crate::errors::{ErrorType, ErrorTypeDefaults, InputValue, LocItem, ValError,
 use crate::tools::{extract_i64, safe_repr};
 use crate::validators::decimal::{create_decimal, get_decimal_type};
 use crate::validators::Exactness;
+use crate::validators::ValBytesMode;
 use crate::ArgsKwargs;
 
 use super::datetime::{
@@ -174,7 +175,11 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
         Err(ValError::new(ErrorTypeDefaults::StringType, self))
     }
 
-    fn validate_bytes<'a>(&'a self, strict: bool) -> ValResult<ValidationMatch<EitherBytes<'a, 'py>>> {
+    fn validate_bytes<'a>(
+        &'a self,
+        strict: bool,
+        mode: ValBytesMode,
+    ) -> ValResult<ValidationMatch<EitherBytes<'a, 'py>>> {
         if let Ok(py_bytes) = self.downcast_exact::<PyBytes>() {
             return Ok(ValidationMatch::exact(py_bytes.into()));
         } else if let Ok(py_bytes) = self.downcast::<PyBytes>() {
@@ -185,7 +190,10 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
             if !strict {
                 return if let Ok(py_str) = self.downcast::<PyString>() {
                     let str = py_string_str(py_str)?;
-                    Ok(str.as_bytes().into())
+                    match mode.deserialize_string(str) {
+                        Ok(b) => Ok(b),
+                        Err(e) => Err(ValError::new(e, self)),
+                    }
                 } else if let Ok(py_byte_array) = self.downcast::<PyByteArray>() {
                     Ok(py_byte_array.to_vec().into())
                 } else {
diff --git a/src/input/input_string.rs b/src/input/input_string.rs
index 3c61cdebc..3ef1b58ce 100644
--- a/src/input/input_string.rs
+++ b/src/input/input_string.rs
@@ -8,6 +8,7 @@ use crate::input::py_string_str;
 use crate::lookup_key::{LookupKey, LookupPath};
 use crate::tools::safe_repr;
 use crate::validators::decimal::create_decimal;
+use crate::validators::ValBytesMode;
 
 use super::datetime::{
     bytes_as_date, bytes_as_datetime, bytes_as_time, bytes_as_timedelta, EitherDate, EitherDateTime, EitherTime,
@@ -105,9 +106,16 @@ impl<'py> Input<'py> for StringMapping<'py> {
         }
     }
 
-    fn validate_bytes<'a>(&'a self, _strict: bool) -> ValResult<ValidationMatch<EitherBytes<'a, 'py>>> {
+    fn validate_bytes<'a>(
+        &'a self,
+        _strict: bool,
+        mode: ValBytesMode,
+    ) -> ValResult<ValidationMatch<EitherBytes<'a, 'py>>> {
         match self {
-            Self::String(s) => py_string_str(s).map(|b| ValidationMatch::strict(b.as_bytes().into())),
+            Self::String(s) => py_string_str(s).and_then(|b| match mode.deserialize_string(b) {
+                Ok(b) => Ok(ValidationMatch::strict(b)),
+                Err(e) => Err(ValError::new(e, self)),
+            }),
             Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::BytesType, self)),
         }
     }
diff --git a/src/lib.rs b/src/lib.rs
index d55e83645..e94abf679 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -7,6 +7,8 @@ use std::sync::OnceLock;
 use jiter::{map_json_error, PartialMode, PythonParse, StringCacheMode};
 use pyo3::exceptions::PyTypeError;
 use pyo3::{prelude::*, sync::GILOnceCell};
+use serializers::BytesMode;
+use validators::ValBytesMode;
 
 // parse this first to get access to the contained macro
 #[macro_use]
@@ -55,7 +57,7 @@ pub fn from_json<'py>(
     allow_partial: bool,
 ) -> PyResult<Bound<'py, PyAny>> {
     let v_match = data
-        .validate_bytes(false)
+        .validate_bytes(false, ValBytesMode { ser: BytesMode::Utf8 })
         .map_err(|_| PyTypeError::new_err("Expected bytes, bytearray or str"))?;
     let json_either_bytes = v_match.into_inner();
     let json_bytes = json_either_bytes.as_slice();
diff --git a/src/serializers/config.rs b/src/serializers/config.rs
index 5421ed920..359d35276 100644
--- a/src/serializers/config.rs
+++ b/src/serializers/config.rs
@@ -52,7 +52,7 @@ pub trait FromConfig {
 macro_rules! serialization_mode {
     ($name:ident, $config_key:expr, $($variant:ident => $value:expr),* $(,)?) => {
         #[derive(Default, Debug, Clone, Copy, PartialEq, Eq)]
-        pub(crate) enum $name {
+        pub enum $name {
             #[default]
             $($variant,)*
         }
@@ -183,9 +183,7 @@ impl BytesMode {
                 Err(e) => Err(Error::custom(e.to_string())),
             },
             Self::Base64 => serializer.serialize_str(&base64::engine::general_purpose::URL_SAFE.encode(bytes)),
-            Self::Hex => {
-                serializer.serialize_str(&bytes.iter().fold(String::new(), |acc, b| acc + &format!("{b:02x}")))
-            }
+            Self::Hex => serializer.serialize_str(hex::encode(bytes).as_str()),
         }
     }
 }
diff --git a/src/serializers/mod.rs b/src/serializers/mod.rs
index 66b345530..1a0405e2c 100644
--- a/src/serializers/mod.rs
+++ b/src/serializers/mod.rs
@@ -8,6 +8,7 @@ use pyo3::{PyTraverseError, PyVisit};
 use crate::definitions::{Definitions, DefinitionsBuilder};
 use crate::py_gc::PyGcTraverse;
 
+pub(crate) use config::BytesMode;
 use config::SerializationConfig;
 pub use errors::{PydanticSerializationError, PydanticSerializationUnexpectedValue};
 use extra::{CollectWarnings, SerRecursionState, WarningsMode};
diff --git a/src/validators/bytes.rs b/src/validators/bytes.rs
index eb9d9441d..c51d77171 100644
--- a/src/validators/bytes.rs
+++ b/src/validators/bytes.rs
@@ -8,11 +8,13 @@ use crate::input::Input;
 
 use crate::tools::SchemaDict;
 
+use super::config::ValBytesMode;
 use super::{BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
 
 #[derive(Debug, Clone)]
 pub struct BytesValidator {
     strict: bool,
+    bytes_mode: ValBytesMode,
 }
 
 impl BuildValidator for BytesValidator {
@@ -31,6 +33,7 @@ impl BuildValidator for BytesValidator {
         } else {
             Ok(Self {
                 strict: is_strict(schema, config)?,
+                bytes_mode: ValBytesMode::from_config(config)?,
             }
             .into())
         }
@@ -47,7 +50,7 @@ impl Validator for BytesValidator {
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         input
-            .validate_bytes(state.strict_or(self.strict))
+            .validate_bytes(state.strict_or(self.strict), self.bytes_mode)
             .map(|m| m.unpack(state).into_py(py))
     }
 
@@ -59,6 +62,7 @@ impl Validator for BytesValidator {
 #[derive(Debug, Clone)]
 pub struct BytesConstrainedValidator {
     strict: bool,
+    bytes_mode: ValBytesMode,
     max_length: Option<usize>,
     min_length: Option<usize>,
 }
@@ -72,7 +76,9 @@ impl Validator for BytesConstrainedValidator {
         input: &(impl Input<'py> + ?Sized),
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
-        let either_bytes = input.validate_bytes(state.strict_or(self.strict))?.unpack(state);
+        let either_bytes = input
+            .validate_bytes(state.strict_or(self.strict), self.bytes_mode)?
+            .unpack(state);
         let len = either_bytes.len()?;
 
         if let Some(min_length) = self.min_length {
@@ -110,6 +116,7 @@ impl BytesConstrainedValidator {
         let py = schema.py();
         Ok(Self {
             strict: is_strict(schema, config)?,
+            bytes_mode: ValBytesMode::from_config(config)?,
             min_length: schema.get_as(intern!(py, "min_length"))?,
             max_length: schema.get_as(intern!(py, "max_length"))?,
         }
diff --git a/src/validators/config.rs b/src/validators/config.rs
new file mode 100644
index 000000000..8ffcfd0f5
--- /dev/null
+++ b/src/validators/config.rs
@@ -0,0 +1,49 @@
+use std::borrow::Cow;
+use std::str::FromStr;
+
+use base64::Engine;
+use pyo3::types::{PyDict, PyString};
+use pyo3::{intern, prelude::*};
+
+use crate::errors::ErrorType;
+use crate::input::EitherBytes;
+use crate::serializers::BytesMode;
+use crate::tools::SchemaDict;
+
+#[derive(Default, Debug, Clone, Copy, PartialEq, Eq)]
+pub struct ValBytesMode {
+    pub ser: BytesMode,
+}
+
+impl ValBytesMode {
+    pub fn from_config(config: Option<&Bound<'_, PyDict>>) -> PyResult<Self> {
+        let Some(config_dict) = config else {
+            return Ok(Self::default());
+        };
+        let raw_mode = config_dict.get_as::<Bound<'_, PyString>>(intern!(config_dict.py(), "val_json_bytes"))?;
+        let ser_mode = raw_mode.map_or_else(|| Ok(BytesMode::default()), |raw| BytesMode::from_str(&raw.to_cow()?))?;
+        Ok(Self { ser: ser_mode })
+    }
+
+    pub fn deserialize_string<'py>(self, s: &str) -> Result<EitherBytes<'_, 'py>, ErrorType> {
+        match self.ser {
+            BytesMode::Utf8 => Ok(EitherBytes::Cow(Cow::Borrowed(s.as_bytes()))),
+            BytesMode::Base64 => match base64::engine::general_purpose::URL_SAFE.decode(s) {
+                Ok(bytes) => Ok(EitherBytes::from(bytes)),
+                Err(err) => Err(ErrorType::BytesInvalidEncoding {
+                    encoding: "base64".to_string(),
+                    encoding_error: err.to_string(),
+                    context: None,
+                }),
+            },
+            BytesMode::Hex => match hex::decode(s) {
+                Ok(vec) => Ok(EitherBytes::from(vec)),
+                Err(err) => Err(ErrorType::BytesInvalidEncoding {
+                    encoding: "hex".to_string(),
+                    encoding_error: err.to_string(),
+                    context: None,
+                }),
+            },
+        }
+    }
+}
diff --git a/src/validators/json.rs b/src/validators/json.rs
index 3e35a640b..f86cc4624 100644
--- a/src/validators/json.rs
+++ b/src/validators/json.rs
@@ -6,8 +6,10 @@ use jiter::{JsonValue, PartialMode, PythonParse};
 
 use crate::errors::{ErrorType, ErrorTypeDefaults, ValError, ValLineError, ValResult};
 use crate::input::{EitherBytes, Input, InputType, ValidationMatch};
+use crate::serializers::BytesMode;
 use crate::tools::SchemaDict;
 
+use super::config::ValBytesMode;
 use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
 
 #[derive(Debug)]
@@ -87,7 +89,7 @@ impl Validator for JsonValidator {
 pub fn validate_json_bytes<'a, 'py>(
     input: &'a (impl Input<'py> + ?Sized),
 ) -> ValResult<ValidationMatch<EitherBytes<'a, 'py>>> {
-    match input.validate_bytes(false) {
+    match input.validate_bytes(false, ValBytesMode { ser: BytesMode::Utf8 }) {
         Ok(v_match) => Ok(v_match),
         Err(ValError::LineErrors(e)) => Err(ValError::LineErrors(
             e.into_iter().map(map_bytes_error).collect::<Vec<_>>(),
diff --git a/src/validators/mod.rs b/src/validators/mod.rs
index 02abda1fd..18c947313 100644
--- a/src/validators/mod.rs
+++ b/src/validators/mod.rs
@@ -16,6 +16,7 @@ use crate::input::{Input, InputType, StringMapping};
 use crate::py_gc::PyGcTraverse;
 use crate::recursion_guard::RecursionState;
 use crate::tools::SchemaDict;
+pub(crate) use config::ValBytesMode;
 
 mod any;
 mod arguments;
@@ -24,6 +25,7 @@ mod bytes;
 mod call;
 mod callable;
 mod chain;
+mod config;
 mod custom_error;
 mod dataclass;
 mod date;
diff --git a/src/validators/uuid.rs b/src/validators/uuid.rs
index 44aa22003..e19dfcfd0 100644
--- a/src/validators/uuid.rs
+++ b/src/validators/uuid.rs
@@ -13,8 +13,10 @@ use crate::input::input_as_python_instance;
 use crate::input::Input;
 use crate::input::InputType;
 use crate::input::ValidationMatch;
+use crate::serializers::BytesMode;
 use crate::tools::SchemaDict;
 
+use super::config::ValBytesMode;
 use super::model::create_class;
 use super::model::force_setattr;
 use super::{BuildValidator, CombinedValidator, DefinitionsBuilder, Exactness, ValidationState, Validator};
@@ -172,7 +174,7 @@ impl UuidValidator {
             }
             None => {
                 let either_bytes = input
-                    .validate_bytes(true)
+                    .validate_bytes(true, ValBytesMode { ser: BytesMode::Utf8 })
                     .map_err(|_| ValError::new(ErrorTypeDefaults::UuidType, input))?
                     .into_inner();
                 let bytes_slice = either_bytes.as_slice();
diff --git a/tests/test_errors.py b/tests/test_errors.py
index daabf04c6..bd6f6214e 100644
--- a/tests/test_errors.py
+++ b/tests/test_errors.py
@@ -320,6 +320,16 @@ def f(input_value, info):
     ('bytes_too_short', 'Data should have at least 1 byte', {'min_length': 1}),
     ('bytes_too_long', 'Data should have at most 42 bytes', {'max_length': 42}),
     ('bytes_too_long', 'Data should have at most 1 byte', {'max_length': 1}),
+    (
+        'bytes_invalid_encoding',
+        'Data should be valid base64: Invalid byte 1, offset 1',
+        {'encoding': 'base64', 'encoding_error': 'Invalid byte 1, offset 1'},
+    ),
+    (
+        'bytes_invalid_encoding',
+        'Data should be valid hex: Odd number of digits',
+        {'encoding': 'hex', 'encoding_error': 'Odd number of digits'},
+    ),
     ('value_error', 'Value error, foobar', {'error': ValueError('foobar')}),
     ('assertion_error', 'Assertion failed, foobar', {'error': AssertionError('foobar')}),
     ('literal_error', 'Input should be foo', {'expected': 'foo'}),
diff --git a/tests/test_json.py b/tests/test_json.py
index 0f599cee1..2a5176a27 100644
--- a/tests/test_json.py
+++ b/tests/test_json.py
@@ -376,3 +376,78 @@ def test_partial_parse():
     with pytest.raises(ValueError, match='EOF while parsing a string at line 1 column 15'):
         from_json(b'["aa", "bb", "c')
     assert from_json(b'["aa", "bb", "c', allow_partial=True) == ['aa', 'bb']
+
+
+def test_json_bytes_base64_round_trip():
+    data = b'hello'
+    encoded = b'"aGVsbG8="'
+    assert to_json(data, bytes_mode='base64') == encoded
+
+    v = SchemaValidator({'type': 'bytes'}, {'val_json_bytes': 'base64'})
+    assert v.validate_json(encoded) == data
+
+    assert to_json({'key': data}, bytes_mode='base64') == b'{"key":"aGVsbG8="}'
+    v = SchemaValidator(
+        {'type': 'dict', 'keys_schema': {'type': 'str'}, 'values_schema': {'type': 'bytes'}},
+        {'val_json_bytes': 'base64'},
+    )
+    assert v.validate_json('{"key":"aGVsbG8="}') == {'key': data}
+
+
+def test_json_bytes_base64_invalid():
+    v = SchemaValidator({'type': 'bytes'}, {'val_json_bytes': 'base64'})
+    wrong_input = 'wrong!'
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_json(json.dumps(wrong_input))
+    assert exc_info.value.errors(include_url=False, include_context=False) == [
+        {
+            'type': 'bytes_invalid_encoding',
+            'loc': (),
+            'msg': f'Data should be valid base64: Invalid byte {ord("!")}, offset {len(wrong_input)-1}.',
+            'input': wrong_input,
+        }
+    ]
+
+
+def test_json_bytes_hex_round_trip():
+    data = b'hello'
+    encoded = b'"68656c6c6f"'
+    assert to_json(data, bytes_mode='hex') == encoded
+
+    v = SchemaValidator({'type': 'bytes'}, {'val_json_bytes': 'hex'})
+    assert v.validate_json(encoded) == data
+
+    assert to_json({'key': data}, bytes_mode='hex') == b'{"key":"68656c6c6f"}'
+    v = SchemaValidator(
+        {'type': 'dict', 'keys_schema': {'type': 'str'}, 'values_schema': {'type': 'bytes'}},
+        {'val_json_bytes': 'hex'},
+    )
+    assert v.validate_json('{"key":"68656c6c6f"}') == {'key': data}
+
+
+def test_json_bytes_hex_invalid():
+    v = SchemaValidator({'type': 'bytes'}, {'val_json_bytes': 'hex'})
+
+    wrong_input = 'a'
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_json(json.dumps(wrong_input))
+    assert exc_info.value.errors(include_url=False, include_context=False) == [
+        {
+            'type': 'bytes_invalid_encoding',
+            'loc': (),
+            'msg': 'Data should be valid hex: Odd number of digits',
+            'input': wrong_input,
+        }
+    ]
+
+    wrong_input = 'ag'
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_json(json.dumps(wrong_input))
+    assert exc_info.value.errors(include_url=False, include_context=False) == [
+        {
+            'type': 'bytes_invalid_encoding',
+            'loc': (),
+            'msg': "Data should be valid hex: Invalid character 'g' at position 1",
+            'input': wrong_input,
+        }
+    ]

From 0a6a839cfd97f33101199a5935f8a8e10279eddc Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 2 Aug 2024 09:11:19 -0500
Subject: [PATCH 325/550] Bump CodSpeedHQ/action from 2 to 3 (#1387)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/codspeed.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/codspeed.yml b/.github/workflows/codspeed.yml
index 332c6ae58..b4851c286 100644
--- a/.github/workflows/codspeed.yml
+++ b/.github/workflows/codspeed.yml
@@ -68,6 +68,6 @@ jobs:
           RUSTFLAGS: "-Cprofile-use=${{ github.workspace }}/merged.profdata"
 
       - name: Run CodSpeed benchmarks
-        uses: CodSpeedHQ/action@v2
+        uses: CodSpeedHQ/action@v3
         with:
           run: pytest tests/benchmarks/ --codspeed

From 3a5f2cbae0b04032bb5e75003973ee231e19f92a Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 2 Aug 2024 09:11:44 -0500
Subject: [PATCH 326/550] Bump the python-packages group with 7 updates (#1388)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 8 ++++----
 tests/requirements.txt         | 6 +++---
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index c125a229c..b004e99ca 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,4 +1,4 @@
-griffe==0.47.0
-pyright==1.1.369
-ruff==0.5.0
-mypy==1.10.1
+griffe==0.48.0
+pyright==1.1.374
+ruff==0.5.5
+mypy==1.11.1
diff --git a/tests/requirements.txt b/tests/requirements.txt
index fc107a45f..342fbfd2d 100644
--- a/tests/requirements.txt
+++ b/tests/requirements.txt
@@ -1,10 +1,10 @@
 backports.zoneinfo==0.2.1;python_version<"3.9"
-coverage==7.5.4
+coverage==7.6.0
 dirty-equals==0.7.1.post0
-hypothesis==6.104.2
+hypothesis==6.108.5
 # pandas doesn't offer prebuilt wheels for all versions and platforms we test in CI e.g. aarch64 musllinux
 pandas==2.1.3; python_version >= "3.9" and python_version < "3.13" and implementation_name == "cpython" and platform_machine == 'x86_64'
-pytest==8.2.2
+pytest==8.3.2
 # we run codspeed benchmarks on x86_64 CPython (i.e. native github actions architecture)
 pytest-codspeed~=2.2.1; implementation_name == "cpython" and platform_machine == 'x86_64'
 # pytest-examples currently depends on aiohttp via black; we don't want to build

From 0ff28ea0b29e1efc22f93607e00d28b60bbc3d6d Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 2 Aug 2024 09:12:21 -0500
Subject: [PATCH 327/550] Bump version_check from 0.9.4 to 0.9.5 (#1382)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index c0ba1f49b..a50cdc006 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -778,9 +778,9 @@ checksum = "5de17fd2f7da591098415cff336e12965a28061ddace43b59cb3c430179c9439"
 
 [[package]]
 name = "version_check"
-version = "0.9.4"
+version = "0.9.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "49874b5167b65d7193b8aba1567f5c7d93d001cafc34600cee003eda787e483f"
+checksum = "0b928f33d975fc6ad9f86c8f283853ad26bdd5b10b7f1542aa2fa15e2289105a"
 
 [[package]]
 name = "wasi"
diff --git a/Cargo.toml b/Cargo.toml
index 04d22e02b..b6f2e5b90 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -77,7 +77,7 @@ strip = false
 pyo3 = { version = "0.22.0", features = ["auto-initialize"] }
 
 [build-dependencies]
-version_check = "0.9.4"
+version_check = "0.9.5"
 # used where logic has to be version/distribution specific, e.g. pypy
 pyo3-build-config = { version = "0.22.0" }
 

From a1ee73642083d139b81ea95a88d34bd97ed626ee Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 2 Aug 2024 09:12:39 -0500
Subject: [PATCH 328/550] Bump pyo3 from 0.22.0 to 0.22.2 (#1383)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 20 ++++++++++----------
 Cargo.toml |  4 ++--
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index a50cdc006..0c0b62edd 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -451,9 +451,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.22.0"
+version = "0.22.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1962a33ed2a201c637fc14a4e0fd4e06e6edfdeee6a5fede0dab55507ad74cf7"
+checksum = "831e8e819a138c36e212f3af3fd9eeffed6bf1510a805af35b0edee5ffa59433"
 dependencies = [
  "cfg-if",
  "indoc",
@@ -470,9 +470,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.22.0"
+version = "0.22.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ab7164b2202753bd33afc7f90a10355a719aa973d1f94502c50d06f3488bc420"
+checksum = "1e8730e591b14492a8945cdff32f089250b05f5accecf74aeddf9e8272ce1fa8"
 dependencies = [
  "once_cell",
  "python3-dll-a",
@@ -481,9 +481,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.22.0"
+version = "0.22.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c6424906ca49013c0829c5c1ed405e20e2da2dc78b82d198564880a704e6a7b7"
+checksum = "5e97e919d2df92eb88ca80a037969f44e5e70356559654962cbb3316d00300c6"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -491,9 +491,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.22.0"
+version = "0.22.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "82b2f19e153122d64afd8ce7aaa72f06a00f52e34e1d1e74b6d71baea396460a"
+checksum = "eb57983022ad41f9e683a599f2fd13c3664d7063a3ac5714cae4b7bee7d3f206"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -503,9 +503,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.22.0"
+version = "0.22.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dd698c04cac17cf0fe63d47790ab311b8b25542f5cb976b65c374035c50f1eef"
+checksum = "ec480c0c51ddec81019531705acac51bcdbeae563557c982aa8263bb96880372"
 dependencies = [
  "heck",
  "proc-macro2",
diff --git a/Cargo.toml b/Cargo.toml
index b6f2e5b90..745aeeb5a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -29,7 +29,7 @@ rust-version = "1.75"
 [dependencies]
 # TODO it would be very nice to remove the "py-clone" feature as it can panic,
 # but needs a bit of work to make sure it's not used in the codebase
-pyo3 = { version = "0.22.0", features = ["generate-import-lib", "num-bigint", "py-clone"] }
+pyo3 = { version = "0.22.2", features = ["generate-import-lib", "num-bigint", "py-clone"] }
 regex = "1.10.4"
 strum = { version = "0.26.3", features = ["derive"] }
 strum_macros = "0.26.4"
@@ -74,7 +74,7 @@ debug = true
 strip = false
 
 [dev-dependencies]
-pyo3 = { version = "0.22.0", features = ["auto-initialize"] }
+pyo3 = { version = "0.22.2", features = ["auto-initialize"] }
 
 [build-dependencies]
 version_check = "0.9.5"

From 1111096917995ecde4cda305b05dcc954e670f8e Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 2 Aug 2024 09:12:51 -0500
Subject: [PATCH 329/550] Bump serde_json from 1.0.118 to 1.0.121 (#1384)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 5 +++--
 Cargo.toml | 2 +-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 0c0b62edd..e86da5f1b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -601,12 +601,13 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.118"
+version = "1.0.121"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d947f6b3163d8857ea16c4fa0dd4840d52f3041039a85decd46867eb1abef2e4"
+checksum = "4ab380d7d9f22ef3f21ad3e6c1ebe8e4fc7a2000ccba2e4d71fc96f15b2cb609"
 dependencies = [
  "indexmap",
  "itoa",
+ "memchr",
  "ryu",
  "serde",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index 745aeeb5a..374672928 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -33,7 +33,7 @@ pyo3 = { version = "0.22.2", features = ["generate-import-lib", "num-bigint", "p
 regex = "1.10.4"
 strum = { version = "0.26.3", features = ["derive"] }
 strum_macros = "0.26.4"
-serde_json = {version = "1.0.116", features = ["arbitrary_precision", "preserve_order"]}
+serde_json = {version = "1.0.121", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.13"
 serde = { version = "1.0.203", features = ["derive"] }
 speedate = "0.14.4"

From 507ff47e6fe10f81d290d1c922475ef3e3710886 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 2 Aug 2024 09:13:02 -0500
Subject: [PATCH 330/550] Bump serde from 1.0.203 to 1.0.204 (#1385)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 8 ++++----
 Cargo.toml | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index e86da5f1b..45da9800a 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -581,18 +581,18 @@ checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
 
 [[package]]
 name = "serde"
-version = "1.0.203"
+version = "1.0.204"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7253ab4de971e72fb7be983802300c30b5a7f0c2e56fab8abfc6a214307c0094"
+checksum = "bc76f558e0cbb2a839d37354c575f1dc3fdc6546b5be373ba43d95f231bf7c12"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.203"
+version = "1.0.204"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "500cbc0ebeb6f46627f50f3f5811ccf6bf00643be300b4c3eabc0ef55dc5b5ba"
+checksum = "e0cd7e117be63d3c3678776753929474f3b04a43a080c744d6b0ae2a8c28e222"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/Cargo.toml b/Cargo.toml
index 374672928..aa5e83ac4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -35,7 +35,7 @@ strum = { version = "0.26.3", features = ["derive"] }
 strum_macros = "0.26.4"
 serde_json = {version = "1.0.121", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.13"
-serde = { version = "1.0.203", features = ["derive"] }
+serde = { version = "1.0.204", features = ["derive"] }
 speedate = "0.14.4"
 smallvec = "1.13.2"
 ahash = "0.8.10"

From c5a42612c17051f481a3f36c33d4f5acb5ef61b9 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Fri, 2 Aug 2024 16:02:22 +0100
Subject: [PATCH 331/550] clean up some string handling cases (#1381)

---
 src/input/input_python.rs | 40 ++++++++++++++++++++++-----------------
 src/serializers/config.rs |  2 +-
 src/serializers/fields.rs | 14 +++++++-------
 3 files changed, 31 insertions(+), 25 deletions(-)

diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index 519a96f89..7840a825a 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -1,4 +1,3 @@
-use std::borrow::Cow;
 use std::str::from_utf8;
 
 use pyo3::intern;
@@ -145,12 +144,8 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
                         Err(_) => Err(ValError::new(ErrorTypeDefaults::StringUnicode, self)),
                     }
                 } else if let Ok(py_byte_array) = self.downcast::<PyByteArray>() {
-                    // Safety: the gil is held while from_utf8 is running so py_byte_array is not mutated,
-                    // and we immediately copy the bytes into a new Python string
-                    match from_utf8(unsafe { py_byte_array.as_bytes() }) {
-                        // Why Python not Rust? to avoid an unnecessary allocation on the Rust side, the
-                        // final output needs to be Python anyway.
-                        Ok(s) => Ok(PyString::new_bound(self.py(), s).into()),
+                    match bytearray_to_str(py_byte_array) {
+                        Ok(py_str) => Ok(py_str.into()),
                         Err(_) => Err(ValError::new(ErrorTypeDefaults::StringUnicode, self)),
                     }
                 } else if coerce_numbers_to_str && !self.is_exact_instance_of::<PyBool>() && {
@@ -212,8 +207,8 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
         }
 
         if !strict {
-            if let Some(cow_str) = maybe_as_string(self, ErrorTypeDefaults::BoolParsing)? {
-                return str_as_bool(self, &cow_str).map(ValidationMatch::lax);
+            if let Some(s) = maybe_as_string(self, ErrorTypeDefaults::BoolParsing)? {
+                return str_as_bool(self, s).map(ValidationMatch::lax);
             } else if let Some(int) = extract_i64(self) {
                 return int_as_bool(self, int).map(ValidationMatch::lax);
             } else if let Ok(float) = self.extract::<f64>() {
@@ -249,8 +244,8 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
 
         'lax: {
             if !strict {
-                return if let Some(cow_str) = maybe_as_string(self, ErrorTypeDefaults::IntParsing)? {
-                    str_as_int(self, &cow_str)
+                return if let Some(s) = maybe_as_string(self, ErrorTypeDefaults::IntParsing)? {
+                    str_as_int(self, s)
                 } else if self.is_exact_instance_of::<PyFloat>() {
                     float_as_int(self, self.extract::<f64>()?)
                 } else if let Ok(decimal) = self.strict_decimal(self.py()) {
@@ -291,9 +286,9 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
         }
 
         if !strict {
-            if let Some(cow_str) = maybe_as_string(self, ErrorTypeDefaults::FloatParsing)? {
+            if let Some(s) = maybe_as_string(self, ErrorTypeDefaults::FloatParsing)? {
                 // checking for bytes and string is fast, so do this before isinstance(float)
-                return str_as_float(self, &cow_str).map(ValidationMatch::lax);
+                return str_as_float(self, s).map(ValidationMatch::lax);
             }
         }
 
@@ -638,13 +633,12 @@ fn from_attributes_applicable(obj: &Bound<'_, PyAny>) -> bool {
 }
 
 /// Utility for extracting a string from a PyAny, if possible.
-fn maybe_as_string<'a>(v: &'a Bound<'_, PyAny>, unicode_error: ErrorType) -> ValResult<Option<Cow<'a, str>>> {
+fn maybe_as_string<'a>(v: &'a Bound<'_, PyAny>, unicode_error: ErrorType) -> ValResult<Option<&'a str>> {
     if let Ok(py_string) = v.downcast::<PyString>() {
-        let str = py_string_str(py_string)?;
-        Ok(Some(Cow::Borrowed(str)))
+        py_string_str(py_string).map(Some)
     } else if let Ok(bytes) = v.downcast::<PyBytes>() {
         match from_utf8(bytes.as_bytes()) {
-            Ok(s) => Ok(Some(Cow::Owned(s.to_string()))),
+            Ok(s) => Ok(Some(s)),
             Err(_) => Err(ValError::new(unicode_error, v)),
         }
     } else {
@@ -652,6 +646,18 @@ fn maybe_as_string<'a>(v: &'a Bound<'_, PyAny>, unicode_error: ErrorType) -> Val
     }
 }
 
+/// Decode a Python bytearray to a Python string.
+///
+/// Using Python's built-in machinery for this should be efficient and avoids questions around
+/// safety of concurrent mutation of the bytearray (by leaving that to the Python interpreter).
+fn bytearray_to_str<'py>(bytearray: &Bound<'py, PyByteArray>) -> PyResult<Bound<'py, PyString>> {
+    let py = bytearray.py();
+    let py_string = bytearray
+        .call_method1(intern!(py, "decode"), (intern!(py, "utf-8"),))?
+        .downcast_into()?;
+    Ok(py_string)
+}
+
 /// Utility for extracting an enum value, if possible.
 fn maybe_as_enum<'py>(v: &Bound<'py, PyAny>) -> Option<Bound<'py, PyAny>> {
     let py = v.py();
diff --git a/src/serializers/config.rs b/src/serializers/config.rs
index 359d35276..13a833176 100644
--- a/src/serializers/config.rs
+++ b/src/serializers/config.rs
@@ -77,7 +77,7 @@ macro_rules! serialization_mode {
                     return Ok(Self::default());
                 };
                 let raw_mode = config_dict.get_as::<Bound<'_, PyString>>(intern!(config_dict.py(), $config_key))?;
-                raw_mode.map_or_else(|| Ok(Self::default()), |raw| Self::from_str(&raw.to_cow()?))
+                raw_mode.map_or_else(|| Ok(Self::default()), |raw| Self::from_str(raw.to_str()?))
             }
         }
 
diff --git a/src/serializers/fields.rs b/src/serializers/fields.rs
index bf72ec218..f4f8910eb 100644
--- a/src/serializers/fields.rs
+++ b/src/serializers/fields.rs
@@ -159,7 +159,7 @@ impl GeneralFieldsSerializer {
         for result in main_iter {
             let (key, value) = result?;
             let key_str = key_str(&key)?;
-            let op_field = self.fields.get(key_str.as_ref());
+            let op_field = self.fields.get(key_str);
             if extra.exclude_none && value.is_none() {
                 if let Some(field) = op_field {
                     if field.required {
@@ -169,7 +169,7 @@ impl GeneralFieldsSerializer {
                 continue;
             }
             let field_extra = Extra {
-                field_name: Some(&key_str),
+                field_name: Some(key_str),
                 ..extra
             };
             if let Some((next_include, next_exclude)) = self.filter.key_filter(&key, include, exclude)? {
@@ -236,13 +236,13 @@ impl GeneralFieldsSerializer {
             }
             let key_str = key_str(&key).map_err(py_err_se_err)?;
             let field_extra = Extra {
-                field_name: Some(&key_str),
+                field_name: Some(key_str),
                 ..extra
             };
 
             let filter = self.filter.key_filter(&key, include, exclude).map_err(py_err_se_err)?;
             if let Some((next_include, next_exclude)) = filter {
-                if let Some(field) = self.fields.get(key_str.as_ref()) {
+                if let Some(field) = self.fields.get(key_str) {
                     if let Some(ref serializer) = field.serializer {
                         if !exclude_default(&value, &field_extra, serializer).map_err(py_err_se_err)? {
                             let s = PydanticSerializer::new(
@@ -252,7 +252,7 @@ impl GeneralFieldsSerializer {
                                 next_exclude.as_ref(),
                                 &field_extra,
                             );
-                            let output_key = field.get_key_json(&key_str, &field_extra);
+                            let output_key = field.get_key_json(key_str, &field_extra);
                             map.serialize_entry(&output_key, &s)?;
                         }
                     }
@@ -446,8 +446,8 @@ impl TypeSerializer for GeneralFieldsSerializer {
     }
 }
 
-fn key_str<'a>(key: &'a Bound<'_, PyAny>) -> PyResult<Cow<'a, str>> {
-    key.downcast::<PyString>()?.to_cow()
+fn key_str<'a>(key: &'a Bound<'_, PyAny>) -> PyResult<&'a str> {
+    key.downcast::<PyString>()?.to_str()
 }
 
 fn dict_items<'py>(

From cc2c46c92fc0a1fc16b829531089d0adc5009ed0 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 5 Aug 2024 10:29:48 +0100
Subject: [PATCH 332/550] Bump base64 from 0.21.7 to 0.22.1 (#1386)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: David Hewitt <mail@davidhewitt.dev>
---
 Cargo.lock         | 4 ++--
 Cargo.toml         | 2 +-
 tests/test_json.py | 2 +-
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 45da9800a..a5c70ffa8 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -32,9 +32,9 @@ checksum = "0c4b4d0bd25bd0b74681c0ad21497610ce1b7c91b1022cd21c80c6fbdd9476b0"
 
 [[package]]
 name = "base64"
-version = "0.21.7"
+version = "0.22.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9d297deb1925b89f2ccc13d7635fa0714f12c87adce1c75356b39ca9b7178567"
+checksum = "72b3254f16251a8381aa12e40e3c4d2f0199f8c6508fbecb9d91f575e0fbb8c6"
 
 [[package]]
 name = "bitvec"
diff --git a/Cargo.toml b/Cargo.toml
index aa5e83ac4..e55158e8f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -42,7 +42,7 @@ ahash = "0.8.10"
 url = "2.5.0"
 # idna is already required by url, added here to be explicit
 idna = "1.0.1"
-base64 = "0.21.7"
+base64 = "0.22.1"
 num-bigint = "0.4.6"
 python3-dll-a = "0.2.10"
 uuid = "1.9.1"
diff --git a/tests/test_json.py b/tests/test_json.py
index 2a5176a27..03855ae67 100644
--- a/tests/test_json.py
+++ b/tests/test_json.py
@@ -403,7 +403,7 @@ def test_json_bytes_base64_invalid():
         {
             'type': 'bytes_invalid_encoding',
             'loc': (),
-            'msg': f'Data should be valid base64: Invalid byte {ord("!")}, offset {len(wrong_input)-1}.',
+            'msg': f'Data should be valid base64: Invalid symbol {ord("!")}, offset {len(wrong_input)-1}.',
             'input': wrong_input,
         }
     ]

From 099a8e125e60669b0044ac63d94d1c74581c62d3 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Mon, 5 Aug 2024 09:01:34 -0500
Subject: [PATCH 333/550] Support `allow_partial='trailing-strings'` (#1390)

---
 python/pydantic_core/_pydantic_core.pyi |  2 +-
 src/lib.rs                              | 25 +++++--------------------
 2 files changed, 6 insertions(+), 21 deletions(-)

diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index 34c70cd31..aeec227f8 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -395,7 +395,7 @@ def from_json(
     *,
     allow_inf_nan: bool = True,
     cache_strings: bool | Literal['all', 'keys', 'none'] = True,
-    allow_partial: bool = False,
+    allow_partial: bool | Literal['off', 'on', 'trailing-strings'] = False,
 ) -> Any:
     """
     Deserialize JSON data to a Python object.
diff --git a/src/lib.rs b/src/lib.rs
index e94abf679..eb598424b 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -42,38 +42,23 @@ pub use validators::{validate_core_schema, PySome, SchemaValidator};
 
 use crate::input::Input;
 
-#[derive(FromPyObject)]
-pub enum CacheStringsArg {
-    Bool(bool),
-    Literal(StringCacheMode),
-}
-
-#[pyfunction(signature = (data, *, allow_inf_nan=true, cache_strings=CacheStringsArg::Bool(true), allow_partial=false))]
+#[pyfunction(signature = (data, *, allow_inf_nan=true, cache_strings=StringCacheMode::All, allow_partial=PartialMode::Off))]
 pub fn from_json<'py>(
     py: Python<'py>,
     data: &Bound<'_, PyAny>,
     allow_inf_nan: bool,
-    cache_strings: CacheStringsArg,
-    allow_partial: bool,
+    cache_strings: StringCacheMode,
+    allow_partial: PartialMode,
 ) -> PyResult<Bound<'py, PyAny>> {
     let v_match = data
         .validate_bytes(false, ValBytesMode { ser: BytesMode::Utf8 })
         .map_err(|_| PyTypeError::new_err("Expected bytes, bytearray or str"))?;
     let json_either_bytes = v_match.into_inner();
     let json_bytes = json_either_bytes.as_slice();
-    let cache_mode = match cache_strings {
-        CacheStringsArg::Bool(b) => b.into(),
-        CacheStringsArg::Literal(mode) => mode,
-    };
-    let partial_mode = if allow_partial {
-        PartialMode::On
-    } else {
-        PartialMode::Off
-    };
     let parse_builder = PythonParse {
         allow_inf_nan,
-        cache_mode,
-        partial_mode,
+        cache_mode: cache_strings,
+        partial_mode: allow_partial,
         catch_duplicate_keys: false,
         lossless_floats: false,
     };

From 81106d9e7463d6e12898f84812accac9ca07bc1f Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Mon, 5 Aug 2024 09:49:10 -0500
Subject: [PATCH 334/550] Uprev to v2.21.0 (#1391)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index a5c70ffa8..910937c29 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -425,7 +425,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.20.1"
+version = "2.21.0"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index e55158e8f..742c85f35 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.20.1"
+version = "2.21.0"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From f79d49bdf5749011cd9d2257ee5bf591199e573e Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Mon, 5 Aug 2024 11:25:34 -0500
Subject: [PATCH 335/550] Revert "use little endian int (#1372)" (#1393)

---
 src/serializers/type_serializers/uuid.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/serializers/type_serializers/uuid.rs b/src/serializers/type_serializers/uuid.rs
index bb731e61b..9609f11da 100644
--- a/src/serializers/type_serializers/uuid.rs
+++ b/src/serializers/type_serializers/uuid.rs
@@ -14,8 +14,7 @@ use super::{
 pub(crate) fn uuid_to_string(py_uuid: &Bound<'_, PyAny>) -> PyResult<String> {
     let py = py_uuid.py();
     let uuid_int_val: u128 = py_uuid.getattr(intern!(py, "int"))?.extract()?;
-    // we use a little endian conversion for compatibility across platforms, see https://github.com/pydantic/pydantic-core/pull/1372
-    let uuid = Uuid::from_u128(uuid_int_val.to_le());
+    let uuid = Uuid::from_u128(uuid_int_val);
     Ok(uuid.to_string())
 }
 

From 6e96b85a865ca16cc4a096c433c9f28590490a5c Mon Sep 17 00:00:00 2001
From: Boxy <rust@boxyuwu.dev>
Date: Tue, 6 Aug 2024 14:57:28 +0100
Subject: [PATCH 336/550] Expose AnySerializer via core schema (#1394)

---
 python/pydantic_core/core_schema.py |  1 +
 tests/serializers/test_any.py       | 29 +++++++++++++++++++++++++++++
 2 files changed, 30 insertions(+)

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index c157a027b..4ac24bd6c 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -219,6 +219,7 @@ def field_name(self) -> str | None:
     'multi-host-url',
     'json',
     'uuid',
+    'any',
 ]
 
 
diff --git a/tests/serializers/test_any.py b/tests/serializers/test_any.py
index 4c3cd9eff..7337d012e 100644
--- a/tests/serializers/test_any.py
+++ b/tests/serializers/test_any.py
@@ -652,3 +652,32 @@ def test_ser_json_inf_nan_with_list_of_any() -> None:
     assert isnan(s.to_python([nan])[0])
     assert s.to_python([nan], mode='json')[0] is None
     assert s.to_json([nan]) == b'[null]'
+
+
+def test_simple_any_ser_schema_repr():
+    assert (
+        plain_repr(SchemaSerializer(core_schema.simple_ser_schema('any')))
+        == 'SchemaSerializer(serializer=Any(AnySerializer),definitions=[])'
+    )
+
+
+def test_simple_any_ser_schema():
+    import operator
+
+    class MyEnum(Enum):
+        A = (1,)
+        B = (2,)
+
+    v = SchemaSerializer(
+        core_schema.no_info_after_validator_function(
+            operator.attrgetter('value'),
+            core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values())),
+            serialization=core_schema.simple_ser_schema('any'),
+        ),
+    )
+
+    assert v.to_python({MyEnum.A: 'x'}) == {MyEnum.A: 'x'}
+    assert v.to_python({MyEnum.A: 'x'}, mode='json') == {'1': 'x'}
+    assert v.to_json({MyEnum.A: 'x'}) == b'{"1":"x"}'
+    assert v.to_python(1) == 1
+    assert v.to_json(1) == b'1'

From e07c41b3bad75948201a2201387225694c2fb501 Mon Sep 17 00:00:00 2001
From: Boxy <rust@boxyuwu.dev>
Date: Wed, 7 Aug 2024 17:11:02 +0100
Subject: [PATCH 337/550] dont embed `RUSTFLAGS` in final binary (#1396)

---
 build.rs   | 9 +++++++++
 src/lib.rs | 5 ++++-
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/build.rs b/build.rs
index d1093c747..f8f66901a 100644
--- a/build.rs
+++ b/build.rs
@@ -36,6 +36,15 @@ fn main() {
         println!("cargo:rustc-cfg=has_coverage_attribute");
     }
     println!("cargo:rustc-check-cfg=cfg(has_coverage_attribute)");
+
+    if std::env::var("RUSTFLAGS")
+        .unwrap_or_default()
+        .contains("-Cprofile-use=")
+    {
+        println!("cargo:rustc-cfg=specified_profile_use");
+    }
+    println!("cargo:rustc-check-cfg=cfg(specified_profile_use)");
+
     generate_self_schema();
     println!("cargo:rustc-env=PROFILE={}", std::env::var("PROFILE").unwrap());
 }
diff --git a/src/lib.rs b/src/lib.rs
index eb598424b..eb486da66 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -98,7 +98,10 @@ pub fn build_info() -> String {
     format!(
         "profile={} pgo={}",
         env!("PROFILE"),
-        option_env!("RUSTFLAGS").unwrap_or("").contains("-Cprofile-use="),
+        // We use a `cfg!` here not `env!`/`option_env!` as those would
+        // embed `RUSTFLAGS` into the generated binary which causes problems
+        // with reproducable builds.
+        cfg!(specified_profile_use),
     )
 }
 

From 585f72563741d87234c7bbd7054114c6560781ed Mon Sep 17 00:00:00 2001
From: Josh Newman <josh@d8e.ai>
Date: Thu, 8 Aug 2024 00:44:33 -0700
Subject: [PATCH 338/550] Validate base64 standard encoding (#1395)

---
 src/validators/config.rs | 15 ++++++++++-----
 tests/test_json.py       | 19 +++++++++++++------
 2 files changed, 23 insertions(+), 11 deletions(-)

diff --git a/src/validators/config.rs b/src/validators/config.rs
index 8ffcfd0f5..a43a7643a 100644
--- a/src/validators/config.rs
+++ b/src/validators/config.rs
@@ -1,7 +1,8 @@
 use std::borrow::Cow;
 use std::str::FromStr;
 
-use base64::Engine;
+use base64::engine::general_purpose::{STANDARD, URL_SAFE};
+use base64::{DecodeError, Engine};
 use pyo3::types::{PyDict, PyString};
 use pyo3::{intern, prelude::*};
 
@@ -28,14 +29,18 @@ impl ValBytesMode {
     pub fn deserialize_string<'py>(self, s: &str) -> Result<EitherBytes<'_, 'py>, ErrorType> {
         match self.ser {
             BytesMode::Utf8 => Ok(EitherBytes::Cow(Cow::Borrowed(s.as_bytes()))),
-            BytesMode::Base64 => match base64::engine::general_purpose::URL_SAFE.decode(s) {
-                Ok(bytes) => Ok(EitherBytes::from(bytes)),
-                Err(err) => Err(ErrorType::BytesInvalidEncoding {
+            BytesMode::Base64 => URL_SAFE
+                .decode(s)
+                .or_else(|err| match err {
+                    DecodeError::InvalidByte(_, b'/' | b'+') => STANDARD.decode(s),
+                    _ => Err(err),
+                })
+                .map(EitherBytes::from)
+                .map_err(|err| ErrorType::BytesInvalidEncoding {
                     encoding: "base64".to_string(),
                     encoding_error: err.to_string(),
                     context: None,
                 }),
-            },
             BytesMode::Hex => match hex::decode(s) {
                 Ok(vec) => Ok(EitherBytes::from(vec)),
                 Err(err) => Err(ErrorType::BytesInvalidEncoding {
diff --git a/tests/test_json.py b/tests/test_json.py
index 03855ae67..f22850704 100644
--- a/tests/test_json.py
+++ b/tests/test_json.py
@@ -379,19 +379,26 @@ def test_partial_parse():
 
 
 def test_json_bytes_base64_round_trip():
-    data = b'hello'
-    encoded = b'"aGVsbG8="'
-    assert to_json(data, bytes_mode='base64') == encoded
+    data = b'\xd8\x07\xc1Tx$\x91F%\xf3\xf3I\xca\xd8@\x0c\xee\xc3\xab\xff\x7f\xd3\xcd\xcd\xf9\xc2\x10\xe4\xa1\xb01e'
+    encoded_std = b'"2AfBVHgkkUYl8/NJythADO7Dq/9/083N+cIQ5KGwMWU="'
+    encoded_url = b'"2AfBVHgkkUYl8_NJythADO7Dq_9_083N-cIQ5KGwMWU="'
+    assert to_json(data, bytes_mode='base64') == encoded_url
 
     v = SchemaValidator({'type': 'bytes'}, {'val_json_bytes': 'base64'})
-    assert v.validate_json(encoded) == data
+    assert v.validate_json(encoded_url) == data
+    assert v.validate_json(encoded_std) == data
+
+    with pytest.raises(ValidationError) as exc:
+        v.validate_json('"wrong!"')
+    [details] = exc.value.errors()
+    assert details['type'] == 'bytes_invalid_encoding'
 
-    assert to_json({'key': data}, bytes_mode='base64') == b'{"key":"aGVsbG8="}'
+    assert to_json({'key': data}, bytes_mode='base64') == b'{"key":' + encoded_url + b'}'
     v = SchemaValidator(
         {'type': 'dict', 'keys_schema': {'type': 'str'}, 'values_schema': {'type': 'bytes'}},
         {'val_json_bytes': 'base64'},
     )
-    assert v.validate_json('{"key":"aGVsbG8="}') == {'key': data}
+    assert v.validate_json(b'{"key":' + encoded_url + b'}') == {'key': data}
 
 
 def test_json_bytes_base64_invalid():

From 863640b2963ac2ccb5194bdedc26409280e2d1f8 Mon Sep 17 00:00:00 2001
From: Boxy <rust@boxyuwu.dev>
Date: Thu, 8 Aug 2024 09:17:10 +0100
Subject: [PATCH 339/550] Show value of wrongly typed in serialization warning
 (#1377)

---
 src/errors/mod.rs                       | 46 ++++++++++++++++++++
 src/errors/validation_exception.rs      | 48 +--------------------
 src/serializers/extra.rs                | 11 ++++-
 tests/serializers/test_any.py           |  4 +-
 tests/serializers/test_bytes.py         | 16 +++++--
 tests/serializers/test_datetime.py      | 10 ++++-
 tests/serializers/test_decimal.py       |  8 +++-
 tests/serializers/test_enum.py          | 40 ++++++++++++-----
 tests/serializers/test_functions.py     | 34 +++++++++++----
 tests/serializers/test_generator.py     | 19 ++++++---
 tests/serializers/test_list_tuple.py    | 30 ++++++-------
 tests/serializers/test_model.py         | 11 +++--
 tests/serializers/test_nullable.py      |  4 +-
 tests/serializers/test_other.py         |  4 +-
 tests/serializers/test_set_frozenset.py | 14 +++---
 tests/serializers/test_simple.py        |  9 ++--
 tests/serializers/test_string.py        | 57 +++++++++++++++++++------
 tests/serializers/test_timedelta.py     |  6 ++-
 tests/serializers/test_union.py         |  2 +-
 tests/serializers/test_url.py           |  8 +++-
 tests/serializers/test_uuid.py          |  8 +++-
 21 files changed, 259 insertions(+), 130 deletions(-)

diff --git a/src/errors/mod.rs b/src/errors/mod.rs
index ffdda90e3..255ea3cc8 100644
--- a/src/errors/mod.rs
+++ b/src/errors/mod.rs
@@ -1,3 +1,6 @@
+use core::fmt;
+use std::borrow::Cow;
+
 use pyo3::prelude::*;
 
 mod line_error;
@@ -30,3 +33,46 @@ pub fn py_err_string(py: Python, err: PyErr) -> String {
         Err(_) => "Unknown Error".to_string(),
     }
 }
+
+// TODO: is_utf8_char_boundary, floor_char_boundary and ceil_char_boundary
+// with builtin methods once https://github.com/rust-lang/rust/issues/93743 is resolved
+// These are just copy pasted from the current implementation
+const fn is_utf8_char_boundary(value: u8) -> bool {
+    // This is bit magic equivalent to: b < 128 || b >= 192
+    (value as i8) >= -0x40
+}
+
+pub fn floor_char_boundary(value: &str, index: usize) -> usize {
+    if index >= value.len() {
+        value.len()
+    } else {
+        let lower_bound = index.saturating_sub(3);
+        let new_index = value.as_bytes()[lower_bound..=index]
+            .iter()
+            .rposition(|b| is_utf8_char_boundary(*b));
+
+        // SAFETY: we know that the character boundary will be within four bytes
+        unsafe { lower_bound + new_index.unwrap_unchecked() }
+    }
+}
+
+pub fn ceil_char_boundary(value: &str, index: usize) -> usize {
+    let upper_bound = Ord::min(index + 4, value.len());
+    value.as_bytes()[index..upper_bound]
+        .iter()
+        .position(|b| is_utf8_char_boundary(*b))
+        .map_or(upper_bound, |pos| pos + index)
+}
+
+pub fn write_truncated_to_50_bytes<F: fmt::Write>(f: &mut F, val: Cow<'_, str>) -> std::fmt::Result {
+    if val.len() > 50 {
+        write!(
+            f,
+            "{}...{}",
+            &val[0..floor_char_boundary(&val, 25)],
+            &val[ceil_char_boundary(&val, val.len() - 24)..]
+        )
+    } else {
+        write!(f, "{val}")
+    }
+}
diff --git a/src/errors/validation_exception.rs b/src/errors/validation_exception.rs
index d41a10e65..e7861fa9b 100644
--- a/src/errors/validation_exception.rs
+++ b/src/errors/validation_exception.rs
@@ -386,51 +386,6 @@ impl ValidationError {
     }
 }
 
-// TODO: is_utf8_char_boundary, floor_char_boundary and ceil_char_boundary
-// with builtin methods once https://github.com/rust-lang/rust/issues/93743 is resolved
-// These are just copy pasted from the current implementation
-const fn is_utf8_char_boundary(value: u8) -> bool {
-    // This is bit magic equivalent to: b < 128 || b >= 192
-    (value as i8) >= -0x40
-}
-
-fn floor_char_boundary(value: &str, index: usize) -> usize {
-    if index >= value.len() {
-        value.len()
-    } else {
-        let lower_bound = index.saturating_sub(3);
-        let new_index = value.as_bytes()[lower_bound..=index]
-            .iter()
-            .rposition(|b| is_utf8_char_boundary(*b));
-
-        // SAFETY: we know that the character boundary will be within four bytes
-        unsafe { lower_bound + new_index.unwrap_unchecked() }
-    }
-}
-
-pub fn ceil_char_boundary(value: &str, index: usize) -> usize {
-    let upper_bound = Ord::min(index + 4, value.len());
-    value.as_bytes()[index..upper_bound]
-        .iter()
-        .position(|b| is_utf8_char_boundary(*b))
-        .map_or(upper_bound, |pos| pos + index)
-}
-
-macro_rules! truncate_input_value {
-    ($out:expr, $value:expr) => {
-        if $value.len() > 50 {
-            write!(
-                $out,
-                ", input_value={}...{}",
-                &$value[0..floor_char_boundary($value, 25)],
-                &$value[ceil_char_boundary($value, $value.len() - 24)..]
-            )?;
-        } else {
-            write!($out, ", input_value={}", $value)?;
-        }
-    };
-}
-
 pub fn pretty_py_line_errors<'a>(
     py: Python,
     input_type: InputType,
@@ -570,7 +525,8 @@ impl PyLineError {
         if !hide_input {
             let input_value = self.input_value.bind(py);
             let input_str = safe_repr(input_value);
-            truncate_input_value!(output, &input_str.to_cow());
+            write!(output, ", input_value=")?;
+            super::write_truncated_to_50_bytes(&mut output, input_str.to_cow())?;
 
             if let Ok(type_) = input_value.get_type().qualname() {
                 write!(output, ", input_type={type_}")?;
diff --git a/src/serializers/extra.rs b/src/serializers/extra.rs
index dbf6f7b31..a62b55304 100644
--- a/src/serializers/extra.rs
+++ b/src/serializers/extra.rs
@@ -15,6 +15,7 @@ use crate::recursion_guard::ContainsRecursionState;
 use crate::recursion_guard::RecursionError;
 use crate::recursion_guard::RecursionGuard;
 use crate::recursion_guard::RecursionState;
+use crate::tools::safe_repr;
 use crate::PydanticSerializationError;
 
 /// this is ugly, would be much better if extra could be stored in `SerializationState`
@@ -424,8 +425,16 @@ impl CollectWarnings {
                 .get_type()
                 .qualname()
                 .unwrap_or_else(|_| PyString::new_bound(value.py(), "<unknown python object>"));
+
+            let input_str = safe_repr(value);
+            let mut value_str = String::with_capacity(100);
+            value_str.push_str("with value `");
+            crate::errors::write_truncated_to_50_bytes(&mut value_str, input_str.to_cow())
+                .expect("Writing to a `String` failed");
+            value_str.push('`');
+
             self.add_warning(format!(
-                "Expected `{field_type}` but got `{type_name}` - serialized value may not be as expected"
+                "Expected `{field_type}` but got `{type_name}` {value_str} - serialized value may not be as expected"
             ));
         }
     }
diff --git a/tests/serializers/test_any.py b/tests/serializers/test_any.py
index 7337d012e..12ac463e1 100644
--- a/tests/serializers/test_any.py
+++ b/tests/serializers/test_any.py
@@ -158,7 +158,7 @@ def test_any_with_date_serializer():
         assert s.to_python(b'bang', mode='json') == 'bang'
 
     assert [w.message.args[0] for w in warning_info.list] == [
-        'Pydantic serializer warnings:\n  Expected `date` but got `bytes` - serialized value may not be as expected'
+        "Pydantic serializer warnings:\n  Expected `date` but got `bytes` with value `b'bang'` - serialized value may not be as expected"
     ]
 
 
@@ -172,7 +172,7 @@ def test_any_with_timedelta_serializer():
         assert s.to_python(b'bang', mode='json') == 'bang'
 
     assert [w.message.args[0] for w in warning_info.list] == [
-        'Pydantic serializer warnings:\n  Expected `timedelta` but got `bytes` - '
+        "Pydantic serializer warnings:\n  Expected `timedelta` but got `bytes` with value `b'bang'` - "
         'serialized value may not be as expected'
     ]
 
diff --git a/tests/serializers/test_bytes.py b/tests/serializers/test_bytes.py
index cc2d44785..32c11fac9 100644
--- a/tests/serializers/test_bytes.py
+++ b/tests/serializers/test_bytes.py
@@ -46,13 +46,21 @@ def test_bytes_dict_key():
 
 def test_bytes_fallback():
     s = SchemaSerializer(core_schema.bytes_schema())
-    with pytest.warns(UserWarning, match='Expected `bytes` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match='Expected `bytes` but got `int` with value `123` - serialized value may not be as expected'
+    ):
         assert s.to_python(123) == 123
-    with pytest.warns(UserWarning, match='Expected `bytes` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match='Expected `bytes` but got `int` with value `123` - serialized value may not be as expected'
+    ):
         assert s.to_python(123, mode='json') == 123
-    with pytest.warns(UserWarning, match='Expected `bytes` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match='Expected `bytes` but got `int` with value `123` - serialized value may not be as expected'
+    ):
         assert s.to_json(123) == b'123'
-    with pytest.warns(UserWarning, match='Expected `bytes` but got `str` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match="Expected `bytes` but got `str` with value `'foo'` - serialized value may not be as expected"
+    ):
         assert s.to_json('foo') == b'"foo"'
 
 
diff --git a/tests/serializers/test_datetime.py b/tests/serializers/test_datetime.py
index 85fc51e95..19d5477f3 100644
--- a/tests/serializers/test_datetime.py
+++ b/tests/serializers/test_datetime.py
@@ -12,10 +12,16 @@ def test_datetime():
     assert v.to_python(datetime(2022, 12, 2, 12, 13, 14), mode='json') == '2022-12-02T12:13:14'
     assert v.to_json(datetime(2022, 12, 2, 12, 13, 14)) == b'"2022-12-02T12:13:14"'
 
-    with pytest.warns(UserWarning, match='Expected `datetime` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning,
+        match='Expected `datetime` but got `int` with value `123` - serialized value may not be as expected',
+    ):
         assert v.to_python(123, mode='json') == 123
 
-    with pytest.warns(UserWarning, match='Expected `datetime` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning,
+        match='Expected `datetime` but got `int` with value `123` - serialized value may not be as expected',
+    ):
         assert v.to_json(123) == b'123'
 
 
diff --git a/tests/serializers/test_decimal.py b/tests/serializers/test_decimal.py
index 1e74c8eb7..277843aec 100644
--- a/tests/serializers/test_decimal.py
+++ b/tests/serializers/test_decimal.py
@@ -20,10 +20,14 @@ def test_decimal():
         == b'"123456789123456789123456789.123456789123456789123456789"'
     )
 
-    with pytest.warns(UserWarning, match='Expected `decimal` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match='Expected `decimal` but got `int` with value `123` - serialized value may not be as expected'
+    ):
         assert v.to_python(123, mode='json') == 123
 
-    with pytest.warns(UserWarning, match='Expected `decimal` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match='Expected `decimal` but got `int` with value `123` - serialized value may not be as expected'
+    ):
         assert v.to_json(123) == b'123'
 
 
diff --git a/tests/serializers/test_enum.py b/tests/serializers/test_enum.py
index 5161a2b39..66ab00691 100644
--- a/tests/serializers/test_enum.py
+++ b/tests/serializers/test_enum.py
@@ -17,9 +17,13 @@ class MyEnum(Enum):
     assert v.to_python(MyEnum.a, mode='json') == 1
     assert v.to_json(MyEnum.a) == b'1'
 
-    with pytest.warns(UserWarning, match='Expected `enum` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match='Expected `enum` but got `int` with value `1` - serialized value may not be as expected'
+    ):
         assert v.to_python(1) == 1
-    with pytest.warns(UserWarning, match='Expected `enum` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match='Expected `enum` but got `int` with value `1` - serialized value may not be as expected'
+    ):
         assert v.to_json(1) == b'1'
 
 
@@ -35,9 +39,13 @@ class MyEnum(int, Enum):
     assert v.to_python(MyEnum.a, mode='json') == 1
     assert v.to_json(MyEnum.a) == b'1'
 
-    with pytest.warns(UserWarning, match='Expected `enum` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match='Expected `enum` but got `int` with value `1` - serialized value may not be as expected'
+    ):
         assert v.to_python(1) == 1
-    with pytest.warns(UserWarning, match='Expected `enum` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match='Expected `enum` but got `int` with value `1` - serialized value may not be as expected'
+    ):
         assert v.to_json(1) == b'1'
 
 
@@ -53,9 +61,13 @@ class MyEnum(str, Enum):
     assert v.to_python(MyEnum.a, mode='json') == 'a'
     assert v.to_json(MyEnum.a) == b'"a"'
 
-    with pytest.warns(UserWarning, match='Expected `enum` but got `str` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match="Expected `enum` but got `str` with value `'a'` - serialized value may not be as expected"
+    ):
         assert v.to_python('a') == 'a'
-    with pytest.warns(UserWarning, match='Expected `enum` but got `str` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match="Expected `enum` but got `str` with value `'a'` - serialized value may not be as expected"
+    ):
         assert v.to_json('a') == b'"a"'
 
 
@@ -76,9 +88,13 @@ class MyEnum(Enum):
     assert v.to_python({MyEnum.a: 'x'}, mode='json') == {'1': 'x'}
     assert v.to_json({MyEnum.a: 'x'}) == b'{"1":"x"}'
 
-    with pytest.warns(UserWarning, match='Expected `enum` but got `str` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match="Expected `enum` but got `str` with value `'x'` - serialized value may not be as expected"
+    ):
         assert v.to_python({'x': 'x'}) == {'x': 'x'}
-    with pytest.warns(UserWarning, match='Expected `enum` but got `str` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match="Expected `enum` but got `str` with value `'x'` - serialized value may not be as expected"
+    ):
         assert v.to_json({'x': 'x'}) == b'{"x":"x"}'
 
 
@@ -99,7 +115,11 @@ class MyEnum(int, Enum):
     assert v.to_python({MyEnum.a: 'x'}, mode='json') == {'1': 'x'}
     assert v.to_json({MyEnum.a: 'x'}) == b'{"1":"x"}'
 
-    with pytest.warns(UserWarning, match='Expected `enum` but got `str` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match="Expected `enum` but got `str` with value `'x'` - serialized value may not be as expected"
+    ):
         assert v.to_python({'x': 'x'}) == {'x': 'x'}
-    with pytest.warns(UserWarning, match='Expected `enum` but got `str` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match="Expected `enum` but got `str` with value `'x'` - serialized value may not be as expected"
+    ):
         assert v.to_json({'x': 'x'}) == b'{"x":"x"}'
diff --git a/tests/serializers/test_functions.py b/tests/serializers/test_functions.py
index c5b28ec31..a151b7454 100644
--- a/tests/serializers/test_functions.py
+++ b/tests/serializers/test_functions.py
@@ -207,7 +207,7 @@ def append_42(value, _info):
     assert s.to_python([1, 2, 3], mode='json') == [1, 2, 3, 42]
     assert s.to_json([1, 2, 3]) == b'[1,2,3,42]'
 
-    msg = r'Expected `list\[int\]` but got `str` - serialized value may not be as expected'
+    msg = r"Expected `list\[int\]` but got `str` with value `'abc'` - serialized value may not be as expected"
     with pytest.warns(UserWarning, match=msg):
         assert s.to_python('abc') == 'abc'
 
@@ -322,11 +322,17 @@ def test_wrong_return_type():
             )
         )
     )
-    with pytest.warns(UserWarning, match='Expected `int` but got `str` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match="Expected `int` but got `str` with value `'123'` - serialized value may not be as expected"
+    ):
         assert s.to_python(123) == '123'
-    with pytest.warns(UserWarning, match='Expected `int` but got `str` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match="Expected `int` but got `str` with value `'123'` - serialized value may not be as expected"
+    ):
         assert s.to_python(123, mode='json') == '123'
-    with pytest.warns(UserWarning, match='Expected `int` but got `str` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match="Expected `int` but got `str` with value `'123'` - serialized value may not be as expected"
+    ):
         assert s.to_json(123) == b'"123"'
 
 
@@ -356,11 +362,17 @@ def f(value, serializer):
     assert s.to_python(3) == 'result=3'
     assert s.to_python(3, mode='json') == 'result=3'
     assert s.to_json(3) == b'"result=3"'
-    with pytest.warns(UserWarning, match='Expected `str` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match='Expected `str` but got `int` with value `42` - serialized value may not be as expected'
+    ):
         assert s.to_python(42) == 42
-    with pytest.warns(UserWarning, match='Expected `str` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match='Expected `str` but got `int` with value `42` - serialized value may not be as expected'
+    ):
         assert s.to_python(42, mode='json') == 42
-    with pytest.warns(UserWarning, match='Expected `str` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match='Expected `str` but got `int` with value `42` - serialized value may not be as expected'
+    ):
         assert s.to_json(42) == b'42'
 
 
@@ -611,7 +623,9 @@ def f(value, _info):
         return value
 
     s = SchemaSerializer(core_schema.with_info_after_validator_function(f, core_schema.int_schema()))
-    with pytest.warns(UserWarning, match='Expected `int` but got `str` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match="Expected `int` but got `str` with value `'abc'` - serialized value may not be as expected"
+    ):
         assert s.to_python('abc') == 'abc'
 
 
@@ -620,7 +634,9 @@ def f(value, handler, _info):
         return handler(value)
 
     s = SchemaSerializer(core_schema.with_info_wrap_validator_function(f, core_schema.int_schema()))
-    with pytest.warns(UserWarning, match='Expected `int` but got `str` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match="Expected `int` but got `str` with value `'abc'` - serialized value may not be as expected"
+    ):
         assert s.to_python('abc') == 'abc'
 
 
diff --git a/tests/serializers/test_generator.py b/tests/serializers/test_generator.py
index 89b6b0350..cbd72ee8e 100644
--- a/tests/serializers/test_generator.py
+++ b/tests/serializers/test_generator.py
@@ -54,12 +54,12 @@ def test_generator_any():
     assert s.to_json(iter(['a', b'b', 3])) == b'["a","b",3]'
     assert s.to_json(gen_ok('a', b'b', 3)) == b'["a","b",3]'
 
-    msg = 'Expected `generator` but got `int` - serialized value may not be as expected'
+    msg = 'Expected `generator` but got `int` with value `4` - serialized value may not be as expected'
     with pytest.warns(UserWarning, match=msg):
         assert s.to_python(4) == 4
-    with pytest.warns(UserWarning, match='Expected `generator` but got `tuple`'):
+    with pytest.warns(UserWarning, match="Expected `generator` but got `tuple` with value `\\('a', b'b', 3\\)`"):
         assert s.to_python(('a', b'b', 3)) == ('a', b'b', 3)
-    with pytest.warns(UserWarning, match='Expected `generator` but got `str`'):
+    with pytest.warns(UserWarning, match="Expected `generator` but got `str` with value `'abc'`"):
         assert s.to_python('abc') == 'abc'
 
     with pytest.raises(ValueError, match='oops'):
@@ -88,14 +88,21 @@ def test_generator_int():
     with pytest.raises(ValueError, match='oops'):
         s.to_json(gen_error(1, 2))
 
-    with pytest.warns(UserWarning, match='Expected `int` but got `str` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match="Expected `int` but got `str` with value `'a'` - serialized value may not be as expected"
+    ):
         s.to_json(gen_ok(1, 'a'))
 
     gen = s.to_python(gen_ok(1, 'a'))
     assert next(gen) == 1
-    with pytest.warns(UserWarning, match='Expected `int` but got `str` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match="Expected `int` but got `str` with value `'a'` - serialized value may not be as expected"
+    ):
         assert next(gen) == 'a'
-    with pytest.warns(UserWarning, match='Expected `generator` but got `tuple` - serialized value may not.+'):
+    with pytest.warns(
+        UserWarning,
+        match='Expected `generator` but got `tuple` with value `\\(1, 2, 3\\)` - serialized value may not.+',
+    ):
         s.to_python((1, 2, 3))
 
 
diff --git a/tests/serializers/test_list_tuple.py b/tests/serializers/test_list_tuple.py
index 3591ffc9d..b4bf1208b 100644
--- a/tests/serializers/test_list_tuple.py
+++ b/tests/serializers/test_list_tuple.py
@@ -18,26 +18,26 @@ def test_list_any():
 
 def test_list_fallback():
     v = SchemaSerializer(core_schema.list_schema(core_schema.any_schema()))
-    msg = 'Expected `list[any]` but got `str` - serialized value may not be as expected'
+    msg = "Expected `list[any]` but got `str` with value `'apple'` - serialized value may not be as expected"
     with pytest.warns(UserWarning, match=re.escape(msg)):
         assert v.to_python('apple') == 'apple'
 
     with pytest.warns(UserWarning) as warning_info:
         assert v.to_json('apple') == b'"apple"'
     assert [w.message.args[0] for w in warning_info.list] == [
-        'Pydantic serializer warnings:\n  Expected `list[any]` but got `str` - serialized value may not be as expected'
+        "Pydantic serializer warnings:\n  Expected `list[any]` but got `str` with value `'apple'` - serialized value may not be as expected"
     ]
 
-    msg = 'Expected `list[any]` but got `bytes` - serialized value may not be as expected'
+    msg = "Expected `list[any]` but got `bytes` with value `b'apple'` - serialized value may not be as expected"
     with pytest.warns(UserWarning, match=re.escape(msg)):
         assert v.to_json(b'apple') == b'"apple"'
 
-    msg = 'Expected `list[any]` but got `tuple` - serialized value may not be as expected'
+    msg = 'Expected `list[any]` but got `tuple` with value `(1, 2, 3)` - serialized value may not be as expected'
     with pytest.warns(UserWarning, match=re.escape(msg)):
         assert v.to_python((1, 2, 3)) == (1, 2, 3)
 
     # # even though we're in the fallback state, non JSON types should still be converted to JSON here
-    msg = 'Expected `list[any]` but got `tuple` - serialized value may not be as expected'
+    msg = 'Expected `list[any]` but got `tuple` with value `(1, 2, 3)` - serialized value may not be as expected'
     with pytest.warns(UserWarning, match=re.escape(msg)):
         assert v.to_python((1, 2, 3), mode='json') == [1, 2, 3]
 
@@ -48,18 +48,18 @@ def test_list_str_fallback():
         assert v.to_json([1, 2, 3]) == b'[1,2,3]'
     assert [w.message.args[0] for w in warning_info.list] == [
         'Pydantic serializer warnings:\n'
-        '  Expected `str` but got `int` - serialized value may not be as expected\n'
-        '  Expected `str` but got `int` - serialized value may not be as expected\n'
-        '  Expected `str` but got `int` - serialized value may not be as expected'
+        '  Expected `str` but got `int` with value `1` - serialized value may not be as expected\n'
+        '  Expected `str` but got `int` with value `2` - serialized value may not be as expected\n'
+        '  Expected `str` but got `int` with value `3` - serialized value may not be as expected'
     ]
     with pytest.raises(PydanticSerializationError) as warning_ex:
         v.to_json([1, 2, 3], warnings='error')
     assert str(warning_ex.value) == ''.join(
         [
             'Pydantic serializer warnings:\n'
-            '  Expected `str` but got `int` - serialized value may not be as expected\n'
-            '  Expected `str` but got `int` - serialized value may not be as expected\n'
-            '  Expected `str` but got `int` - serialized value may not be as expected'
+            '  Expected `str` but got `int` with value `1` - serialized value may not be as expected\n'
+            '  Expected `str` but got `int` with value `2` - serialized value may not be as expected\n'
+            '  Expected `str` but got `int` with value `3` - serialized value may not be as expected'
         ]
     )
 
@@ -243,25 +243,25 @@ def test_include_error_call_time(schema_func, seq_f, include, exclude):
 
 def test_tuple_fallback():
     v = SchemaSerializer(core_schema.tuple_variable_schema(core_schema.any_schema()))
-    msg = 'Expected `tuple[any, ...]` but got `str` - serialized value may not be as expected'
+    msg = "Expected `tuple[any, ...]` but got `str` with value `'apple'` - serialized value may not be as expected"
     with pytest.warns(UserWarning, match=re.escape(msg)):
         assert v.to_python('apple') == 'apple'
 
     with pytest.warns(UserWarning) as warning_info:
         assert v.to_json([1, 2, 3]) == b'[1,2,3]'
     assert [w.message.args[0] for w in warning_info.list] == [
-        'Pydantic serializer warnings:\n  Expected `tuple[any, ...]` but got `list` - '
+        'Pydantic serializer warnings:\n  Expected `tuple[any, ...]` but got `list` with value `[1, 2, 3]` - '
         'serialized value may not be as expected'
     ]
 
-    msg = 'Expected `tuple[any, ...]` but got `bytes` - serialized value may not be as expected'
+    msg = "Expected `tuple[any, ...]` but got `bytes` with value `b'apple'` - serialized value may not be as expected"
     with pytest.warns(UserWarning, match=re.escape(msg)):
         assert v.to_json(b'apple') == b'"apple"'
 
     assert v.to_python((1, 2, 3)) == (1, 2, 3)
 
     # even though we're in the fallback state, non JSON types should still be converted to JSON here
-    msg = 'Expected `tuple[any, ...]` but got `list` - serialized value may not be as expected'
+    msg = 'Expected `tuple[any, ...]` but got `list` with value `[1, 2, 3]` - serialized value may not be as expected'
     with pytest.warns(UserWarning, match=re.escape(msg)):
         assert v.to_python([1, 2, 3], mode='json') == [1, 2, 3]
 
diff --git a/tests/serializers/test_model.py b/tests/serializers/test_model.py
index ddf9e5f97..207354946 100644
--- a/tests/serializers/test_model.py
+++ b/tests/serializers/test_model.py
@@ -230,14 +230,17 @@ def test_model_wrong_warn():
     assert s.to_python(None, mode='json') is None
     assert s.to_json(None) == b'null'
 
-    with pytest.warns(UserWarning, match='Expected `MyModel` but got `int` - serialized value may.+'):
+    with pytest.warns(UserWarning, match='Expected `MyModel` but got `int` with value `123` - serialized value may.+'):
         assert s.to_python(123) == 123
-    with pytest.warns(UserWarning, match='Expected `MyModel` but got `int` - serialized value may.+'):
+    with pytest.warns(UserWarning, match='Expected `MyModel` but got `int` with value `123` - serialized value may.+'):
         assert s.to_python(123, mode='json') == 123
-    with pytest.warns(UserWarning, match='Expected `MyModel` but got `int` - serialized value may.+'):
+    with pytest.warns(UserWarning, match='Expected `MyModel` but got `int` with value `123` - serialized value may.+'):
         assert s.to_json(123) == b'123'
 
-    with pytest.warns(UserWarning, match='Expected `MyModel` but got `dict` - serialized value may.+'):
+    with pytest.warns(
+        UserWarning,
+        match="Expected `MyModel` but got `dict` with value `{'foo': 1, 'bar': b'more'}` - serialized value may.+",
+    ):
         assert s.to_python({'foo': 1, 'bar': b'more'}) == {'foo': 1, 'bar': b'more'}
 
 
diff --git a/tests/serializers/test_nullable.py b/tests/serializers/test_nullable.py
index 173fcb3ca..86b64a213 100644
--- a/tests/serializers/test_nullable.py
+++ b/tests/serializers/test_nullable.py
@@ -11,5 +11,7 @@ def test_nullable():
     assert s.to_python(1, mode='json') == 1
     assert s.to_json(1) == b'1'
     assert s.to_json(None) == b'null'
-    with pytest.warns(UserWarning, match='Expected `int` but got `str` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match="Expected `int` but got `str` with value `'aaa'` - serialized value may not be as expected"
+    ):
         assert s.to_json('aaa') == b'"aaa"'
diff --git a/tests/serializers/test_other.py b/tests/serializers/test_other.py
index 505c003d4..13877d096 100644
--- a/tests/serializers/test_other.py
+++ b/tests/serializers/test_other.py
@@ -44,7 +44,9 @@ def test_lax_or_strict():
     assert plain_repr(s) == 'SchemaSerializer(serializer=Str(StrSerializer),definitions=[])'
 
     assert s.to_json('abc') == b'"abc"'
-    with pytest.warns(UserWarning, match='Expected `str` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match='Expected `str` but got `int` with value `123` - serialized value may not be as expected'
+    ):
         assert s.to_json(123) == b'123'
 
 
diff --git a/tests/serializers/test_set_frozenset.py b/tests/serializers/test_set_frozenset.py
index 1c638a979..c2df80f0a 100644
--- a/tests/serializers/test_set_frozenset.py
+++ b/tests/serializers/test_set_frozenset.py
@@ -26,11 +26,15 @@ def test_frozenset_any():
 @pytest.mark.parametrize(
     'input_value,json_output,warning_type',
     [
-        ('apple', 'apple', r'`set\[int\]` but got `str`'),
-        ([1, 2, 3], [1, 2, 3], r'`set\[int\]` but got `list`'),
-        ((1, 2, 3), [1, 2, 3], r'`set\[int\]` but got `tuple`'),
-        (frozenset([1, 2, 3]), IsList(1, 2, 3, check_order=False), r'`set\[int\]` but got `frozenset`'),
-        ({1, 2, 'a'}, IsList(1, 2, 'a', check_order=False), '`int` but got `str`'),
+        ('apple', 'apple', r"`set\[int\]` but got `str` with value `'apple'`"),
+        ([1, 2, 3], [1, 2, 3], r'`set\[int\]` but got `list` with value `\[1, 2, 3\]`'),
+        ((1, 2, 3), [1, 2, 3], r'`set\[int\]` but got `tuple` with value `\(1, 2, 3\)`'),
+        (
+            frozenset([1, 2, 3]),
+            IsList(1, 2, 3, check_order=False),
+            r'`set\[int\]` but got `frozenset` with value `frozenset\({1, 2, 3}\)`',
+        ),
+        ({1, 2, 'a'}, IsList(1, 2, 'a', check_order=False), "`int` but got `str` with value `'a'`"),
     ],
 )
 def test_set_fallback(input_value, json_output, warning_type):
diff --git a/tests/serializers/test_simple.py b/tests/serializers/test_simple.py
index b0fe7b836..19b3b4f55 100644
--- a/tests/serializers/test_simple.py
+++ b/tests/serializers/test_simple.py
@@ -109,17 +109,20 @@ def test_int_to_float_key():
 def test_simple_serializers_fallback(schema_type):
     s = SchemaSerializer({'type': schema_type})
     with pytest.warns(
-        UserWarning, match=f'Expected `{schema_type}` but got `list` - serialized value may not be as expected'
+        UserWarning,
+        match=f'Expected `{schema_type}` but got `list` with value `\\[1, 2, 3\\]` - serialized value may not be as expected',
     ):
         assert s.to_python([1, 2, 3]) == [1, 2, 3]
 
     with pytest.warns(
-        UserWarning, match=f'Expected `{schema_type}` but got `list` - serialized value may not be as expected'
+        UserWarning,
+        match=f"Expected `{schema_type}` but got `list` with value `\\[1, 2, b'bytes'\\]` - serialized value may not be as expected",
     ):
         assert s.to_python([1, 2, b'bytes'], mode='json') == [1, 2, 'bytes']
 
     with pytest.warns(
-        UserWarning, match=f'Expected `{schema_type}` but got `list` - serialized value may not be as expected'
+        UserWarning,
+        match=f'Expected `{schema_type}` but got `list` with value `\\[1, 2, 3\\]` - serialized value may not be as expected',
     ):
         assert s.to_json([1, 2, 3]) == b'[1,2,3]'
 
diff --git a/tests/serializers/test_string.py b/tests/serializers/test_string.py
index 6038b6a67..074179d8a 100644
--- a/tests/serializers/test_string.py
+++ b/tests/serializers/test_string.py
@@ -23,28 +23,58 @@ def test_str():
     assert json.loads(json_emoji) == 'emoji 💩'
 
 
+def test_huge_str():
+    v = SchemaSerializer(core_schema.int_schema())
+    msg = "Expected `int` but got `str` with value `'123456789012345678901234...89012345678901234567890'` - serialized value may not be as expected"
+    with pytest.warns(UserWarning, match=msg):
+        v.to_python(
+            '12345678901234567890123456789012345678901234567890123456789012345678901234567890\
+                           12345678901234567890123456789012345678901234567890123456789012345678901234567890\
+                           12345678901234567890123456789012345678901234567890123456789012345678901234567890\
+                           12345678901234567890123456789012345678901234567890123456789012345678901234567890'
+        )
+
+
 def test_str_fallback():
     s = SchemaSerializer(core_schema.str_schema())
     assert s.to_python(None) is None
     assert s.to_python(None, mode='json') is None
     assert s.to_json(None) == b'null'
-    with pytest.warns(UserWarning, match='Expected `str` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match='Expected `str` but got `int` with value `123` - serialized value may not be as expected'
+    ):
         assert s.to_python(123) == 123
-    with pytest.warns(UserWarning, match='Expected `str` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match='Expected `str` but got `int` with value `123` - serialized value may not be as expected'
+    ):
         assert s.to_python(123, mode='json') == 123
-    with pytest.warns(UserWarning, match='Expected `str` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match='Expected `str` but got `int` with value `123` - serialized value may not be as expected'
+    ):
         assert s.to_json(123) == b'123'
-    with pytest.warns(UserWarning, match='Expected `str` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match='Expected `str` but got `int` with value `123` - serialized value may not be as expected'
+    ):
         assert s.to_python(123, warnings='warn') == 123
-    with pytest.warns(UserWarning, match='Expected `str` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match='Expected `str` but got `int` with value `123` - serialized value may not be as expected'
+    ):
         assert s.to_python(123, mode='json', warnings='warn') == 123
-    with pytest.warns(UserWarning, match='Expected `str` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match='Expected `str` but got `int` with value `123` - serialized value may not be as expected'
+    ):
         assert s.to_json(123, warnings='warn') == b'123'
-    with pytest.warns(UserWarning, match='Expected `str` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match='Expected `str` but got `int` with value `123` - serialized value may not be as expected'
+    ):
         assert s.to_python(123, warnings=True) == 123
-    with pytest.warns(UserWarning, match='Expected `str` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match='Expected `str` but got `int` with value `123` - serialized value may not be as expected'
+    ):
         assert s.to_python(123, mode='json', warnings=True) == 123
-    with pytest.warns(UserWarning, match='Expected `str` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match='Expected `str` but got `int` with value `123` - serialized value may not be as expected'
+    ):
         assert s.to_json(123, warnings=True) == b'123'
 
 
@@ -61,15 +91,18 @@ def test_str_no_warnings():
 def test_str_errors():
     s = SchemaSerializer(core_schema.str_schema())
     with pytest.raises(
-        PydanticSerializationError, match='Expected `str` but got `int` - serialized value may not be as expected'
+        PydanticSerializationError,
+        match='Expected `str` but got `int` with value `123` - serialized value may not be as expected',
     ):
         assert s.to_python(123, warnings='error') == 123
     with pytest.raises(
-        PydanticSerializationError, match='Expected `str` but got `int` - serialized value may not be as expected'
+        PydanticSerializationError,
+        match='Expected `str` but got `int` with value `123` - serialized value may not be as expected',
     ):
         assert s.to_python(123, mode='json', warnings='error') == 123
     with pytest.raises(
-        PydanticSerializationError, match='Expected `str` but got `int` - serialized value may not be as expected'
+        PydanticSerializationError,
+        match='Expected `str` but got `int` with value `123` - serialized value may not be as expected',
     ):
         assert s.to_json(123, warnings='error') == b'123'
 
diff --git a/tests/serializers/test_timedelta.py b/tests/serializers/test_timedelta.py
index 91b5716b0..19abb673d 100644
--- a/tests/serializers/test_timedelta.py
+++ b/tests/serializers/test_timedelta.py
@@ -18,12 +18,14 @@ def test_timedelta():
     assert v.to_json(timedelta(days=2, hours=3, minutes=4)) == b'"P2DT3H4M"'
 
     with pytest.warns(
-        UserWarning, match='Expected `timedelta` but got `int` - serialized value may not be as expected'
+        UserWarning,
+        match='Expected `timedelta` but got `int` with value `123` - serialized value may not be as expected',
     ):
         assert v.to_python(123, mode='json') == 123
 
     with pytest.warns(
-        UserWarning, match='Expected `timedelta` but got `int` - serialized value may not be as expected'
+        UserWarning,
+        match='Expected `timedelta` but got `int` with value `123` - serialized value may not be as expected',
     ):
         assert v.to_json(123) == b'123'
 
diff --git a/tests/serializers/test_union.py b/tests/serializers/test_union.py
index ee5ed3fc4..86811e560 100644
--- a/tests/serializers/test_union.py
+++ b/tests/serializers/test_union.py
@@ -32,7 +32,7 @@ def test_union_bool_int(input_value, expected_value, bool_case_label, int_case_l
 
 def test_union_error():
     s = SchemaSerializer(core_schema.union_schema([core_schema.bool_schema(), core_schema.int_schema()]))
-    msg = 'Expected `Union[bool, int]` but got `str` - serialized value may not be as expected'
+    msg = "Expected `Union[bool, int]` but got `str` with value `'a string'` - serialized value may not be as expected"
     with pytest.warns(UserWarning, match=re.escape(msg)):
         assert s.to_python('a string') == 'a string'
 
diff --git a/tests/serializers/test_url.py b/tests/serializers/test_url.py
index 17cb70a80..be906c75b 100644
--- a/tests/serializers/test_url.py
+++ b/tests/serializers/test_url.py
@@ -18,7 +18,10 @@ def test_url():
     assert s.to_python(url, mode='json') == 'https://example.com/'
     assert s.to_json(url) == b'"https://example.com/"'
 
-    with pytest.warns(UserWarning, match='Expected `url` but got `str` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning,
+        match="Expected `url` but got `str` with value `'https://example.com'` - serialized value may not be as expected",
+    ):
         assert s.to_python('https://example.com', mode='json') == 'https://example.com'
 
 
@@ -36,7 +39,8 @@ def test_multi_host_url():
     assert s.to_json(url) == b'"https://example.com,example.org/path"'
 
     with pytest.warns(
-        UserWarning, match='Expected `multi-host-url` but got `str` - serialized value may not be as expected'
+        UserWarning,
+        match="Expected `multi-host-url` but got `str` with value `'https://ex.com,ex.org/path'` - serialized value may not be as expected",
     ):
         assert s.to_python('https://ex.com,ex.org/path', mode='json') == 'https://ex.com,ex.org/path'
 
diff --git a/tests/serializers/test_uuid.py b/tests/serializers/test_uuid.py
index 9929891cb..fed9cfc98 100644
--- a/tests/serializers/test_uuid.py
+++ b/tests/serializers/test_uuid.py
@@ -14,10 +14,14 @@ def test_uuid():
     )
     assert v.to_json(UUID('12345678-1234-5678-1234-567812345678')) == b'"12345678-1234-5678-1234-567812345678"'
 
-    with pytest.warns(UserWarning, match='Expected `uuid` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match='Expected `uuid` but got `int` with value `123` - serialized value may not be as expected'
+    ):
         assert v.to_python(123, mode='json') == 123
 
-    with pytest.warns(UserWarning, match='Expected `uuid` but got `int` - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning, match='Expected `uuid` but got `int` with value `123` - serialized value may not be as expected'
+    ):
         assert v.to_json(123) == b'123'
 
 

From fd81a7572355738acb7b79c2b45a9bcf0481e386 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Mon, 12 Aug 2024 11:35:55 -0500
Subject: [PATCH 340/550] Try each option in union serializer before inference
 (#1398)

---
 src/serializers/type_serializers/union.rs | 40 ++++++++++++++++-------
 src/tools.rs                              |  2 ++
 src/validators/union.rs                   |  4 +--
 tests/serializers/test_union.py           | 24 ++++++++++++++
 4 files changed, 57 insertions(+), 13 deletions(-)

diff --git a/src/serializers/type_serializers/union.rs b/src/serializers/type_serializers/union.rs
index 51fc07e8d..4ca7fb06b 100644
--- a/src/serializers/type_serializers/union.rs
+++ b/src/serializers/type_serializers/union.rs
@@ -1,16 +1,17 @@
 use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList, PyTuple};
+use smallvec::SmallVec;
 use std::borrow::Cow;
 
 use crate::build_tools::py_schema_err;
 use crate::definitions::DefinitionsBuilder;
-use crate::tools::SchemaDict;
+use crate::tools::{SchemaDict, UNION_ERR_SMALLVEC_CAPACITY};
 use crate::PydanticSerializationUnexpectedValue;
 
 use super::{
-    infer_json_key, infer_serialize, infer_to_python, py_err_se_err, BuildSerializer, CombinedSerializer, Extra,
-    SerCheck, TypeSerializer,
+    infer_json_key, infer_serialize, infer_to_python, BuildSerializer, CombinedSerializer, Extra, SerCheck,
+    TypeSerializer,
 };
 
 #[derive(Debug, Clone)]
@@ -78,13 +79,14 @@ impl TypeSerializer for UnionSerializer {
         // try the serializers in left to right order with error_on fallback=true
         let mut new_extra = extra.clone();
         new_extra.check = SerCheck::Strict;
+        let mut errors: SmallVec<[PyErr; UNION_ERR_SMALLVEC_CAPACITY]> = SmallVec::new();
 
         for comb_serializer in &self.choices {
             match comb_serializer.to_python(value, include, exclude, &new_extra) {
                 Ok(v) => return Ok(v),
                 Err(err) => match err.is_instance_of::<PydanticSerializationUnexpectedValue>(value.py()) {
                     true => (),
-                    false => return Err(err),
+                    false => errors.push(err),
                 },
             }
         }
@@ -95,12 +97,16 @@ impl TypeSerializer for UnionSerializer {
                     Ok(v) => return Ok(v),
                     Err(err) => match err.is_instance_of::<PydanticSerializationUnexpectedValue>(value.py()) {
                         true => (),
-                        false => return Err(err),
+                        false => errors.push(err),
                     },
                 }
             }
         }
 
+        for err in &errors {
+            extra.warnings.custom_warning(err.to_string());
+        }
+
         extra.warnings.on_fallback_py(self.get_name(), value, extra)?;
         infer_to_python(value, include, exclude, extra)
     }
@@ -108,12 +114,14 @@ impl TypeSerializer for UnionSerializer {
     fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         let mut new_extra = extra.clone();
         new_extra.check = SerCheck::Strict;
+        let mut errors: SmallVec<[PyErr; UNION_ERR_SMALLVEC_CAPACITY]> = SmallVec::new();
+
         for comb_serializer in &self.choices {
             match comb_serializer.json_key(key, &new_extra) {
                 Ok(v) => return Ok(v),
                 Err(err) => match err.is_instance_of::<PydanticSerializationUnexpectedValue>(key.py()) {
                     true => (),
-                    false => return Err(err),
+                    false => errors.push(err),
                 },
             }
         }
@@ -124,12 +132,16 @@ impl TypeSerializer for UnionSerializer {
                     Ok(v) => return Ok(v),
                     Err(err) => match err.is_instance_of::<PydanticSerializationUnexpectedValue>(key.py()) {
                         true => (),
-                        false => return Err(err),
+                        false => errors.push(err),
                     },
                 }
             }
         }
 
+        for err in &errors {
+            extra.warnings.custom_warning(err.to_string());
+        }
+
         extra.warnings.on_fallback_py(self.get_name(), key, extra)?;
         infer_json_key(key, extra)
     }
@@ -145,12 +157,14 @@ impl TypeSerializer for UnionSerializer {
         let py = value.py();
         let mut new_extra = extra.clone();
         new_extra.check = SerCheck::Strict;
+        let mut errors: SmallVec<[PyErr; UNION_ERR_SMALLVEC_CAPACITY]> = SmallVec::new();
+
         for comb_serializer in &self.choices {
             match comb_serializer.to_python(value, include, exclude, &new_extra) {
                 Ok(v) => return infer_serialize(v.bind(py), serializer, None, None, extra),
-                Err(err) => match err.is_instance_of::<PydanticSerializationUnexpectedValue>(py) {
+                Err(err) => match err.is_instance_of::<PydanticSerializationUnexpectedValue>(value.py()) {
                     true => (),
-                    false => return Err(py_err_se_err(err)),
+                    false => errors.push(err),
                 },
             }
         }
@@ -159,14 +173,18 @@ impl TypeSerializer for UnionSerializer {
             for comb_serializer in &self.choices {
                 match comb_serializer.to_python(value, include, exclude, &new_extra) {
                     Ok(v) => return infer_serialize(v.bind(py), serializer, None, None, extra),
-                    Err(err) => match err.is_instance_of::<PydanticSerializationUnexpectedValue>(py) {
+                    Err(err) => match err.is_instance_of::<PydanticSerializationUnexpectedValue>(value.py()) {
                         true => (),
-                        false => return Err(py_err_se_err(err)),
+                        false => errors.push(err),
                     },
                 }
             }
         }
 
+        for err in &errors {
+            extra.warnings.custom_warning(err.to_string());
+        }
+
         extra.warnings.on_fallback_ser::<S>(self.get_name(), value, extra)?;
         infer_serialize(value, serializer, include, exclude, extra)
     }
diff --git a/src/tools.rs b/src/tools.rs
index adf64c91a..121ae3880 100644
--- a/src/tools.rs
+++ b/src/tools.rs
@@ -146,3 +146,5 @@ pub(crate) fn new_py_string<'py>(py: Python<'py>, s: &str, cache_str: StringCach
         pystring_fast_new(py, s, ascii_only)
     }
 }
+
+pub(crate) const UNION_ERR_SMALLVEC_CAPACITY: usize = 4;
diff --git a/src/validators/union.rs b/src/validators/union.rs
index 6fb9fb070..da24868c5 100644
--- a/src/validators/union.rs
+++ b/src/validators/union.rs
@@ -12,7 +12,7 @@ use crate::errors::{ErrorType, ToErrorValue, ValError, ValLineError, ValResult};
 use crate::input::{BorrowInput, Input, ValidatedDict};
 use crate::lookup_key::LookupKey;
 use crate::py_gc::PyGcTraverse;
-use crate::tools::SchemaDict;
+use crate::tools::{SchemaDict, UNION_ERR_SMALLVEC_CAPACITY};
 
 use super::custom_error::CustomError;
 use super::literal::LiteralLookup;
@@ -249,7 +249,7 @@ struct ChoiceLineErrors<'a> {
 
 enum MaybeErrors<'a> {
     Custom(&'a CustomError),
-    Errors(SmallVec<[ChoiceLineErrors<'a>; 4]>),
+    Errors(SmallVec<[ChoiceLineErrors<'a>; UNION_ERR_SMALLVEC_CAPACITY]>),
 }
 
 impl<'a> MaybeErrors<'a> {
diff --git a/tests/serializers/test_union.py b/tests/serializers/test_union.py
index 86811e560..9ab121b70 100644
--- a/tests/serializers/test_union.py
+++ b/tests/serializers/test_union.py
@@ -626,3 +626,27 @@ def test_union_serializer_picks_exact_type_over_subclass_json(
     )
     assert s.to_python(input_value, mode='json') == expected_value
     assert s.to_json(input_value) == json.dumps(expected_value).encode()
+
+
+def test_custom_serializer() -> None:
+    s = SchemaSerializer(
+        core_schema.union_schema(
+            [
+                core_schema.dict_schema(
+                    keys_schema=core_schema.any_schema(),
+                    values_schema=core_schema.any_schema(),
+                    serialization=core_schema.plain_serializer_function_ser_schema(lambda x: x['id']),
+                ),
+                core_schema.list_schema(
+                    items_schema=core_schema.dict_schema(
+                        keys_schema=core_schema.any_schema(),
+                        values_schema=core_schema.any_schema(),
+                        serialization=core_schema.plain_serializer_function_ser_schema(lambda x: x['id']),
+                    )
+                ),
+            ]
+        )
+    )
+    print(s)
+    assert s.to_python([{'id': 1}, {'id': 2}]) == [1, 2]
+    assert s.to_python({'id': 1}) == 1

From 7368c1f760748349c6eb8a02438e1c4b9aa95314 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Tue, 13 Aug 2024 01:06:22 +0100
Subject: [PATCH 341/550] stop clone-ing serializers (#1402)

---
 src/serializers/computed_fields.rs             |  4 ++--
 src/serializers/fields.rs                      |  4 ++--
 src/serializers/infer.rs                       |  2 +-
 src/serializers/shared.rs                      |  4 ++--
 src/serializers/type_serializers/any.rs        | 12 +++++++++++-
 src/serializers/type_serializers/bytes.rs      |  2 +-
 src/serializers/type_serializers/dataclass.rs  |  2 +-
 .../type_serializers/datetime_etc.rs           |  2 +-
 src/serializers/type_serializers/decimal.rs    |  2 +-
 .../type_serializers/definitions.rs            |  2 +-
 src/serializers/type_serializers/dict.rs       |  2 +-
 src/serializers/type_serializers/enum_.rs      |  2 +-
 src/serializers/type_serializers/float.rs      |  2 +-
 src/serializers/type_serializers/format.rs     |  4 ++--
 src/serializers/type_serializers/function.rs   | 18 +++++++++---------
 src/serializers/type_serializers/generator.rs  | 16 ++++++++--------
 src/serializers/type_serializers/json.rs       |  2 +-
 .../type_serializers/json_or_python.rs         |  2 +-
 src/serializers/type_serializers/list.rs       |  2 +-
 src/serializers/type_serializers/literal.rs    |  2 +-
 src/serializers/type_serializers/model.rs      |  2 +-
 src/serializers/type_serializers/nullable.rs   |  2 +-
 .../type_serializers/set_frozenset.rs          |  2 +-
 src/serializers/type_serializers/simple.rs     |  4 ++--
 src/serializers/type_serializers/string.rs     |  2 +-
 src/serializers/type_serializers/timedelta.rs  |  2 +-
 src/serializers/type_serializers/tuple.rs      |  2 +-
 src/serializers/type_serializers/typed_dict.rs |  2 +-
 src/serializers/type_serializers/union.rs      |  2 +-
 src/serializers/type_serializers/url.rs        |  2 +-
 src/serializers/type_serializers/uuid.rs       |  2 +-
 .../type_serializers/with_default.rs           |  2 +-
 32 files changed, 62 insertions(+), 52 deletions(-)

diff --git a/src/serializers/computed_fields.rs b/src/serializers/computed_fields.rs
index 2d80d4f61..0cfa2d4d1 100644
--- a/src/serializers/computed_fields.rs
+++ b/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>,
diff --git a/src/serializers/fields.rs b/src/serializers/fields.rs
index f4f8910eb..87c34d364 100644
--- a/src/serializers/fields.rs
+++ b/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>,
diff --git a/src/serializers/infer.rs b/src/serializers/infer.rs
index 45d8957bb..514a6711b 100644
--- a/src/serializers/infer.rs
+++ b/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,
diff --git a/src/serializers/shared.rs b/src/serializers/shared.rs
index b9e0a727d..e7930512c 100644
--- a/src/serializers/shared.rs
+++ b/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),)*
@@ -256,7 +256,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>,
diff --git a/src/serializers/type_serializers/any.rs b/src/serializers/type_serializers/any.rs
index 179e2885d..3056959ea 100644
--- a/src/serializers/type_serializers/any.rs
+++ b/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";
 
diff --git a/src/serializers/type_serializers/bytes.rs b/src/serializers/type_serializers/bytes.rs
index 4fc53e224..fa17b941a 100644
--- a/src/serializers/type_serializers/bytes.rs
+++ b/src/serializers/type_serializers/bytes.rs
@@ -11,7 +11,7 @@ use super::{
     TypeSerializer,
 };
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct BytesSerializer {
     bytes_mode: BytesMode,
 }
diff --git a/src/serializers/type_serializers/dataclass.rs b/src/serializers/type_serializers/dataclass.rs
index ebcca0dec..ffe71adb9 100644
--- a/src/serializers/type_serializers/dataclass.rs
+++ b/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>,
diff --git a/src/serializers/type_serializers/datetime_etc.rs b/src/serializers/type_serializers/datetime_etc.rs
index a042ae99b..957fbcf29 100644
--- a/src/serializers/type_serializers/datetime_etc.rs
+++ b/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 {
diff --git a/src/serializers/type_serializers/decimal.rs b/src/serializers/type_serializers/decimal.rs
index 6237f53cb..2da84ab8f 100644
--- a/src/serializers/type_serializers/decimal.rs
+++ b/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 {
diff --git a/src/serializers/type_serializers/definitions.rs b/src/serializers/type_serializers/definitions.rs
index 071e50f8c..38fd7cea5 100644
--- a/src/serializers/type_serializers/definitions.rs
+++ b/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 {
diff --git a/src/serializers/type_serializers/dict.rs b/src/serializers/type_serializers/dict.rs
index cf4458bd7..ec750faed 100644
--- a/src/serializers/type_serializers/dict.rs
+++ b/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>,
diff --git a/src/serializers/type_serializers/enum_.rs b/src/serializers/type_serializers/enum_.rs
index d4d8aec02..8a604e772 100644
--- a/src/serializers/type_serializers/enum_.rs
+++ b/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>>,
diff --git a/src/serializers/type_serializers/float.rs b/src/serializers/type_serializers/float.rs
index 13af9294c..8ade81157 100644
--- a/src/serializers/type_serializers/float.rs
+++ b/src/serializers/type_serializers/float.rs
@@ -15,7 +15,7 @@ use super::{
     SerMode, TypeSerializer,
 };
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct FloatSerializer {
     inf_nan_mode: InfNanMode,
 }
diff --git a/src/serializers/type_serializers/format.rs b/src/serializers/type_serializers/format.rs
index 8b180f505..cf785c1cc 100644
--- a/src/serializers/type_serializers/format.rs
+++ b/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,
 }
diff --git a/src/serializers/type_serializers/function.rs b/src/serializers/type_serializers/function.rs
index 856be6fb3..d0fea665f 100644
--- a/src/serializers/type_serializers/function.rs
+++ b/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,
diff --git a/src/serializers/type_serializers/generator.rs b/src/serializers/type_serializers/generator.rs
index d7d211456..c85cd0f72 100644
--- a/src/serializers/type_serializers/generator.rs
+++ b/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()),
diff --git a/src/serializers/type_serializers/json.rs b/src/serializers/type_serializers/json.rs
index 8bc87bb2c..7f9b20492 100644
--- a/src/serializers/type_serializers/json.rs
+++ b/src/serializers/type_serializers/json.rs
@@ -16,7 +16,7 @@ use super::{
     TypeSerializer,
 };
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct JsonSerializer {
     serializer: Box<CombinedSerializer>,
 }
diff --git a/src/serializers/type_serializers/json_or_python.rs b/src/serializers/type_serializers/json_or_python.rs
index ce9a9c8c9..0e2de3370 100644
--- a/src/serializers/type_serializers/json_or_python.rs
+++ b/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>,
diff --git a/src/serializers/type_serializers/list.rs b/src/serializers/type_serializers/list.rs
index 44805f523..adec6c13c 100644
--- a/src/serializers/type_serializers/list.rs
+++ b/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>,
diff --git a/src/serializers/type_serializers/literal.rs b/src/serializers/type_serializers/literal.rs
index 258f35ed9..ce353dc03 100644
--- a/src/serializers/type_serializers/literal.rs
+++ b/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>,
diff --git a/src/serializers/type_serializers/model.rs b/src/serializers/type_serializers/model.rs
index 5459c63ac..8df3f9678 100644
--- a/src/serializers/type_serializers/model.rs
+++ b/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>,
diff --git a/src/serializers/type_serializers/nullable.rs b/src/serializers/type_serializers/nullable.rs
index 4abd56808..fb63384d1 100644
--- a/src/serializers/type_serializers/nullable.rs
+++ b/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>,
 }
diff --git a/src/serializers/type_serializers/set_frozenset.rs b/src/serializers/type_serializers/set_frozenset.rs
index 5e3d5ae29..7373c286d 100644
--- a/src/serializers/type_serializers/set_frozenset.rs
+++ b/src/serializers/type_serializers/set_frozenset.rs
@@ -17,7 +17,7 @@ use super::{
 
 macro_rules! build_serializer {
     ($struct_name:ident, $expected_type:literal, $py_type:ty) => {
-        #[derive(Debug, Clone)]
+        #[derive(Debug)]
         pub struct $struct_name {
             item_serializer: Box<CombinedSerializer>,
             name: String,
diff --git a/src/serializers/type_serializers/simple.rs b/src/serializers/type_serializers/simple.rs
index 5ad315a31..5df8ec071 100644
--- a/src/serializers/type_serializers/simple.rs
+++ b/src/serializers/type_serializers/simple.rs
@@ -13,7 +13,7 @@ use super::{
     SerCheck, SerMode, TypeSerializer,
 };
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct NoneSerializer;
 
 impl BuildSerializer for NoneSerializer {
@@ -87,7 +87,7 @@ impl TypeSerializer for NoneSerializer {
 
 macro_rules! build_simple_serializer {
     ($struct_name:ident, $expected_type:literal, $rust_type:ty, $ob_type:expr, $key_method:ident, $subtypes_allowed:expr) => {
-        #[derive(Debug, Clone)]
+        #[derive(Debug)]
         pub struct $struct_name;
 
         impl $struct_name {
diff --git a/src/serializers/type_serializers/string.rs b/src/serializers/type_serializers/string.rs
index 33b7d0d12..9e9a7162e 100644
--- a/src/serializers/type_serializers/string.rs
+++ b/src/serializers/type_serializers/string.rs
@@ -10,7 +10,7 @@ use super::{
     IsType, ObType, SerMode, TypeSerializer,
 };
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct StrSerializer;
 
 impl StrSerializer {
diff --git a/src/serializers/type_serializers/timedelta.rs b/src/serializers/type_serializers/timedelta.rs
index a28258e2a..a62b595d0 100644
--- a/src/serializers/type_serializers/timedelta.rs
+++ b/src/serializers/type_serializers/timedelta.rs
@@ -12,7 +12,7 @@ use super::{
     TypeSerializer,
 };
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct TimeDeltaSerializer {
     timedelta_mode: TimedeltaMode,
 }
diff --git a/src/serializers/type_serializers/tuple.rs b/src/serializers/type_serializers/tuple.rs
index 3dd5b1ca9..07196bf43 100644
--- a/src/serializers/type_serializers/tuple.rs
+++ b/src/serializers/type_serializers/tuple.rs
@@ -17,7 +17,7 @@ use super::{
     PydanticSerializer, SchemaFilter, SerMode, TypeSerializer,
 };
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct TupleSerializer {
     serializers: Vec<CombinedSerializer>,
     variadic_item_index: Option<usize>,
diff --git a/src/serializers/type_serializers/typed_dict.rs b/src/serializers/type_serializers/typed_dict.rs
index 90b448fb2..e80a9e9b3 100644
--- a/src/serializers/type_serializers/typed_dict.rs
+++ b/src/serializers/type_serializers/typed_dict.rs
@@ -11,7 +11,7 @@ use crate::tools::SchemaDict;
 
 use super::{BuildSerializer, CombinedSerializer, ComputedFields, FieldsMode, GeneralFieldsSerializer, SerField};
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct TypedDictBuilder;
 
 impl BuildSerializer for TypedDictBuilder {
diff --git a/src/serializers/type_serializers/union.rs b/src/serializers/type_serializers/union.rs
index 4ca7fb06b..2915115c3 100644
--- a/src/serializers/type_serializers/union.rs
+++ b/src/serializers/type_serializers/union.rs
@@ -14,7 +14,7 @@ use super::{
     TypeSerializer,
 };
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct UnionSerializer {
     choices: Vec<CombinedSerializer>,
     name: String,
diff --git a/src/serializers/type_serializers/url.rs b/src/serializers/type_serializers/url.rs
index f7dccf017..2ed2af739 100644
--- a/src/serializers/type_serializers/url.rs
+++ b/src/serializers/type_serializers/url.rs
@@ -14,7 +14,7 @@ use super::{
 
 macro_rules! build_serializer {
     ($struct_name:ident, $expected_type:literal, $extract:ty) => {
-        #[derive(Debug, Clone)]
+        #[derive(Debug)]
         pub struct $struct_name;
 
         impl BuildSerializer for $struct_name {
diff --git a/src/serializers/type_serializers/uuid.rs b/src/serializers/type_serializers/uuid.rs
index 9609f11da..01627c27c 100644
--- a/src/serializers/type_serializers/uuid.rs
+++ b/src/serializers/type_serializers/uuid.rs
@@ -18,7 +18,7 @@ pub(crate) fn uuid_to_string(py_uuid: &Bound<'_, PyAny>) -> PyResult<String> {
     Ok(uuid.to_string())
 }
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct UuidSerializer;
 
 impl_py_gc_traverse!(UuidSerializer {});
diff --git a/src/serializers/type_serializers/with_default.rs b/src/serializers/type_serializers/with_default.rs
index 0e50e10a2..6d510ce55 100644
--- a/src/serializers/type_serializers/with_default.rs
+++ b/src/serializers/type_serializers/with_default.rs
@@ -10,7 +10,7 @@ use crate::validators::DefaultType;
 
 use super::{BuildSerializer, CombinedSerializer, Extra, TypeSerializer};
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub struct WithDefaultSerializer {
     default: DefaultType,
     serializer: Box<CombinedSerializer>,

From 39a6b104f658617d2c3ca3724bab46965f810d64 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Tue, 13 Aug 2024 03:09:02 -0500
Subject: [PATCH 342/550] Fix float serialization behavior in strict mode
 (#1400)

---
 src/serializers/type_serializers/float.rs | 18 +++++++++++-------
 tests/serializers/test_union.py           | 12 ++++++++++++
 2 files changed, 23 insertions(+), 7 deletions(-)

diff --git a/src/serializers/type_serializers/float.rs b/src/serializers/type_serializers/float.rs
index 8ade81157..c6f80c2ca 100644
--- a/src/serializers/type_serializers/float.rs
+++ b/src/serializers/type_serializers/float.rs
@@ -12,8 +12,9 @@ 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)]
 pub struct FloatSerializer {
@@ -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)?;
diff --git a/tests/serializers/test_union.py b/tests/serializers/test_union.py
index 9ab121b70..83527f648 100644
--- a/tests/serializers/test_union.py
+++ b/tests/serializers/test_union.py
@@ -628,6 +628,18 @@ def test_union_serializer_picks_exact_type_over_subclass_json(
     assert s.to_json(input_value) == json.dumps(expected_value).encode()
 
 
+def test_union_float_int() -> None:
+    s = SchemaSerializer(core_schema.union_schema([core_schema.float_schema(), core_schema.int_schema()]))
+
+    assert s.to_python(1) == 1
+    assert json.loads(s.to_json(1)) == 1
+
+    s = SchemaSerializer(core_schema.union_schema([core_schema.int_schema(), core_schema.float_schema()]))
+
+    assert s.to_python(1) == 1
+    assert json.loads(s.to_json(1)) == 1
+
+
 def test_custom_serializer() -> None:
     s = SchemaSerializer(
         core_schema.union_schema(

From a0725759f9d5578905a641089669187966c0681b Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Tue, 13 Aug 2024 13:24:28 -0500
Subject: [PATCH 343/550] For missing fields, we don't warn on `exclude_`, so
 don't warn on `exclude` (#1403)

---
 src/serializers/fields.rs       |  2 +-
 tests/serializers/test_model.py | 21 +++++++++++++++++++++
 2 files changed, 22 insertions(+), 1 deletion(-)

diff --git a/src/serializers/fields.rs b/src/serializers/fields.rs
index 87c34d364..16c3f2d55 100644
--- a/src/serializers/fields.rs
+++ b/src/serializers/fields.rs
@@ -206,7 +206,7 @@ impl GeneralFieldsSerializer {
 
         if extra.check.enabled()
             // If any of these are true we can't count fields
-            && !(extra.exclude_defaults || extra.exclude_unset || extra.exclude_none)
+            && !(extra.exclude_defaults || extra.exclude_unset || extra.exclude_none || exclude.is_some())
             // Check for missing fields, we can't have extra fields here
             && self.required_fields > used_req_fields
         {
diff --git a/tests/serializers/test_model.py b/tests/serializers/test_model.py
index 207354946..abb32af3c 100644
--- a/tests/serializers/test_model.py
+++ b/tests/serializers/test_model.py
@@ -1,6 +1,7 @@
 import dataclasses
 import json
 import platform
+import warnings
 from random import randint
 from typing import Any, ClassVar, Dict
 
@@ -1080,3 +1081,23 @@ class Model:
     m.__pydantic_extra__ = {'extra': 'extra'}
 
     assert s.to_python(m) == {'extra': 'extra bam!'}
+
+
+def test_no_warn_on_exclude() -> None:
+    warnings.simplefilter('error')
+
+    s = SchemaSerializer(
+        core_schema.model_schema(
+            BasicModel,
+            core_schema.model_fields_schema(
+                {
+                    'a': core_schema.model_field(core_schema.int_schema()),
+                    'b': core_schema.model_field(core_schema.int_schema()),
+                }
+            ),
+        )
+    )
+
+    value = BasicModel(a=0, b=1)
+    assert s.to_python(value, exclude={'b'}) == {'a': 0}
+    assert s.to_python(value, mode='json', exclude={'b'}) == {'a': 0}

From bb67044c67b705d3ac7990ef067deb786e8d5afe Mon Sep 17 00:00:00 2001
From: Isaac To <candleindark@users.noreply.github.com>
Date: Wed, 14 Aug 2024 00:37:07 -0700
Subject: [PATCH 344/550] Use `typing_extensions.TypedDict` on Python < 3.12
 (#1404)

---
 python/pydantic_core/__init__.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/python/pydantic_core/__init__.py b/python/pydantic_core/__init__.py
index 5b2655c91..791de9d92 100644
--- a/python/pydantic_core/__init__.py
+++ b/python/pydantic_core/__init__.py
@@ -34,7 +34,7 @@
 else:
     from typing import NotRequired as _NotRequired
 
-if _sys.version_info < (3, 9):
+if _sys.version_info < (3, 12):
     from typing_extensions import TypedDict as _TypedDict
 else:
     from typing import TypedDict as _TypedDict

From 3d8295efe31bf36f3350f7bd1a0ea240cc566589 Mon Sep 17 00:00:00 2001
From: Huan-Cheng Chang <changhc84@gmail.com>
Date: Thu, 15 Aug 2024 15:36:54 +0100
Subject: [PATCH 345/550] Support complex numbers (#1331)

---
 generate_self_schema.py                     |   2 +-
 python/pydantic_core/core_schema.py         |  46 ++++++
 src/errors/types.rs                         |   5 +
 src/input/input_abstract.rs                 |   4 +-
 src/input/input_json.rs                     |  33 +++++
 src/input/input_python.rs                   |  46 +++++-
 src/input/input_string.rs                   |   9 ++
 src/input/return_enums.rs                   |  29 +++-
 src/serializers/infer.rs                    |  24 ++-
 src/serializers/ob_type.rs                  |   8 +-
 src/serializers/shared.rs                   |   2 +
 src/serializers/type_serializers/complex.rs |  95 ++++++++++++
 src/serializers/type_serializers/mod.rs     |   1 +
 src/validators/complex.rs                   |  75 ++++++++++
 src/validators/mod.rs                       |   3 +
 tests/serializers/test_complex.py           |  39 +++++
 tests/test_errors.py                        |  10 ++
 tests/test_schema_functions.py              |   1 +
 tests/validators/test_complex.py            | 154 ++++++++++++++++++++
 tests/validators/test_dict.py               |  23 +++
 20 files changed, 601 insertions(+), 8 deletions(-)
 create mode 100644 src/serializers/type_serializers/complex.rs
 create mode 100644 src/validators/complex.rs
 create mode 100644 tests/serializers/test_complex.py
 create mode 100644 tests/validators/test_complex.py

diff --git a/generate_self_schema.py b/generate_self_schema.py
index ac12062f3..aeb411c6d 100644
--- a/generate_self_schema.py
+++ b/generate_self_schema.py
@@ -50,7 +50,7 @@
 def get_schema(obj: Any, definitions: dict[str, core_schema.CoreSchema]) -> core_schema.CoreSchema:  # noqa: C901
     if isinstance(obj, str):
         return {'type': obj}
-    elif obj in (datetime, timedelta, date, time, bool, int, float, str, decimal.Decimal):
+    elif obj in (datetime, timedelta, date, time, bool, int, float, str, decimal.Decimal, complex):
         return {'type': obj.__name__.lower()}
     elif is_typeddict(obj):
         return type_dict_schema(obj, definitions)
diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index 4ac24bd6c..886194cbc 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -745,6 +745,48 @@ def decimal_schema(
     )
 
 
+class ComplexSchema(TypedDict, total=False):
+    type: Required[Literal['complex']]
+    strict: bool
+    ref: str
+    metadata: Any
+    serialization: SerSchema
+
+
+def complex_schema(
+    *,
+    strict: bool | None = None,
+    ref: str | None = None,
+    metadata: Any = None,
+    serialization: SerSchema | None = None,
+) -> ComplexSchema:
+    """
+    Returns a schema that matches a complex value, e.g.:
+
+    ```py
+    from pydantic_core import SchemaValidator, core_schema
+
+    schema = core_schema.complex_schema()
+    v = SchemaValidator(schema)
+    assert v.validate_python('1+2j') == complex(1, 2)
+    assert v.validate_python(complex(1, 2)) == complex(1, 2)
+    ```
+
+    Args:
+        strict: Whether the value should be a complex object instance or a value that can be converted to a complex object
+        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
+        serialization: Custom serialization schema
+    """
+    return _dict_not_none(
+        type='complex',
+        strict=strict,
+        ref=ref,
+        metadata=metadata,
+        serialization=serialization,
+    )
+
+
 class StringSchema(TypedDict, total=False):
     type: Required[Literal['str']]
     pattern: Union[str, Pattern[str]]
@@ -3796,6 +3838,7 @@ def definition_reference_schema(
         DefinitionsSchema,
         DefinitionReferenceSchema,
         UuidSchema,
+        ComplexSchema,
     ]
 elif False:
     CoreSchema: TypeAlias = Mapping[str, Any]
@@ -3851,6 +3894,7 @@ def definition_reference_schema(
     'definitions',
     'definition-ref',
     'uuid',
+    'complex',
 ]
 
 CoreSchemaFieldType = Literal['model-field', 'dataclass-field', 'typed-dict-field', 'computed-field']
@@ -3956,6 +4000,8 @@ def definition_reference_schema(
     'decimal_max_digits',
     'decimal_max_places',
     'decimal_whole_digits',
+    'complex_type',
+    'complex_str_parsing',
 ]
 
 
diff --git a/src/errors/types.rs b/src/errors/types.rs
index 8807ba129..ec129a63a 100644
--- a/src/errors/types.rs
+++ b/src/errors/types.rs
@@ -426,6 +426,9 @@ error_types! {
     DecimalWholeDigits {
         whole_digits: {ctx_type: u64, ctx_fn: field_from_context},
     },
+    // Complex errors
+    ComplexType {},
+    ComplexStrParsing {},
 }
 
 macro_rules! render {
@@ -569,6 +572,8 @@ impl ErrorType {
             Self::DecimalMaxDigits {..} => "Decimal input should have no more than {max_digits} digit{expected_plural} in total",
             Self::DecimalMaxPlaces {..} => "Decimal input should have no more than {decimal_places} decimal place{expected_plural}",
             Self::DecimalWholeDigits {..} => "Decimal input should have no more than {whole_digits} digit{expected_plural} before the decimal point",
+            Self::ComplexType {..} => "Input should be a valid python complex object, a number, or a valid complex string following the rules at https://docs.python.org/3/library/functions.html#complex",
+            Self::ComplexStrParsing {..} => "Input should be a valid complex string following the rules at https://docs.python.org/3/library/functions.html#complex",
         }
     }
 
diff --git a/src/input/input_abstract.rs b/src/input/input_abstract.rs
index b0e058d9b..24a2e0239 100644
--- a/src/input/input_abstract.rs
+++ b/src/input/input_abstract.rs
@@ -10,7 +10,7 @@ use crate::tools::py_err;
 use crate::validators::ValBytesMode;
 
 use super::datetime::{EitherDate, EitherDateTime, EitherTime, EitherTimedelta};
-use super::return_enums::{EitherBytes, EitherInt, EitherString};
+use super::return_enums::{EitherBytes, EitherComplex, EitherInt, EitherString};
 use super::{EitherFloat, GenericIterator, ValidationMatch};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
@@ -173,6 +173,8 @@ pub trait Input<'py>: fmt::Debug + ToPyObject {
         strict: bool,
         microseconds_overflow_behavior: speedate::MicrosecondsPrecisionOverflowBehavior,
     ) -> ValMatch<EitherTimedelta<'py>>;
+
+    fn validate_complex(&self, strict: bool, py: Python<'py>) -> ValMatch<EitherComplex<'py>>;
 }
 
 /// The problem to solve here is that iterating collections often returns owned
diff --git a/src/input/input_json.rs b/src/input/input_json.rs
index 3adc36ba6..5eb505f6e 100644
--- a/src/input/input_json.rs
+++ b/src/input/input_json.rs
@@ -8,7 +8,9 @@ use speedate::MicrosecondsPrecisionOverflowBehavior;
 use strum::EnumMessage;
 
 use crate::errors::{ErrorType, ErrorTypeDefaults, InputValue, LocItem, ValError, ValResult};
+use crate::input::return_enums::EitherComplex;
 use crate::lookup_key::{LookupKey, LookupPath};
+use crate::validators::complex::string_to_complex;
 use crate::validators::decimal::create_decimal;
 use crate::validators::ValBytesMode;
 
@@ -304,6 +306,30 @@ impl<'py, 'data> Input<'py> for JsonValue<'data> {
             _ => Err(ValError::new(ErrorTypeDefaults::TimeDeltaType, self)),
         }
     }
+
+    fn validate_complex(&self, strict: bool, py: Python<'py>) -> ValResult<ValidationMatch<EitherComplex<'py>>> {
+        match self {
+            JsonValue::Str(s) => Ok(ValidationMatch::strict(EitherComplex::Py(string_to_complex(
+                &PyString::new_bound(py, s),
+                self,
+            )?))),
+            JsonValue::Float(f) => {
+                if !strict {
+                    Ok(ValidationMatch::lax(EitherComplex::Complex([*f, 0.0])))
+                } else {
+                    Err(ValError::new(ErrorTypeDefaults::ComplexStrParsing, self))
+                }
+            }
+            JsonValue::Int(f) => {
+                if !strict {
+                    Ok(ValidationMatch::lax(EitherComplex::Complex([(*f) as f64, 0.0])))
+                } else {
+                    Err(ValError::new(ErrorTypeDefaults::ComplexStrParsing, self))
+                }
+            }
+            _ => Err(ValError::new(ErrorTypeDefaults::ComplexType, self)),
+        }
+    }
 }
 
 /// Required for JSON Object keys so the string can behave like an Input
@@ -440,6 +466,13 @@ impl<'py> Input<'py> for str {
     ) -> ValResult<ValidationMatch<EitherTimedelta<'py>>> {
         bytes_as_timedelta(self, self.as_bytes(), microseconds_overflow_behavior).map(ValidationMatch::lax)
     }
+
+    fn validate_complex(&self, _strict: bool, py: Python<'py>) -> ValResult<ValidationMatch<EitherComplex<'py>>> {
+        Ok(ValidationMatch::strict(EitherComplex::Py(string_to_complex(
+            self.to_object(py).downcast_bound::<PyString>(py)?,
+            self,
+        )?)))
+    }
 }
 
 impl BorrowInput<'_> for &'_ String {
diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index 7840a825a..46c32a9de 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -5,15 +5,17 @@ use pyo3::prelude::*;
 
 use pyo3::types::PyType;
 use pyo3::types::{
-    PyBool, PyByteArray, PyBytes, PyDate, PyDateTime, PyDict, PyFloat, PyFrozenSet, PyInt, PyIterator, PyList,
-    PyMapping, PySet, PyString, PyTime, PyTuple,
+    PyBool, PyByteArray, PyBytes, PyComplex, PyDate, PyDateTime, PyDict, PyFloat, PyFrozenSet, PyInt, PyIterator,
+    PyList, PyMapping, PySet, PyString, PyTime, PyTuple,
 };
 
 use pyo3::PyTypeCheck;
+use pyo3::PyTypeInfo;
 use speedate::MicrosecondsPrecisionOverflowBehavior;
 
 use crate::errors::{ErrorType, ErrorTypeDefaults, InputValue, LocItem, ValError, ValResult};
 use crate::tools::{extract_i64, safe_repr};
+use crate::validators::complex::string_to_complex;
 use crate::validators::decimal::{create_decimal, get_decimal_type};
 use crate::validators::Exactness;
 use crate::validators::ValBytesMode;
@@ -25,6 +27,7 @@ use super::datetime::{
     EitherTime,
 };
 use super::input_abstract::ValMatch;
+use super::return_enums::EitherComplex;
 use super::return_enums::{iterate_attributes, iterate_mapping_items, ValidationMatch};
 use super::shared::{
     decimal_as_int, float_as_int, get_enum_meta_object, int_as_bool, str_as_bool, str_as_float, str_as_int,
@@ -598,6 +601,45 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
 
         Err(ValError::new(ErrorTypeDefaults::TimeDeltaType, self))
     }
+
+    fn validate_complex<'a>(&'a self, strict: bool, py: Python<'py>) -> ValResult<ValidationMatch<EitherComplex<'py>>> {
+        if let Ok(complex) = self.downcast::<PyComplex>() {
+            return Ok(ValidationMatch::strict(EitherComplex::Py(complex.to_owned())));
+        }
+        if strict {
+            return Err(ValError::new(
+                ErrorType::IsInstanceOf {
+                    class: PyComplex::type_object_bound(py)
+                        .qualname()
+                        .and_then(|name| name.extract())
+                        .unwrap_or_else(|_| "complex".to_owned()),
+                    context: None,
+                },
+                self,
+            ));
+        }
+
+        if let Ok(s) = self.downcast::<PyString>() {
+            // If input is not a valid complex string, instead of telling users to correct
+            // the string, it makes more sense to tell them to provide any acceptable value
+            // since they might have just given values of some incorrect types instead
+            // of actually trying some complex strings.
+            if let Ok(c) = string_to_complex(s, self) {
+                return Ok(ValidationMatch::lax(EitherComplex::Py(c)));
+            }
+        } else if self.is_exact_instance_of::<PyFloat>() {
+            return Ok(ValidationMatch::lax(EitherComplex::Complex([
+                self.extract::<f64>().unwrap(),
+                0.0,
+            ])));
+        } else if self.is_exact_instance_of::<PyInt>() {
+            return Ok(ValidationMatch::lax(EitherComplex::Complex([
+                self.extract::<i64>().unwrap() as f64,
+                0.0,
+            ])));
+        }
+        Err(ValError::new(ErrorTypeDefaults::ComplexType, self))
+    }
 }
 
 impl<'py> BorrowInput<'py> for Bound<'py, PyAny> {
diff --git a/src/input/input_string.rs b/src/input/input_string.rs
index 3ef1b58ce..7adcaeb28 100644
--- a/src/input/input_string.rs
+++ b/src/input/input_string.rs
@@ -7,6 +7,7 @@ use crate::errors::{ErrorTypeDefaults, InputValue, LocItem, ValError, ValResult}
 use crate::input::py_string_str;
 use crate::lookup_key::{LookupKey, LookupPath};
 use crate::tools::safe_repr;
+use crate::validators::complex::string_to_complex;
 use crate::validators::decimal::create_decimal;
 use crate::validators::ValBytesMode;
 
@@ -14,6 +15,7 @@ use super::datetime::{
     bytes_as_date, bytes_as_datetime, bytes_as_time, bytes_as_timedelta, EitherDate, EitherDateTime, EitherTime,
 };
 use super::input_abstract::{Never, ValMatch};
+use super::return_enums::EitherComplex;
 use super::shared::{str_as_bool, str_as_float, str_as_int};
 use super::{
     Arguments, BorrowInput, EitherBytes, EitherFloat, EitherInt, EitherString, EitherTimedelta, GenericIterator, Input,
@@ -225,6 +227,13 @@ impl<'py> Input<'py> for StringMapping<'py> {
             Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::TimeDeltaType, self)),
         }
     }
+
+    fn validate_complex(&self, _strict: bool, _py: Python<'py>) -> ValResult<ValidationMatch<EitherComplex<'py>>> {
+        match self {
+            Self::String(s) => Ok(ValidationMatch::strict(EitherComplex::Py(string_to_complex(s, self)?))),
+            Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::ComplexType, self)),
+        }
+    }
 }
 
 impl<'py> BorrowInput<'py> for StringMapping<'py> {
diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index 6b62ac85a..593599bab 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -12,7 +12,7 @@ use pyo3::intern;
 use pyo3::prelude::*;
 #[cfg(not(PyPy))]
 use pyo3::types::PyFunction;
-use pyo3::types::{PyBytes, PyFloat, PyFrozenSet, PyIterator, PyMapping, PySet, PyString};
+use pyo3::types::{PyBytes, PyComplex, PyFloat, PyFrozenSet, PyIterator, PyMapping, PySet, PyString};
 
 use serde::{ser::Error, Serialize, Serializer};
 
@@ -724,3 +724,30 @@ impl ToPyObject for Int {
         }
     }
 }
+
+#[derive(Clone)]
+pub enum EitherComplex<'a> {
+    Complex([f64; 2]),
+    Py(Bound<'a, PyComplex>),
+}
+
+impl<'a> IntoPy<PyObject> for EitherComplex<'a> {
+    fn into_py(self, py: Python<'_>) -> PyObject {
+        match self {
+            Self::Complex(c) => PyComplex::from_doubles_bound(py, c[0], c[1]).into_py(py),
+            Self::Py(c) => c.into_py(py),
+        }
+    }
+}
+
+impl<'a> EitherComplex<'a> {
+    pub fn as_f64(&self, py: Python<'_>) -> [f64; 2] {
+        match self {
+            EitherComplex::Complex(f) => *f,
+            EitherComplex::Py(f) => [
+                f.getattr(intern!(py, "real")).unwrap().extract().unwrap(),
+                f.getattr(intern!(py, "imag")).unwrap().extract().unwrap(),
+            ],
+        }
+    }
+}
diff --git a/src/serializers/infer.rs b/src/serializers/infer.rs
index 514a6711b..032ede46b 100644
--- a/src/serializers/infer.rs
+++ b/src/serializers/infer.rs
@@ -4,6 +4,7 @@ use pyo3::exceptions::PyTypeError;
 use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::pybacked::PyBackedStr;
+use pyo3::types::PyComplex;
 use pyo3::types::{PyByteArray, PyBytes, PyDict, PyFrozenSet, PyIterator, PyList, PySet, PyString, PyTuple};
 
 use serde::ser::{Error, Serialize, SerializeMap, SerializeSeq, Serializer};
@@ -226,6 +227,13 @@ pub(crate) fn infer_to_python_known(
                 }
                 PyList::new_bound(py, items).into_py(py)
             }
+            ObType::Complex => {
+                let dict = value.downcast::<PyDict>()?;
+                let new_dict = PyDict::new_bound(py);
+                let _ = new_dict.set_item("real", dict.get_item("real")?);
+                let _ = new_dict.set_item("imag", dict.get_item("imag")?);
+                new_dict.into_py(py)
+            }
             ObType::Path => value.str()?.into_py(py),
             ObType::Pattern => value.getattr(intern!(py, "pattern"))?.into_py(py),
             ObType::Unknown => {
@@ -274,6 +282,13 @@ pub(crate) fn infer_to_python_known(
                 );
                 iter.into_py(py)
             }
+            ObType::Complex => {
+                let dict = value.downcast::<PyDict>()?;
+                let new_dict = PyDict::new_bound(py);
+                let _ = new_dict.set_item("real", dict.get_item("real")?);
+                let _ = new_dict.set_item("imag", dict.get_item("imag")?);
+                new_dict.into_py(py)
+            }
             ObType::Unknown => {
                 if let Some(fallback) = extra.fallback {
                     let next_value = fallback.call1((value,))?;
@@ -402,6 +417,13 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
         ObType::None => serializer.serialize_none(),
         ObType::Int | ObType::IntSubclass => serialize!(Int),
         ObType::Bool => serialize!(bool),
+        ObType::Complex => {
+            let v = value.downcast::<PyComplex>().map_err(py_err_se_err)?;
+            let mut map = serializer.serialize_map(Some(2))?;
+            map.serialize_entry(&"real", &v.real())?;
+            map.serialize_entry(&"imag", &v.imag())?;
+            map.end()
+        }
         ObType::Float | ObType::FloatSubclass => {
             let v = value.extract::<f64>().map_err(py_err_se_err)?;
             type_serializers::float::serialize_f64(v, serializer, extra.config.inf_nan_mode)
@@ -647,7 +669,7 @@ pub(crate) fn infer_json_key_known<'a>(
             }
             Ok(Cow::Owned(key_build.finish()))
         }
-        ObType::List | ObType::Set | ObType::Frozenset | ObType::Dict | ObType::Generator => {
+        ObType::List | ObType::Set | ObType::Frozenset | ObType::Dict | ObType::Generator | ObType::Complex => {
             py_err!(PyTypeError; "`{}` not valid as object key", ob_type)
         }
         ObType::Dataclass | ObType::PydanticSerializable => {
diff --git a/src/serializers/ob_type.rs b/src/serializers/ob_type.rs
index 196cf27b7..8d20efaa9 100644
--- a/src/serializers/ob_type.rs
+++ b/src/serializers/ob_type.rs
@@ -1,8 +1,8 @@
 use pyo3::prelude::*;
 use pyo3::sync::GILOnceCell;
 use pyo3::types::{
-    PyBool, PyByteArray, PyBytes, PyDate, PyDateTime, PyDelta, PyDict, PyFloat, PyFrozenSet, PyInt, PyIterator, PyList,
-    PyNone, PySet, PyString, PyTime, PyTuple, PyType,
+    PyBool, PyByteArray, PyBytes, PyComplex, PyDate, PyDateTime, PyDelta, PyDict, PyFloat, PyFrozenSet, PyInt,
+    PyIterator, PyList, PyNone, PySet, PyString, PyTime, PyTuple, PyType,
 };
 use pyo3::{intern, PyTypeInfo};
 
@@ -48,6 +48,7 @@ pub struct ObTypeLookup {
     pattern_object: PyObject,
     // uuid type
     uuid_object: PyObject,
+    complex: usize,
 }
 
 static TYPE_LOOKUP: GILOnceCell<ObTypeLookup> = GILOnceCell::new();
@@ -101,6 +102,7 @@ impl ObTypeLookup {
                 .to_object(py),
             pattern_object: py.import_bound("re").unwrap().getattr("Pattern").unwrap().to_object(py),
             uuid_object: py.import_bound("uuid").unwrap().getattr("UUID").unwrap().to_object(py),
+            complex: PyComplex::type_object_raw(py) as usize,
         }
     }
 
@@ -171,6 +173,7 @@ impl ObTypeLookup {
             ObType::Pattern => self.path_object.as_ptr() as usize == ob_type,
             ObType::Uuid => self.uuid_object.as_ptr() as usize == ob_type,
             ObType::Unknown => false,
+            ObType::Complex => self.complex == ob_type,
         };
 
         if ans {
@@ -426,6 +429,7 @@ pub enum ObType {
     Uuid,
     // unknown type
     Unknown,
+    Complex,
 }
 
 impl PartialEq for ObType {
diff --git a/src/serializers/shared.rs b/src/serializers/shared.rs
index e7930512c..cb12f8840 100644
--- a/src/serializers/shared.rs
+++ b/src/serializers/shared.rs
@@ -142,6 +142,7 @@ combined_serializer! {
         Enum: super::type_serializers::enum_::EnumSerializer;
         Recursive: super::type_serializers::definitions::DefinitionRefSerializer;
         Tuple: super::type_serializers::tuple::TupleSerializer;
+        Complex: super::type_serializers::complex::ComplexSerializer;
     }
 }
 
@@ -251,6 +252,7 @@ impl PyGcTraverse for CombinedSerializer {
             CombinedSerializer::Recursive(inner) => inner.py_gc_traverse(visit),
             CombinedSerializer::Tuple(inner) => inner.py_gc_traverse(visit),
             CombinedSerializer::Uuid(inner) => inner.py_gc_traverse(visit),
+            CombinedSerializer::Complex(inner) => inner.py_gc_traverse(visit),
         }
     }
 }
diff --git a/src/serializers/type_serializers/complex.rs b/src/serializers/type_serializers/complex.rs
new file mode 100644
index 000000000..5a525476e
--- /dev/null
+++ b/src/serializers/type_serializers/complex.rs
@@ -0,0 +1,95 @@
+use std::borrow::Cow;
+
+use pyo3::prelude::*;
+use pyo3::types::{PyComplex, PyDict};
+
+use crate::definitions::DefinitionsBuilder;
+
+use super::{infer_serialize, infer_to_python, BuildSerializer, CombinedSerializer, Extra, SerMode, TypeSerializer};
+
+#[derive(Debug, Clone)]
+pub struct ComplexSerializer {}
+
+impl BuildSerializer for ComplexSerializer {
+    const EXPECTED_TYPE: &'static str = "complex";
+    fn build(
+        _schema: &Bound<'_, PyDict>,
+        _config: Option<&Bound<'_, PyDict>>,
+        _definitions: &mut DefinitionsBuilder<CombinedSerializer>,
+    ) -> PyResult<CombinedSerializer> {
+        Ok(Self {}.into())
+    }
+}
+
+impl_py_gc_traverse!(ComplexSerializer {});
+
+impl TypeSerializer for ComplexSerializer {
+    fn to_python(
+        &self,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
+        extra: &Extra,
+    ) -> PyResult<PyObject> {
+        let py = value.py();
+        match value.downcast::<PyComplex>() {
+            Ok(py_complex) => match extra.mode {
+                SerMode::Json => {
+                    let re = py_complex.real();
+                    let im = py_complex.imag();
+                    let mut s = format!("{im}j");
+                    if re != 0.0 {
+                        let mut sign = "";
+                        if im >= 0.0 {
+                            sign = "+";
+                        }
+                        s = format!("{re}{sign}{s}");
+                    }
+                    Ok(s.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<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
+        self._invalid_as_json_key(key, extra, "complex")
+    }
+
+    fn serde_serialize<S: serde::ser::Serializer>(
+        &self,
+        value: &Bound<'_, PyAny>,
+        serializer: S,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
+        extra: &Extra,
+    ) -> Result<S::Ok, S::Error> {
+        match value.downcast::<PyComplex>() {
+            Ok(py_complex) => {
+                let re = py_complex.real();
+                let im = py_complex.imag();
+                let mut s = format!("{im}j");
+                if re != 0.0 {
+                    let mut sign = "";
+                    if im >= 0.0 {
+                        sign = "+";
+                    }
+                    s = format!("{re}{sign}{s}");
+                }
+                Ok(serializer.collect_str::<String>(&s)?)
+            }
+            Err(_) => {
+                extra.warnings.on_fallback_ser::<S>(self.get_name(), value, extra)?;
+                infer_serialize(value, serializer, include, exclude, extra)
+            }
+        }
+    }
+
+    fn get_name(&self) -> &str {
+        "complex"
+    }
+}
diff --git a/src/serializers/type_serializers/mod.rs b/src/serializers/type_serializers/mod.rs
index da36f0bc1..dabd006a3 100644
--- a/src/serializers/type_serializers/mod.rs
+++ b/src/serializers/type_serializers/mod.rs
@@ -1,5 +1,6 @@
 pub mod any;
 pub mod bytes;
+pub mod complex;
 pub mod dataclass;
 pub mod datetime_etc;
 pub mod decimal;
diff --git a/src/validators/complex.rs b/src/validators/complex.rs
new file mode 100644
index 000000000..d1d9f6c35
--- /dev/null
+++ b/src/validators/complex.rs
@@ -0,0 +1,75 @@
+use pyo3::exceptions::PyValueError;
+use pyo3::prelude::*;
+use pyo3::sync::GILOnceCell;
+use pyo3::types::{PyComplex, PyDict, PyString, PyType};
+
+use crate::build_tools::is_strict;
+use crate::errors::{ErrorTypeDefaults, ToErrorValue, ValError, ValResult};
+use crate::input::Input;
+
+use super::{BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
+
+static COMPLEX_TYPE: GILOnceCell<Py<PyType>> = GILOnceCell::new();
+
+pub fn get_complex_type(py: Python) -> &Bound<'_, PyType> {
+    COMPLEX_TYPE
+        .get_or_init(py, || py.get_type_bound::<PyComplex>().into())
+        .bind(py)
+}
+
+#[derive(Debug)]
+pub struct ComplexValidator {
+    strict: bool,
+}
+
+impl BuildValidator for ComplexValidator {
+    const EXPECTED_TYPE: &'static str = "complex";
+    fn build(
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
+        _definitions: &mut DefinitionsBuilder<CombinedValidator>,
+    ) -> PyResult<CombinedValidator> {
+        Ok(Self {
+            strict: is_strict(schema, config)?,
+        }
+        .into())
+    }
+}
+
+impl_py_gc_traverse!(ComplexValidator {});
+
+impl Validator for ComplexValidator {
+    fn validate<'py>(
+        &self,
+        py: Python<'py>,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
+    ) -> ValResult<PyObject> {
+        let res = input.validate_complex(self.strict, py)?.unpack(state);
+        Ok(res.into_py(py))
+    }
+
+    fn get_name(&self) -> &str {
+        "complex"
+    }
+}
+
+pub(crate) fn string_to_complex<'py>(
+    arg: &Bound<'py, PyString>,
+    input: impl ToErrorValue,
+) -> ValResult<Bound<'py, PyComplex>> {
+    let py = arg.py();
+    Ok(get_complex_type(py)
+        .call1((arg,))
+        .map_err(|err| {
+            // Since arg is a string, the only possible error here is ValueError
+            // triggered by invalid complex strings and thus only this case is handled.
+            if err.is_instance_of::<PyValueError>(py) {
+                ValError::new(ErrorTypeDefaults::ComplexStrParsing, input)
+            } else {
+                ValError::InternalErr(err)
+            }
+        })?
+        .downcast::<PyComplex>()?
+        .to_owned())
+}
diff --git a/src/validators/mod.rs b/src/validators/mod.rs
index 18c947313..5f88d5dc8 100644
--- a/src/validators/mod.rs
+++ b/src/validators/mod.rs
@@ -25,6 +25,7 @@ mod bytes;
 mod call;
 mod callable;
 mod chain;
+pub(crate) mod complex;
 mod config;
 mod custom_error;
 mod dataclass;
@@ -582,6 +583,7 @@ pub fn build_validator(
         // recursive (self-referencing) models
         definitions::DefinitionRefValidator,
         definitions::DefinitionsValidatorBuilder,
+        complex::ComplexValidator,
     )
 }
 
@@ -735,6 +737,7 @@ pub enum CombinedValidator {
     DefinitionRef(definitions::DefinitionRefValidator),
     // input dependent
     JsonOrPython(json_or_python::JsonOrPython),
+    Complex(complex::ComplexValidator),
 }
 
 /// This trait must be implemented by all validators, it allows various validators to be accessed consistently,
diff --git a/tests/serializers/test_complex.py b/tests/serializers/test_complex.py
new file mode 100644
index 000000000..e7c98246a
--- /dev/null
+++ b/tests/serializers/test_complex.py
@@ -0,0 +1,39 @@
+import math
+
+import pytest
+
+from pydantic_core import SchemaSerializer, core_schema
+
+
+@pytest.mark.parametrize(
+    'value,expected',
+    [
+        (complex(-1.23e-4, 567.89), '-0.000123+567.89j'),
+        (complex(0, -1.23), '-1.23j'),
+        (complex(1.5, 0), '1.5+0j'),
+        (complex(1, 2), '1+2j'),
+        (complex(0, 1), '1j'),
+        (complex(0, 1e-500), '0j'),
+        (complex(-float('inf'), 2), '-inf+2j'),
+        (complex(float('inf'), 2), 'inf+2j'),
+        (complex(float('nan'), 2), 'NaN+2j'),
+    ],
+)
+def test_complex_json(value, expected):
+    v = SchemaSerializer(core_schema.complex_schema())
+    c = v.to_python(value)
+    c_json = v.to_python(value, mode='json')
+    json_str = v.to_json(value).decode()
+
+    assert c_json == expected
+    assert json_str == f'"{expected}"'
+
+    if math.isnan(value.imag):
+        assert math.isnan(c.imag)
+    else:
+        assert c.imag == value.imag
+
+    if math.isnan(value.real):
+        assert math.isnan(c.real)
+    else:
+        assert c.imag == value.imag
diff --git a/tests/test_errors.py b/tests/test_errors.py
index bd6f6214e..b8265f04e 100644
--- a/tests/test_errors.py
+++ b/tests/test_errors.py
@@ -395,6 +395,16 @@ def f(input_value, info):
         'Decimal input should have no more than 1 digit before the decimal point',
         {'whole_digits': 1},
     ),
+    (
+        'complex_type',
+        'Input should be a valid python complex object, a number, or a valid complex string following the rules at https://docs.python.org/3/library/functions.html#complex',
+        None,
+    ),
+    (
+        'complex_str_parsing',
+        'Input should be a valid complex string following the rules at https://docs.python.org/3/library/functions.html#complex',
+        None,
+    ),
 ]
 
 
diff --git a/tests/test_schema_functions.py b/tests/test_schema_functions.py
index 0971f0b9a..6d96678c8 100644
--- a/tests/test_schema_functions.py
+++ b/tests/test_schema_functions.py
@@ -290,6 +290,7 @@ def args(*args, **kwargs):
     (core_schema.uuid_schema, args(), {'type': 'uuid'}),
     (core_schema.decimal_schema, args(), {'type': 'decimal'}),
     (core_schema.decimal_schema, args(multiple_of=5, gt=1.2), {'type': 'decimal', 'multiple_of': 5, 'gt': 1.2}),
+    (core_schema.complex_schema, args(), {'type': 'complex'}),
 ]
 
 
diff --git a/tests/validators/test_complex.py b/tests/validators/test_complex.py
new file mode 100644
index 000000000..83c5d416d
--- /dev/null
+++ b/tests/validators/test_complex.py
@@ -0,0 +1,154 @@
+import math
+import platform
+import re
+
+import pytest
+
+from pydantic_core import SchemaValidator, ValidationError
+
+from ..conftest import Err
+
+EXPECTED_PARSE_ERROR_MESSAGE = 'Input should be a valid complex string following the rules at https://docs.python.org/3/library/functions.html#complex'
+EXPECTED_TYPE_ERROR_MESSAGE = 'Input should be a valid python complex object, a number, or a valid complex string following the rules at https://docs.python.org/3/library/functions.html#complex'
+EXPECTED_TYPE_ERROR_PY_STRICT_MESSAGE = 'Input should be an instance of complex'
+
+
+@pytest.mark.parametrize(
+    'input_value,expected',
+    [
+        (complex(2, 4), complex(2, 4)),
+        ('2', complex(2, 0)),
+        ('2j', complex(0, 2)),
+        ('+1.23e-4-5.67e+8J', complex(1.23e-4, -5.67e8)),
+        ('1.5-j', complex(1.5, -1)),
+        ('-j', complex(0, -1)),
+        ('j', complex(0, 1)),
+        (3, complex(3, 0)),
+        (2.0, complex(2, 0)),
+        ('1e-700j', complex(0, 0)),
+        ('', Err(EXPECTED_TYPE_ERROR_MESSAGE)),
+        ('\t( -1.23+4.5J   \n', Err(EXPECTED_TYPE_ERROR_MESSAGE)),
+        ({'real': 2, 'imag': 4}, Err(EXPECTED_TYPE_ERROR_MESSAGE)),
+        ({'real': 'test', 'imag': 1}, Err(EXPECTED_TYPE_ERROR_MESSAGE)),
+        ({'real': True, 'imag': 1}, Err(EXPECTED_TYPE_ERROR_MESSAGE)),
+        ('foobar', Err(EXPECTED_TYPE_ERROR_MESSAGE)),
+        ([], Err(EXPECTED_TYPE_ERROR_MESSAGE)),
+        ([('x', 'y')], Err(EXPECTED_TYPE_ERROR_MESSAGE)),
+        ((), Err(EXPECTED_TYPE_ERROR_MESSAGE)),
+        ((('x', 'y'),), Err(EXPECTED_TYPE_ERROR_MESSAGE)),
+        (
+            (type('Foobar', (), {'x': 1})()),
+            Err(EXPECTED_TYPE_ERROR_MESSAGE),
+        ),
+    ],
+    ids=repr,
+)
+def test_complex_cases(input_value, expected):
+    v = SchemaValidator({'type': 'complex'})
+    if isinstance(expected, Err):
+        with pytest.raises(ValidationError, match=re.escape(expected.message)):
+            v.validate_python(input_value)
+    else:
+        assert v.validate_python(input_value) == expected
+
+
+@pytest.mark.parametrize(
+    'input_value,expected',
+    [
+        (complex(2, 4), complex(2, 4)),
+        ('2', Err(EXPECTED_TYPE_ERROR_PY_STRICT_MESSAGE)),
+        ('2j', Err(EXPECTED_TYPE_ERROR_PY_STRICT_MESSAGE)),
+        ('+1.23e-4-5.67e+8J', Err(EXPECTED_TYPE_ERROR_PY_STRICT_MESSAGE)),
+        ('1.5-j', Err(EXPECTED_TYPE_ERROR_PY_STRICT_MESSAGE)),
+        ('-j', Err(EXPECTED_TYPE_ERROR_PY_STRICT_MESSAGE)),
+        ('j', Err(EXPECTED_TYPE_ERROR_PY_STRICT_MESSAGE)),
+        (3, Err(EXPECTED_TYPE_ERROR_PY_STRICT_MESSAGE)),
+        (2.0, Err(EXPECTED_TYPE_ERROR_PY_STRICT_MESSAGE)),
+        ('1e-700j', Err(EXPECTED_TYPE_ERROR_PY_STRICT_MESSAGE)),
+        ('', Err(EXPECTED_TYPE_ERROR_PY_STRICT_MESSAGE)),
+        ('\t( -1.23+4.5J   \n', Err(EXPECTED_TYPE_ERROR_PY_STRICT_MESSAGE)),
+        ({'real': 2, 'imag': 4}, Err(EXPECTED_TYPE_ERROR_PY_STRICT_MESSAGE)),
+        ({'real': 'test', 'imag': 1}, Err(EXPECTED_TYPE_ERROR_PY_STRICT_MESSAGE)),
+        ({'real': True, 'imag': 1}, Err(EXPECTED_TYPE_ERROR_PY_STRICT_MESSAGE)),
+        ('foobar', Err(EXPECTED_TYPE_ERROR_PY_STRICT_MESSAGE)),
+    ],
+    ids=repr,
+)
+def test_complex_strict(input_value, expected):
+    v = SchemaValidator({'type': 'complex', 'strict': True})
+    if isinstance(expected, Err):
+        with pytest.raises(ValidationError, match=re.escape(expected.message)):
+            v.validate_python(input_value)
+    else:
+        assert v.validate_python(input_value) == expected
+
+
+@pytest.mark.xfail(
+    platform.python_implementation() == 'PyPy',
+    reason='PyPy cannot process this string due to a bug, even if this string is considered valid in python',
+)
+def test_valid_complex_string_with_space():
+    v = SchemaValidator({'type': 'complex'})
+    assert v.validate_python('\t( -1.23+4.5J )\n') == complex(-1.23, 4.5)
+
+
+def test_nan_inf_complex():
+    v = SchemaValidator({'type': 'complex'})
+    c = v.validate_python('NaN+Infinityj')
+    # c != complex(float('nan'), float('inf')) as nan != nan,
+    # so we need to examine the values individually
+    assert math.isnan(c.real)
+    assert math.isinf(c.imag)
+
+
+def test_overflow_complex():
+    # Python simply converts too large float values to inf, so these strings
+    # are still valid, even if the numbers are out of range
+    v = SchemaValidator({'type': 'complex'})
+
+    c = v.validate_python('5e600j')
+    assert math.isinf(c.imag)
+
+    c = v.validate_python('-5e600j')
+    assert math.isinf(c.imag)
+
+
+def test_json_complex():
+    v = SchemaValidator({'type': 'complex'})
+    assert v.validate_json('"-1.23e+4+5.67e-8J"') == complex(-1.23e4, 5.67e-8)
+    assert v.validate_json('1') == complex(1, 0)
+    assert v.validate_json('1.0') == complex(1, 0)
+    # "1" is a valid complex string
+    assert v.validate_json('"1"') == complex(1, 0)
+
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_json('{"real": 2, "imag": 4}')
+    assert exc_info.value.errors(include_url=False) == [
+        {
+            'type': 'complex_type',
+            'loc': (),
+            'msg': EXPECTED_TYPE_ERROR_MESSAGE,
+            'input': {'real': 2, 'imag': 4},
+        }
+    ]
+
+
+def test_json_complex_strict():
+    v = SchemaValidator({'type': 'complex', 'strict': True})
+    assert v.validate_json('"-1.23e+4+5.67e-8J"') == complex(-1.23e4, 5.67e-8)
+    # "1" is a valid complex string
+    assert v.validate_json('"1"') == complex(1, 0)
+
+    with pytest.raises(ValidationError, match=re.escape(EXPECTED_PARSE_ERROR_MESSAGE)):
+        v.validate_json('1')
+    with pytest.raises(ValidationError, match=re.escape(EXPECTED_PARSE_ERROR_MESSAGE)):
+        v.validate_json('1.0')
+    with pytest.raises(ValidationError, match=re.escape(EXPECTED_TYPE_ERROR_MESSAGE)):
+        v.validate_json('{"real": 2, "imag": 4}')
+
+
+def test_string_complex():
+    v = SchemaValidator({'type': 'complex'})
+    assert v.validate_strings('+1.23e-4-5.67e+8J') == complex(1.23e-4, -5.67e8)
+    with pytest.raises(ValidationError, match=re.escape(EXPECTED_PARSE_ERROR_MESSAGE)):
+        v.validate_strings("{'real': 1, 'imag': 0}")
diff --git a/tests/validators/test_dict.py b/tests/validators/test_dict.py
index 7b3ca19c8..4057ce76e 100644
--- a/tests/validators/test_dict.py
+++ b/tests/validators/test_dict.py
@@ -235,3 +235,26 @@ def test_json_dict():
     assert exc_info.value.errors(include_url=False) == [
         {'type': 'dict_type', 'loc': (), 'msg': 'Input should be an object', 'input': 1}
     ]
+
+
+def test_dict_complex_key():
+    v = SchemaValidator(
+        {'type': 'dict', 'keys_schema': {'type': 'complex', 'strict': True}, 'values_schema': {'type': 'str'}}
+    )
+    assert v.validate_python({complex(1, 2): '1'}) == {complex(1, 2): '1'}
+    with pytest.raises(ValidationError, match='Input should be an instance of complex'):
+        assert v.validate_python({'1+2j': b'1'}) == {complex(1, 2): '1'}
+
+    v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'complex'}, 'values_schema': {'type': 'str'}})
+    with pytest.raises(
+        ValidationError, match='Input should be a valid python complex object, a number, or a valid complex string'
+    ):
+        v.validate_python({'1+2ja': b'1'})
+
+
+def test_json_dict_complex_key():
+    v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'complex'}, 'values_schema': {'type': 'int'}})
+    assert v.validate_json('{"1+2j": 2, "-3": 4}') == {complex(1, 2): 2, complex(-3, 0): 4}
+    assert v.validate_json('{"1+2j": 2, "infj": 4}') == {complex(1, 2): 2, complex(0, float('inf')): 4}
+    with pytest.raises(ValidationError, match='Input should be a valid complex string'):
+        v.validate_json('{"1+2j": 2, "": 4}') == {complex(1, 2): 2, complex(0, float('inf')): 4}

From fdd1e85f3e133cc2e8a78faf7f6f2fa711f4b403 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Thu, 15 Aug 2024 10:12:38 -0500
Subject: [PATCH 346/550] =?UTF-8?q?Adding=20tagged=20union=20serializer=20?=
 =?UTF-8?q?=F0=9F=9A=80=20=20(#1397)?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/common/mod.rs                         |   1 +
 src/common/union.rs                       |  43 +++
 src/input/input_abstract.rs               |   4 -
 src/input/input_json.rs                   |   4 -
 src/input/input_python.rs                 |   7 -
 src/input/input_string.rs                 |   3 -
 src/lib.rs                                |   1 +
 src/serializers/shared.rs                 |   3 +-
 src/serializers/type_serializers/union.rs | 418 +++++++++++++++++-----
 src/tools.rs                              |   2 -
 src/validators/union.rs                   |  88 +----
 tests/serializers/test_union.py           |  49 +++
 12 files changed, 430 insertions(+), 193 deletions(-)
 create mode 100644 src/common/mod.rs
 create mode 100644 src/common/union.rs

diff --git a/src/common/mod.rs b/src/common/mod.rs
new file mode 100644
index 000000000..11f2e1ece
--- /dev/null
+++ b/src/common/mod.rs
@@ -0,0 +1 @@
+pub(crate) mod union;
diff --git a/src/common/union.rs b/src/common/union.rs
new file mode 100644
index 000000000..17fe9ad90
--- /dev/null
+++ b/src/common/union.rs
@@ -0,0 +1,43 @@
+use pyo3::prelude::*;
+use pyo3::{PyTraverseError, PyVisit};
+
+use crate::lookup_key::LookupKey;
+use crate::py_gc::PyGcTraverse;
+
+#[derive(Debug, Clone)]
+pub enum Discriminator {
+    /// use `LookupKey` to find the tag, same as we do to find values in typed_dict aliases
+    LookupKey(LookupKey),
+    /// call a function to find the tag to use
+    Function(PyObject),
+}
+
+impl Discriminator {
+    pub fn new(py: Python, raw: &Bound<'_, PyAny>) -> PyResult<Self> {
+        if raw.is_callable() {
+            return Ok(Self::Function(raw.to_object(py)));
+        }
+
+        let lookup_key = LookupKey::from_py(py, raw, None)?;
+        Ok(Self::LookupKey(lookup_key))
+    }
+
+    pub fn to_string_py(&self, py: Python) -> PyResult<String> {
+        match self {
+            Self::Function(f) => Ok(format!("{}()", f.getattr(py, "__name__")?)),
+            Self::LookupKey(lookup_key) => Ok(lookup_key.to_string()),
+        }
+    }
+}
+
+impl PyGcTraverse for Discriminator {
+    fn py_gc_traverse(&self, visit: &PyVisit<'_>) -> Result<(), PyTraverseError> {
+        match self {
+            Self::Function(obj) => visit.call(obj)?,
+            Self::LookupKey(_) => {}
+        }
+        Ok(())
+    }
+}
+
+pub(crate) const SMALL_UNION_THRESHOLD: usize = 4;
diff --git a/src/input/input_abstract.rs b/src/input/input_abstract.rs
index 24a2e0239..d85ae0a56 100644
--- a/src/input/input_abstract.rs
+++ b/src/input/input_abstract.rs
@@ -239,7 +239,6 @@ pub trait ValidatedDict<'py> {
     where
         Self: 'a;
     fn get_item<'k>(&self, key: &'k LookupKey) -> ValResult<Option<(&'k LookupPath, Self::Item<'_>)>>;
-    fn as_py_dict(&self) -> Option<&Bound<'py, PyDict>>;
     // FIXME this is a bit of a leaky abstraction
     fn is_py_get_attr(&self) -> bool {
         false
@@ -282,9 +281,6 @@ impl<'py> ValidatedDict<'py> for Never {
     fn get_item<'k>(&self, _key: &'k LookupKey) -> ValResult<Option<(&'k LookupPath, Self::Item<'_>)>> {
         unreachable!()
     }
-    fn as_py_dict(&self) -> Option<&Bound<'py, PyDict>> {
-        unreachable!()
-    }
     fn iterate<'a, R>(
         &'a self,
         _consumer: impl ConsumeIterator<ValResult<(Self::Key<'a>, Self::Item<'a>)>, Output = R>,
diff --git a/src/input/input_json.rs b/src/input/input_json.rs
index 5eb505f6e..66dd0b054 100644
--- a/src/input/input_json.rs
+++ b/src/input/input_json.rs
@@ -509,10 +509,6 @@ impl<'py, 'data> ValidatedDict<'py> for &'_ JsonObject<'data> {
         key.json_get(self)
     }
 
-    fn as_py_dict(&self) -> Option<&Bound<'py, PyDict>> {
-        None
-    }
-
     fn iterate<'a, R>(
         &'a self,
         consumer: impl ConsumeIterator<ValResult<(Self::Key<'a>, Self::Item<'a>)>, Output = R>,
diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index 46c32a9de..6c0528222 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -817,13 +817,6 @@ impl<'py> ValidatedDict<'py> for GenericPyMapping<'_, 'py> {
         matches!(self, Self::GetAttr(..))
     }
 
-    fn as_py_dict(&self) -> Option<&Bound<'py, PyDict>> {
-        match self {
-            Self::Dict(dict) => Some(dict),
-            _ => None,
-        }
-    }
-
     fn iterate<'a, R>(
         &'a self,
         consumer: impl ConsumeIterator<ValResult<(Self::Key<'a>, Self::Item<'a>)>, Output = R>,
diff --git a/src/input/input_string.rs b/src/input/input_string.rs
index 7adcaeb28..190dd46bf 100644
--- a/src/input/input_string.rs
+++ b/src/input/input_string.rs
@@ -293,9 +293,6 @@ impl<'py> ValidatedDict<'py> for StringMappingDict<'py> {
     fn get_item<'k>(&self, key: &'k LookupKey) -> ValResult<Option<(&'k LookupPath, Self::Item<'_>)>> {
         key.py_get_string_mapping_item(&self.0)
     }
-    fn as_py_dict(&self) -> Option<&Bound<'py, PyDict>> {
-        None
-    }
     fn iterate<'a, R>(
         &'a self,
         consumer: impl super::ConsumeIterator<ValResult<(Self::Key<'a>, Self::Item<'a>)>, Output = R>,
diff --git a/src/lib.rs b/src/lib.rs
index eb486da66..d1e042863 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -16,6 +16,7 @@ mod py_gc;
 
 mod argument_markers;
 mod build_tools;
+mod common;
 mod definitions;
 mod errors;
 mod input;
diff --git a/src/serializers/shared.rs b/src/serializers/shared.rs
index cb12f8840..8eb54c837 100644
--- a/src/serializers/shared.rs
+++ b/src/serializers/shared.rs
@@ -88,7 +88,6 @@ combined_serializer! {
     // `find_only` is for type_serializers which are built directly via the `type` key and `find_serializer`
     // but aren't actually used for serialization, e.g. their `build` method must return another serializer
     find_only: {
-        super::type_serializers::union::TaggedUnionBuilder;
         super::type_serializers::other::ChainBuilder;
         super::type_serializers::other::CustomErrorBuilder;
         super::type_serializers::other::CallBuilder;
@@ -138,6 +137,7 @@ combined_serializer! {
         Json: super::type_serializers::json::JsonSerializer;
         JsonOrPython: super::type_serializers::json_or_python::JsonOrPythonSerializer;
         Union: super::type_serializers::union::UnionSerializer;
+        TaggedUnion: super::type_serializers::union::TaggedUnionSerializer;
         Literal: super::type_serializers::literal::LiteralSerializer;
         Enum: super::type_serializers::enum_::EnumSerializer;
         Recursive: super::type_serializers::definitions::DefinitionRefSerializer;
@@ -247,6 +247,7 @@ impl PyGcTraverse for CombinedSerializer {
             CombinedSerializer::Json(inner) => inner.py_gc_traverse(visit),
             CombinedSerializer::JsonOrPython(inner) => inner.py_gc_traverse(visit),
             CombinedSerializer::Union(inner) => inner.py_gc_traverse(visit),
+            CombinedSerializer::TaggedUnion(inner) => inner.py_gc_traverse(visit),
             CombinedSerializer::Literal(inner) => inner.py_gc_traverse(visit),
             CombinedSerializer::Enum(inner) => inner.py_gc_traverse(visit),
             CombinedSerializer::Recursive(inner) => inner.py_gc_traverse(visit),
diff --git a/src/serializers/type_serializers/union.rs b/src/serializers/type_serializers/union.rs
index 2915115c3..23aa874fa 100644
--- a/src/serializers/type_serializers/union.rs
+++ b/src/serializers/type_serializers/union.rs
@@ -1,3 +1,4 @@
+use ahash::AHashMap as HashMap;
 use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList, PyTuple};
@@ -5,8 +6,12 @@ use smallvec::SmallVec;
 use std::borrow::Cow;
 
 use crate::build_tools::py_schema_err;
+use crate::common::union::{Discriminator, SMALL_UNION_THRESHOLD};
 use crate::definitions::DefinitionsBuilder;
-use crate::tools::{SchemaDict, UNION_ERR_SMALLVEC_CAPACITY};
+use crate::errors::write_truncated_to_50_bytes;
+use crate::lookup_key::LookupKey;
+use crate::serializers::type_serializers::py_err_se_err;
+use crate::tools::{safe_repr, SchemaDict};
 use crate::PydanticSerializationUnexpectedValue;
 
 use super::{
@@ -68,20 +73,33 @@ impl UnionSerializer {
 
 impl_py_gc_traverse!(UnionSerializer { choices });
 
-impl TypeSerializer for UnionSerializer {
-    fn to_python(
-        &self,
-        value: &Bound<'_, PyAny>,
-        include: Option<&Bound<'_, PyAny>>,
-        exclude: Option<&Bound<'_, PyAny>>,
-        extra: &Extra,
-    ) -> PyResult<PyObject> {
-        // try the serializers in left to right order with error_on fallback=true
-        let mut new_extra = extra.clone();
-        new_extra.check = SerCheck::Strict;
-        let mut errors: SmallVec<[PyErr; UNION_ERR_SMALLVEC_CAPACITY]> = SmallVec::new();
+fn to_python(
+    value: &Bound<'_, PyAny>,
+    include: Option<&Bound<'_, PyAny>>,
+    exclude: Option<&Bound<'_, PyAny>>,
+    extra: &Extra,
+    choices: &[CombinedSerializer],
+    name: &str,
+    retry_with_lax_check: bool,
+) -> PyResult<PyObject> {
+    // try the serializers in left to right order with error_on fallback=true
+    let mut new_extra = extra.clone();
+    new_extra.check = SerCheck::Strict;
+    let mut errors: SmallVec<[PyErr; SMALL_UNION_THRESHOLD]> = SmallVec::new();
 
-        for comb_serializer in &self.choices {
+    for comb_serializer in choices {
+        match comb_serializer.to_python(value, include, exclude, &new_extra) {
+            Ok(v) => return Ok(v),
+            Err(err) => match err.is_instance_of::<PydanticSerializationUnexpectedValue>(value.py()) {
+                true => (),
+                false => errors.push(err),
+            },
+        }
+    }
+
+    if retry_with_lax_check {
+        new_extra.check = SerCheck::Lax;
+        for comb_serializer in choices {
             match comb_serializer.to_python(value, include, exclude, &new_extra) {
                 Ok(v) => return Ok(v),
                 Err(err) => match err.is_instance_of::<PydanticSerializationUnexpectedValue>(value.py()) {
@@ -90,33 +108,40 @@ impl TypeSerializer for UnionSerializer {
                 },
             }
         }
-        if self.retry_with_lax_check() {
-            new_extra.check = SerCheck::Lax;
-            for comb_serializer in &self.choices {
-                match comb_serializer.to_python(value, include, exclude, &new_extra) {
-                    Ok(v) => return Ok(v),
-                    Err(err) => match err.is_instance_of::<PydanticSerializationUnexpectedValue>(value.py()) {
-                        true => (),
-                        false => errors.push(err),
-                    },
-                }
-            }
-        }
-
-        for err in &errors {
-            extra.warnings.custom_warning(err.to_string());
-        }
+    }
 
-        extra.warnings.on_fallback_py(self.get_name(), value, extra)?;
-        infer_to_python(value, include, exclude, extra)
+    for err in &errors {
+        extra.warnings.custom_warning(err.to_string());
     }
 
-    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
-        let mut new_extra = extra.clone();
-        new_extra.check = SerCheck::Strict;
-        let mut errors: SmallVec<[PyErr; UNION_ERR_SMALLVEC_CAPACITY]> = SmallVec::new();
+    extra.warnings.on_fallback_py(name, value, extra)?;
+    infer_to_python(value, include, exclude, extra)
+}
 
-        for comb_serializer in &self.choices {
+fn json_key<'a>(
+    key: &'a Bound<'_, PyAny>,
+    extra: &Extra,
+    choices: &[CombinedSerializer],
+    name: &str,
+    retry_with_lax_check: bool,
+) -> PyResult<Cow<'a, str>> {
+    let mut new_extra = extra.clone();
+    new_extra.check = SerCheck::Strict;
+    let mut errors: SmallVec<[PyErr; SMALL_UNION_THRESHOLD]> = SmallVec::new();
+
+    for comb_serializer in choices {
+        match comb_serializer.json_key(key, &new_extra) {
+            Ok(v) => return Ok(v),
+            Err(err) => match err.is_instance_of::<PydanticSerializationUnexpectedValue>(key.py()) {
+                true => (),
+                false => errors.push(err),
+            },
+        }
+    }
+
+    if retry_with_lax_check {
+        new_extra.check = SerCheck::Lax;
+        for comb_serializer in choices {
             match comb_serializer.json_key(key, &new_extra) {
                 Ok(v) => return Ok(v),
                 Err(err) => match err.is_instance_of::<PydanticSerializationUnexpectedValue>(key.py()) {
@@ -125,25 +150,233 @@ impl TypeSerializer for UnionSerializer {
                 },
             }
         }
-        if self.retry_with_lax_check() {
-            new_extra.check = SerCheck::Lax;
-            for comb_serializer in &self.choices {
-                match comb_serializer.json_key(key, &new_extra) {
+    }
+
+    for err in &errors {
+        extra.warnings.custom_warning(err.to_string());
+    }
+
+    extra.warnings.on_fallback_py(name, key, extra)?;
+    infer_json_key(key, extra)
+}
+
+#[allow(clippy::too_many_arguments)]
+fn serde_serialize<S: serde::ser::Serializer>(
+    value: &Bound<'_, PyAny>,
+    serializer: S,
+    include: Option<&Bound<'_, PyAny>>,
+    exclude: Option<&Bound<'_, PyAny>>,
+    extra: &Extra,
+    choices: &[CombinedSerializer],
+    name: &str,
+    retry_with_lax_check: bool,
+) -> Result<S::Ok, S::Error> {
+    let py = value.py();
+    let mut new_extra = extra.clone();
+    new_extra.check = SerCheck::Strict;
+    let mut errors: SmallVec<[PyErr; SMALL_UNION_THRESHOLD]> = SmallVec::new();
+
+    for comb_serializer in choices {
+        match comb_serializer.to_python(value, include, exclude, &new_extra) {
+            Ok(v) => return infer_serialize(v.bind(py), serializer, None, None, extra),
+            Err(err) => match err.is_instance_of::<PydanticSerializationUnexpectedValue>(py) {
+                true => (),
+                false => errors.push(err),
+            },
+        }
+    }
+
+    if retry_with_lax_check {
+        new_extra.check = SerCheck::Lax;
+        for comb_serializer in choices {
+            match comb_serializer.to_python(value, include, exclude, &new_extra) {
+                Ok(v) => return infer_serialize(v.bind(py), serializer, None, None, extra),
+                Err(err) => match err.is_instance_of::<PydanticSerializationUnexpectedValue>(py) {
+                    true => (),
+                    false => errors.push(err),
+                },
+            }
+        }
+    }
+
+    for err in &errors {
+        extra.warnings.custom_warning(err.to_string());
+    }
+
+    extra.warnings.on_fallback_ser::<S>(name, value, extra)?;
+    infer_serialize(value, serializer, include, exclude, extra)
+}
+
+impl TypeSerializer for UnionSerializer {
+    fn to_python(
+        &self,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
+        extra: &Extra,
+    ) -> PyResult<PyObject> {
+        to_python(
+            value,
+            include,
+            exclude,
+            extra,
+            &self.choices,
+            self.get_name(),
+            self.retry_with_lax_check(),
+        )
+    }
+
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
+        json_key(key, extra, &self.choices, self.get_name(), self.retry_with_lax_check())
+    }
+
+    fn serde_serialize<S: serde::ser::Serializer>(
+        &self,
+        value: &Bound<'_, PyAny>,
+        serializer: S,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
+        extra: &Extra,
+    ) -> Result<S::Ok, S::Error> {
+        serde_serialize(
+            value,
+            serializer,
+            include,
+            exclude,
+            extra,
+            &self.choices,
+            self.get_name(),
+            self.retry_with_lax_check(),
+        )
+    }
+
+    fn get_name(&self) -> &str {
+        &self.name
+    }
+
+    fn retry_with_lax_check(&self) -> bool {
+        self.choices.iter().any(CombinedSerializer::retry_with_lax_check)
+    }
+}
+
+#[derive(Debug)]
+pub struct TaggedUnionSerializer {
+    discriminator: Discriminator,
+    lookup: HashMap<String, usize>,
+    choices: Vec<CombinedSerializer>,
+    name: String,
+}
+
+impl BuildSerializer for TaggedUnionSerializer {
+    const EXPECTED_TYPE: &'static str = "tagged-union";
+
+    fn build(
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
+        definitions: &mut DefinitionsBuilder<CombinedSerializer>,
+    ) -> PyResult<CombinedSerializer> {
+        let py = schema.py();
+        let discriminator = Discriminator::new(py, &schema.get_as_req(intern!(py, "discriminator"))?)?;
+
+        // TODO: guarantee at least 1 choice
+        let choices_map: Bound<PyDict> = schema.get_as_req(intern!(py, "choices"))?;
+        let mut lookup = HashMap::with_capacity(choices_map.len());
+        let mut choices = Vec::with_capacity(choices_map.len());
+
+        for (idx, (choice_key, choice_schema)) in choices_map.into_iter().enumerate() {
+            let serializer = CombinedSerializer::build(choice_schema.downcast()?, config, definitions)?;
+            choices.push(serializer);
+            lookup.insert(choice_key.to_string(), idx);
+        }
+
+        let descr = choices
+            .iter()
+            .map(TypeSerializer::get_name)
+            .collect::<Vec<_>>()
+            .join(", ");
+
+        Ok(Self {
+            discriminator,
+            lookup,
+            choices,
+            name: format!("TaggedUnion[{descr}]"),
+        }
+        .into())
+    }
+}
+
+impl_py_gc_traverse!(TaggedUnionSerializer { discriminator, choices });
+
+impl TypeSerializer for TaggedUnionSerializer {
+    fn to_python(
+        &self,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
+        extra: &Extra,
+    ) -> PyResult<PyObject> {
+        let py = value.py();
+
+        let mut new_extra = extra.clone();
+        new_extra.check = SerCheck::Strict;
+
+        if let Some(tag) = self.get_discriminator_value(value, extra) {
+            let tag_str = tag.to_string();
+            if let Some(&serializer_index) = self.lookup.get(&tag_str) {
+                let serializer = &self.choices[serializer_index];
+
+                match serializer.to_python(value, include, exclude, &new_extra) {
                     Ok(v) => return Ok(v),
-                    Err(err) => match err.is_instance_of::<PydanticSerializationUnexpectedValue>(key.py()) {
-                        true => (),
-                        false => errors.push(err),
+                    Err(err) => match err.is_instance_of::<PydanticSerializationUnexpectedValue>(py) {
+                        true => {
+                            if self.retry_with_lax_check() {
+                                new_extra.check = SerCheck::Lax;
+                                return serializer.to_python(value, include, exclude, &new_extra);
+                            }
+                        }
+                        false => return Err(err),
                     },
                 }
             }
         }
 
-        for err in &errors {
-            extra.warnings.custom_warning(err.to_string());
+        to_python(
+            value,
+            include,
+            exclude,
+            extra,
+            &self.choices,
+            self.get_name(),
+            self.retry_with_lax_check(),
+        )
+    }
+
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
+        let py = key.py();
+        let mut new_extra = extra.clone();
+        new_extra.check = SerCheck::Strict;
+
+        if let Some(tag) = self.get_discriminator_value(key, extra) {
+            let tag_str = tag.to_string();
+            if let Some(&serializer_index) = self.lookup.get(&tag_str) {
+                let serializer = &self.choices[serializer_index];
+
+                match serializer.json_key(key, &new_extra) {
+                    Ok(v) => return Ok(v),
+                    Err(err) => match err.is_instance_of::<PydanticSerializationUnexpectedValue>(py) {
+                        true => {
+                            if self.retry_with_lax_check() {
+                                new_extra.check = SerCheck::Lax;
+                                return serializer.json_key(key, &new_extra);
+                            }
+                        }
+                        false => return Err(err),
+                    },
+                }
+            }
         }
 
-        extra.warnings.on_fallback_py(self.get_name(), key, extra)?;
-        infer_json_key(key, extra)
+        json_key(key, extra, &self.choices, self.get_name(), self.retry_with_lax_check())
     }
 
     fn serde_serialize<S: serde::ser::Serializer>(
@@ -157,36 +390,40 @@ impl TypeSerializer for UnionSerializer {
         let py = value.py();
         let mut new_extra = extra.clone();
         new_extra.check = SerCheck::Strict;
-        let mut errors: SmallVec<[PyErr; UNION_ERR_SMALLVEC_CAPACITY]> = SmallVec::new();
 
-        for comb_serializer in &self.choices {
-            match comb_serializer.to_python(value, include, exclude, &new_extra) {
-                Ok(v) => return infer_serialize(v.bind(py), serializer, None, None, extra),
-                Err(err) => match err.is_instance_of::<PydanticSerializationUnexpectedValue>(value.py()) {
-                    true => (),
-                    false => errors.push(err),
-                },
-            }
-        }
-        if self.retry_with_lax_check() {
-            new_extra.check = SerCheck::Lax;
-            for comb_serializer in &self.choices {
-                match comb_serializer.to_python(value, include, exclude, &new_extra) {
+        if let Some(tag) = self.get_discriminator_value(value, extra) {
+            let tag_str = tag.to_string();
+            if let Some(&serializer_index) = self.lookup.get(&tag_str) {
+                let selected_serializer = &self.choices[serializer_index];
+
+                match selected_serializer.to_python(value, include, exclude, &new_extra) {
                     Ok(v) => return infer_serialize(v.bind(py), serializer, None, None, extra),
-                    Err(err) => match err.is_instance_of::<PydanticSerializationUnexpectedValue>(value.py()) {
-                        true => (),
-                        false => errors.push(err),
+                    Err(err) => match err.is_instance_of::<PydanticSerializationUnexpectedValue>(py) {
+                        true => {
+                            if self.retry_with_lax_check() {
+                                new_extra.check = SerCheck::Lax;
+                                match selected_serializer.to_python(value, include, exclude, &new_extra) {
+                                    Ok(v) => return infer_serialize(v.bind(py), serializer, None, None, extra),
+                                    Err(err) => return Err(py_err_se_err(err)),
+                                }
+                            }
+                        }
+                        false => return Err(py_err_se_err(err)),
                     },
                 }
             }
         }
 
-        for err in &errors {
-            extra.warnings.custom_warning(err.to_string());
-        }
-
-        extra.warnings.on_fallback_ser::<S>(self.get_name(), value, extra)?;
-        infer_serialize(value, serializer, include, exclude, extra)
+        serde_serialize(
+            value,
+            serializer,
+            include,
+            exclude,
+            extra,
+            &self.choices,
+            self.get_name(),
+            self.retry_with_lax_check(),
+        )
     }
 
     fn get_name(&self) -> &str {
@@ -198,24 +435,29 @@ impl TypeSerializer for UnionSerializer {
     }
 }
 
-pub struct TaggedUnionBuilder;
-
-impl BuildSerializer for TaggedUnionBuilder {
-    const EXPECTED_TYPE: &'static str = "tagged-union";
-
-    fn build(
-        schema: &Bound<'_, PyDict>,
-        config: Option<&Bound<'_, PyDict>>,
-        definitions: &mut DefinitionsBuilder<CombinedSerializer>,
-    ) -> PyResult<CombinedSerializer> {
-        let schema_choices: Bound<'_, PyDict> = schema.get_as_req(intern!(schema.py(), "choices"))?;
-        let mut choices: Vec<CombinedSerializer> = Vec::with_capacity(schema_choices.len());
+impl TaggedUnionSerializer {
+    fn get_discriminator_value(&self, value: &Bound<'_, PyAny>, extra: &Extra) -> Option<Py<PyAny>> {
+        let py = value.py();
+        let discriminator_value = match &self.discriminator {
+            Discriminator::LookupKey(lookup_key) => match lookup_key {
+                LookupKey::Simple { py_key, .. } => value.getattr(py_key).ok().map(|obj| obj.to_object(py)),
+                _ => None,
+            },
+            Discriminator::Function(func) => func.call1(py, (value,)).ok(),
+        };
+        if discriminator_value.is_none() {
+            let input_str = safe_repr(value);
+            let mut value_str = String::with_capacity(100);
+            value_str.push_str("with value `");
+            write_truncated_to_50_bytes(&mut value_str, input_str.to_cow()).expect("Writing to a `String` failed");
+            value_str.push('`');
 
-        for (_, value) in schema_choices {
-            if let Ok(choice_schema) = value.downcast::<PyDict>() {
-                choices.push(CombinedSerializer::build(choice_schema, config, definitions)?);
-            }
+            extra.warnings.custom_warning(
+                format!(
+                    "Failed to get discriminator value for tagged union serialization {value_str} - defaulting to left to right union serialization."
+                )
+            );
         }
-        UnionSerializer::from_choices(choices)
+        discriminator_value
     }
 }
diff --git a/src/tools.rs b/src/tools.rs
index 121ae3880..adf64c91a 100644
--- a/src/tools.rs
+++ b/src/tools.rs
@@ -146,5 +146,3 @@ pub(crate) fn new_py_string<'py>(py: Python<'py>, s: &str, cache_str: StringCach
         pystring_fast_new(py, s, ascii_only)
     }
 }
-
-pub(crate) const UNION_ERR_SMALLVEC_CAPACITY: usize = 4;
diff --git a/src/validators/union.rs b/src/validators/union.rs
index da24868c5..747f6a0cf 100644
--- a/src/validators/union.rs
+++ b/src/validators/union.rs
@@ -1,6 +1,7 @@
 use std::fmt::Write;
 use std::str::FromStr;
 
+use crate::py_gc::PyGcTraverse;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList, PyString, PyTuple};
 use pyo3::{intern, PyTraverseError, PyVisit};
@@ -8,11 +9,10 @@ use smallvec::SmallVec;
 
 use crate::build_tools::py_schema_err;
 use crate::build_tools::{is_strict, schema_or_config};
+use crate::common::union::{Discriminator, SMALL_UNION_THRESHOLD};
 use crate::errors::{ErrorType, ToErrorValue, ValError, ValLineError, ValResult};
 use crate::input::{BorrowInput, Input, ValidatedDict};
-use crate::lookup_key::LookupKey;
-use crate::py_gc::PyGcTraverse;
-use crate::tools::{SchemaDict, UNION_ERR_SMALLVEC_CAPACITY};
+use crate::tools::SchemaDict;
 
 use super::custom_error::CustomError;
 use super::literal::LiteralLookup;
@@ -249,7 +249,7 @@ struct ChoiceLineErrors<'a> {
 
 enum MaybeErrors<'a> {
     Custom(&'a CustomError),
-    Errors(SmallVec<[ChoiceLineErrors<'a>; UNION_ERR_SMALLVEC_CAPACITY]>),
+    Errors(SmallVec<[ChoiceLineErrors<'a>; SMALL_UNION_THRESHOLD]>),
 }
 
 impl<'a> MaybeErrors<'a> {
@@ -295,49 +295,6 @@ impl<'a> MaybeErrors<'a> {
     }
 }
 
-#[derive(Debug, Clone)]
-enum Discriminator {
-    /// use `LookupKey` to find the tag, same as we do to find values in typed_dict aliases
-    LookupKey(LookupKey),
-    /// call a function to find the tag to use
-    Function(PyObject),
-    /// Custom discriminator specifically for the root `Schema` union in self-schema
-    SelfSchema,
-}
-
-impl Discriminator {
-    fn new(py: Python, raw: &Bound<'_, PyAny>) -> PyResult<Self> {
-        if raw.is_callable() {
-            return Ok(Self::Function(raw.to_object(py)));
-        } else if let Ok(py_str) = raw.downcast::<PyString>() {
-            if py_str.to_str()? == "self-schema-discriminator" {
-                return Ok(Self::SelfSchema);
-            }
-        }
-
-        let lookup_key = LookupKey::from_py(py, raw, None)?;
-        Ok(Self::LookupKey(lookup_key))
-    }
-
-    fn to_string_py(&self, py: Python) -> PyResult<String> {
-        match self {
-            Self::Function(f) => Ok(format!("{}()", f.getattr(py, "__name__")?)),
-            Self::LookupKey(lookup_key) => Ok(lookup_key.to_string()),
-            Self::SelfSchema => Ok("self-schema".to_string()),
-        }
-    }
-}
-
-impl PyGcTraverse for Discriminator {
-    fn py_gc_traverse(&self, visit: &PyVisit<'_>) -> Result<(), PyTraverseError> {
-        match self {
-            Self::Function(obj) => visit.call(obj)?,
-            Self::LookupKey(_) | Self::SelfSchema => {}
-        }
-        Ok(())
-    }
-}
-
 #[derive(Debug)]
 pub struct TaggedUnionValidator {
     discriminator: Discriminator,
@@ -388,11 +345,6 @@ impl BuildValidator for TaggedUnionValidator {
         let key = intern!(py, "from_attributes");
         let from_attributes = schema_or_config(schema, config, key, key)?.unwrap_or(true);
 
-        let descr = match discriminator {
-            Discriminator::SelfSchema => "self-schema".to_string(),
-            _ => descr,
-        };
-
         Ok(Self {
             discriminator,
             lookup,
@@ -436,9 +388,6 @@ impl Validator for TaggedUnionValidator {
                     self.find_call_validator(py, tag.bind(py), input, state)
                 }
             }
-            Discriminator::SelfSchema => {
-                self.find_call_validator(py, self.self_schema_tag(py, input, state)?.as_any(), input, state)
-            }
         }
     }
 
@@ -448,35 +397,6 @@ impl Validator for TaggedUnionValidator {
 }
 
 impl TaggedUnionValidator {
-    fn self_schema_tag<'py>(
-        &self,
-        py: Python<'py>,
-        input: &(impl Input<'py> + ?Sized),
-        state: &mut ValidationState<'_, 'py>,
-    ) -> ValResult<Bound<'py, PyString>> {
-        let dict = input.strict_dict()?;
-        let dict = dict.as_py_dict().expect("self schema is always a Python dictionary");
-        let tag = match dict.get_item(intern!(py, "type"))? {
-            Some(t) => t.downcast_into::<PyString>()?,
-            None => return Err(self.tag_not_found(input)),
-        };
-        let tag = tag.to_str()?;
-        // custom logic to distinguish between different function and tuple schemas
-        if tag == "function" {
-            let Some(mode) = dict.get_item(intern!(py, "mode"))? else {
-                return Err(self.tag_not_found(input));
-            };
-            let tag = match mode.validate_str(true, false)?.into_inner().as_cow()?.as_ref() {
-                "plain" => Ok(intern!(py, "function-plain").to_owned()),
-                "wrap" => Ok(intern!(py, "function-wrap").to_owned()),
-                _ => Ok(intern!(py, "function").to_owned()),
-            };
-            tag
-        } else {
-            Ok(state.maybe_cached_str(py, tag))
-        }
-    }
-
     fn find_call_validator<'py>(
         &self,
         py: Python<'py>,
diff --git a/tests/serializers/test_union.py b/tests/serializers/test_union.py
index 83527f648..d97d52f03 100644
--- a/tests/serializers/test_union.py
+++ b/tests/serializers/test_union.py
@@ -628,6 +628,55 @@ def test_union_serializer_picks_exact_type_over_subclass_json(
     assert s.to_json(input_value) == json.dumps(expected_value).encode()
 
 
+def test_tagged_union() -> None:
+    @dataclasses.dataclass
+    class ModelA:
+        field: int
+        tag: Literal['a'] = 'a'
+
+    @dataclasses.dataclass
+    class ModelB:
+        field: int
+        tag: Literal['b'] = 'b'
+
+    s = SchemaSerializer(
+        core_schema.tagged_union_schema(
+            choices={
+                'a': core_schema.dataclass_schema(
+                    ModelA,
+                    core_schema.dataclass_args_schema(
+                        'ModelA',
+                        [
+                            core_schema.dataclass_field(name='field', schema=core_schema.int_schema()),
+                            core_schema.dataclass_field(name='tag', schema=core_schema.literal_schema(['a'])),
+                        ],
+                    ),
+                    ['field', 'tag'],
+                ),
+                'b': core_schema.dataclass_schema(
+                    ModelB,
+                    core_schema.dataclass_args_schema(
+                        'ModelB',
+                        [
+                            core_schema.dataclass_field(name='field', schema=core_schema.int_schema()),
+                            core_schema.dataclass_field(name='tag', schema=core_schema.literal_schema(['b'])),
+                        ],
+                    ),
+                    ['field', 'tag'],
+                ),
+            },
+            discriminator='tag',
+        )
+    )
+
+    assert 'TaggedUnionSerializer' in repr(s)
+
+    model_a = ModelA(field=1)
+    model_b = ModelB(field=1)
+    assert s.to_python(model_a) == {'field': 1, 'tag': 'a'}
+    assert s.to_python(model_b) == {'field': 1, 'tag': 'b'}
+
+
 def test_union_float_int() -> None:
     s = SchemaSerializer(core_schema.union_schema([core_schema.float_schema(), core_schema.int_schema()]))
 

From 08a99b52739ae8d889c68c7bd1b7db6207bf14fe Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Thu, 15 Aug 2024 10:21:41 -0500
Subject: [PATCH 347/550] Introduce `exactness` into `Decimal` validation logic
 (#1405)

---
 src/input/input_abstract.rs      | 13 +-------
 src/input/input_json.rs          | 13 ++++----
 src/input/input_python.rs        | 54 +++++++++++++++-----------------
 src/input/input_string.rs        |  4 +--
 src/validators/decimal.rs        |  2 +-
 tests/validators/test_decimal.py | 22 ++++++++++++-
 6 files changed, 57 insertions(+), 51 deletions(-)

diff --git a/src/input/input_abstract.rs b/src/input/input_abstract.rs
index d85ae0a56..01deea4bc 100644
--- a/src/input/input_abstract.rs
+++ b/src/input/input_abstract.rs
@@ -98,18 +98,7 @@ pub trait Input<'py>: fmt::Debug + ToPyObject {
 
     fn validate_float(&self, strict: bool) -> ValMatch<EitherFloat<'_>>;
 
-    fn validate_decimal(&self, strict: bool, py: Python<'py>) -> ValResult<Bound<'py, PyAny>> {
-        if strict {
-            self.strict_decimal(py)
-        } else {
-            self.lax_decimal(py)
-        }
-    }
-    fn strict_decimal(&self, py: Python<'py>) -> ValResult<Bound<'py, PyAny>>;
-    #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn lax_decimal(&self, py: Python<'py>) -> ValResult<Bound<'py, PyAny>> {
-        self.strict_decimal(py)
-    }
+    fn validate_decimal(&self, strict: bool, py: Python<'py>) -> ValMatch<Bound<'py, PyAny>>;
 
     type Dict<'a>: ValidatedDict<'py>
     where
diff --git a/src/input/input_json.rs b/src/input/input_json.rs
index 66dd0b054..7c77928d0 100644
--- a/src/input/input_json.rs
+++ b/src/input/input_json.rs
@@ -167,12 +167,13 @@ impl<'py, 'data> Input<'py> for JsonValue<'data> {
         }
     }
 
-    fn strict_decimal(&self, py: Python<'py>) -> ValResult<Bound<'py, PyAny>> {
+    fn validate_decimal(&self, _strict: bool, py: Python<'py>) -> ValMatch<Bound<'py, PyAny>> {
         match self {
-            JsonValue::Float(f) => create_decimal(&PyString::new_bound(py, &f.to_string()), self),
-
+            JsonValue::Float(f) => {
+                create_decimal(&PyString::new_bound(py, &f.to_string()), self).map(ValidationMatch::strict)
+            }
             JsonValue::Str(..) | JsonValue::Int(..) | JsonValue::BigInt(..) => {
-                create_decimal(self.to_object(py).bind(py), self)
+                create_decimal(self.to_object(py).bind(py), self).map(ValidationMatch::strict)
             }
             _ => Err(ValError::new(ErrorTypeDefaults::DecimalType, self)),
         }
@@ -399,8 +400,8 @@ impl<'py> Input<'py> for str {
         str_as_float(self, self).map(ValidationMatch::lax)
     }
 
-    fn strict_decimal(&self, py: Python<'py>) -> ValResult<Bound<'py, PyAny>> {
-        create_decimal(self.to_object(py).bind(py), self)
+    fn validate_decimal(&self, _strict: bool, py: Python<'py>) -> ValMatch<Bound<'py, PyAny>> {
+        create_decimal(self.to_object(py).bind(py), self).map(ValidationMatch::lax)
     }
 
     type Dict<'a> = Never;
diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index 6c0528222..b9d95b8bf 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -251,8 +251,8 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
                     str_as_int(self, s)
                 } else if self.is_exact_instance_of::<PyFloat>() {
                     float_as_int(self, self.extract::<f64>()?)
-                } else if let Ok(decimal) = self.strict_decimal(self.py()) {
-                    decimal_as_int(self, &decimal)
+                } else if let Ok(decimal) = self.validate_decimal(true, self.py()) {
+                    decimal_as_int(self, &decimal.into_inner())
                 } else if let Ok(float) = self.extract::<f64>() {
                     float_as_int(self, float)
                 } else if let Some(enum_val) = maybe_as_enum(self) {
@@ -310,48 +310,44 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
         Err(ValError::new(ErrorTypeDefaults::FloatType, self))
     }
 
-    fn strict_decimal(&self, py: Python<'py>) -> ValResult<Bound<'py, PyAny>> {
+    fn validate_decimal(&self, strict: bool, py: Python<'py>) -> ValMatch<Bound<'py, PyAny>> {
         let decimal_type = get_decimal_type(py);
+
         // Fast path for existing decimal objects
         if self.is_exact_instance(decimal_type) {
-            return Ok(self.to_owned());
+            return Ok(ValidationMatch::exact(self.to_owned().clone()));
+        }
+
+        if !strict {
+            if self.is_instance_of::<PyString>() || (self.is_instance_of::<PyInt>() && !self.is_instance_of::<PyBool>())
+            {
+                // Checking isinstance for str / int / bool is fast compared to decimal / float
+                return create_decimal(self, self).map(ValidationMatch::lax);
+            }
+
+            if self.is_instance_of::<PyFloat>() {
+                return create_decimal(self.str()?.as_any(), self).map(ValidationMatch::lax);
+            }
         }
 
-        // Try subclasses of decimals, they will be upcast to Decimal
         if self.is_instance(decimal_type)? {
-            return create_decimal(self, self);
+            // Upcast subclasses to decimal
+            return create_decimal(self, self).map(ValidationMatch::strict);
         }
 
-        Err(ValError::new(
+        let error_type = if strict {
             ErrorType::IsInstanceOf {
                 class: decimal_type
                     .qualname()
                     .and_then(|name| name.extract())
                     .unwrap_or_else(|_| "Decimal".to_owned()),
                 context: None,
-            },
-            self,
-        ))
-    }
-
-    fn lax_decimal(&self, py: Python<'py>) -> ValResult<Bound<'py, PyAny>> {
-        let decimal_type = get_decimal_type(py);
-        // Fast path for existing decimal objects
-        if self.is_exact_instance(decimal_type) {
-            return Ok(self.to_owned().clone());
-        }
-
-        if self.is_instance_of::<PyString>() || (self.is_instance_of::<PyInt>() && !self.is_instance_of::<PyBool>()) {
-            // checking isinstance for str / int / bool is fast compared to decimal / float
-            create_decimal(self, self)
-        } else if self.is_instance(decimal_type)? {
-            // upcast subclasses to decimal
-            return create_decimal(self, self);
-        } else if self.is_instance_of::<PyFloat>() {
-            create_decimal(self.str()?.as_any(), self)
+            }
         } else {
-            Err(ValError::new(ErrorTypeDefaults::DecimalType, self))
-        }
+            ErrorTypeDefaults::DecimalType
+        };
+
+        Err(ValError::new(error_type, self))
     }
 
     type Dict<'a> = GenericPyMapping<'a, 'py> where Self: 'a;
diff --git a/src/input/input_string.rs b/src/input/input_string.rs
index 190dd46bf..1e6b14825 100644
--- a/src/input/input_string.rs
+++ b/src/input/input_string.rs
@@ -143,9 +143,9 @@ impl<'py> Input<'py> for StringMapping<'py> {
         }
     }
 
-    fn strict_decimal(&self, _py: Python<'py>) -> ValResult<Bound<'py, PyAny>> {
+    fn validate_decimal(&self, _strict: bool, _py: Python<'py>) -> ValMatch<Bound<'py, PyAny>> {
         match self {
-            Self::String(s) => create_decimal(s, self),
+            Self::String(s) => create_decimal(s, self).map(ValidationMatch::strict),
             Self::Mapping(_) => Err(ValError::new(ErrorTypeDefaults::DecimalType, self)),
         }
     }
diff --git a/src/validators/decimal.rs b/src/validators/decimal.rs
index d1c15c299..8008d4260 100644
--- a/src/validators/decimal.rs
+++ b/src/validators/decimal.rs
@@ -122,7 +122,7 @@ impl Validator for DecimalValidator {
         input: &(impl Input<'py> + ?Sized),
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
-        let decimal = input.validate_decimal(state.strict_or(self.strict), py)?;
+        let decimal = input.validate_decimal(state.strict_or(self.strict), py)?.unpack(state);
 
         if !self.allow_inf_nan || self.check_digits {
             if !decimal.call_method0(intern!(py, "is_finite"))?.extract()? {
diff --git a/tests/validators/test_decimal.py b/tests/validators/test_decimal.py
index 931fe6377..fa1c0270d 100644
--- a/tests/validators/test_decimal.py
+++ b/tests/validators/test_decimal.py
@@ -9,7 +9,7 @@
 import pytest
 from dirty_equals import FunctionCheck, IsStr
 
-from pydantic_core import SchemaValidator, ValidationError
+from pydantic_core import SchemaValidator, ValidationError, core_schema
 
 from ..conftest import Err, PyAndJson, plain_repr
 
@@ -467,3 +467,23 @@ def test_validate_max_digits_and_decimal_places_edge_case() -> None:
     assert v.validate_python(Decimal('9999999999999999.999999999999999999')) == Decimal(
         '9999999999999999.999999999999999999'
     )
+
+
+def test_str_validation_w_strict() -> None:
+    s = SchemaValidator(core_schema.decimal_schema(strict=True))
+
+    with pytest.raises(ValidationError):
+        assert s.validate_python('1.23')
+
+
+def test_str_validation_w_lax() -> None:
+    s = SchemaValidator(core_schema.decimal_schema(strict=False))
+
+    assert s.validate_python('1.23') == Decimal('1.23')
+
+
+def test_union_with_str_prefers_str() -> None:
+    s = SchemaValidator(core_schema.union_schema([core_schema.decimal_schema(), core_schema.str_schema()]))
+
+    assert s.validate_python('1.23') == '1.23'
+    assert s.validate_python(1.23) == Decimal('1.23')

From a6d0d631b529e5b4f38ccd71dd79af60a61516b8 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Thu, 15 Aug 2024 10:23:57 -0500
Subject: [PATCH 348/550] Version bump to prep for new release (#1406)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 910937c29..b030f2357 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -425,7 +425,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.21.0"
+version = "2.22.0"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index 742c85f35..ae54788dd 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.21.0"
+version = "2.22.0"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From de04f032c9c55764fa1b65401443bc2d4b4b0f59 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Fri, 16 Aug 2024 12:43:31 -0500
Subject: [PATCH 349/550] Disable automatic assignees with `hooky` (#1408)

---
 pyproject.toml | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index 97ee3319f..9d8e5f046 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -103,8 +103,7 @@ exclude_lines = [
 
 # configuring https://github.com/pydantic/hooky
 [tool.hooky]
-assignees = ['samuelcolvin', 'adriangb', 'dmontagu', 'davidhewitt', 'lig']
-reviewers = ['samuelcolvin', 'adriangb', 'dmontagu', 'davidhewitt']
+reviewers = ['sydney-runkle', 'davidhewitt']
 require_change_file = false
 
 [tool.pyright]

From b12765200656dce48db01053ee468c0c4c88bf4d Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Mon, 19 Aug 2024 12:46:51 -0500
Subject: [PATCH 350/550] Adding `cls` reference to `TypedDictSchema` (#1410)

---
 python/pydantic_core/core_schema.py | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index 886194cbc..2cb99ef33 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -2818,6 +2818,7 @@ def typed_dict_field(
 class TypedDictSchema(TypedDict, total=False):
     type: Required[Literal['typed-dict']]
     fields: Required[Dict[str, TypedDictField]]
+    cls: Type[TypedDict]
     computed_fields: List[ComputedField]
     strict: bool
     extras_schema: CoreSchema
@@ -2834,6 +2835,7 @@ class TypedDictSchema(TypedDict, total=False):
 def typed_dict_schema(
     fields: Dict[str, TypedDictField],
     *,
+    cls: Type[TypedDict] | None = None,
     computed_fields: list[ComputedField] | None = None,
     strict: bool | None = None,
     extras_schema: CoreSchema | None = None,
@@ -2849,10 +2851,15 @@ def typed_dict_schema(
     Returns a schema that matches a typed dict, e.g.:
 
     ```py
+    from typing_extensions import TypedDict
+
     from pydantic_core import SchemaValidator, core_schema
 
+    class MyTypedDict(TypedDict):
+        a: str
+
     wrapper_schema = core_schema.typed_dict_schema(
-        {'a': core_schema.typed_dict_field(core_schema.str_schema())}
+        {'a': core_schema.typed_dict_field(core_schema.str_schema())}, cls=MyTypedDict
     )
     v = SchemaValidator(wrapper_schema)
     assert v.validate_python({'a': 'hello'}) == {'a': 'hello'}
@@ -2860,6 +2867,7 @@ def typed_dict_schema(
 
     Args:
         fields: The fields to use for the typed dict
+        cls: The class to use for the typed dict
         computed_fields: Computed fields to use when serializing the model, only applies when directly inside a model
         strict: Whether the typed dict is strict
         extras_schema: The extra validator to use for the typed dict
@@ -2873,6 +2881,7 @@ def typed_dict_schema(
     return _dict_not_none(
         type='typed-dict',
         fields=fields,
+        cls=cls,
         computed_fields=computed_fields,
         strict=strict,
         extras_schema=extras_schema,

From 51c412b3b1c2d7e488403b952bf0047e0c16bd5c Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Mon, 19 Aug 2024 13:39:58 -0500
Subject: [PATCH 351/550] Breaking change: Change `metadata` type hint from
 `Any` -> `Dict[str, Any] | None` (#1411)

---
 python/pydantic_core/core_schema.py | 238 +++++++++++++++-------------
 1 file changed, 128 insertions(+), 110 deletions(-)

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index 2cb99ef33..8635b63a5 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -440,11 +440,11 @@ class ComputedField(TypedDict, total=False):
     property_name: Required[str]
     return_schema: Required[CoreSchema]
     alias: str
-    metadata: Any
+    metadata: Dict[str, Any]
 
 
 def computed_field(
-    property_name: str, return_schema: CoreSchema, *, alias: str | None = None, metadata: Any = None
+    property_name: str, return_schema: CoreSchema, *, alias: str | None = None, metadata: Dict[str, Any] | None = None
 ) -> ComputedField:
     """
     ComputedFields are properties of a model or dataclass that are included in serialization.
@@ -463,11 +463,13 @@ def computed_field(
 class AnySchema(TypedDict, total=False):
     type: Required[Literal['any']]
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
-def any_schema(*, ref: str | None = None, metadata: Any = None, serialization: SerSchema | None = None) -> AnySchema:
+def any_schema(
+    *, ref: str | None = None, metadata: Dict[str, Any] | None = None, serialization: SerSchema | None = None
+) -> AnySchema:
     """
     Returns a schema that matches any value, e.g.:
 
@@ -490,11 +492,13 @@ def any_schema(*, ref: str | None = None, metadata: Any = None, serialization: S
 class NoneSchema(TypedDict, total=False):
     type: Required[Literal['none']]
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
-def none_schema(*, ref: str | None = None, metadata: Any = None, serialization: SerSchema | None = None) -> NoneSchema:
+def none_schema(
+    *, ref: str | None = None, metadata: Dict[str, Any] | None = None, serialization: SerSchema | None = None
+) -> NoneSchema:
     """
     Returns a schema that matches a None value, e.g.:
 
@@ -518,12 +522,15 @@ class BoolSchema(TypedDict, total=False):
     type: Required[Literal['bool']]
     strict: bool
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
 def bool_schema(
-    strict: bool | None = None, ref: str | None = None, metadata: Any = None, serialization: SerSchema | None = None
+    strict: bool | None = None,
+    ref: str | None = None,
+    metadata: Dict[str, Any] | None = None,
+    serialization: SerSchema | None = None,
 ) -> BoolSchema:
     """
     Returns a schema that matches a bool value, e.g.:
@@ -554,7 +561,7 @@ class IntSchema(TypedDict, total=False):
     gt: int
     strict: bool
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
@@ -567,7 +574,7 @@ def int_schema(
     gt: int | None = None,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> IntSchema:
     """
@@ -616,7 +623,7 @@ class FloatSchema(TypedDict, total=False):
     gt: float
     strict: bool
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
@@ -630,7 +637,7 @@ def float_schema(
     gt: float | None = None,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> FloatSchema:
     """
@@ -683,7 +690,7 @@ class DecimalSchema(TypedDict, total=False):
     decimal_places: int
     strict: bool
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
@@ -699,7 +706,7 @@ def decimal_schema(
     decimal_places: int | None = None,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> DecimalSchema:
     """
@@ -749,7 +756,7 @@ class ComplexSchema(TypedDict, total=False):
     type: Required[Literal['complex']]
     strict: bool
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
@@ -757,7 +764,7 @@ def complex_schema(
     *,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> ComplexSchema:
     """
@@ -799,7 +806,7 @@ class StringSchema(TypedDict, total=False):
     strict: bool
     coerce_numbers_to_str: bool
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
@@ -815,7 +822,7 @@ def str_schema(
     strict: bool | None = None,
     coerce_numbers_to_str: bool | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> StringSchema:
     """
@@ -871,7 +878,7 @@ class BytesSchema(TypedDict, total=False):
     min_length: int
     strict: bool
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
@@ -881,7 +888,7 @@ def bytes_schema(
     min_length: int | None = None,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> BytesSchema:
     """
@@ -926,7 +933,7 @@ class DateSchema(TypedDict, total=False):
     # value is restricted to -86_400 < offset < 86_400 by bounds in generate_self_schema.py
     now_utc_offset: int
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
@@ -940,7 +947,7 @@ def date_schema(
     now_op: Literal['past', 'future'] | None = None,
     now_utc_offset: int | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> DateSchema:
     """
@@ -992,7 +999,7 @@ class TimeSchema(TypedDict, total=False):
     tz_constraint: Union[Literal['aware', 'naive'], int]
     microseconds_precision: Literal['truncate', 'error']
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
@@ -1006,7 +1013,7 @@ def time_schema(
     tz_constraint: Literal['aware', 'naive'] | int | None = None,
     microseconds_precision: Literal['truncate', 'error'] = 'truncate',
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> TimeSchema:
     """
@@ -1062,7 +1069,7 @@ class DatetimeSchema(TypedDict, total=False):
     now_utc_offset: int
     microseconds_precision: Literal['truncate', 'error']  # default: 'truncate'
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
@@ -1078,7 +1085,7 @@ def datetime_schema(
     now_utc_offset: int | None = None,
     microseconds_precision: Literal['truncate', 'error'] = 'truncate',
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> DatetimeSchema:
     """
@@ -1135,7 +1142,7 @@ class TimedeltaSchema(TypedDict, total=False):
     gt: timedelta
     microseconds_precision: Literal['truncate', 'error']
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
@@ -1148,7 +1155,7 @@ def timedelta_schema(
     gt: timedelta | None = None,
     microseconds_precision: Literal['truncate', 'error'] = 'truncate',
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> TimedeltaSchema:
     """
@@ -1192,12 +1199,16 @@ class LiteralSchema(TypedDict, total=False):
     type: Required[Literal['literal']]
     expected: Required[List[Any]]
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
 def literal_schema(
-    expected: list[Any], *, ref: str | None = None, metadata: Any = None, serialization: SerSchema | None = None
+    expected: list[Any],
+    *,
+    ref: str | None = None,
+    metadata: Dict[str, Any] | None = None,
+    serialization: SerSchema | None = None,
 ) -> LiteralSchema:
     """
     Returns a schema that matches a literal value, e.g.:
@@ -1227,7 +1238,7 @@ class EnumSchema(TypedDict, total=False):
     missing: Callable[[Any], Any]
     strict: bool
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
@@ -1239,7 +1250,7 @@ def enum_schema(
     missing: Callable[[Any], Any] | None = None,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> EnumSchema:
     """
@@ -1291,7 +1302,7 @@ class IsInstanceSchema(TypedDict, total=False):
     cls: Required[Any]
     cls_repr: str
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
@@ -1300,7 +1311,7 @@ def is_instance_schema(
     *,
     cls_repr: str | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> IsInstanceSchema:
     """
@@ -1334,7 +1345,7 @@ class IsSubclassSchema(TypedDict, total=False):
     cls: Required[Type[Any]]
     cls_repr: str
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
@@ -1343,7 +1354,7 @@ def is_subclass_schema(
     *,
     cls_repr: str | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> IsInstanceSchema:
     """
@@ -1378,12 +1389,12 @@ class B(A):
 class CallableSchema(TypedDict, total=False):
     type: Required[Literal['callable']]
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
 def callable_schema(
-    *, ref: str | None = None, metadata: Any = None, serialization: SerSchema | None = None
+    *, ref: str | None = None, metadata: Dict[str, Any] | None = None, serialization: SerSchema | None = None
 ) -> CallableSchema:
     """
     Returns a schema that checks if a value is callable, equivalent to python's `callable` method, e.g.:
@@ -1409,7 +1420,7 @@ class UuidSchema(TypedDict, total=False):
     version: Literal[1, 3, 4, 5]
     strict: bool
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
@@ -1418,7 +1429,7 @@ def uuid_schema(
     version: Literal[1, 3, 4, 5] | None = None,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> UuidSchema:
     return _dict_not_none(
@@ -1447,7 +1458,7 @@ class ListSchema(TypedDict, total=False):
     fail_fast: bool
     strict: bool
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: IncExSeqOrElseSerSchema
 
 
@@ -1459,7 +1470,7 @@ def list_schema(
     fail_fast: bool | None = None,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: IncExSeqOrElseSerSchema | None = None,
 ) -> ListSchema:
     """
@@ -1503,7 +1514,7 @@ def tuple_positional_schema(
     extras_schema: CoreSchema | None = None,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: IncExSeqOrElseSerSchema | None = None,
 ) -> TupleSchema:
     """
@@ -1553,7 +1564,7 @@ def tuple_variable_schema(
     max_length: int | None = None,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: IncExSeqOrElseSerSchema | None = None,
 ) -> TupleSchema:
     """
@@ -1599,7 +1610,7 @@ class TupleSchema(TypedDict, total=False):
     fail_fast: bool
     strict: bool
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: IncExSeqOrElseSerSchema
 
 
@@ -1612,7 +1623,7 @@ def tuple_schema(
     fail_fast: bool | None = None,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: IncExSeqOrElseSerSchema | None = None,
 ) -> TupleSchema:
     """
@@ -1662,7 +1673,7 @@ class SetSchema(TypedDict, total=False):
     fail_fast: bool
     strict: bool
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
@@ -1674,7 +1685,7 @@ def set_schema(
     fail_fast: bool | None = None,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> SetSchema:
     """
@@ -1721,7 +1732,7 @@ class FrozenSetSchema(TypedDict, total=False):
     fail_fast: bool
     strict: bool
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
@@ -1733,7 +1744,7 @@ def frozenset_schema(
     fail_fast: bool | None = None,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> FrozenSetSchema:
     """
@@ -1778,7 +1789,7 @@ class GeneratorSchema(TypedDict, total=False):
     min_length: int
     max_length: int
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: IncExSeqOrElseSerSchema
 
 
@@ -1788,7 +1799,7 @@ def generator_schema(
     min_length: int | None = None,
     max_length: int | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: IncExSeqOrElseSerSchema | None = None,
 ) -> GeneratorSchema:
     """
@@ -1853,7 +1864,7 @@ class DictSchema(TypedDict, total=False):
     max_length: int
     strict: bool
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: IncExDictOrElseSerSchema
 
 
@@ -1865,7 +1876,7 @@ def dict_schema(
     max_length: int | None = None,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> DictSchema:
     """
@@ -1930,7 +1941,7 @@ class _ValidatorFunctionSchema(TypedDict, total=False):
     function: Required[ValidationFunction]
     schema: Required[CoreSchema]
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
@@ -1943,7 +1954,7 @@ def no_info_before_validator_function(
     schema: CoreSchema,
     *,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> BeforeValidatorFunctionSchema:
     """
@@ -1987,7 +1998,7 @@ def with_info_before_validator_function(
     *,
     field_name: str | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> BeforeValidatorFunctionSchema:
     """
@@ -2038,7 +2049,7 @@ def no_info_after_validator_function(
     schema: CoreSchema,
     *,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> AfterValidatorFunctionSchema:
     """
@@ -2080,7 +2091,7 @@ def with_info_after_validator_function(
     *,
     field_name: str | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> AfterValidatorFunctionSchema:
     """
@@ -2154,7 +2165,7 @@ class WrapValidatorFunctionSchema(TypedDict, total=False):
     function: Required[WrapValidatorFunction]
     schema: Required[CoreSchema]
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
@@ -2163,7 +2174,7 @@ def no_info_wrap_validator_function(
     schema: CoreSchema,
     *,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> WrapValidatorFunctionSchema:
     """
@@ -2210,7 +2221,7 @@ def with_info_wrap_validator_function(
     *,
     field_name: str | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> WrapValidatorFunctionSchema:
     """
@@ -2257,7 +2268,7 @@ class PlainValidatorFunctionSchema(TypedDict, total=False):
     type: Required[Literal['function-plain']]
     function: Required[ValidationFunction]
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
@@ -2265,7 +2276,7 @@ def no_info_plain_validator_function(
     function: NoInfoValidatorFunction,
     *,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> PlainValidatorFunctionSchema:
     """
@@ -2303,7 +2314,7 @@ def with_info_plain_validator_function(
     *,
     field_name: str | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> PlainValidatorFunctionSchema:
     """
@@ -2346,7 +2357,7 @@ class WithDefaultSchema(TypedDict, total=False):
     validate_default: bool  # default: False
     strict: bool
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
@@ -2359,7 +2370,7 @@ def with_default_schema(
     validate_default: bool | None = None,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> WithDefaultSchema:
     """
@@ -2408,7 +2419,7 @@ class NullableSchema(TypedDict, total=False):
     schema: Required[CoreSchema]
     strict: bool
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
@@ -2417,7 +2428,7 @@ def nullable_schema(
     *,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> NullableSchema:
     """
@@ -2454,7 +2465,7 @@ class UnionSchema(TypedDict, total=False):
     mode: Literal['smart', 'left_to_right']  # default: 'smart'
     strict: bool
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
@@ -2468,7 +2479,7 @@ def union_schema(
     mode: Literal['smart', 'left_to_right'] | None = None,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> UnionSchema:
     """
@@ -2522,7 +2533,7 @@ class TaggedUnionSchema(TypedDict, total=False):
     strict: bool
     from_attributes: bool  # default: True
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
@@ -2536,7 +2547,7 @@ def tagged_union_schema(
     strict: bool | None = None,
     from_attributes: bool | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> TaggedUnionSchema:
     """
@@ -2613,12 +2624,16 @@ class ChainSchema(TypedDict, total=False):
     type: Required[Literal['chain']]
     steps: Required[List[CoreSchema]]
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
 def chain_schema(
-    steps: list[CoreSchema], *, ref: str | None = None, metadata: Any = None, serialization: SerSchema | None = None
+    steps: list[CoreSchema],
+    *,
+    ref: str | None = None,
+    metadata: Dict[str, Any] | None = None,
+    serialization: SerSchema | None = None,
 ) -> ChainSchema:
     """
     Returns a schema that chains the provided validation schemas, e.g.:
@@ -2653,7 +2668,7 @@ class LaxOrStrictSchema(TypedDict, total=False):
     strict_schema: Required[CoreSchema]
     strict: bool
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
@@ -2663,7 +2678,7 @@ def lax_or_strict_schema(
     *,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> LaxOrStrictSchema:
     """
@@ -2716,7 +2731,7 @@ class JsonOrPythonSchema(TypedDict, total=False):
     json_schema: Required[CoreSchema]
     python_schema: Required[CoreSchema]
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
@@ -2725,7 +2740,7 @@ def json_or_python_schema(
     python_schema: CoreSchema,
     *,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> JsonOrPythonSchema:
     """
@@ -2775,7 +2790,7 @@ class TypedDictField(TypedDict, total=False):
     validation_alias: Union[str, List[Union[str, int]], List[List[Union[str, int]]]]
     serialization_alias: str
     serialization_exclude: bool  # default: False
-    metadata: Any
+    metadata: Dict[str, Any]
 
 
 def typed_dict_field(
@@ -2785,7 +2800,7 @@ def typed_dict_field(
     validation_alias: str | list[str | int] | list[list[str | int]] | None = None,
     serialization_alias: str | None = None,
     serialization_exclude: bool | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
 ) -> TypedDictField:
     """
     Returns a schema that matches a typed dict field, e.g.:
@@ -2827,7 +2842,7 @@ class TypedDictSchema(TypedDict, total=False):
     total: bool  # default: True
     populate_by_name: bool  # replaces `allow_population_by_field_name` in pydantic v1
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
     config: CoreConfig
 
@@ -2843,7 +2858,7 @@ def typed_dict_schema(
     total: bool | None = None,
     populate_by_name: bool | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
     config: CoreConfig | None = None,
 ) -> TypedDictSchema:
@@ -2902,7 +2917,7 @@ class ModelField(TypedDict, total=False):
     serialization_alias: str
     serialization_exclude: bool  # default: False
     frozen: bool
-    metadata: Any
+    metadata: Dict[str, Any]
 
 
 def model_field(
@@ -2912,7 +2927,7 @@ def model_field(
     serialization_alias: str | None = None,
     serialization_exclude: bool | None = None,
     frozen: bool | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
 ) -> ModelField:
     """
     Returns a schema for a model field, e.g.:
@@ -2954,7 +2969,7 @@ class ModelFieldsSchema(TypedDict, total=False):
     populate_by_name: bool  # replaces `allow_population_by_field_name` in pydantic v1
     from_attributes: bool
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
@@ -2969,7 +2984,7 @@ def model_fields_schema(
     populate_by_name: bool | None = None,
     from_attributes: bool | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> ModelFieldsSchema:
     """
@@ -3028,7 +3043,7 @@ class ModelSchema(TypedDict, total=False):
     extra_behavior: ExtraBehavior
     config: CoreConfig
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
@@ -3045,7 +3060,7 @@ def model_schema(
     extra_behavior: ExtraBehavior | None = None,
     config: CoreConfig | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> ModelSchema:
     """
@@ -3124,7 +3139,7 @@ class DataclassField(TypedDict, total=False):
     validation_alias: Union[str, List[Union[str, int]], List[List[Union[str, int]]]]
     serialization_alias: str
     serialization_exclude: bool  # default: False
-    metadata: Any
+    metadata: Dict[str, Any]
 
 
 def dataclass_field(
@@ -3137,7 +3152,7 @@ def dataclass_field(
     validation_alias: str | list[str | int] | list[list[str | int]] | None = None,
     serialization_alias: str | None = None,
     serialization_exclude: bool | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     frozen: bool | None = None,
 ) -> DataclassField:
     """
@@ -3189,7 +3204,7 @@ class DataclassArgsSchema(TypedDict, total=False):
     populate_by_name: bool  # default: False
     collect_init_only: bool  # default: False
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
     extra_behavior: ExtraBehavior
 
@@ -3202,7 +3217,7 @@ def dataclass_args_schema(
     populate_by_name: bool | None = None,
     collect_init_only: bool | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
     extra_behavior: ExtraBehavior | None = None,
 ) -> DataclassArgsSchema:
@@ -3259,7 +3274,7 @@ class DataclassSchema(TypedDict, total=False):
     strict: bool  # default: False
     frozen: bool  # default False
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
     slots: bool
     config: CoreConfig
@@ -3275,7 +3290,7 @@ def dataclass_schema(
     revalidate_instances: Literal['always', 'never', 'subclass-instances'] | None = None,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
     frozen: bool | None = None,
     slots: bool | None = None,
@@ -3364,7 +3379,7 @@ class ArgumentsSchema(TypedDict, total=False):
     var_args_schema: CoreSchema
     var_kwargs_schema: CoreSchema
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
@@ -3375,7 +3390,7 @@ def arguments_schema(
     var_args_schema: CoreSchema | None = None,
     var_kwargs_schema: CoreSchema | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> ArgumentsSchema:
     """
@@ -3423,7 +3438,7 @@ class CallSchema(TypedDict, total=False):
     function_name: str  # default function.__name__
     return_schema: CoreSchema
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
@@ -3434,7 +3449,7 @@ def call_schema(
     function_name: str | None = None,
     return_schema: CoreSchema | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> CallSchema:
     """
@@ -3488,7 +3503,7 @@ class CustomErrorSchema(TypedDict, total=False):
     custom_error_message: str
     custom_error_context: Dict[str, Union[str, int, float]]
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
@@ -3499,7 +3514,7 @@ def custom_error_schema(
     custom_error_message: str | None = None,
     custom_error_context: dict[str, Any] | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> CustomErrorSchema:
     """
@@ -3542,7 +3557,7 @@ class JsonSchema(TypedDict, total=False):
     type: Required[Literal['json']]
     schema: CoreSchema
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
@@ -3550,7 +3565,7 @@ def json_schema(
     schema: CoreSchema | None = None,
     *,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> JsonSchema:
     """
@@ -3602,7 +3617,7 @@ class UrlSchema(TypedDict, total=False):
     default_path: str
     strict: bool
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
@@ -3616,7 +3631,7 @@ def url_schema(
     default_path: str | None = None,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> UrlSchema:
     """
@@ -3668,7 +3683,7 @@ class MultiHostUrlSchema(TypedDict, total=False):
     default_path: str
     strict: bool
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
@@ -3682,7 +3697,7 @@ def multi_host_url_schema(
     default_path: str | None = None,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Any = None,
+    metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> MultiHostUrlSchema:
     """
@@ -3728,7 +3743,7 @@ class DefinitionsSchema(TypedDict, total=False):
     type: Required[Literal['definitions']]
     schema: Required[CoreSchema]
     definitions: Required[List[CoreSchema]]
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
@@ -3759,12 +3774,15 @@ class DefinitionReferenceSchema(TypedDict, total=False):
     type: Required[Literal['definition-ref']]
     schema_ref: Required[str]
     ref: str
-    metadata: Any
+    metadata: Dict[str, Any]
     serialization: SerSchema
 
 
 def definition_reference_schema(
-    schema_ref: str, ref: str | None = None, metadata: Any = None, serialization: SerSchema | None = None
+    schema_ref: str,
+    ref: str | None = None,
+    metadata: Dict[str, Any] | None = None,
+    serialization: SerSchema | None = None,
 ) -> DefinitionReferenceSchema:
     """
     Returns a schema that points to a schema stored in "definitions", this is useful for nested recursive

From 4113638a8e98a3351845f1b472fa006b38ddfcea Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Mon, 19 Aug 2024 13:43:36 -0500
Subject: [PATCH 352/550] Prep for v2.23.0 (#1412)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index b030f2357..1979e71a5 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -425,7 +425,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.22.0"
+version = "2.23.0"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index ae54788dd..dfb3048f8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.22.0"
+version = "2.23.0"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From f4a06755dbe590a40ddc7977fabaed30f497fd9a Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Thu, 22 Aug 2024 10:02:53 -0500
Subject: [PATCH 353/550] Use more explicit warning regarding serialization
 warning for missing fields (#1415)

---
 src/errors/mod.rs                         | 46 ---------------
 src/errors/validation_exception.rs        |  4 +-
 src/serializers/extra.rs                  | 11 +---
 src/serializers/fields.rs                 | 20 ++++++-
 src/serializers/type_serializers/model.rs |  3 +-
 src/serializers/type_serializers/union.rs | 12 +---
 src/tools.rs                              | 64 +++++++++++++++++----
 tests/serializers/test_model.py           | 68 ++++++++++++++++++++---
 8 files changed, 143 insertions(+), 85 deletions(-)

diff --git a/src/errors/mod.rs b/src/errors/mod.rs
index 255ea3cc8..ffdda90e3 100644
--- a/src/errors/mod.rs
+++ b/src/errors/mod.rs
@@ -1,6 +1,3 @@
-use core::fmt;
-use std::borrow::Cow;
-
 use pyo3::prelude::*;
 
 mod line_error;
@@ -33,46 +30,3 @@ pub fn py_err_string(py: Python, err: PyErr) -> String {
         Err(_) => "Unknown Error".to_string(),
     }
 }
-
-// TODO: is_utf8_char_boundary, floor_char_boundary and ceil_char_boundary
-// with builtin methods once https://github.com/rust-lang/rust/issues/93743 is resolved
-// These are just copy pasted from the current implementation
-const fn is_utf8_char_boundary(value: u8) -> bool {
-    // This is bit magic equivalent to: b < 128 || b >= 192
-    (value as i8) >= -0x40
-}
-
-pub fn floor_char_boundary(value: &str, index: usize) -> usize {
-    if index >= value.len() {
-        value.len()
-    } else {
-        let lower_bound = index.saturating_sub(3);
-        let new_index = value.as_bytes()[lower_bound..=index]
-            .iter()
-            .rposition(|b| is_utf8_char_boundary(*b));
-
-        // SAFETY: we know that the character boundary will be within four bytes
-        unsafe { lower_bound + new_index.unwrap_unchecked() }
-    }
-}
-
-pub fn ceil_char_boundary(value: &str, index: usize) -> usize {
-    let upper_bound = Ord::min(index + 4, value.len());
-    value.as_bytes()[index..upper_bound]
-        .iter()
-        .position(|b| is_utf8_char_boundary(*b))
-        .map_or(upper_bound, |pos| pos + index)
-}
-
-pub fn write_truncated_to_50_bytes<F: fmt::Write>(f: &mut F, val: Cow<'_, str>) -> std::fmt::Result {
-    if val.len() > 50 {
-        write!(
-            f,
-            "{}...{}",
-            &val[0..floor_char_boundary(&val, 25)],
-            &val[ceil_char_boundary(&val, val.len() - 24)..]
-        )
-    } else {
-        write!(f, "{val}")
-    }
-}
diff --git a/src/errors/validation_exception.rs b/src/errors/validation_exception.rs
index e7861fa9b..8d3b4eca0 100644
--- a/src/errors/validation_exception.rs
+++ b/src/errors/validation_exception.rs
@@ -18,7 +18,7 @@ use crate::errors::LocItem;
 use crate::get_pydantic_version;
 use crate::input::InputType;
 use crate::serializers::{DuckTypingSerMode, Extra, SerMode, SerializationState};
-use crate::tools::{safe_repr, SchemaDict};
+use crate::tools::{safe_repr, write_truncated_to_limited_bytes, SchemaDict};
 
 use super::line_error::ValLineError;
 use super::location::Location;
@@ -526,7 +526,7 @@ impl PyLineError {
             let input_value = self.input_value.bind(py);
             let input_str = safe_repr(input_value);
             write!(output, ", input_value=")?;
-            super::write_truncated_to_50_bytes(&mut output, input_str.to_cow())?;
+            write_truncated_to_limited_bytes(&mut output, &input_str.to_string(), 50)?;
 
             if let Ok(type_) = input_value.get_type().qualname() {
                 write!(output, ", input_type={type_}")?;
diff --git a/src/serializers/extra.rs b/src/serializers/extra.rs
index a62b55304..963fcea8c 100644
--- a/src/serializers/extra.rs
+++ b/src/serializers/extra.rs
@@ -15,7 +15,7 @@ use crate::recursion_guard::ContainsRecursionState;
 use crate::recursion_guard::RecursionError;
 use crate::recursion_guard::RecursionGuard;
 use crate::recursion_guard::RecursionState;
-use crate::tools::safe_repr;
+use crate::tools::truncate_safe_repr;
 use crate::PydanticSerializationError;
 
 /// this is ugly, would be much better if extra could be stored in `SerializationState`
@@ -426,15 +426,10 @@ impl CollectWarnings {
                 .qualname()
                 .unwrap_or_else(|_| PyString::new_bound(value.py(), "<unknown python object>"));
 
-            let input_str = safe_repr(value);
-            let mut value_str = String::with_capacity(100);
-            value_str.push_str("with value `");
-            crate::errors::write_truncated_to_50_bytes(&mut value_str, input_str.to_cow())
-                .expect("Writing to a `String` failed");
-            value_str.push('`');
+            let value_str = truncate_safe_repr(value, None);
 
             self.add_warning(format!(
-                "Expected `{field_type}` but got `{type_name}` {value_str} - serialized value may not be as expected"
+                "Expected `{field_type}` but got `{type_name}` with value `{value_str}` - serialized value may not be as expected"
             ));
         }
     }
diff --git a/src/serializers/fields.rs b/src/serializers/fields.rs
index 16c3f2d55..32c16b18a 100644
--- a/src/serializers/fields.rs
+++ b/src/serializers/fields.rs
@@ -9,6 +9,7 @@ use smallvec::SmallVec;
 
 use crate::serializers::extra::SerCheck;
 use crate::serializers::DuckTypingSerMode;
+use crate::tools::truncate_safe_repr;
 use crate::PydanticSerializationUnexpectedValue;
 
 use super::computed_fields::ComputedFields;
@@ -210,7 +211,24 @@ impl GeneralFieldsSerializer {
             // Check for missing fields, we can't have extra fields here
             && self.required_fields > used_req_fields
         {
-            Err(PydanticSerializationUnexpectedValue::new_err(None))
+            let required_fields = self.required_fields;
+            let type_name = match extra.model {
+                Some(model) => model
+                    .get_type()
+                    .qualname()
+                    .ok()
+                    .unwrap_or_else(|| PyString::new_bound(py, "<unknown python object>"))
+                    .to_string(),
+                None => "<unknown python object>".to_string(),
+            };
+            let field_value = match extra.model {
+                Some(model) => truncate_safe_repr(model, Some(100)),
+                None => "<unknown python object>".to_string(),
+            };
+
+            Err(PydanticSerializationUnexpectedValue::new_err(Some(format!(
+                "Expected {required_fields} fields but got {used_req_fields} for type `{type_name}` with value `{field_value}` - serialized value may not be as expected."
+            ))))
         } else {
             Ok(output_dict)
         }
diff --git a/src/serializers/type_serializers/model.rs b/src/serializers/type_serializers/model.rs
index 8df3f9678..36ddaf69f 100644
--- a/src/serializers/type_serializers/model.rs
+++ b/src/serializers/type_serializers/model.rs
@@ -167,9 +167,9 @@ impl TypeSerializer for ModelSerializer {
     ) -> PyResult<PyObject> {
         let model = Some(value);
         let duck_typing_ser_mode = extra.duck_typing_ser_mode.next_mode();
+
         let model_extra = Extra {
             model,
-            field_name: None,
             duck_typing_ser_mode,
             ..*extra
         };
@@ -221,7 +221,6 @@ impl TypeSerializer for ModelSerializer {
         let duck_typing_ser_mode = extra.duck_typing_ser_mode.next_mode();
         let model_extra = Extra {
             model,
-            field_name: None,
             duck_typing_ser_mode,
             ..*extra
         };
diff --git a/src/serializers/type_serializers/union.rs b/src/serializers/type_serializers/union.rs
index 23aa874fa..38f8ab45a 100644
--- a/src/serializers/type_serializers/union.rs
+++ b/src/serializers/type_serializers/union.rs
@@ -8,10 +8,9 @@ use std::borrow::Cow;
 use crate::build_tools::py_schema_err;
 use crate::common::union::{Discriminator, SMALL_UNION_THRESHOLD};
 use crate::definitions::DefinitionsBuilder;
-use crate::errors::write_truncated_to_50_bytes;
 use crate::lookup_key::LookupKey;
 use crate::serializers::type_serializers::py_err_se_err;
-use crate::tools::{safe_repr, SchemaDict};
+use crate::tools::{truncate_safe_repr, SchemaDict};
 use crate::PydanticSerializationUnexpectedValue;
 
 use super::{
@@ -446,15 +445,10 @@ impl TaggedUnionSerializer {
             Discriminator::Function(func) => func.call1(py, (value,)).ok(),
         };
         if discriminator_value.is_none() {
-            let input_str = safe_repr(value);
-            let mut value_str = String::with_capacity(100);
-            value_str.push_str("with value `");
-            write_truncated_to_50_bytes(&mut value_str, input_str.to_cow()).expect("Writing to a `String` failed");
-            value_str.push('`');
-
+            let value_str = truncate_safe_repr(value, None);
             extra.warnings.custom_warning(
                 format!(
-                    "Failed to get discriminator value for tagged union serialization {value_str} - defaulting to left to right union serialization."
+                    "Failed to get discriminator value for tagged union serialization with value `{value_str}` - defaulting to left to right union serialization."
                 )
             );
         }
diff --git a/src/tools.rs b/src/tools.rs
index adf64c91a..21fec1a7d 100644
--- a/src/tools.rs
+++ b/src/tools.rs
@@ -1,4 +1,4 @@
-use std::borrow::Cow;
+use core::fmt;
 
 use pyo3::exceptions::PyKeyError;
 use pyo3::prelude::*;
@@ -96,15 +96,6 @@ pub enum ReprOutput<'py> {
     Fallback(String),
 }
 
-impl ReprOutput<'_> {
-    pub fn to_cow(&self) -> Cow<'_, str> {
-        match self {
-            ReprOutput::Python(s) => s.to_string_lossy(),
-            ReprOutput::Fallback(s) => s.into(),
-        }
-    }
-}
-
 impl std::fmt::Display for ReprOutput<'_> {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         match self {
@@ -124,6 +115,15 @@ pub fn safe_repr<'py>(v: &Bound<'py, PyAny>) -> ReprOutput<'py> {
     }
 }
 
+pub fn truncate_safe_repr(v: &Bound<'_, PyAny>, max_len: Option<usize>) -> String {
+    let max_len = max_len.unwrap_or(50); // default to 100 bytes
+    let input_str = safe_repr(v);
+    let mut limited_str = String::with_capacity(max_len);
+    write_truncated_to_limited_bytes(&mut limited_str, &input_str.to_string(), max_len)
+        .expect("Writing to a `String` failed");
+    limited_str
+}
+
 pub fn extract_i64(v: &Bound<'_, PyAny>) -> Option<i64> {
     #[cfg(PyPy)]
     if !v.is_instance_of::<pyo3::types::PyInt>() {
@@ -146,3 +146,47 @@ pub(crate) fn new_py_string<'py>(py: Python<'py>, s: &str, cache_str: StringCach
         pystring_fast_new(py, s, ascii_only)
     }
 }
+
+// TODO: is_utf8_char_boundary, floor_char_boundary and ceil_char_boundary
+// with builtin methods once https://github.com/rust-lang/rust/issues/93743 is resolved
+// These are just copy pasted from the current implementation
+const fn is_utf8_char_boundary(value: u8) -> bool {
+    // This is bit magic equivalent to: b < 128 || b >= 192
+    (value as i8) >= -0x40
+}
+
+pub fn floor_char_boundary(value: &str, index: usize) -> usize {
+    if index >= value.len() {
+        value.len()
+    } else {
+        let lower_bound = index.saturating_sub(3);
+        let new_index = value.as_bytes()[lower_bound..=index]
+            .iter()
+            .rposition(|b| is_utf8_char_boundary(*b));
+
+        // SAFETY: we know that the character boundary will be within four bytes
+        unsafe { lower_bound + new_index.unwrap_unchecked() }
+    }
+}
+
+pub fn ceil_char_boundary(value: &str, index: usize) -> usize {
+    let upper_bound = Ord::min(index + 4, value.len());
+    value.as_bytes()[index..upper_bound]
+        .iter()
+        .position(|b| is_utf8_char_boundary(*b))
+        .map_or(upper_bound, |pos| pos + index)
+}
+
+pub fn write_truncated_to_limited_bytes<F: fmt::Write>(f: &mut F, val: &str, max_len: usize) -> std::fmt::Result {
+    if val.len() > max_len {
+        let mid_point = max_len.div_ceil(2);
+        write!(
+            f,
+            "{}...{}",
+            &val[0..floor_char_boundary(val, mid_point)],
+            &val[ceil_char_boundary(val, val.len() - (mid_point - 1))..]
+        )
+    } else {
+        write!(f, "{val}")
+    }
+}
diff --git a/tests/serializers/test_model.py b/tests/serializers/test_model.py
index abb32af3c..9735cd0d3 100644
--- a/tests/serializers/test_model.py
+++ b/tests/serializers/test_model.py
@@ -13,7 +13,13 @@
 import pytest
 from dirty_equals import IsJson
 
-from pydantic_core import PydanticSerializationError, SchemaSerializer, SchemaValidator, core_schema
+from pydantic_core import (
+    PydanticSerializationError,
+    PydanticSerializationUnexpectedValue,
+    SchemaSerializer,
+    SchemaValidator,
+    core_schema,
+)
 
 from ..conftest import plain_repr
 
@@ -1084,20 +1090,68 @@ class Model:
 
 
 def test_no_warn_on_exclude() -> None:
-    warnings.simplefilter('error')
+    with warnings.catch_warnings():
+        warnings.simplefilter('error')
+
+        s = SchemaSerializer(
+            core_schema.model_schema(
+                BasicModel,
+                core_schema.model_fields_schema(
+                    {
+                        'a': core_schema.model_field(core_schema.int_schema()),
+                        'b': core_schema.model_field(core_schema.int_schema()),
+                    }
+                ),
+            )
+        )
+
+        value = BasicModel(a=0, b=1)
+        assert s.to_python(value, exclude={'b'}) == {'a': 0}
+        assert s.to_python(value, mode='json', exclude={'b'}) == {'a': 0}
+
+
+def test_warn_on_missing_field() -> None:
+    class AModel(BasicModel): ...
+
+    class BModel(BasicModel): ...
 
     s = SchemaSerializer(
         core_schema.model_schema(
             BasicModel,
             core_schema.model_fields_schema(
                 {
-                    'a': core_schema.model_field(core_schema.int_schema()),
-                    'b': core_schema.model_field(core_schema.int_schema()),
+                    'root': core_schema.model_field(
+                        core_schema.tagged_union_schema(
+                            choices={
+                                'a': core_schema.model_schema(
+                                    AModel,
+                                    core_schema.model_fields_schema(
+                                        {
+                                            'type': core_schema.model_field(core_schema.literal_schema(['a'])),
+                                            'a': core_schema.model_field(core_schema.int_schema()),
+                                        }
+                                    ),
+                                ),
+                                'b': core_schema.model_schema(
+                                    BModel,
+                                    core_schema.model_fields_schema(
+                                        {
+                                            'type': core_schema.model_field(core_schema.literal_schema(['b'])),
+                                            'b': core_schema.model_field(core_schema.int_schema()),
+                                        }
+                                    ),
+                                ),
+                            },
+                            discriminator='type',
+                        )
+                    ),
                 }
             ),
         )
     )
 
-    value = BasicModel(a=0, b=1)
-    assert s.to_python(value, exclude={'b'}) == {'a': 0}
-    assert s.to_python(value, mode='json', exclude={'b'}) == {'a': 0}
+    with pytest.raises(
+        PydanticSerializationUnexpectedValue, match='Expected 2 fields but got 1 for type `.*AModel` with value `.*`.+'
+    ):
+        value = BasicModel(root=AModel(type='a'))
+        s.to_python(value)

From d0384c788e79a37b4ccbc8b9dc5559ccda682166 Mon Sep 17 00:00:00 2001
From: Kangxing Xie <k.xie2003@outlook.com>
Date: Tue, 27 Aug 2024 01:16:09 +1000
Subject: [PATCH 354/550] Support `BigInt` serialization for `int` subclasses
 (#1417)

---
 src/serializers/infer.rs      | 14 ++++++++++----
 tests/serializers/test_any.py | 34 ++++++++++++++++++++++++++++++++++
 2 files changed, 44 insertions(+), 4 deletions(-)

diff --git a/src/serializers/infer.rs b/src/serializers/infer.rs
index 032ede46b..00add47f3 100644
--- a/src/serializers/infer.rs
+++ b/src/serializers/infer.rs
@@ -1,5 +1,6 @@
 use std::borrow::Cow;
 
+use num_bigint::BigInt;
 use pyo3::exceptions::PyTypeError;
 use pyo3::intern;
 use pyo3::prelude::*;
@@ -116,10 +117,15 @@ pub(crate) fn infer_to_python_known(
             // `bool` and `None` can't be subclasses, `ObType::Int`, `ObType::Float`, `ObType::Str` refer to exact types
             ObType::None | ObType::Bool | ObType::Int | ObType::Str => value.into_py(py),
             // have to do this to make sure subclasses of for example str are upcast to `str`
-            ObType::IntSubclass => match extract_i64(value) {
-                Some(v) => v.into_py(py),
-                None => return py_err!(PyTypeError; "expected int, got {}", safe_repr(value)),
-            },
+            ObType::IntSubclass => {
+                if let Some(v) = extract_i64(value) {
+                    v.into_py(py)
+                } else if let Ok(b) = value.extract::<BigInt>() {
+                    b.into_py(py)
+                } else {
+                    return py_err!(PyTypeError; "Expected int, got {}", safe_repr(value));
+                }
+            }
             ObType::Float | ObType::FloatSubclass => {
                 let v = value.extract::<f64>()?;
                 if (v.is_nan() || v.is_infinite()) && extra.config.inf_nan_mode == InfNanMode::Null {
diff --git a/tests/serializers/test_any.py b/tests/serializers/test_any.py
index 12ac463e1..344e0ff02 100644
--- a/tests/serializers/test_any.py
+++ b/tests/serializers/test_any.py
@@ -654,6 +654,40 @@ def test_ser_json_inf_nan_with_list_of_any() -> None:
     assert s.to_json([nan]) == b'[null]'
 
 
+def test_ser_json_int_subclass_value_larger_than_i64():
+    class IntSubclass(int):
+        pass
+
+    schema = core_schema.model_schema(
+        MyModel,
+        core_schema.model_fields_schema(
+            dict(
+                stuff=core_schema.model_field(
+                    core_schema.dict_schema(
+                        keys_schema=core_schema.str_schema(),
+                        values_schema=core_schema.any_schema(),
+                    )
+                )
+            )
+        ),
+    )
+    s = SchemaSerializer(schema)
+
+    assert (
+        s.to_json(
+            MyModel(stuff={'value': IntSubclass(9_223_372_036_854_775_809)}),
+        )
+        == b'{"stuff":{"value":9223372036854775809}}'
+    )
+
+    assert str(
+        s.to_python(
+            MyModel(stuff={'value': IntSubclass(9_223_372_036_854_775_809)}),
+            mode='json',
+        )
+    ) == str({'stuff': {'value': 9223372036854775809}})
+
+
 def test_simple_any_ser_schema_repr():
     assert (
         plain_repr(SchemaSerializer(core_schema.simple_ser_schema('any')))

From cd04138fe204cf20b9e2813cfa92dc44fae4b15d Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Wed, 28 Aug 2024 04:51:58 -0500
Subject: [PATCH 355/550] Refactor `BigInt` boilerplate (#1421)

---
 src/input/return_enums.rs | 20 +++++++++++++-------
 src/serializers/infer.rs  |  9 +++------
 src/tools.rs              | 10 +++++++++-
 3 files changed, 25 insertions(+), 14 deletions(-)

diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index 593599bab..888dff714 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -20,7 +20,7 @@ use crate::errors::{
     py_err_string, ErrorType, ErrorTypeDefaults, InputValue, ToErrorValue, ValError, ValLineError, ValResult,
 };
 use crate::py_gc::PyGcTraverse;
-use crate::tools::{extract_i64, new_py_string, py_err};
+use crate::tools::{extract_i64, extract_int, new_py_string, py_err};
 use crate::validators::{CombinedValidator, Exactness, ValidationState, Validator};
 
 use super::{py_error_on_minusone, BorrowInput, Input};
@@ -662,6 +662,15 @@ pub enum Int {
     Big(BigInt),
 }
 
+impl IntoPy<PyObject> for Int {
+    fn into_py(self, py: Python<'_>) -> PyObject {
+        match self {
+            Self::I64(i) => i.into_py(py),
+            Self::Big(big_i) => big_i.into_py(py),
+        }
+    }
+}
+
 // The default serialization for BigInt is some internal representation which roundtrips efficiently
 // but is not the JSON value which users would expect to see.
 fn serialize_bigint_as_number<S>(big_int: &BigInt, serializer: S) -> Result<S::Ok, S::Error>
@@ -706,12 +715,9 @@ impl<'a> Rem for &'a Int {
 
 impl FromPyObject<'_> for Int {
     fn extract_bound(obj: &Bound<'_, PyAny>) -> PyResult<Self> {
-        if let Some(i) = extract_i64(obj) {
-            Ok(Int::I64(i))
-        } else if let Ok(b) = obj.extract::<BigInt>() {
-            Ok(Int::Big(b))
-        } else {
-            py_err!(PyTypeError; "Expected int, got {}", obj.get_type())
+        match extract_int(obj) {
+            Some(i) => Ok(i),
+            None => py_err!(PyTypeError; "Expected int, got {}", obj.get_type()),
         }
     }
 }
diff --git a/src/serializers/infer.rs b/src/serializers/infer.rs
index 00add47f3..4e6bb504f 100644
--- a/src/serializers/infer.rs
+++ b/src/serializers/infer.rs
@@ -1,6 +1,5 @@
 use std::borrow::Cow;
 
-use num_bigint::BigInt;
 use pyo3::exceptions::PyTypeError;
 use pyo3::intern;
 use pyo3::prelude::*;
@@ -12,7 +11,7 @@ use serde::ser::{Error, Serialize, SerializeMap, SerializeSeq, Serializer};
 
 use crate::input::{EitherTimedelta, Int};
 use crate::serializers::type_serializers;
-use crate::tools::{extract_i64, py_err, safe_repr};
+use crate::tools::{extract_int, py_err, safe_repr};
 use crate::url::{PyMultiHostUrl, PyUrl};
 
 use super::config::InfNanMode;
@@ -118,10 +117,8 @@ pub(crate) fn infer_to_python_known(
             ObType::None | ObType::Bool | ObType::Int | ObType::Str => value.into_py(py),
             // have to do this to make sure subclasses of for example str are upcast to `str`
             ObType::IntSubclass => {
-                if let Some(v) = extract_i64(value) {
-                    v.into_py(py)
-                } else if let Ok(b) = value.extract::<BigInt>() {
-                    b.into_py(py)
+                if let Some(i) = extract_int(value) {
+                    i.into_py(py)
                 } else {
                     return py_err!(PyTypeError; "Expected int, got {}", safe_repr(value));
                 }
diff --git a/src/tools.rs b/src/tools.rs
index 21fec1a7d..231a94df6 100644
--- a/src/tools.rs
+++ b/src/tools.rs
@@ -1,10 +1,13 @@
 use core::fmt;
 
+use num_bigint::BigInt;
+
 use pyo3::exceptions::PyKeyError;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyString};
 use pyo3::{intern, FromPyObject};
 
+use crate::input::Int;
 use jiter::{cached_py_string, pystring_fast_new, StringCacheMode};
 
 pub trait SchemaDict<'py> {
@@ -133,10 +136,15 @@ pub fn extract_i64(v: &Bound<'_, PyAny>) -> Option<i64> {
         // Can remove this after PyPy 7.3.17 is released
         return None;
     }
-
     v.extract().ok()
 }
 
+pub fn extract_int(v: &Bound<'_, PyAny>) -> Option<Int> {
+    extract_i64(v)
+        .map(Int::I64)
+        .or_else(|| v.extract::<BigInt>().ok().map(Int::Big))
+}
+
 pub(crate) fn new_py_string<'py>(py: Python<'py>, s: &str, cache_str: StringCacheMode) -> Bound<'py, PyString> {
     // we could use `bytecount::num_chars(s.as_bytes()) == s.len()` as orjson does, but it doesn't appear to be faster
     let ascii_only = false;

From d93e6b15419bcefaf0e952591c3d9e1901171181 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Thu, 29 Aug 2024 13:24:46 -0500
Subject: [PATCH 356/550] Prep for `v2.23.1` patch release (#1425)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 1979e71a5..dd8d94cb9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -425,7 +425,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.23.0"
+version = "2.23.1"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index dfb3048f8..915391fa2 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.23.0"
+version = "2.23.1"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From fcdca0f6f1f316b6e5f0d3841c46eb41a975745b Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Wed, 4 Sep 2024 07:05:07 -0500
Subject: [PATCH 357/550] Adding missing API docs to `pydantic_core` (#1420)

Co-authored-by: Victorien <65306057+Viicos@users.noreply.github.com>
---
 python/pydantic_core/_pydantic_core.pyi | 324 +++++++++++++++++++++---
 src/input/datetime.rs                   |   9 +-
 2 files changed, 301 insertions(+), 32 deletions(-)

diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index aeec227f8..fb52a5b10 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -70,14 +70,18 @@ class SchemaValidator:
     `CombinedValidator` which may in turn own more `CombinedValidator`s which make up the full schema validator.
     """
 
-    def __new__(cls, schema: CoreSchema, config: CoreConfig | None = None) -> Self:
-        """
-        Create a new SchemaValidator.
+    # note: pyo3 currently supports __new__, but not __init__, though we include __init__ stubs
+    # and docstrings here (and in the following classes) for documentation purposes
+
+    def __init__(self, schema: CoreSchema, config: CoreConfig | None = None) -> None:
+        """Initializes the `SchemaValidator`.
 
         Arguments:
-            schema: The [`CoreSchema`][pydantic_core.core_schema.CoreSchema] to use for validation.
+            schema: The `CoreSchema` to use for validation.
             config: Optionally a [`CoreConfig`][pydantic_core.core_schema.CoreConfig] to configure validation.
         """
+
+    def __new__(cls, schema: CoreSchema, config: CoreConfig | None = None) -> Self: ...
     @property
     def title(self) -> str:
         """
@@ -242,14 +246,15 @@ class SchemaSerializer:
     `CombinedSerializer` which may in turn own more `CombinedSerializer`s which make up the full schema serializer.
     """
 
-    def __new__(cls, schema: CoreSchema, config: CoreConfig | None = None) -> Self:
-        """
-        Create a new SchemaSerializer.
+    def __init__(self, schema: CoreSchema, config: CoreConfig | None = None) -> None:
+        """Initializes the `SchemaSerializer`.
 
         Arguments:
-            schema: The [`CoreSchema`][pydantic_core.core_schema.CoreSchema] to use for serialization.
+            schema: The `CoreSchema` to use for serialization.
             config: Optionally a [`CoreConfig`][pydantic_core.core_schema.CoreConfig] to to configure serialization.
         """
+
+    def __new__(cls, schema: CoreSchema, config: CoreConfig | None = None) -> Self: ...
     def to_python(
         self,
         value: Any,
@@ -471,9 +476,8 @@ class Url(SupportsAllComparisons):
     by Mozilla.
     """
 
-    def __new__(cls, url: str) -> Self:
-        """
-        Create a new `Url` instance.
+    def __init__(self, url: str) -> None:
+        """Initializes the `Url`.
 
         Args:
             url: String representation of a URL.
@@ -484,6 +488,8 @@ class Url(SupportsAllComparisons):
         Raises:
             ValidationError: If the URL is invalid.
         """
+
+    def __new__(cls, url: str) -> Self: ...
     @property
     def scheme(self) -> str:
         """
@@ -607,9 +613,8 @@ class MultiHostUrl(SupportsAllComparisons):
     by Mozilla.
     """
 
-    def __new__(cls, url: str) -> Self:
-        """
-        Create a new `MultiHostUrl` instance.
+    def __init__(self, url: str) -> None:
+        """Initializes the `MultiHostUrl`.
 
         Args:
             url: String representation of a URL.
@@ -620,6 +625,8 @@ class MultiHostUrl(SupportsAllComparisons):
         Raises:
             ValidationError: If the URL is invalid.
         """
+
+    def __new__(cls, url: str) -> Self: ...
     @property
     def scheme(self) -> str:
         """
@@ -822,54 +829,290 @@ class ValidationError(ValueError):
 
 @final
 class PydanticCustomError(ValueError):
+    """A custom exception providing flexible error handling for Pydantic validators.
+
+    You can raise this error in custom validators when you'd like flexibility in regards to the error type, message, and context.
+
+    Example:
+        ```py
+        from pydantic_core import PydanticCustomError
+
+        def custom_validator(v) -> None:
+            if v <= 10:
+                raise PydanticCustomError('custom_value_error', 'Value must be greater than {value}', {'value': 10, 'extra_context': 'extra_data'})
+            return v
+        ```
+    """
+
+    def __init__(
+        self, error_type: LiteralString, message_template: LiteralString, context: dict[str, Any] | None = None
+    ) -> None:
+        """Initializes the `PydanticCustomError`.
+
+        Arguments:
+            error_type: The error type.
+            message_template: The message template.
+            context: The data to inject into the message template.
+        """
+
     def __new__(
         cls, error_type: LiteralString, message_template: LiteralString, context: dict[str, Any] | None = None
     ) -> Self: ...
     @property
-    def context(self) -> dict[str, Any] | None: ...
+    def context(self) -> dict[str, Any] | None:
+        """Values which are required to render the error message, and could hence be useful in passing error data forward."""
+
     @property
-    def type(self) -> str: ...
+    def type(self) -> str:
+        """The error type associated with the error. For consistency with Pydantic, this is typically a snake_case string."""
+
     @property
-    def message_template(self) -> str: ...
-    def message(self) -> str: ...
+    def message_template(self) -> str:
+        """The message template associated with the error. This is a string that can be formatted with context variables in `{curly_braces}`."""
+
+    def message(self) -> str:
+        """The formatted message associated with the error. This presents as the message template with context variables appropriately injected."""
 
 @final
 class PydanticKnownError(ValueError):
+    """A helper class for raising exceptions that mimic Pydantic's built-in exceptions, with more flexibility in regards to context.
+
+    Unlike [`PydanticCustomError`][pydantic_core.PydanticCustomError], the `error_type` argument must be a known `ErrorType`.
+
+    Example:
+        ```py
+        from pydantic_core import PydanticKnownError
+
+        def custom_validator(v) -> None:
+            if v <= 10:
+                raise PydanticKnownError(error_type='greater_than', context={'gt': 10})
+            return v
+        ```
+    """
+
+    def __init__(self, error_type: ErrorType, context: dict[str, Any] | None = None) -> None:
+        """Initializes the `PydanticKnownError`.
+
+        Arguments:
+            error_type: The error type.
+            context: The data to inject into the message template.
+        """
+
     def __new__(cls, error_type: ErrorType, context: dict[str, Any] | None = None) -> Self: ...
     @property
-    def context(self) -> dict[str, Any] | None: ...
+    def context(self) -> dict[str, Any] | None:
+        """Values which are required to render the error message, and could hence be useful in passing error data forward."""
+
     @property
-    def type(self) -> ErrorType: ...
+    def type(self) -> ErrorType:
+        """The type of the error."""
+
     @property
-    def message_template(self) -> str: ...
-    def message(self) -> str: ...
+    def message_template(self) -> str:
+        """The message template associated with the provided error type. This is a string that can be formatted with context variables in `{curly_braces}`."""
+
+    def message(self) -> str:
+        """The formatted message associated with the error. This presents as the message template with context variables appropriately injected."""
 
 @final
 class PydanticOmit(Exception):
+    """An exception to signal that a field should be omitted from a generated result.
+
+    This could span from omitting a field from a JSON Schema to omitting a field from a serialized result.
+    Upcoming: more robust support for using PydanticOmit in custom serializers is still in development.
+    Right now, this is primarily used in the JSON Schema generation process.
+
+    Example:
+        ```py
+        from typing import Callable
+
+        from pydantic_core import PydanticOmit
+
+        from pydantic import BaseModel
+        from pydantic.json_schema import GenerateJsonSchema, JsonSchemaValue
+
+
+        class MyGenerateJsonSchema(GenerateJsonSchema):
+            def handle_invalid_for_json_schema(self, schema, error_info) -> JsonSchemaValue:
+                raise PydanticOmit
+
+
+        class Predicate(BaseModel):
+            name: str = 'no-op'
+            func: Callable = lambda x: x
+
+
+        instance_example = Predicate()
+
+        validation_schema = instance_example.model_json_schema(schema_generator=MyGenerateJsonSchema, mode='validation')
+        print(validation_schema)
+        '''
+        {'properties': {'name': {'default': 'no-op', 'title': 'Name', 'type': 'string'}}, 'title': 'Predicate', 'type': 'object'}
+        '''
+        ```
+
+    For a more in depth example / explanation, see the [customizing JSON schema](../concepts/json_schema.md#customizing-the-json-schema-generation-process) docs.
+    """
+
     def __new__(cls) -> Self: ...
 
 @final
 class PydanticUseDefault(Exception):
+    """An exception to signal that standard validation either failed or should be skipped, and the default value should be used instead.
+
+    This warning can be raised in custom valiation functions to redirect the flow of validation.
+
+    Example:
+        ```py
+        from pydantic_core import PydanticUseDefault
+        from datetime import datetime
+        from pydantic import BaseModel, field_validator
+
+
+        class Event(BaseModel):
+            name: str = 'meeting'
+            time: datetime
+
+            @field_validator('name', mode='plain')
+            def name_must_be_present(cls, v) -> str:
+                if not v or not isinstance(v, str):
+                    raise PydanticUseDefault()
+                return v
+
+
+        event1 = Event(name='party', time=datetime(2024, 1, 1, 12, 0, 0))
+        print(repr(event1))
+        # > Event(name='party', time=datetime.datetime(2024, 1, 1, 12, 0))
+        event2 = Event(time=datetime(2024, 1, 1, 12, 0, 0))
+        print(repr(event2))
+        # > Event(name='meeting', time=datetime.datetime(2024, 1, 1, 12, 0))
+        ```
+
+    For an additional example, seethe [validating partial json data](../concepts/json.md#partial-json-parsing) section of the Pydantic documentation.
+    """
+
     def __new__(cls) -> Self: ...
 
 @final
 class PydanticSerializationError(ValueError):
+    """An error raised when an issue occurs during serialization.
+
+    In custom serializers, this error can be used to indicate that serialization has failed.
+    """
+
+    def __init__(self, message: str) -> None:
+        """Initializes the `PydanticSerializationError`.
+
+        Arguments:
+            message: The message associated with the error.
+        """
+
     def __new__(cls, message: str) -> Self: ...
 
 @final
 class PydanticSerializationUnexpectedValue(ValueError):
+    """An error raised when an unexpected value is encountered during serialization.
+
+    This error is often caught and coerced into a warning, as `pydantic-core` generally makes a best attempt
+    at serializing values, in contrast with validation where errors are eagerly raised.
+
+    Example:
+        ```py
+        from pydantic import BaseModel, field_serializer
+        from pydantic_core import PydanticSerializationUnexpectedValue
+
+        class BasicPoint(BaseModel):
+            x: int
+            y: int
+
+            @field_serializer('*')
+            def serialize(self, v):
+                if not isinstance(v, int):
+                    raise PydanticSerializationUnexpectedValue(f'Expected type `int`, got {type(v)} with value {v}')
+                return v
+
+        point = BasicPoint(x=1, y=2)
+        # some sort of mutation
+        point.x = 'a'
+
+        print(point.model_dump())
+        '''
+        UserWarning: Pydantic serializer warnings:
+        PydanticSerializationUnexpectedValue(Expected type `int`, got <class 'str'> with value a)
+        return self.__pydantic_serializer__.to_python(
+        {'x': 'a', 'y': 2}
+        '''
+        ```
+
+    This is often used internally in `pydantic-core` when unexpected types are encountered during serialization,
+    but it can also be used by users in custom serializers, as seen above.
+    """
+
+    def __init__(self, message: str) -> None:
+        """Initializes the `PydanticSerializationUnexpectedValue`.
+
+        Arguments:
+            message: The message associated with the unexpected value.
+        """
+
     def __new__(cls, message: str | None = None) -> Self: ...
 
 @final
 class ArgsKwargs:
+    """A construct used to store arguments and keyword arguments for a function call.
+
+    This data structure is generally used to store information for core schemas associated with functions (like in an arguments schema).
+    This data structure is also currently used for some validation against dataclasses.
+
+    Example:
+        ```py
+        from pydantic.dataclasses import dataclass
+        from pydantic import model_validator
+
+
+        @dataclass
+        class Model:
+            a: int
+            b: int
+
+            @model_validator(mode="before")
+            @classmethod
+            def no_op_validator(cls, values):
+                print(values)
+                return values
+
+        Model(1, b=2)
+        #> ArgsKwargs((1,), {"b": 2})
+
+        Model(1, 2)
+        #> ArgsKwargs((1, 2), {})
+
+        Model(a=1, b=2)
+        #> ArgsKwargs((), {"a": 1, "b": 2})
+        ```
+    """
+
+    def __init__(self, args: tuple[Any, ...], kwargs: dict[str, Any] | None = None) -> None:
+        """Initializes the `ArgsKwargs`.
+
+        Arguments:
+            args: The arguments (inherently ordered) for a function call.
+            kwargs: The keyword arguments for a function call
+        """
+
     def __new__(cls, args: tuple[Any, ...], kwargs: dict[str, Any] | None = None) -> Self: ...
     @property
-    def args(self) -> tuple[Any, ...]: ...
+    def args(self) -> tuple[Any, ...]:
+        """The arguments (inherently ordered) for a function call."""
+
     @property
-    def kwargs(self) -> dict[str, Any] | None: ...
+    def kwargs(self) -> dict[str, Any] | None:
+        """The keyword arguments for a function call."""
 
 @final
 class PydanticUndefinedType:
+    """A type used as a sentinel for undefined values."""
+
     def __copy__(self) -> Self: ...
     def __deepcopy__(self, memo: Any) -> Self: ...
 
@@ -884,14 +1127,37 @@ def list_all_errors() -> list[ErrorTypeInfo]:
     """
 @final
 class TzInfo(datetime.tzinfo):
-    def tzname(self, _dt: datetime.datetime | None) -> str | None: ...
-    def utcoffset(self, _dt: datetime.datetime | None) -> datetime.timedelta: ...
-    def dst(self, _dt: datetime.datetime | None) -> datetime.timedelta: ...
-    def fromutc(self, dt: datetime.datetime) -> datetime.datetime: ...
+    """An `pydantic-core` implementation of the abstract [`datetime.tzinfo`] class."""
+
+    # Docstrings for attributes sourced from the abstract base class, [`datetime.tzinfo`](https://docs.python.org/3/library/datetime.html#datetime.tzinfo).
+
+    def tzname(self, dt: datetime.datetime | None) -> str | None:
+        """Return the time zone name corresponding to the [`datetime`][datetime.datetime] object _dt_, as a string.
+
+        For more info, see [`tzinfo.tzname`][datetime.tzinfo.tzname].
+        """
+
+    def utcoffset(self, dt: datetime.datetime | None) -> datetime.timedelta | None:
+        """Return offset of local time from UTC, as a [`timedelta`][datetime.timedelta] object that is positive east of UTC. If local time is west of UTC, this should be negative.
+
+        More info can be found at [`tzinfo.utcoffset`][datetime.tzinfo.utcoffset].
+        """
+
+    def dst(self, dt: datetime.datetime | None) -> datetime.timedelta | None:
+        """Return the daylight saving time (DST) adjustment, as a [`timedelta`][datetime.timedelta] object or `None` if DST information isn’t known.
+
+        More info can be found at[`tzinfo.dst`][datetime.tzinfo.dst]."""
+
+    def fromutc(self, dt: datetime.datetime) -> datetime.datetime:
+        """Adjust the date and time data associated datetime object _dt_, returning an equivalent datetime in self’s local time.
+
+        More info can be found at [`tzinfo.fromutc`][datetime.tzinfo.fromutc]."""
+
     def __deepcopy__(self, _memo: dict[Any, Any]) -> TzInfo: ...
 
 def validate_core_schema(schema: CoreSchema, *, strict: bool | None = None) -> CoreSchema:
-    """Validate a CoreSchema
+    """Validate a core schema.
+
     This currently uses lax mode for validation (i.e. will coerce strings to dates and such)
     but may use strict mode in the future.
     We may also remove this function altogether, do not rely on it being present if you are
diff --git a/src/input/datetime.rs b/src/input/datetime.rs
index f8ae6929e..577a91014 100644
--- a/src/input/datetime.rs
+++ b/src/input/datetime.rs
@@ -516,15 +516,18 @@ impl TzInfo {
         Self::try_from(seconds.trunc() as i32)
     }
 
-    fn utcoffset<'py>(&self, py: Python<'py>, _dt: &Bound<'_, PyAny>) -> PyResult<Bound<'py, PyDelta>> {
+    #[allow(unused_variables)]
+    fn utcoffset<'py>(&self, py: Python<'py>, dt: &Bound<'_, PyAny>) -> PyResult<Bound<'py, PyDelta>> {
         PyDelta::new_bound(py, 0, self.seconds, 0, true)
     }
 
-    fn tzname(&self, _dt: &Bound<'_, PyAny>) -> String {
+    #[allow(unused_variables)]
+    fn tzname(&self, dt: &Bound<'_, PyAny>) -> String {
         self.__str__()
     }
 
-    fn dst(&self, _dt: &Bound<'_, PyAny>) -> Option<&PyDelta> {
+    #[allow(unused_variables)]
+    fn dst(&self, dt: &Bound<'_, PyAny>) -> Option<&PyDelta> {
         None
     }
 

From 0946d71cbceba809473926128699e7e1b9ec3025 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Thu, 5 Sep 2024 08:29:48 -0500
Subject: [PATCH 358/550] Version bump for docs update (#1438)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index dd8d94cb9..79696c7e9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -425,7 +425,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.23.1"
+version = "2.23.2"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index 915391fa2..27cc055b8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.23.1"
+version = "2.23.2"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From fa6b75b76b4f07a8fb335b81eb57b869dbc3a9a2 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Thu, 5 Sep 2024 09:25:02 -0500
Subject: [PATCH 359/550] Try removing flaky xfail test (#1439)

---
 tests/validators/test_complex.py | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/tests/validators/test_complex.py b/tests/validators/test_complex.py
index 83c5d416d..a0fe628db 100644
--- a/tests/validators/test_complex.py
+++ b/tests/validators/test_complex.py
@@ -1,6 +1,7 @@
 import math
 import platform
 import re
+import sys
 
 import pytest
 
@@ -84,7 +85,7 @@ def test_complex_strict(input_value, expected):
 
 
 @pytest.mark.xfail(
-    platform.python_implementation() == 'PyPy',
+    platform.python_implementation() == 'PyPy' and sys.version_info < (3, 10),
     reason='PyPy cannot process this string due to a bug, even if this string is considered valid in python',
 )
 def test_valid_complex_string_with_space():

From 4dabe3c6529597ab28c9e6c1b08363953d3a1a3e Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 5 Sep 2024 13:04:13 -0500
Subject: [PATCH 360/550] Bump the python-packages group with 8 updates (#1428)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 tests/requirements-linting.txt | 8 ++++----
 tests/requirements.txt         | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index b004e99ca..c614101d5 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,4 +1,4 @@
-griffe==0.48.0
-pyright==1.1.374
-ruff==0.5.5
-mypy==1.11.1
+griffe==1.2.0
+pyright==1.1.378
+ruff==0.6.3
+mypy==1.11.2
diff --git a/tests/requirements.txt b/tests/requirements.txt
index 342fbfd2d..5ee5ebfda 100644
--- a/tests/requirements.txt
+++ b/tests/requirements.txt
@@ -1,7 +1,7 @@
 backports.zoneinfo==0.2.1;python_version<"3.9"
-coverage==7.6.0
-dirty-equals==0.7.1.post0
-hypothesis==6.108.5
+coverage==7.6.1
+dirty-equals==0.8.0
+hypothesis==6.111.2
 # pandas doesn't offer prebuilt wheels for all versions and platforms we test in CI e.g. aarch64 musllinux
 pandas==2.1.3; python_version >= "3.9" and python_version < "3.13" and implementation_name == "cpython" and platform_machine == 'x86_64'
 pytest==8.3.2
@@ -9,7 +9,7 @@ pytest==8.3.2
 pytest-codspeed~=2.2.1; implementation_name == "cpython" and platform_machine == 'x86_64'
 # pytest-examples currently depends on aiohttp via black; we don't want to build
 # it on platforms like aarch64 musllinux in CI
-pytest-examples==0.0.12; implementation_name == "cpython" and platform_machine == 'x86_64'
+pytest-examples==0.0.13; implementation_name == "cpython" and platform_machine == 'x86_64'
 pytest-speed==0.3.5
 pytest-mock==3.14.0
 pytest-pretty==1.2.0

From 638e33df2a2f7f7b88794b34cc1226430bc4e14a Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 5 Sep 2024 13:04:23 -0500
Subject: [PATCH 361/550] Bump serde from 1.0.204 to 1.0.209 (#1429)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 8 ++++----
 Cargo.toml | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 79696c7e9..28cbe6b49 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -581,18 +581,18 @@ checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
 
 [[package]]
 name = "serde"
-version = "1.0.204"
+version = "1.0.209"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc76f558e0cbb2a839d37354c575f1dc3fdc6546b5be373ba43d95f231bf7c12"
+checksum = "99fce0ffe7310761ca6bf9faf5115afbc19688edd00171d81b1bb1b116c63e09"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.204"
+version = "1.0.209"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0cd7e117be63d3c3678776753929474f3b04a43a080c744d6b0ae2a8c28e222"
+checksum = "a5831b979fd7b5439637af1752d535ff49f4860c0f341d1baeb6faf0f4242170"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/Cargo.toml b/Cargo.toml
index 27cc055b8..5c0ae5b20 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -35,7 +35,7 @@ strum = { version = "0.26.3", features = ["derive"] }
 strum_macros = "0.26.4"
 serde_json = {version = "1.0.121", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.13"
-serde = { version = "1.0.204", features = ["derive"] }
+serde = { version = "1.0.209", features = ["derive"] }
 speedate = "0.14.4"
 smallvec = "1.13.2"
 ahash = "0.8.10"

From 4bd42980e282455d42e036c41edff8d22d27392c Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 5 Sep 2024 13:04:31 -0500
Subject: [PATCH 362/550] Bump idna from 1.0.1 to 1.0.2 (#1430)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 6 +++---
 Cargo.toml | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 28cbe6b49..56e1c8ca9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -263,9 +263,9 @@ dependencies = [
 
 [[package]]
 name = "idna"
-version = "1.0.1"
+version = "1.0.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "44a986806a1cc899952ba462bc1f28afbfd5850ab6cb030ccb20dd02cc527a24"
+checksum = "bd69211b9b519e98303c015e21a007e293db403b6c85b9b124e133d25e242cdd"
 dependencies = [
  "icu_normalizer",
  "icu_properties",
@@ -431,7 +431,7 @@ dependencies = [
  "base64",
  "enum_dispatch",
  "hex",
- "idna 1.0.1",
+ "idna 1.0.2",
  "jiter",
  "num-bigint",
  "pyo3",
diff --git a/Cargo.toml b/Cargo.toml
index 5c0ae5b20..8b48d9e99 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -41,7 +41,7 @@ smallvec = "1.13.2"
 ahash = "0.8.10"
 url = "2.5.0"
 # idna is already required by url, added here to be explicit
-idna = "1.0.1"
+idna = "1.0.2"
 base64 = "0.22.1"
 num-bigint = "0.4.6"
 python3-dll-a = "0.2.10"

From e26afb836ab3c9be9f6c2f8ffc116438bffe4ed0 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 5 Sep 2024 13:04:38 -0500
Subject: [PATCH 363/550] Bump uuid from 1.9.1 to 1.10.0 (#1431)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 56e1c8ca9..105ecc47f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -773,9 +773,9 @@ checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
 
 [[package]]
 name = "uuid"
-version = "1.9.1"
+version = "1.10.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5de17fd2f7da591098415cff336e12965a28061ddace43b59cb3c430179c9439"
+checksum = "81dfa00651efa65069b0b6b651f4aaa31ba9e3c3ce0137aaad053604ee7e0314"
 
 [[package]]
 name = "version_check"
diff --git a/Cargo.toml b/Cargo.toml
index 8b48d9e99..f9a7d5b6c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -45,7 +45,7 @@ idna = "1.0.2"
 base64 = "0.22.1"
 num-bigint = "0.4.6"
 python3-dll-a = "0.2.10"
-uuid = "1.9.1"
+uuid = "1.10.0"
 jiter = { version = "0.5", features = ["python"] }
 hex = "0.4.3"
 

From bc540483f22290c87e21c7f264f5d054d6ec7b7b Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 5 Sep 2024 13:04:45 -0500
Subject: [PATCH 364/550] Bump regex from 1.10.5 to 1.10.6 (#1432)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 105ecc47f..4db9b9c8e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -540,9 +540,9 @@ checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
 
 [[package]]
 name = "regex"
-version = "1.10.5"
+version = "1.10.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b91213439dad192326a0d7c6ee3955910425f441d7038e0d6933b0aec5c4517f"
+checksum = "4219d74c6b67a3654a9fbebc4b419e22126d13d2f3c4a07ee0cb61ff79a79619"
 dependencies = [
  "aho-corasick",
  "memchr",
diff --git a/Cargo.toml b/Cargo.toml
index f9a7d5b6c..28658a5ac 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -30,7 +30,7 @@ rust-version = "1.75"
 # TODO it would be very nice to remove the "py-clone" feature as it can panic,
 # but needs a bit of work to make sure it's not used in the codebase
 pyo3 = { version = "0.22.2", features = ["generate-import-lib", "num-bigint", "py-clone"] }
-regex = "1.10.4"
+regex = "1.10.6"
 strum = { version = "0.26.3", features = ["derive"] }
 strum_macros = "0.26.4"
 serde_json = {version = "1.0.121", features = ["arbitrary_precision", "preserve_order"]}

From e1cd613f3b126aed6a7bb9fa1f60b71ff3970c68 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 5 Sep 2024 13:04:54 -0500
Subject: [PATCH 365/550] Bump serde_json from 1.0.121 to 1.0.127 (#1433)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 4db9b9c8e..16284dc6c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -601,9 +601,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.121"
+version = "1.0.127"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4ab380d7d9f22ef3f21ad3e6c1ebe8e4fc7a2000ccba2e4d71fc96f15b2cb609"
+checksum = "8043c06d9f82bd7271361ed64f415fe5e12a77fdb52e573e7f06a516dea329ad"
 dependencies = [
  "indexmap",
  "itoa",
diff --git a/Cargo.toml b/Cargo.toml
index 28658a5ac..7829f3101 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -33,7 +33,7 @@ pyo3 = { version = "0.22.2", features = ["generate-import-lib", "num-bigint", "p
 regex = "1.10.6"
 strum = { version = "0.26.3", features = ["derive"] }
 strum_macros = "0.26.4"
-serde_json = {version = "1.0.121", features = ["arbitrary_precision", "preserve_order"]}
+serde_json = {version = "1.0.127", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.13"
 serde = { version = "1.0.209", features = ["derive"] }
 speedate = "0.14.4"

From dec5faa27a9d22831f2e0e671fccc211e1a2e78b Mon Sep 17 00:00:00 2001
From: Jord <87128575+JBLDKY@users.noreply.github.com>
Date: Thu, 5 Sep 2024 20:25:28 +0200
Subject: [PATCH 366/550] Negative integers with leading zeros raise ValueError
 (#1436)

---
 src/input/shared.rs          | 33 ++++++++++++++++++++++++++++-----
 tests/validators/test_int.py |  6 ++++++
 2 files changed, 34 insertions(+), 5 deletions(-)

diff --git a/src/input/shared.rs b/src/input/shared.rs
index 95b9912a5..0c81c1cfe 100644
--- a/src/input/shared.rs
+++ b/src/input/shared.rs
@@ -122,6 +122,22 @@ fn clean_int_str(mut s: &str) -> Option<Cow<str>> {
         s = suffix;
     }
 
+    // Remember if the number is negative
+    // the `strip_leading_zeros` function will not strip leading zeros for negative numbers
+    // therefore we simply "take away" the unary minus sign temporarily and add it back before
+    // returning. This allows consistent handling of leading zeros for both positive and negative numbers.
+    let mut is_negative = false;
+    if let Some(suffix) = s.strip_prefix('-') {
+        // Invalidate "--" and "-+" as an integer prefix by returning None
+        if suffix.starts_with('-') | suffix.starts_with('+') {
+            return None;
+        }
+
+        is_negative = true;
+        // Continue as usual without the unary minus sign
+        s = suffix;
+    }
+
     // strip loading zeros
     s = strip_leading_zeros(s)?;
 
@@ -136,13 +152,20 @@ fn clean_int_str(mut s: &str) -> Option<Cow<str>> {
 
     // remove underscores
     if let Some(str_stripped) = strip_underscores(s) {
-        Some(str_stripped.into())
-    } else {
-        match len_before == s.len() {
-            true => None,
-            false => Some(s.into()),
+        match is_negative {
+            true => return Some(("-".to_string() + &str_stripped).into()),
+            false => return Some(str_stripped.into()),
         }
     }
+
+    if len_before == s.len() {
+        return None;
+    }
+
+    match is_negative {
+        true => Some(("-".to_string() + s).into()),
+        false => Some(s.into()),
+    }
 }
 
 /// strip leading zeros from a string, we can't simple use `s.trim_start_matches('0')`, because:
diff --git a/tests/validators/test_int.py b/tests/validators/test_int.py
index f93919f17..47944126a 100644
--- a/tests/validators/test_int.py
+++ b/tests/validators/test_int.py
@@ -52,6 +52,12 @@
         ('++4_2', Err('Input should be a valid integer, unable to parse string as an integer')),
         ('-+1', Err('Input should be a valid integer, unable to parse string as an integer')),
         ('+-1', Err('Input should be a valid integer, unable to parse string as an integer')),
+        ('--0001', Err('Input should be a valid integer, unable to parse string as an integer')),
+        ('-+0001', Err('Input should be a valid integer, unable to parse string as an integer')),
+        ('-0-001', Err('Input should be a valid integer, unable to parse string as an integer')),
+        ('-0+001', Err('Input should be a valid integer, unable to parse string as an integer')),
+        ('-00001', -1),
+        ('-00042_000', -42000),
         ('4_2', 42),
         ('0_42', 42),
         ('4_2.0', 42),

From 6169ea91abdf90547caa1701e8e0cc6ff26f5547 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Micha=C5=82=20G=C3=B3rny?= <mgorny@gentoo.org>
Date: Fri, 6 Sep 2024 07:36:13 +0200
Subject: [PATCH 367/550] Improve test_valid_complex_string_with_space() xfail
 condition (#1441)

---
 tests/validators/test_complex.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/tests/validators/test_complex.py b/tests/validators/test_complex.py
index a0fe628db..244091265 100644
--- a/tests/validators/test_complex.py
+++ b/tests/validators/test_complex.py
@@ -85,7 +85,7 @@ def test_complex_strict(input_value, expected):
 
 
 @pytest.mark.xfail(
-    platform.python_implementation() == 'PyPy' and sys.version_info < (3, 10),
+    platform.python_implementation() == 'PyPy' and sys.pypy_version_info < (7, 3, 17),
     reason='PyPy cannot process this string due to a bug, even if this string is considered valid in python',
 )
 def test_valid_complex_string_with_space():

From c462f775c3ed58ea530aad52190533721ccc2a70 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 6 Sep 2024 04:03:59 -0500
Subject: [PATCH 368/550] Bump serde_json from 1.0.127 to 1.0.128 (#1440)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 16284dc6c..74dd6c31b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -601,9 +601,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.127"
+version = "1.0.128"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8043c06d9f82bd7271361ed64f415fe5e12a77fdb52e573e7f06a516dea329ad"
+checksum = "6ff5456707a1de34e7e37f2a6fd3d3f808c318259cbd01ab6377795054b483d8"
 dependencies = [
  "indexmap",
  "itoa",
diff --git a/Cargo.toml b/Cargo.toml
index 7829f3101..4597d2431 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -33,7 +33,7 @@ pyo3 = { version = "0.22.2", features = ["generate-import-lib", "num-bigint", "p
 regex = "1.10.6"
 strum = { version = "0.26.3", features = ["derive"] }
 strum_macros = "0.26.4"
-serde_json = {version = "1.0.127", features = ["arbitrary_precision", "preserve_order"]}
+serde_json = {version = "1.0.128", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.13"
 serde = { version = "1.0.209", features = ["derive"] }
 speedate = "0.14.4"

From f2a0bb81d953fef9deb4487efe30514449c3b537 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Fri, 6 Sep 2024 06:37:54 -0500
Subject: [PATCH 369/550] Fix tagged union serialization warning when using
 aliases (#1442)

---
 src/lookup_key.rs                         | 49 +++++++++----------
 src/serializers/type_serializers/union.rs |  9 ++--
 tests/serializers/test_union.py           | 59 +++++++++++++++++++++++
 3 files changed, 87 insertions(+), 30 deletions(-)

diff --git a/src/lookup_key.rs b/src/lookup_key.rs
index 4cc131df8..7415d0942 100644
--- a/src/lookup_key.rs
+++ b/src/lookup_key.rs
@@ -191,34 +191,10 @@ impl LookupKey {
         }
     }
 
-    pub fn py_get_attr<'py, 's>(
+    pub fn simple_py_get_attr<'py, 's>(
         &'s self,
         obj: &Bound<'py, PyAny>,
-        kwargs: Option<&Bound<'py, PyDict>>,
-    ) -> ValResult<Option<(&'s LookupPath, Bound<'py, PyAny>)>> {
-        match self._py_get_attr(obj, kwargs) {
-            Ok(v) => Ok(v),
-            Err(err) => {
-                let error = py_err_string(obj.py(), err);
-                Err(ValError::new(
-                    ErrorType::GetAttributeError { error, context: None },
-                    obj,
-                ))
-            }
-        }
-    }
-
-    pub fn _py_get_attr<'py, 's>(
-        &'s self,
-        obj: &Bound<'py, PyAny>,
-        kwargs: Option<&Bound<'py, PyDict>>,
     ) -> PyResult<Option<(&'s LookupPath, Bound<'py, PyAny>)>> {
-        if let Some(dict) = kwargs {
-            if let Ok(Some(item)) = self.py_get_dict_item(dict) {
-                return Ok(Some(item));
-            }
-        }
-
         match self {
             Self::Simple { py_key, path, .. } => match py_get_attrs(obj, py_key)? {
                 Some(value) => Ok(Some((path, value))),
@@ -260,6 +236,29 @@ impl LookupKey {
         }
     }
 
+    pub fn py_get_attr<'py, 's>(
+        &'s self,
+        obj: &Bound<'py, PyAny>,
+        kwargs: Option<&Bound<'py, PyDict>>,
+    ) -> ValResult<Option<(&'s LookupPath, Bound<'py, PyAny>)>> {
+        if let Some(dict) = kwargs {
+            if let Ok(Some(item)) = self.py_get_dict_item(dict) {
+                return Ok(Some(item));
+            }
+        }
+
+        match self.simple_py_get_attr(obj) {
+            Ok(v) => Ok(v),
+            Err(err) => {
+                let error = py_err_string(obj.py(), err);
+                Err(ValError::new(
+                    ErrorType::GetAttributeError { error, context: None },
+                    obj,
+                ))
+            }
+        }
+    }
+
     pub fn json_get<'a, 'data, 's>(
         &'s self,
         dict: &'a JsonObject<'data>,
diff --git a/src/serializers/type_serializers/union.rs b/src/serializers/type_serializers/union.rs
index 38f8ab45a..46ec5312e 100644
--- a/src/serializers/type_serializers/union.rs
+++ b/src/serializers/type_serializers/union.rs
@@ -8,7 +8,6 @@ use std::borrow::Cow;
 use crate::build_tools::py_schema_err;
 use crate::common::union::{Discriminator, SMALL_UNION_THRESHOLD};
 use crate::definitions::DefinitionsBuilder;
-use crate::lookup_key::LookupKey;
 use crate::serializers::type_serializers::py_err_se_err;
 use crate::tools::{truncate_safe_repr, SchemaDict};
 use crate::PydanticSerializationUnexpectedValue;
@@ -438,10 +437,10 @@ impl TaggedUnionSerializer {
     fn get_discriminator_value(&self, value: &Bound<'_, PyAny>, extra: &Extra) -> Option<Py<PyAny>> {
         let py = value.py();
         let discriminator_value = match &self.discriminator {
-            Discriminator::LookupKey(lookup_key) => match lookup_key {
-                LookupKey::Simple { py_key, .. } => value.getattr(py_key).ok().map(|obj| obj.to_object(py)),
-                _ => None,
-            },
+            Discriminator::LookupKey(lookup_key) => lookup_key
+                .simple_py_get_attr(value)
+                .ok()
+                .and_then(|opt| opt.map(|(_, bound)| bound.to_object(py))),
             Discriminator::Function(func) => func.call1(py, (value,)).ok(),
         };
         if discriminator_value.is_none() {
diff --git a/tests/serializers/test_union.py b/tests/serializers/test_union.py
index d97d52f03..342f12cf4 100644
--- a/tests/serializers/test_union.py
+++ b/tests/serializers/test_union.py
@@ -711,3 +711,62 @@ def test_custom_serializer() -> None:
     print(s)
     assert s.to_python([{'id': 1}, {'id': 2}]) == [1, 2]
     assert s.to_python({'id': 1}) == 1
+
+
+def test_tagged_union_with_aliases() -> None:
+    @dataclasses.dataclass
+    class ModelA:
+        field: int
+        tag: Literal['a'] = 'a'
+
+    @dataclasses.dataclass
+    class ModelB:
+        field: int
+        tag: Literal['b'] = 'b'
+
+    s = SchemaSerializer(
+        core_schema.tagged_union_schema(
+            choices={
+                'a': core_schema.dataclass_schema(
+                    ModelA,
+                    core_schema.dataclass_args_schema(
+                        'ModelA',
+                        [
+                            core_schema.dataclass_field(name='field', schema=core_schema.int_schema()),
+                            core_schema.dataclass_field(
+                                name='tag',
+                                schema=core_schema.literal_schema(['a']),
+                                validation_alias='TAG',
+                                serialization_alias='TAG',
+                            ),
+                        ],
+                    ),
+                    ['field', 'tag'],
+                ),
+                'b': core_schema.dataclass_schema(
+                    ModelB,
+                    core_schema.dataclass_args_schema(
+                        'ModelB',
+                        [
+                            core_schema.dataclass_field(name='field', schema=core_schema.int_schema()),
+                            core_schema.dataclass_field(
+                                name='tag',
+                                schema=core_schema.literal_schema(['b']),
+                                validation_alias='TAG',
+                                serialization_alias='TAG',
+                            ),
+                        ],
+                    ),
+                    ['field', 'tag'],
+                ),
+            },
+            discriminator=[['tag'], ['TAG']],
+        )
+    )
+
+    assert 'TaggedUnionSerializer' in repr(s)
+
+    model_a = ModelA(field=1)
+    model_b = ModelB(field=1)
+    assert s.to_python(model_a) == {'field': 1, 'TAG': 'a'}
+    assert s.to_python(model_b) == {'field': 1, 'TAG': 'b'}

From 3bd1baac38c754dcd1eec6e7c95afe8bec1e61a0 Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Fri, 6 Sep 2024 16:27:54 +0200
Subject: [PATCH 370/550] Fix `_IncEx` type annotation (#1443)

---
 python/pydantic_core/_pydantic_core.pyi | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index fb52a5b10..271601bfa 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -237,7 +237,7 @@ class SchemaValidator:
             `None` if the schema has no default value, otherwise a [`Some`][pydantic_core.Some] containing the default.
         """
 
-_IncEx: TypeAlias = set[int] | set[str] | dict[int, _IncEx] | dict[str, _IncEx] | None
+_IncEx: TypeAlias = set[int] | set[str] | dict[int, _IncEx | bool] | dict[str, _IncEx | bool]
 
 @final
 class SchemaSerializer:
@@ -260,8 +260,8 @@ class SchemaSerializer:
         value: Any,
         *,
         mode: str | None = None,
-        include: _IncEx = None,
-        exclude: _IncEx = None,
+        include: _IncEx | None = None,
+        exclude: _IncEx | None = None,
         by_alias: bool = True,
         exclude_unset: bool = False,
         exclude_defaults: bool = False,
@@ -306,8 +306,8 @@ class SchemaSerializer:
         value: Any,
         *,
         indent: int | None = None,
-        include: _IncEx = None,
-        exclude: _IncEx = None,
+        include: _IncEx | None = None,
+        exclude: _IncEx | None = None,
         by_alias: bool = True,
         exclude_unset: bool = False,
         exclude_defaults: bool = False,
@@ -351,8 +351,8 @@ def to_json(
     value: Any,
     *,
     indent: int | None = None,
-    include: _IncEx = None,
-    exclude: _IncEx = None,
+    include: _IncEx | None = None,
+    exclude: _IncEx | None = None,
     by_alias: bool = True,
     exclude_none: bool = False,
     round_trip: bool = False,
@@ -426,8 +426,8 @@ def from_json(
 def to_jsonable_python(
     value: Any,
     *,
-    include: _IncEx = None,
-    exclude: _IncEx = None,
+    include: _IncEx | None = None,
+    exclude: _IncEx | None = None,
     by_alias: bool = True,
     exclude_none: bool = False,
     round_trip: bool = False,

From ba8eab4acba8ad04c45f27a58a5d001c8f212361 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Sat, 7 Sep 2024 09:50:50 -0500
Subject: [PATCH 371/550] Bump version to v2.23.3 (#1444)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 74dd6c31b..f7acd7801 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -425,7 +425,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.23.2"
+version = "2.23.3"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index 4597d2431..8cc5be11d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.23.2"
+version = "2.23.3"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From 16331d71a7fcf6134d7b3e8ed73b2e1efb65be7f Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Mon, 16 Sep 2024 16:40:50 +0200
Subject: [PATCH 372/550] Fix variance issue in `_IncEx` type alias, only allow
 `True` (#1453)

---
 python/pydantic_core/_pydantic_core.pyi | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index 271601bfa..e195cbb41 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -1,4 +1,5 @@
 import datetime
+from collections.abc import Mapping
 from typing import Any, Callable, Generic, Literal, TypeVar, final
 
 from _typeshed import SupportsAllComparisons
@@ -237,7 +238,7 @@ class SchemaValidator:
             `None` if the schema has no default value, otherwise a [`Some`][pydantic_core.Some] containing the default.
         """
 
-_IncEx: TypeAlias = set[int] | set[str] | dict[int, _IncEx | bool] | dict[str, _IncEx | bool]
+_IncEx: TypeAlias = set[int] | set[str] | Mapping[int, _IncEx | Literal[True]] | Mapping[str, _IncEx | Literal[True]]
 
 @final
 class SchemaSerializer:

From 4a0c332b94c5690ca2e79b970090b68a0ed4468e Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Mon, 16 Sep 2024 10:31:45 -0500
Subject: [PATCH 373/550] Clean up serialization warnings for invalid data in
 unions (#1449)

---
 src/serializers/extra.rs                  |  10 ++-
 src/serializers/type_serializers/union.rs | 100 +++++++---------------
 tests/serializers/test_model.py           |   5 +-
 tests/serializers/test_union.py           |  16 +++-
 4 files changed, 51 insertions(+), 80 deletions(-)

diff --git a/src/serializers/extra.rs b/src/serializers/extra.rs
index 963fcea8c..ba47445b5 100644
--- a/src/serializers/extra.rs
+++ b/src/serializers/extra.rs
@@ -392,7 +392,15 @@ impl CollectWarnings {
         if value.is_none() {
             Ok(())
         } else if extra.check.enabled() {
-            Err(PydanticSerializationUnexpectedValue::new_err(None))
+            let type_name = value
+                .get_type()
+                .qualname()
+                .unwrap_or_else(|_| PyString::new_bound(value.py(), "<unknown python object>"));
+
+            let value_str = truncate_safe_repr(value, None);
+            Err(PydanticSerializationUnexpectedValue::new_err(Some(format!(
+                "Expected `{field_type}` but got `{type_name}` with value `{value_str}` - serialized value may not be as expected"
+            ))))
         } else {
             self.fallback_warning(field_type, value);
             Ok(())
diff --git a/src/serializers/type_serializers/union.rs b/src/serializers/type_serializers/union.rs
index 46ec5312e..24544a971 100644
--- a/src/serializers/type_serializers/union.rs
+++ b/src/serializers/type_serializers/union.rs
@@ -8,9 +8,7 @@ use std::borrow::Cow;
 use crate::build_tools::py_schema_err;
 use crate::common::union::{Discriminator, SMALL_UNION_THRESHOLD};
 use crate::definitions::DefinitionsBuilder;
-use crate::serializers::type_serializers::py_err_se_err;
 use crate::tools::{truncate_safe_repr, SchemaDict};
-use crate::PydanticSerializationUnexpectedValue;
 
 use super::{
     infer_json_key, infer_serialize, infer_to_python, BuildSerializer, CombinedSerializer, Extra, SerCheck,
@@ -77,7 +75,6 @@ fn to_python(
     exclude: Option<&Bound<'_, PyAny>>,
     extra: &Extra,
     choices: &[CombinedSerializer],
-    name: &str,
     retry_with_lax_check: bool,
 ) -> PyResult<PyObject> {
     // try the serializers in left to right order with error_on fallback=true
@@ -88,22 +85,15 @@ fn to_python(
     for comb_serializer in choices {
         match comb_serializer.to_python(value, include, exclude, &new_extra) {
             Ok(v) => return Ok(v),
-            Err(err) => match err.is_instance_of::<PydanticSerializationUnexpectedValue>(value.py()) {
-                true => (),
-                false => errors.push(err),
-            },
+            Err(err) => errors.push(err),
         }
     }
 
     if retry_with_lax_check {
         new_extra.check = SerCheck::Lax;
         for comb_serializer in choices {
-            match comb_serializer.to_python(value, include, exclude, &new_extra) {
-                Ok(v) => return Ok(v),
-                Err(err) => match err.is_instance_of::<PydanticSerializationUnexpectedValue>(value.py()) {
-                    true => (),
-                    false => errors.push(err),
-                },
+            if let Ok(v) = comb_serializer.to_python(value, include, exclude, &new_extra) {
+                return Ok(v);
             }
         }
     }
@@ -112,7 +102,6 @@ fn to_python(
         extra.warnings.custom_warning(err.to_string());
     }
 
-    extra.warnings.on_fallback_py(name, value, extra)?;
     infer_to_python(value, include, exclude, extra)
 }
 
@@ -120,7 +109,6 @@ fn json_key<'a>(
     key: &'a Bound<'_, PyAny>,
     extra: &Extra,
     choices: &[CombinedSerializer],
-    name: &str,
     retry_with_lax_check: bool,
 ) -> PyResult<Cow<'a, str>> {
     let mut new_extra = extra.clone();
@@ -130,22 +118,15 @@ fn json_key<'a>(
     for comb_serializer in choices {
         match comb_serializer.json_key(key, &new_extra) {
             Ok(v) => return Ok(v),
-            Err(err) => match err.is_instance_of::<PydanticSerializationUnexpectedValue>(key.py()) {
-                true => (),
-                false => errors.push(err),
-            },
+            Err(err) => errors.push(err),
         }
     }
 
     if retry_with_lax_check {
         new_extra.check = SerCheck::Lax;
         for comb_serializer in choices {
-            match comb_serializer.json_key(key, &new_extra) {
-                Ok(v) => return Ok(v),
-                Err(err) => match err.is_instance_of::<PydanticSerializationUnexpectedValue>(key.py()) {
-                    true => (),
-                    false => errors.push(err),
-                },
+            if let Ok(v) = comb_serializer.json_key(key, &new_extra) {
+                return Ok(v);
             }
         }
     }
@@ -154,7 +135,6 @@ fn json_key<'a>(
         extra.warnings.custom_warning(err.to_string());
     }
 
-    extra.warnings.on_fallback_py(name, key, extra)?;
     infer_json_key(key, extra)
 }
 
@@ -166,7 +146,6 @@ fn serde_serialize<S: serde::ser::Serializer>(
     exclude: Option<&Bound<'_, PyAny>>,
     extra: &Extra,
     choices: &[CombinedSerializer],
-    name: &str,
     retry_with_lax_check: bool,
 ) -> Result<S::Ok, S::Error> {
     let py = value.py();
@@ -177,22 +156,15 @@ fn serde_serialize<S: serde::ser::Serializer>(
     for comb_serializer in choices {
         match comb_serializer.to_python(value, include, exclude, &new_extra) {
             Ok(v) => return infer_serialize(v.bind(py), serializer, None, None, extra),
-            Err(err) => match err.is_instance_of::<PydanticSerializationUnexpectedValue>(py) {
-                true => (),
-                false => errors.push(err),
-            },
+            Err(err) => errors.push(err),
         }
     }
 
     if retry_with_lax_check {
         new_extra.check = SerCheck::Lax;
         for comb_serializer in choices {
-            match comb_serializer.to_python(value, include, exclude, &new_extra) {
-                Ok(v) => return infer_serialize(v.bind(py), serializer, None, None, extra),
-                Err(err) => match err.is_instance_of::<PydanticSerializationUnexpectedValue>(py) {
-                    true => (),
-                    false => errors.push(err),
-                },
+            if let Ok(v) = comb_serializer.to_python(value, include, exclude, &new_extra) {
+                return infer_serialize(v.bind(py), serializer, None, None, extra);
             }
         }
     }
@@ -201,7 +173,6 @@ fn serde_serialize<S: serde::ser::Serializer>(
         extra.warnings.custom_warning(err.to_string());
     }
 
-    extra.warnings.on_fallback_ser::<S>(name, value, extra)?;
     infer_serialize(value, serializer, include, exclude, extra)
 }
 
@@ -219,13 +190,12 @@ impl TypeSerializer for UnionSerializer {
             exclude,
             extra,
             &self.choices,
-            self.get_name(),
             self.retry_with_lax_check(),
         )
     }
 
     fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
-        json_key(key, extra, &self.choices, self.get_name(), self.retry_with_lax_check())
+        json_key(key, extra, &self.choices, self.retry_with_lax_check())
     }
 
     fn serde_serialize<S: serde::ser::Serializer>(
@@ -243,7 +213,6 @@ impl TypeSerializer for UnionSerializer {
             exclude,
             extra,
             &self.choices,
-            self.get_name(),
             self.retry_with_lax_check(),
         )
     }
@@ -313,8 +282,6 @@ impl TypeSerializer for TaggedUnionSerializer {
         exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
-        let py = value.py();
-
         let mut new_extra = extra.clone();
         new_extra.check = SerCheck::Strict;
 
@@ -325,15 +292,14 @@ impl TypeSerializer for TaggedUnionSerializer {
 
                 match serializer.to_python(value, include, exclude, &new_extra) {
                     Ok(v) => return Ok(v),
-                    Err(err) => match err.is_instance_of::<PydanticSerializationUnexpectedValue>(py) {
-                        true => {
-                            if self.retry_with_lax_check() {
-                                new_extra.check = SerCheck::Lax;
-                                return serializer.to_python(value, include, exclude, &new_extra);
+                    Err(_) => {
+                        if self.retry_with_lax_check() {
+                            new_extra.check = SerCheck::Lax;
+                            if let Ok(v) = serializer.to_python(value, include, exclude, &new_extra) {
+                                return Ok(v);
                             }
                         }
-                        false => return Err(err),
-                    },
+                    }
                 }
             }
         }
@@ -344,13 +310,11 @@ impl TypeSerializer for TaggedUnionSerializer {
             exclude,
             extra,
             &self.choices,
-            self.get_name(),
             self.retry_with_lax_check(),
         )
     }
 
     fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
-        let py = key.py();
         let mut new_extra = extra.clone();
         new_extra.check = SerCheck::Strict;
 
@@ -361,20 +325,19 @@ impl TypeSerializer for TaggedUnionSerializer {
 
                 match serializer.json_key(key, &new_extra) {
                     Ok(v) => return Ok(v),
-                    Err(err) => match err.is_instance_of::<PydanticSerializationUnexpectedValue>(py) {
-                        true => {
-                            if self.retry_with_lax_check() {
-                                new_extra.check = SerCheck::Lax;
-                                return serializer.json_key(key, &new_extra);
+                    Err(_) => {
+                        if self.retry_with_lax_check() {
+                            new_extra.check = SerCheck::Lax;
+                            if let Ok(v) = serializer.json_key(key, &new_extra) {
+                                return Ok(v);
                             }
                         }
-                        false => return Err(err),
-                    },
+                    }
                 }
             }
         }
 
-        json_key(key, extra, &self.choices, self.get_name(), self.retry_with_lax_check())
+        json_key(key, extra, &self.choices, self.retry_with_lax_check())
     }
 
     fn serde_serialize<S: serde::ser::Serializer>(
@@ -396,18 +359,14 @@ impl TypeSerializer for TaggedUnionSerializer {
 
                 match selected_serializer.to_python(value, include, exclude, &new_extra) {
                     Ok(v) => return infer_serialize(v.bind(py), serializer, None, None, extra),
-                    Err(err) => match err.is_instance_of::<PydanticSerializationUnexpectedValue>(py) {
-                        true => {
-                            if self.retry_with_lax_check() {
-                                new_extra.check = SerCheck::Lax;
-                                match selected_serializer.to_python(value, include, exclude, &new_extra) {
-                                    Ok(v) => return infer_serialize(v.bind(py), serializer, None, None, extra),
-                                    Err(err) => return Err(py_err_se_err(err)),
-                                }
+                    Err(_) => {
+                        if self.retry_with_lax_check() {
+                            new_extra.check = SerCheck::Lax;
+                            if let Ok(v) = selected_serializer.to_python(value, include, exclude, &new_extra) {
+                                return infer_serialize(v.bind(py), serializer, None, None, extra);
                             }
                         }
-                        false => return Err(py_err_se_err(err)),
-                    },
+                    }
                 }
             }
         }
@@ -419,7 +378,6 @@ impl TypeSerializer for TaggedUnionSerializer {
             exclude,
             extra,
             &self.choices,
-            self.get_name(),
             self.retry_with_lax_check(),
         )
     }
diff --git a/tests/serializers/test_model.py b/tests/serializers/test_model.py
index 9735cd0d3..9fa44032a 100644
--- a/tests/serializers/test_model.py
+++ b/tests/serializers/test_model.py
@@ -15,7 +15,6 @@
 
 from pydantic_core import (
     PydanticSerializationError,
-    PydanticSerializationUnexpectedValue,
     SchemaSerializer,
     SchemaValidator,
     core_schema,
@@ -1150,8 +1149,6 @@ class BModel(BasicModel): ...
         )
     )
 
-    with pytest.raises(
-        PydanticSerializationUnexpectedValue, match='Expected 2 fields but got 1 for type `.*AModel` with value `.*`.+'
-    ):
+    with pytest.warns(UserWarning, match='Expected 2 fields but got 1 for type `.*AModel` with value `.*`.+'):
         value = BasicModel(root=AModel(type='a'))
         s.to_python(value)
diff --git a/tests/serializers/test_union.py b/tests/serializers/test_union.py
index 342f12cf4..8b6d6f128 100644
--- a/tests/serializers/test_union.py
+++ b/tests/serializers/test_union.py
@@ -1,7 +1,7 @@
 import dataclasses
 import json
-import re
 import uuid
+import warnings
 from decimal import Decimal
 from typing import Any, ClassVar, Union
 
@@ -32,9 +32,17 @@ def test_union_bool_int(input_value, expected_value, bool_case_label, int_case_l
 
 def test_union_error():
     s = SchemaSerializer(core_schema.union_schema([core_schema.bool_schema(), core_schema.int_schema()]))
-    msg = "Expected `Union[bool, int]` but got `str` with value `'a string'` - serialized value may not be as expected"
-    with pytest.warns(UserWarning, match=re.escape(msg)):
-        assert s.to_python('a string') == 'a string'
+
+    messages = [
+        "Expected `bool` but got `str` with value `'a string'` - serialized value may not be as expected",
+        "Expected `int` but got `str` with value `'a string'` - serialized value may not be as expected",
+    ]
+
+    with warnings.catch_warnings(record=True) as w:
+        warnings.simplefilter('always')
+        s.to_python('a string')
+        for m in messages:
+            assert m in str(w[0].message)
 
 
 class ModelA:

From dbe03f68e720462752ebac03cd669e0ac53c8d9a Mon Sep 17 00:00:00 2001
From: sydney-runkle <sydneymarierunkle@gmail.com>
Date: Mon, 16 Sep 2024 11:35:31 -0400
Subject: [PATCH 374/550] version bump

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index f7acd7801..38f11f369 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -425,7 +425,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.23.3"
+version = "2.23.4"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index 8cc5be11d..0871b8a5d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.23.3"
+version = "2.23.4"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From bc0c97add770e047cbb4e797ce1db4a42fb30fd9 Mon Sep 17 00:00:00 2001
From: Bas Schoenmaeckers <7943856+bschoenmaeckers@users.noreply.github.com>
Date: Tue, 17 Sep 2024 14:08:06 +0200
Subject: [PATCH 375/550] Do not require padding when decoding base64 bytes
 (#1448)

---
 src/validators/config.rs | 18 ++++++++++++++----
 tests/test_json.py       |  6 ++++++
 2 files changed, 20 insertions(+), 4 deletions(-)

diff --git a/src/validators/config.rs b/src/validators/config.rs
index a43a7643a..a14104628 100644
--- a/src/validators/config.rs
+++ b/src/validators/config.rs
@@ -1,8 +1,9 @@
 use std::borrow::Cow;
 use std::str::FromStr;
 
-use base64::engine::general_purpose::{STANDARD, URL_SAFE};
-use base64::{DecodeError, Engine};
+use base64::engine::general_purpose::GeneralPurpose;
+use base64::engine::{DecodePaddingMode, GeneralPurposeConfig};
+use base64::{alphabet, DecodeError, Engine};
 use pyo3::types::{PyDict, PyString};
 use pyo3::{intern, prelude::*};
 
@@ -11,6 +12,15 @@ use crate::input::EitherBytes;
 use crate::serializers::BytesMode;
 use crate::tools::SchemaDict;
 
+const URL_SAFE_OPTIONAL_PADDING: GeneralPurpose = GeneralPurpose::new(
+    &alphabet::URL_SAFE,
+    GeneralPurposeConfig::new().with_decode_padding_mode(DecodePaddingMode::Indifferent),
+);
+const STANDARD_OPTIONAL_PADDING: GeneralPurpose = GeneralPurpose::new(
+    &alphabet::STANDARD,
+    GeneralPurposeConfig::new().with_decode_padding_mode(DecodePaddingMode::Indifferent),
+);
+
 #[derive(Default, Debug, Clone, Copy, PartialEq, Eq)]
 pub struct ValBytesMode {
     pub ser: BytesMode,
@@ -29,10 +39,10 @@ impl ValBytesMode {
     pub fn deserialize_string<'py>(self, s: &str) -> Result<EitherBytes<'_, 'py>, ErrorType> {
         match self.ser {
             BytesMode::Utf8 => Ok(EitherBytes::Cow(Cow::Borrowed(s.as_bytes()))),
-            BytesMode::Base64 => URL_SAFE
+            BytesMode::Base64 => URL_SAFE_OPTIONAL_PADDING
                 .decode(s)
                 .or_else(|err| match err {
-                    DecodeError::InvalidByte(_, b'/' | b'+') => STANDARD.decode(s),
+                    DecodeError::InvalidByte(_, b'/' | b'+') => STANDARD_OPTIONAL_PADDING.decode(s),
                     _ => Err(err),
                 })
                 .map(EitherBytes::from)
diff --git a/tests/test_json.py b/tests/test_json.py
index f22850704..c78ed3ad0 100644
--- a/tests/test_json.py
+++ b/tests/test_json.py
@@ -401,6 +401,12 @@ def test_json_bytes_base64_round_trip():
     assert v.validate_json(b'{"key":' + encoded_url + b'}') == {'key': data}
 
 
+def test_json_bytes_base64_no_padding():
+    v = SchemaValidator({'type': 'bytes'}, {'val_json_bytes': 'base64'})
+    base_64_without_padding = 'bm8tcGFkZGluZw'
+    assert v.validate_json(json.dumps(base_64_without_padding)) == b'no-padding'
+
+
 def test_json_bytes_base64_invalid():
     v = SchemaValidator({'type': 'bytes'}, {'val_json_bytes': 'base64'})
     wrong_input = 'wrong!'

From e0b4c94054b4bca649d63a8f18843c3baadee1c4 Mon Sep 17 00:00:00 2001
From: Oliver Parker <46482091+ollz272@users.noreply.github.com>
Date: Wed, 18 Sep 2024 15:06:17 +0100
Subject: [PATCH 376/550] feat: add 'millisecond' option to ser_json_timedelta
 config parameter (#1427)

Co-authored-by: David Hewitt <mail@davidhewitt.dev>
---
 python/pydantic_core/_pydantic_core.pyi       |   8 +-
 python/pydantic_core/core_schema.py           |   2 +-
 src/input/datetime.rs                         |  87 ++++++++++
 src/serializers/config.rs                     |  42 ++---
 src/serializers/infer.rs                      |   4 +-
 src/serializers/type_serializers/timedelta.rs |   6 +-
 tests/serializers/test_any.py                 | 161 +++++++++++++++---
 tests/serializers/test_pickling.py            |   2 +-
 tests/serializers/test_timedelta.py           |   2 +-
 tests/test_garbage_collection.py              |   2 +-
 10 files changed, 259 insertions(+), 57 deletions(-)

diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index e195cbb41..adff512c9 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -357,7 +357,7 @@ def to_json(
     by_alias: bool = True,
     exclude_none: bool = False,
     round_trip: bool = False,
-    timedelta_mode: Literal['iso8601', 'float'] = 'iso8601',
+    timedelta_mode: Literal['iso8601', 'seconds_float', 'milliseconds_float'] = 'iso8601',
     bytes_mode: Literal['utf8', 'base64', 'hex'] = 'utf8',
     inf_nan_mode: Literal['null', 'constants', 'strings'] = 'constants',
     serialize_unknown: bool = False,
@@ -378,7 +378,7 @@ def to_json(
         by_alias: Whether to use the alias names of fields.
         exclude_none: Whether to exclude fields that have a value of `None`.
         round_trip: Whether to enable serialization and validation round-trip support.
-        timedelta_mode: How to serialize `timedelta` objects, either `'iso8601'` or `'float'`.
+        timedelta_mode: How to serialize `timedelta` objects, either `'iso8601'`, `'seconds_float'` or `'milliseconds_float'`.
         bytes_mode: How to serialize `bytes` objects, either `'utf8'`, `'base64'`, or `'hex'`.
         inf_nan_mode: How to serialize `Infinity`, `-Infinity` and `NaN` values, either `'null'`, `'constants'`, or `'strings'`.
         serialize_unknown: Attempt to serialize unknown types, `str(value)` will be used, if that fails
@@ -432,7 +432,7 @@ def to_jsonable_python(
     by_alias: bool = True,
     exclude_none: bool = False,
     round_trip: bool = False,
-    timedelta_mode: Literal['iso8601', 'float'] = 'iso8601',
+    timedelta_mode: Literal['iso8601', 'seconds_float', 'milliseconds_float'] = 'iso8601',
     bytes_mode: Literal['utf8', 'base64', 'hex'] = 'utf8',
     inf_nan_mode: Literal['null', 'constants', 'strings'] = 'constants',
     serialize_unknown: bool = False,
@@ -453,7 +453,7 @@ def to_jsonable_python(
         by_alias: Whether to use the alias names of fields.
         exclude_none: Whether to exclude fields that have a value of `None`.
         round_trip: Whether to enable serialization and validation round-trip support.
-        timedelta_mode: How to serialize `timedelta` objects, either `'iso8601'` or `'float'`.
+        timedelta_mode: How to serialize `timedelta` objects, either `'iso8601'`, `'seconds_float'`, or`'milliseconds_float'`.
         bytes_mode: How to serialize `bytes` objects, either `'utf8'`, `'base64'`, or `'hex'`.
         inf_nan_mode: How to serialize `Infinity`, `-Infinity` and `NaN` values, either `'null'`, `'constants'`, or `'strings'`.
         serialize_unknown: Attempt to serialize unknown types, `str(value)` will be used, if that fails
diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index 8635b63a5..c5748fd19 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -105,7 +105,7 @@ class CoreConfig(TypedDict, total=False):
     # fields related to float fields only
     allow_inf_nan: bool  # default: True
     # the config options are used to customise serialization to JSON
-    ser_json_timedelta: Literal['iso8601', 'float']  # default: 'iso8601'
+    ser_json_timedelta: Literal['iso8601', 'seconds_float', 'milliseconds_float']  # default: 'iso8601'
     ser_json_bytes: Literal['utf8', 'base64', 'hex']  # default: 'utf8'
     ser_json_inf_nan: Literal['null', 'constants', 'strings']  # default: 'null'
     val_json_bytes: Literal['utf8', 'base64', 'hex']  # default: 'utf8'
diff --git a/src/input/datetime.rs b/src/input/datetime.rs
index 577a91014..db5daff40 100644
--- a/src/input/datetime.rs
+++ b/src/input/datetime.rs
@@ -109,6 +109,93 @@ impl<'a> EitherTimedelta<'a> {
             Self::Raw(duration) => duration_as_pytimedelta(py, duration),
         }
     }
+
+    pub fn total_seconds(&self) -> PyResult<f64> {
+        match self {
+            Self::Raw(timedelta) => {
+                let mut days: i64 = i64::from(timedelta.day);
+                let mut seconds: i64 = i64::from(timedelta.second);
+                let mut microseconds = i64::from(timedelta.microsecond);
+                if !timedelta.positive {
+                    days = -days;
+                    seconds = -seconds;
+                    microseconds = -microseconds;
+                }
+
+                let days_seconds = (86_400 * days) + seconds;
+                if let Some(days_seconds_as_micros) = days_seconds.checked_mul(1_000_000) {
+                    let total_microseconds = days_seconds_as_micros + microseconds;
+                    Ok(total_microseconds as f64 / 1_000_000.0)
+                } else {
+                    // Fall back to floating-point operations if the multiplication overflows
+                    let total_seconds = days_seconds as f64 + microseconds as f64 / 1_000_000.0;
+                    Ok(total_seconds)
+                }
+            }
+            Self::PyExact(py_timedelta) => {
+                let days: i64 = py_timedelta.get_days().into(); // -999999999 to 999999999
+                let seconds: i64 = py_timedelta.get_seconds().into(); // 0 through 86399
+                let microseconds = py_timedelta.get_microseconds(); // 0 through 999999
+                let days_seconds = (86_400 * days) + seconds;
+                if let Some(days_seconds_as_micros) = days_seconds.checked_mul(1_000_000) {
+                    let total_microseconds = days_seconds_as_micros + i64::from(microseconds);
+                    Ok(total_microseconds as f64 / 1_000_000.0)
+                } else {
+                    // Fall back to floating-point operations if the multiplication overflows
+                    let total_seconds = days_seconds as f64 + f64::from(microseconds) / 1_000_000.0;
+                    Ok(total_seconds)
+                }
+            }
+            Self::PySubclass(py_timedelta) => py_timedelta
+                .call_method0(intern!(py_timedelta.py(), "total_seconds"))?
+                .extract(),
+        }
+    }
+
+    pub fn total_milliseconds(&self) -> PyResult<f64> {
+        match self {
+            Self::Raw(timedelta) => {
+                let mut days: i64 = i64::from(timedelta.day);
+                let mut seconds: i64 = i64::from(timedelta.second);
+                let mut microseconds = i64::from(timedelta.microsecond);
+                if !timedelta.positive {
+                    days = -days;
+                    seconds = -seconds;
+                    microseconds = -microseconds;
+                }
+
+                let days_seconds = (86_400 * days) + seconds;
+                if let Some(days_seconds_as_micros) = days_seconds.checked_mul(1_000_000) {
+                    let total_microseconds = days_seconds_as_micros + microseconds;
+                    Ok(total_microseconds as f64 / 1_000.0)
+                } else {
+                    // Fall back to floating-point operations if the multiplication overflows
+                    let total_seconds = days_seconds as f64 + microseconds as f64 / 1_000.0;
+                    Ok(total_seconds)
+                }
+            }
+            Self::PyExact(py_timedelta) => {
+                let days: i64 = py_timedelta.get_days().into(); // -999999999 to 999999999
+                let seconds: i64 = py_timedelta.get_seconds().into(); // 0 through 86399
+                let microseconds = py_timedelta.get_microseconds(); // 0 through 999999
+                let days_seconds = (86_400 * days) + seconds;
+                if let Some(days_seconds_as_micros) = days_seconds.checked_mul(1_000_000) {
+                    let total_microseconds = days_seconds_as_micros + i64::from(microseconds);
+                    Ok(total_microseconds as f64 / 1_000.0)
+                } else {
+                    // Fall back to floating-point operations if the multiplication overflows
+                    let total_milliseconds = days_seconds as f64 * 1_000.0 + f64::from(microseconds) / 1_000.0;
+                    Ok(total_milliseconds)
+                }
+            }
+            Self::PySubclass(py_timedelta) => {
+                let total_seconds: f64 = py_timedelta
+                    .call_method0(intern!(py_timedelta.py(), "total_seconds"))?
+                    .extract()?;
+                Ok(total_seconds / 1000.0)
+            }
+        }
+    }
 }
 
 impl<'a> TryFrom<&'_ Bound<'a, PyAny>> for EitherTimedelta<'a> {
diff --git a/src/serializers/config.rs b/src/serializers/config.rs
index 13a833176..8b1367958 100644
--- a/src/serializers/config.rs
+++ b/src/serializers/config.rs
@@ -4,7 +4,7 @@ use std::str::{from_utf8, FromStr, Utf8Error};
 use base64::Engine;
 use pyo3::intern;
 use pyo3::prelude::*;
-use pyo3::types::{PyDelta, PyDict, PyString};
+use pyo3::types::{PyDict, PyString};
 
 use serde::ser::Error;
 
@@ -88,7 +88,8 @@ serialization_mode! {
     TimedeltaMode,
     "ser_json_timedelta",
     Iso8601 => "iso8601",
-    Float => "float",
+    SecondsFloat => "seconds_float",
+    MillisecondsFloat => "milliseconds_float"
 }
 
 serialization_mode! {
@@ -108,43 +109,42 @@ serialization_mode! {
 }
 
 impl TimedeltaMode {
-    fn total_seconds<'py>(py_timedelta: &Bound<'py, PyDelta>) -> PyResult<Bound<'py, PyAny>> {
-        py_timedelta.call_method0(intern!(py_timedelta.py(), "total_seconds"))
-    }
-
     pub fn either_delta_to_json(self, py: Python, either_delta: &EitherTimedelta) -> PyResult<PyObject> {
         match self {
             Self::Iso8601 => {
                 let d = either_delta.to_duration()?;
                 Ok(d.to_string().into_py(py))
             }
-            Self::Float => {
-                // convert to int via a py timedelta not duration since we know this this case the input would have
-                // been a py timedelta
-                let py_timedelta = either_delta.try_into_py(py)?;
-                let seconds = Self::total_seconds(&py_timedelta)?;
+            Self::SecondsFloat => {
+                let seconds: f64 = either_delta.total_seconds()?;
                 Ok(seconds.into_py(py))
             }
+            Self::MillisecondsFloat => {
+                let milliseconds: f64 = either_delta.total_milliseconds()?;
+                Ok(milliseconds.into_py(py))
+            }
         }
     }
 
-    pub fn json_key<'py>(self, py: Python, either_delta: &EitherTimedelta) -> PyResult<Cow<'py, str>> {
+    pub fn json_key<'py>(self, either_delta: &EitherTimedelta) -> PyResult<Cow<'py, str>> {
         match self {
             Self::Iso8601 => {
                 let d = either_delta.to_duration()?;
                 Ok(d.to_string().into())
             }
-            Self::Float => {
-                let py_timedelta = either_delta.try_into_py(py)?;
-                let seconds: f64 = Self::total_seconds(&py_timedelta)?.extract()?;
+            Self::SecondsFloat => {
+                let seconds: f64 = either_delta.total_seconds()?;
                 Ok(seconds.to_string().into())
             }
+            Self::MillisecondsFloat => {
+                let milliseconds: f64 = either_delta.total_milliseconds()?;
+                Ok(milliseconds.to_string().into())
+            }
         }
     }
 
     pub fn timedelta_serialize<S: serde::ser::Serializer>(
         self,
-        py: Python,
         either_delta: &EitherTimedelta,
         serializer: S,
     ) -> Result<S::Ok, S::Error> {
@@ -153,12 +153,14 @@ impl TimedeltaMode {
                 let d = either_delta.to_duration().map_err(py_err_se_err)?;
                 serializer.serialize_str(&d.to_string())
             }
-            Self::Float => {
-                let py_timedelta = either_delta.try_into_py(py).map_err(py_err_se_err)?;
-                let seconds = Self::total_seconds(&py_timedelta).map_err(py_err_se_err)?;
-                let seconds: f64 = seconds.extract().map_err(py_err_se_err)?;
+            Self::SecondsFloat => {
+                let seconds: f64 = either_delta.total_seconds().map_err(py_err_se_err)?;
                 serializer.serialize_f64(seconds)
             }
+            Self::MillisecondsFloat => {
+                let milliseconds: f64 = either_delta.total_milliseconds().map_err(py_err_se_err)?;
+                serializer.serialize_f64(milliseconds)
+            }
         }
     }
 }
diff --git a/src/serializers/infer.rs b/src/serializers/infer.rs
index 4e6bb504f..f03e890d5 100644
--- a/src/serializers/infer.rs
+++ b/src/serializers/infer.rs
@@ -477,7 +477,7 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
             extra
                 .config
                 .timedelta_mode
-                .timedelta_serialize(value.py(), &either_delta, serializer)
+                .timedelta_serialize(&either_delta, serializer)
         }
         ObType::Url => {
             let py_url: PyUrl = value.extract().map_err(py_err_se_err)?;
@@ -655,7 +655,7 @@ pub(crate) fn infer_json_key_known<'a>(
         }
         ObType::Timedelta => {
             let either_delta = EitherTimedelta::try_from(key)?;
-            extra.config.timedelta_mode.json_key(key.py(), &either_delta)
+            extra.config.timedelta_mode.json_key(&either_delta)
         }
         ObType::Url => {
             let py_url: PyUrl = key.extract()?;
diff --git a/src/serializers/type_serializers/timedelta.rs b/src/serializers/type_serializers/timedelta.rs
index a62b595d0..acc604732 100644
--- a/src/serializers/type_serializers/timedelta.rs
+++ b/src/serializers/type_serializers/timedelta.rs
@@ -54,7 +54,7 @@ impl TypeSerializer for TimeDeltaSerializer {
 
     fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         match EitherTimedelta::try_from(key) {
-            Ok(either_timedelta) => self.timedelta_mode.json_key(key.py(), &either_timedelta),
+            Ok(either_timedelta) => self.timedelta_mode.json_key(&either_timedelta),
             Err(_) => {
                 extra.warnings.on_fallback_py(self.get_name(), key, extra)?;
                 infer_json_key(key, extra)
@@ -71,9 +71,7 @@ impl TypeSerializer for TimeDeltaSerializer {
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         match EitherTimedelta::try_from(value) {
-            Ok(either_timedelta) => self
-                .timedelta_mode
-                .timedelta_serialize(value.py(), &either_timedelta, serializer),
+            Ok(either_timedelta) => self.timedelta_mode.timedelta_serialize(&either_timedelta, serializer),
             Err(_) => {
                 extra.warnings.on_fallback_ser::<S>(self.get_name(), value, extra)?;
                 infer_serialize(value, serializer, include, exclude, extra)
diff --git a/tests/serializers/test_any.py b/tests/serializers/test_any.py
index 344e0ff02..9fbc8ac03 100644
--- a/tests/serializers/test_any.py
+++ b/tests/serializers/test_any.py
@@ -177,28 +177,139 @@ def test_any_with_timedelta_serializer():
     ]
 
 
-def test_any_config_timedelta_float():
-    s = SchemaSerializer(core_schema.any_schema(), config={'ser_json_timedelta': 'float'})
-    h2 = timedelta(hours=2)
-    assert s.to_python(h2) == h2
-    assert s.to_python(h2, mode='json') == 7200.0
-    assert s.to_json(h2) == b'7200.0'
-
-    assert s.to_python({h2: 'foo'}) == {h2: 'foo'}
-    assert s.to_python({h2: 'foo'}, mode='json') == {'7200': 'foo'}
-    assert s.to_json({h2: 'foo'}) == b'{"7200":"foo"}'
-
-
-def test_any_config_timedelta_float_faction():
-    s = SchemaSerializer(core_schema.any_schema(), config={'ser_json_timedelta': 'float'})
-    one_half_s = timedelta(seconds=1.5)
-    assert s.to_python(one_half_s) == one_half_s
-    assert s.to_python(one_half_s, mode='json') == 1.5
-    assert s.to_json(one_half_s) == b'1.5'
+@pytest.mark.parametrize(
+    'td,expected_to_python,expected_to_json,expected_to_python_dict,expected_to_json_dict,mode',
+    [
+        (timedelta(hours=2), 7200000.0, b'7200000.0', {'7200000': 'foo'}, b'{"7200000":"foo"}', 'milliseconds_float'),
+        (
+            timedelta(hours=-2),
+            -7200000.0,
+            b'-7200000.0',
+            {'-7200000': 'foo'},
+            b'{"-7200000":"foo"}',
+            'milliseconds_float',
+        ),
+        (timedelta(seconds=1.5), 1500.0, b'1500.0', {'1500': 'foo'}, b'{"1500":"foo"}', 'milliseconds_float'),
+        (timedelta(seconds=-1.5), -1500.0, b'-1500.0', {'-1500': 'foo'}, b'{"-1500":"foo"}', 'milliseconds_float'),
+        (timedelta(microseconds=1), 0.001, b'0.001', {'0.001': 'foo'}, b'{"0.001":"foo"}', 'milliseconds_float'),
+        (
+            timedelta(microseconds=-1),
+            -0.001,
+            b'-0.001',
+            {'-0.001': 'foo'},
+            b'{"-0.001":"foo"}',
+            'milliseconds_float',
+        ),
+        (
+            timedelta(days=1),
+            86400000.0,
+            b'86400000.0',
+            {'86400000': 'foo'},
+            b'{"86400000":"foo"}',
+            'milliseconds_float',
+        ),
+        (
+            timedelta(days=-1),
+            -86400000.0,
+            b'-86400000.0',
+            {'-86400000': 'foo'},
+            b'{"-86400000":"foo"}',
+            'milliseconds_float',
+        ),
+        (
+            timedelta(days=1, seconds=1),
+            86401000.0,
+            b'86401000.0',
+            {'86401000': 'foo'},
+            b'{"86401000":"foo"}',
+            'milliseconds_float',
+        ),
+        (
+            timedelta(days=-1, seconds=-1),
+            -86401000.0,
+            b'-86401000.0',
+            {'-86401000': 'foo'},
+            b'{"-86401000":"foo"}',
+            'milliseconds_float',
+        ),
+        (
+            timedelta(days=1, seconds=-1),
+            86399000.0,
+            b'86399000.0',
+            {'86399000': 'foo'},
+            b'{"86399000":"foo"}',
+            'milliseconds_float',
+        ),
+        (
+            timedelta(days=1, seconds=1, microseconds=1),
+            86401000.001,
+            b'86401000.001',
+            {'86401000.001': 'foo'},
+            b'{"86401000.001":"foo"}',
+            'milliseconds_float',
+        ),
+        (
+            timedelta(days=-1, seconds=-1, microseconds=-1),
+            -86401000.001,
+            b'-86401000.001',
+            {'-86401000.001': 'foo'},
+            b'{"-86401000.001":"foo"}',
+            'milliseconds_float',
+        ),
+        (timedelta(hours=2), 7200.0, b'7200.0', {'7200': 'foo'}, b'{"7200":"foo"}', 'seconds_float'),
+        (timedelta(hours=-2), -7200.0, b'-7200.0', {'-7200': 'foo'}, b'{"-7200":"foo"}', 'seconds_float'),
+        (timedelta(seconds=1.5), 1.5, b'1.5', {'1.5': 'foo'}, b'{"1.5":"foo"}', 'seconds_float'),
+        (timedelta(seconds=-1.5), -1.5, b'-1.5', {'-1.5': 'foo'}, b'{"-1.5":"foo"}', 'seconds_float'),
+        (timedelta(microseconds=1), 1e-6, b'1e-6', {'0.000001': 'foo'}, b'{"0.000001":"foo"}', 'seconds_float'),
+        (
+            timedelta(microseconds=-1),
+            -1e-6,
+            b'-1e-6',
+            {'-0.000001': 'foo'},
+            b'{"-0.000001":"foo"}',
+            'seconds_float',
+        ),
+        (timedelta(days=1), 86400.0, b'86400.0', {'86400': 'foo'}, b'{"86400":"foo"}', 'seconds_float'),
+        (timedelta(days=-1), -86400.0, b'-86400.0', {'-86400': 'foo'}, b'{"-86400":"foo"}', 'seconds_float'),
+        (timedelta(days=1, seconds=1), 86401.0, b'86401.0', {'86401': 'foo'}, b'{"86401":"foo"}', 'seconds_float'),
+        (
+            timedelta(days=-1, seconds=-1),
+            -86401.0,
+            b'-86401.0',
+            {'-86401': 'foo'},
+            b'{"-86401":"foo"}',
+            'seconds_float',
+        ),
+        (timedelta(days=1, seconds=-1), 86399.0, b'86399.0', {'86399': 'foo'}, b'{"86399":"foo"}', 'seconds_float'),
+        (
+            timedelta(days=1, seconds=1, microseconds=1),
+            86401.000001,
+            b'86401.000001',
+            {'86401.000001': 'foo'},
+            b'{"86401.000001":"foo"}',
+            'seconds_float',
+        ),
+        (
+            timedelta(days=-1, seconds=-1, microseconds=-1),
+            -86401.000001,
+            b'-86401.000001',
+            {'-86401.000001': 'foo'},
+            b'{"-86401.000001":"foo"}',
+            'seconds_float',
+        ),
+    ],
+)
+def test_any_config_timedelta(
+    td: timedelta, expected_to_python, expected_to_json, expected_to_python_dict, expected_to_json_dict, mode
+):
+    s = SchemaSerializer(core_schema.any_schema(), config={'ser_json_timedelta': mode})
+    assert s.to_python(td) == td
+    assert s.to_python(td, mode='json') == expected_to_python
+    assert s.to_json(td) == expected_to_json
 
-    assert s.to_python({one_half_s: 'foo'}) == {one_half_s: 'foo'}
-    assert s.to_python({one_half_s: 'foo'}, mode='json') == {'1.5': 'foo'}
-    assert s.to_json({one_half_s: 'foo'}) == b'{"1.5":"foo"}'
+    assert s.to_python({td: 'foo'}) == {td: 'foo'}
+    assert s.to_python({td: 'foo'}, mode='json') == expected_to_python_dict
+    assert s.to_json({td: 'foo'}) == expected_to_json_dict
 
 
 def test_recursion(any_serializer):
@@ -422,9 +533,13 @@ def test_base64():
         (lambda: datetime(2032, 1, 1), {}, b'"2032-01-01T00:00:00"'),
         (lambda: time(12, 34, 56), {}, b'"12:34:56"'),
         (lambda: timedelta(days=12, seconds=34, microseconds=56), {}, b'"P12DT34.000056S"'),
-        (lambda: timedelta(days=12, seconds=34, microseconds=56), dict(timedelta_mode='float'), b'1036834.000056'),
+        (
+            lambda: timedelta(days=12, seconds=34, microseconds=56),
+            dict(timedelta_mode='seconds_float'),
+            b'1036834.000056',
+        ),
         (lambda: timedelta(seconds=-1), {}, b'"-PT1S"'),
-        (lambda: timedelta(seconds=-1), dict(timedelta_mode='float'), b'-1.0'),
+        (lambda: timedelta(seconds=-1), dict(timedelta_mode='seconds_float'), b'-1.0'),
         (lambda: {1, 2, 3}, {}, b'[1,2,3]'),
         (lambda: frozenset([1, 2, 3]), {}, b'[1,2,3]'),
         (lambda: (v for v in range(4)), {}, b'[0,1,2,3]'),
diff --git a/tests/serializers/test_pickling.py b/tests/serializers/test_pickling.py
index 2ca230313..b6bc105d5 100644
--- a/tests/serializers/test_pickling.py
+++ b/tests/serializers/test_pickling.py
@@ -42,7 +42,7 @@ def test_schema_serializer_capturing_function(value, expected_python, expected_j
 
 
 def test_schema_serializer_containing_config():
-    s = SchemaSerializer(core_schema.timedelta_schema(), config={'ser_json_timedelta': 'float'})
+    s = SchemaSerializer(core_schema.timedelta_schema(), config={'ser_json_timedelta': 'seconds_float'})
     s = pickle.loads(pickle.dumps(s))
 
     assert s.to_python(timedelta(seconds=4, microseconds=500_000)) == timedelta(seconds=4, microseconds=500_000)
diff --git a/tests/serializers/test_timedelta.py b/tests/serializers/test_timedelta.py
index 19abb673d..9fcc9d362 100644
--- a/tests/serializers/test_timedelta.py
+++ b/tests/serializers/test_timedelta.py
@@ -31,7 +31,7 @@ def test_timedelta():
 
 
 def test_timedelta_float():
-    v = SchemaSerializer(core_schema.timedelta_schema(), config={'ser_json_timedelta': 'float'})
+    v = SchemaSerializer(core_schema.timedelta_schema(), config={'ser_json_timedelta': 'seconds_float'})
     assert v.to_python(timedelta(seconds=4, microseconds=500_000)) == timedelta(seconds=4, microseconds=500_000)
 
     assert v.to_python(timedelta(seconds=4, microseconds=500_000), mode='json') == 4.5
diff --git a/tests/test_garbage_collection.py b/tests/test_garbage_collection.py
index f4e178f26..803979aa9 100644
--- a/tests/test_garbage_collection.py
+++ b/tests/test_garbage_collection.py
@@ -28,7 +28,7 @@ class BaseModel:
 
         def __init_subclass__(cls) -> None:
             cls.__schema__ = SchemaSerializer(
-                core_schema.model_schema(cls, GC_TEST_SCHEMA_INNER), config={'ser_json_timedelta': 'float'}
+                core_schema.model_schema(cls, GC_TEST_SCHEMA_INNER), config={'ser_json_timedelta': 'seconds_float'}
             )
 
     cache: 'WeakValueDictionary[int, Any]' = WeakValueDictionary()

From 8c1a0da3a3a2cba8af119de1030e04b920aa0bf0 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Fri, 20 Sep 2024 07:57:16 -0500
Subject: [PATCH 377/550] Support wider variety of enum validation cases
 (#1456)

---
 src/validators/enum_.rs        |  11 ++-
 tests/validators/test_enums.py | 143 +++++++++++++++++++++++++++++++++
 tests/validators/test_model.py |  65 +++++++++++++++
 3 files changed, 216 insertions(+), 3 deletions(-)

diff --git a/src/validators/enum_.rs b/src/validators/enum_.rs
index 0449a95da..73589d806 100644
--- a/src/validators/enum_.rs
+++ b/src/validators/enum_.rs
@@ -116,11 +116,15 @@ impl<T: EnumValidateValue> Validator for EnumValidator<T> {
                 },
                 input,
             ));
-        } else if let Some(v) = T::validate_value(py, input, &self.lookup, strict)? {
-            state.floor_exactness(Exactness::Lax);
+        }
+
+        state.floor_exactness(Exactness::Lax);
+
+        if let Some(v) = T::validate_value(py, input, &self.lookup, strict)? {
             return Ok(v);
+        } else if let Ok(res) = class.as_unbound().call1(py, (input.as_python(),)) {
+            return Ok(res);
         } else if let Some(ref missing) = self.missing {
-            state.floor_exactness(Exactness::Lax);
             let enum_value = missing.bind(py).call1((input.to_object(py),)).map_err(|_| {
                 ValError::new(
                     ErrorType::Enum {
@@ -146,6 +150,7 @@ impl<T: EnumValidateValue> Validator for EnumValidator<T> {
                 return Err(type_error.into());
             }
         }
+
         Err(ValError::new(
             ErrorType::Enum {
                 expected: self.expected_repr.clone(),
diff --git a/tests/validators/test_enums.py b/tests/validators/test_enums.py
index a4fb3c5c2..83e286417 100644
--- a/tests/validators/test_enums.py
+++ b/tests/validators/test_enums.py
@@ -1,5 +1,6 @@
 import re
 import sys
+from decimal import Decimal
 from enum import Enum, IntEnum, IntFlag
 
 import pytest
@@ -344,3 +345,145 @@ class ColorEnum(IntEnum):
 
     assert v.validate_python(ColorEnum.GREEN) is ColorEnum.GREEN
     assert v.validate_python(1 << 63) is ColorEnum.GREEN
+
+
+@pytest.mark.parametrize(
+    'value',
+    [-1, 0, 1],
+)
+def test_enum_int_validation_should_succeed_for_decimal(value: int):
+    class MyEnum(Enum):
+        VALUE = value
+
+    class MyIntEnum(IntEnum):
+        VALUE = value
+
+    v = SchemaValidator(
+        core_schema.with_default_schema(
+            schema=core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values())),
+            default=MyEnum.VALUE,
+        )
+    )
+
+    v_int = SchemaValidator(
+        core_schema.with_default_schema(
+            schema=core_schema.enum_schema(MyIntEnum, list(MyIntEnum.__members__.values())),
+            default=MyIntEnum.VALUE,
+        )
+    )
+
+    assert v.validate_python(Decimal(value)) is MyEnum.VALUE
+    assert v.validate_python(Decimal(float(value))) is MyEnum.VALUE
+    assert v_int.validate_python(Decimal(value)) is MyIntEnum.VALUE
+    assert v_int.validate_python(Decimal(float(value))) is MyIntEnum.VALUE
+
+
+@pytest.mark.skipif(
+    sys.version_info >= (3, 13),
+    reason='Python 3.13+ enum initialization is different, see https://github.com/python/cpython/blob/ec610069637d56101896803a70d418a89afe0b4b/Lib/enum.py#L1159-L1163',
+)
+def test_enum_int_validation_should_succeed_for_custom_type():
+    class AnyWrapper:
+        def __init__(self, value):
+            self.value = value
+
+        def __eq__(self, other: object) -> bool:
+            return self.value == other
+
+    class MyEnum(Enum):
+        VALUE = 999
+        SECOND_VALUE = 1000000
+        THIRD_VALUE = 'Py03'
+
+    v = SchemaValidator(
+        core_schema.with_default_schema(
+            schema=core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values())),
+            default=MyEnum.VALUE,
+        )
+    )
+
+    assert v.validate_python(AnyWrapper(999)) is MyEnum.VALUE
+    assert v.validate_python(AnyWrapper(1000000)) is MyEnum.SECOND_VALUE
+    assert v.validate_python(AnyWrapper('Py03')) is MyEnum.THIRD_VALUE
+
+
+def test_enum_str_validation_should_fail_for_decimal_when_expecting_str_value():
+    class MyEnum(Enum):
+        VALUE = '1'
+
+    v = SchemaValidator(
+        core_schema.with_default_schema(
+            schema=core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values())),
+            default=MyEnum.VALUE,
+        )
+    )
+
+    with pytest.raises(ValidationError):
+        v.validate_python(Decimal(1))
+
+
+def test_enum_int_validation_should_fail_for_incorrect_decimal_value():
+    class MyEnum(Enum):
+        VALUE = 1
+
+    v = SchemaValidator(
+        core_schema.with_default_schema(
+            schema=core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values())),
+            default=MyEnum.VALUE,
+        )
+    )
+
+    with pytest.raises(ValidationError):
+        v.validate_python(Decimal(2))
+
+    with pytest.raises(ValidationError):
+        v.validate_python((1, 2))
+
+    with pytest.raises(ValidationError):
+        v.validate_python(Decimal(1.1))
+
+
+def test_enum_int_validation_should_fail_for_plain_type_without_eq_checking():
+    class MyEnum(Enum):
+        VALUE = 1
+
+    class MyClass:
+        def __init__(self, value):
+            self.value = value
+
+    v = SchemaValidator(
+        core_schema.with_default_schema(
+            schema=core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values())),
+            default=MyEnum.VALUE,
+        )
+    )
+
+    with pytest.raises(ValidationError):
+        v.validate_python(MyClass(1))
+
+
+def support_custom_new_method() -> None:
+    """Demonstrates support for custom new methods, as well as conceptually, multi-value enums without dependency on a 3rd party lib for testing."""
+
+    class Animal(Enum):
+        CAT = 'cat', 'meow'
+        DOG = 'dog', 'woof'
+
+        def __new__(cls, species: str, sound: str):
+            obj = object.__new__(cls)
+
+            obj._value_ = species
+            obj._all_values = (species, sound)
+
+            obj.species = species
+            obj.sound = sound
+
+            cls._value2member_map_[sound] = obj
+
+            return obj
+
+    v = SchemaValidator(core_schema.enum_schema(Animal, list(Animal.__members__.values())))
+    assert v.validate_python('cat') is Animal.CAT
+    assert v.validate_python('meow') is Animal.CAT
+    assert v.validate_python('dog') is Animal.DOG
+    assert v.validate_python('woof') is Animal.DOG
diff --git a/tests/validators/test_model.py b/tests/validators/test_model.py
index bdcfbb2e9..b6a60f55c 100644
--- a/tests/validators/test_model.py
+++ b/tests/validators/test_model.py
@@ -1,5 +1,7 @@
 import re
+import sys
 from copy import deepcopy
+from decimal import Decimal
 from typing import Any, Callable, Dict, List, Set, Tuple
 
 import pytest
@@ -1312,3 +1314,66 @@ class OtherModel:
             'ctx': {'class_name': 'MyModel'},
         }
     ]
+
+
+@pytest.mark.skipif(
+    sys.version_info >= (3, 13),
+    reason='Python 3.13+ enum initialization is different, see https://github.com/python/cpython/blob/ec610069637d56101896803a70d418a89afe0b4b/Lib/enum.py#L1159-L1163',
+)
+def test_model_with_enum_int_field_validation_should_succeed_for_any_type_equality_checks():
+    # GIVEN
+    from enum import Enum
+
+    class EnumClass(Enum):
+        enum_value = 1
+        enum_value_2 = 2
+        enum_value_3 = 3
+
+    class IntWrappable:
+        def __init__(self, value: int):
+            self.value = value
+
+        def __eq__(self, other: object) -> bool:
+            return self.value == other
+
+    class MyModel:
+        __slots__ = (
+            '__dict__',
+            '__pydantic_fields_set__',
+            '__pydantic_extra__',
+            '__pydantic_private__',
+        )
+        enum_field: EnumClass
+
+    # WHEN
+    v = SchemaValidator(
+        core_schema.model_schema(
+            MyModel,
+            core_schema.model_fields_schema(
+                {
+                    'enum_field': core_schema.model_field(
+                        core_schema.enum_schema(EnumClass, list(EnumClass.__members__.values()))
+                    ),
+                    'enum_field_2': core_schema.model_field(
+                        core_schema.enum_schema(EnumClass, list(EnumClass.__members__.values()))
+                    ),
+                    'enum_field_3': core_schema.model_field(
+                        core_schema.enum_schema(EnumClass, list(EnumClass.__members__.values()))
+                    ),
+                }
+            ),
+        )
+    )
+
+    # THEN
+    v.validate_json('{"enum_field": 1, "enum_field_2": 2, "enum_field_3": 3}')
+    m = v.validate_python(
+        {
+            'enum_field': Decimal(1),
+            'enum_field_2': Decimal(2),
+            'enum_field_3': IntWrappable(3),
+        }
+    )
+    v.validate_assignment(m, 'enum_field', Decimal(1))
+    v.validate_assignment(m, 'enum_field_2', Decimal(2))
+    v.validate_assignment(m, 'enum_field_3', IntWrappable(3))

From f3f436e95998bef9f427c33edf6fe6ad3ebc31f1 Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Fri, 20 Sep 2024 18:35:01 +0200
Subject: [PATCH 378/550] Add support for unpacked `TypedDict` to type hint
 variadic keyword arguments in `ArgumentsValidator` (#1451)

Co-authored-by: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Co-authored-by: David Hewitt <david.hewitt@pydantic.dev>
---
 python/pydantic_core/core_schema.py |   9 +++
 src/validators/arguments.rs         | 108 ++++++++++++++++++++++------
 tests/validators/test_arguments.py  |  57 ++++++++++++++-
 3 files changed, 152 insertions(+), 22 deletions(-)

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index c5748fd19..922900170 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -3372,11 +3372,15 @@ def arguments_parameter(
     return _dict_not_none(name=name, schema=schema, mode=mode, alias=alias)
 
 
+VarKwargsMode: TypeAlias = Literal['uniform', 'unpacked-typed-dict']
+
+
 class ArgumentsSchema(TypedDict, total=False):
     type: Required[Literal['arguments']]
     arguments_schema: Required[List[ArgumentsParameter]]
     populate_by_name: bool
     var_args_schema: CoreSchema
+    var_kwargs_mode: VarKwargsMode
     var_kwargs_schema: CoreSchema
     ref: str
     metadata: Dict[str, Any]
@@ -3388,6 +3392,7 @@ def arguments_schema(
     *,
     populate_by_name: bool | None = None,
     var_args_schema: CoreSchema | None = None,
+    var_kwargs_mode: VarKwargsMode | None = None,
     var_kwargs_schema: CoreSchema | None = None,
     ref: str | None = None,
     metadata: Dict[str, Any] | None = None,
@@ -3414,6 +3419,9 @@ def arguments_schema(
         arguments: The arguments to use for the arguments schema
         populate_by_name: Whether to populate by name
         var_args_schema: The variable args schema to use for the arguments schema
+        var_kwargs_mode: The validation mode to use for variadic keyword arguments. If `'uniform'`, every value of the
+            keyword arguments will be validated against the `var_kwargs_schema` schema. If `'unpacked-typed-dict'`,
+            the `var_kwargs_schema` argument must be a [`typed_dict_schema`][pydantic_core.core_schema.typed_dict_schema]
         var_kwargs_schema: The variable kwargs schema to use for the arguments schema
         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
@@ -3424,6 +3432,7 @@ def arguments_schema(
         arguments_schema=arguments,
         populate_by_name=populate_by_name,
         var_args_schema=var_args_schema,
+        var_kwargs_mode=var_kwargs_mode,
         var_kwargs_schema=var_kwargs_schema,
         ref=ref,
         metadata=metadata,
diff --git a/src/validators/arguments.rs b/src/validators/arguments.rs
index 075bc009e..22f870c56 100644
--- a/src/validators/arguments.rs
+++ b/src/validators/arguments.rs
@@ -1,3 +1,5 @@
+use std::str::FromStr;
+
 use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList, PyString, PyTuple};
@@ -15,6 +17,27 @@ use crate::tools::SchemaDict;
 use super::validation_state::ValidationState;
 use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, Validator};
 
+#[derive(Debug, PartialEq)]
+enum VarKwargsMode {
+    Uniform,
+    UnpackedTypedDict,
+}
+
+impl FromStr for VarKwargsMode {
+    type Err = PyErr;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "uniform" => Ok(Self::Uniform),
+            "unpacked-typed-dict" => Ok(Self::UnpackedTypedDict),
+            s => py_schema_err!(
+                "Invalid var_kwargs mode: `{}`, expected `uniform` or `unpacked-typed-dict`",
+                s
+            ),
+        }
+    }
+}
+
 #[derive(Debug)]
 struct Parameter {
     positional: bool,
@@ -29,6 +52,7 @@ pub struct ArgumentsValidator {
     parameters: Vec<Parameter>,
     positional_params_count: usize,
     var_args_validator: Option<Box<CombinedValidator>>,
+    var_kwargs_mode: VarKwargsMode,
     var_kwargs_validator: Option<Box<CombinedValidator>>,
     loc_by_alias: bool,
     extra: ExtraBehavior,
@@ -117,6 +141,22 @@ impl BuildValidator for ArgumentsValidator {
             });
         }
 
+        let py_var_kwargs_mode: Bound<PyString> = schema
+            .get_as(intern!(py, "var_kwargs_mode"))?
+            .unwrap_or_else(|| PyString::new_bound(py, "uniform"));
+
+        let var_kwargs_mode = VarKwargsMode::from_str(py_var_kwargs_mode.to_str()?)?;
+        let var_kwargs_validator = match schema.get_item(intern!(py, "var_kwargs_schema"))? {
+            Some(v) => Some(Box::new(build_validator(&v, config, definitions)?)),
+            None => None,
+        };
+
+        if var_kwargs_mode == VarKwargsMode::UnpackedTypedDict && var_kwargs_validator.is_none() {
+            return py_schema_err!(
+                "`var_kwargs_schema` must be specified when `var_kwargs_mode` is `'unpacked-typed-dict'`"
+            );
+        }
+
         Ok(Self {
             parameters,
             positional_params_count,
@@ -124,10 +164,8 @@ impl BuildValidator for ArgumentsValidator {
                 Some(v) => Some(Box::new(build_validator(&v, config, definitions)?)),
                 None => None,
             },
-            var_kwargs_validator: match schema.get_item(intern!(py, "var_kwargs_schema"))? {
-                Some(v) => Some(Box::new(build_validator(&v, config, definitions)?)),
-                None => None,
-            },
+            var_kwargs_mode,
+            var_kwargs_validator,
             loc_by_alias: config.get_as(intern!(py, "loc_by_alias"))?.unwrap_or(true),
             extra: ExtraBehavior::from_schema_or_config(py, schema, config, ExtraBehavior::Forbid)?,
         }
@@ -255,6 +293,9 @@ impl Validator for ArgumentsValidator {
                 }
             }
         }
+
+        let remaining_kwargs = PyDict::new_bound(py);
+
         // if there are kwargs check any that haven't been processed yet
         if let Some(kwargs) = args.kwargs() {
             if kwargs.len() > used_kwargs.len() {
@@ -278,26 +319,33 @@ impl Validator for ArgumentsValidator {
                         Err(err) => return Err(err),
                     };
                     if !used_kwargs.contains(either_str.as_cow()?.as_ref()) {
-                        match self.var_kwargs_validator {
-                            Some(ref validator) => match validator.validate(py, value.borrow_input(), state) {
-                                Ok(value) => {
-                                    output_kwargs.set_item(either_str.as_py_string(py, state.cache_str()), value)?;
-                                }
-                                Err(ValError::LineErrors(line_errors)) => {
-                                    for err in line_errors {
-                                        errors.push(err.with_outer_location(raw_key.clone()));
+                        match self.var_kwargs_mode {
+                            VarKwargsMode::Uniform => match &self.var_kwargs_validator {
+                                Some(validator) => match validator.validate(py, value.borrow_input(), state) {
+                                    Ok(value) => {
+                                        output_kwargs
+                                            .set_item(either_str.as_py_string(py, state.cache_str()), value)?;
+                                    }
+                                    Err(ValError::LineErrors(line_errors)) => {
+                                        for err in line_errors {
+                                            errors.push(err.with_outer_location(raw_key.clone()));
+                                        }
+                                    }
+                                    Err(err) => return Err(err),
+                                },
+                                None => {
+                                    if let ExtraBehavior::Forbid = self.extra {
+                                        errors.push(ValLineError::new_with_loc(
+                                            ErrorTypeDefaults::UnexpectedKeywordArgument,
+                                            value,
+                                            raw_key.clone(),
+                                        ));
                                     }
                                 }
-                                Err(err) => return Err(err),
                             },
-                            None => {
-                                if let ExtraBehavior::Forbid = self.extra {
-                                    errors.push(ValLineError::new_with_loc(
-                                        ErrorTypeDefaults::UnexpectedKeywordArgument,
-                                        value,
-                                        raw_key.clone(),
-                                    ));
-                                }
+                            VarKwargsMode::UnpackedTypedDict => {
+                                // Save to the remaining kwargs, we will validate as a single dict:
+                                remaining_kwargs.set_item(either_str.as_py_string(py, state.cache_str()), value)?;
                             }
                         }
                     }
@@ -305,6 +353,24 @@ impl Validator for ArgumentsValidator {
             }
         }
 
+        if self.var_kwargs_mode == VarKwargsMode::UnpackedTypedDict {
+            // `var_kwargs_validator` is guaranteed to be `Some`:
+            match self
+                .var_kwargs_validator
+                .as_ref()
+                .unwrap()
+                .validate(py, remaining_kwargs.as_any(), state)
+            {
+                Ok(value) => {
+                    output_kwargs.update(value.downcast_bound::<PyDict>(py).unwrap().as_mapping())?;
+                }
+                Err(ValError::LineErrors(line_errors)) => {
+                    errors.extend(line_errors);
+                }
+                Err(err) => return Err(err),
+            }
+        }
+
         if !errors.is_empty() {
             Err(ValError::LineErrors(errors))
         } else {
diff --git a/tests/validators/test_arguments.py b/tests/validators/test_arguments.py
index 915f05878..1fb17dcee 100644
--- a/tests/validators/test_arguments.py
+++ b/tests/validators/test_arguments.py
@@ -769,6 +769,19 @@ def test_build_non_default_follows():
         )
 
 
+def test_build_missing_var_kwargs():
+    with pytest.raises(
+        SchemaError, match="`var_kwargs_schema` must be specified when `var_kwargs_mode` is `'unpacked-typed-dict'`"
+    ):
+        SchemaValidator(
+            {
+                'type': 'arguments',
+                'arguments_schema': [],
+                'var_kwargs_mode': 'unpacked-typed-dict',
+            }
+        )
+
+
 @pytest.mark.parametrize(
     'input_value,expected',
     [
@@ -778,7 +791,7 @@ def test_build_non_default_follows():
     ],
     ids=repr,
 )
-def test_kwargs(py_and_json: PyAndJson, input_value, expected):
+def test_kwargs_uniform(py_and_json: PyAndJson, input_value, expected):
     v = py_and_json(
         {
             'type': 'arguments',
@@ -796,6 +809,48 @@ def test_kwargs(py_and_json: PyAndJson, input_value, expected):
         assert v.validate_test(input_value) == expected
 
 
+@pytest.mark.parametrize(
+    'input_value,expected',
+    [
+        [ArgsKwargs((), {'x': 1}), ((), {'x': 1})],
+        [ArgsKwargs((), {'x': 1.0}), Err('x\n  Input should be a valid integer [type=int_type,')],
+        [ArgsKwargs((), {'x': 1, 'z': 'str'}), ((), {'x': 1, 'y': 'str'})],
+        [ArgsKwargs((), {'x': 1, 'y': 'str'}), Err('y\n  Extra inputs are not permitted [type=extra_forbidden,')],
+    ],
+)
+def test_kwargs_typed_dict(py_and_json: PyAndJson, input_value, expected):
+    v = py_and_json(
+        {
+            'type': 'arguments',
+            'arguments_schema': [],
+            'var_kwargs_mode': 'unpacked-typed-dict',
+            'var_kwargs_schema': {
+                'type': 'typed-dict',
+                'fields': {
+                    'x': {
+                        'type': 'typed-dict-field',
+                        'schema': {'type': 'int', 'strict': True},
+                        'required': True,
+                    },
+                    'y': {
+                        'type': 'typed-dict-field',
+                        'schema': {'type': 'str'},
+                        'required': False,
+                        'validation_alias': 'z',
+                    },
+                },
+                'config': {'extra_fields_behavior': 'forbid'},
+            },
+        }
+    )
+
+    if isinstance(expected, Err):
+        with pytest.raises(ValidationError, match=re.escape(expected.message)):
+            v.validate_test(input_value)
+    else:
+        assert v.validate_test(input_value) == expected
+
+
 @pytest.mark.parametrize(
     'input_value,expected',
     [

From 31a5156d891498db8ea66344bb9ff2e5ef47eb71 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Fri, 20 Sep 2024 11:38:23 -0500
Subject: [PATCH 379/550] Prep for v2.24.0 (#1458)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 38f11f369..a25fe1bbb 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -425,7 +425,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.23.4"
+version = "2.24.0"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index 0871b8a5d..eacc43127 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.23.4"
+version = "2.24.0"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From bfccf0983f2f4abe7081ea8bde7736e50dee5d9f Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Mon, 23 Sep 2024 13:43:32 +0100
Subject: [PATCH 380/550] restore Windows aarch64 builds (#1464)

---
 .github/workflows/ci.yml | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index ae15660a2..cf785a91f 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -455,10 +455,9 @@ jobs:
             target: i686
             python-architecture: x86
             interpreter: 3.8 3.9 3.10 3.11 3.12 3.13
-          # FIXME aarch64 builds broken, see https://github.com/PyO3/maturin/issues/2110
-          # - os: windows
-          #   target: aarch64
-          #   interpreter: 3.11 3.12 3.13
+          - os: windows
+            target: aarch64
+            interpreter: 3.11 3.12 3.13
 
         exclude:
           # See above; disabled for now.

From 4aa52a8feed83f16617234999f13ef2f7ed6f2b9 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Mon, 23 Sep 2024 16:13:51 +0100
Subject: [PATCH 381/550] limit windows builds to Rust 1.77 (to keep Windows 7
 support) (#1463)

---
 .github/workflows/ci.yml | 17 ++++++++++-------
 1 file changed, 10 insertions(+), 7 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index cf785a91f..48d6526c3 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -485,7 +485,9 @@ jobs:
           target: ${{ matrix.target }}
           manylinux: ${{ matrix.manylinux }}
           args: --release --out dist --interpreter ${{ matrix.interpreter || '3.8 3.9 3.10 3.11 3.12 3.13 pypy3.9 pypy3.10' }}
-          rust-toolchain: stable
+          # Limit windows builds to 1.77 to keep Windows 7 support.
+          # FIXME: Unpin when Python 3.8 support is dropped. (3.9 requires Windows 10)
+          rust-toolchain: ${{ (matrix.os == 'windows' && '1.77') || 'stable' }}
           docker-options: -e CI
 
       - run: ${{ (matrix.os == 'windows' && 'dir') || 'ls -lh' }} dist/
@@ -534,17 +536,18 @@ jobs:
 
       - name: install rust stable
         id: rust-toolchain
-        uses: dtolnay/rust-toolchain@stable
+        uses: dtolnay/rust-toolchain@master
         with:
           components: llvm-tools
+          # Limit windows builds to 1.77 to keep Windows 7 support.
+          # FIXME: Unpin when Python 3.8 support is dropped. (3.9 requires Windows 10)
+          toolchain: ${{ (matrix.os == 'windows' && '1.77') || 'stable' }}
 
       - run: pip install -U 'ruff==0.5.0' typing_extensions
 
       # generate self-schema now, so we don't have to do so inside docker in maturin build
       - run: python generate_self_schema.py
 
-      - run: rustc --version --verbose
-
       - name: build initial wheel
         uses: PyO3/maturin-action@v1
         with:
@@ -553,7 +556,7 @@ jobs:
             --release
             --out pgo-wheel
             --interpreter ${{ matrix.interpreter }}
-          rust-toolchain: stable
+          rust-toolchain: ${{ steps.rust-toolchain.outputs.name }}
           docker-options: -e CI
         env:
           RUSTFLAGS: "-Cprofile-generate=${{ github.workspace }}/profdata"
@@ -568,7 +571,7 @@ jobs:
           pip install -r tests/requirements.txt
           pip install pydantic-core --no-index --no-deps --find-links pgo-wheel --force-reinstall
           pytest tests/benchmarks
-          rustup run stable bash -c 'echo LLVM_PROFDATA=$RUSTUP_HOME/toolchains/$RUSTUP_TOOLCHAIN/lib/rustlib/${{ env.RUST_HOST }}/bin/llvm-profdata >> "$GITHUB_ENV"'
+          rustup run ${{ steps.rust-toolchain.outputs.name }} bash -c 'echo LLVM_PROFDATA=$RUSTUP_HOME/toolchains/$RUSTUP_TOOLCHAIN/lib/rustlib/${{ env.RUST_HOST }}/bin/llvm-profdata >> "$GITHUB_ENV"'
 
       - name: merge pgo data
         run: ${{ env.LLVM_PROFDATA }} merge -o ${{ github.workspace }}/merged.profdata ${{ github.workspace }}/profdata
@@ -581,7 +584,7 @@ jobs:
             --release
             --out dist
             --interpreter ${{ matrix.interpreter }}
-          rust-toolchain: stable
+          rust-toolchain: ${{steps.rust-toolchain.outputs.name}}
           docker-options: -e CI
         env:
           RUSTFLAGS: "-Cprofile-use=${{ github.workspace }}/merged.profdata"

From f389728432949ecceddecb1f59bb503b0998e9aa Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Wed, 25 Sep 2024 11:36:31 -0500
Subject: [PATCH 382/550] Fix equality checks for primitives in literals
 (#1459)

---
 src/validators/literal.rs        | 53 +++++++++++++++++++-------------
 tests/validators/test_literal.py | 12 ++++++++
 2 files changed, 43 insertions(+), 22 deletions(-)

diff --git a/src/validators/literal.rs b/src/validators/literal.rs
index 5e09c97dc..9ef0d5f82 100644
--- a/src/validators/literal.rs
+++ b/src/validators/literal.rs
@@ -35,6 +35,10 @@ pub struct LiteralLookup<T: Debug> {
     expected_py_dict: Option<Py<PyDict>>,
     // Catch all for unhashable types like list
     expected_py_values: Option<Vec<(Py<PyAny>, usize)>>,
+    // Fallback for ints, bools, and strings to use Python hash and equality checks
+    // which we can't mix with `expected_py_dict`, as there may be conflicts
+    // for an example, see tests/test_validators/test_literal.py::test_mix_int_enum_with_int
+    expected_py_primitives: Option<Py<PyDict>>,
 
     pub values: Vec<T>,
 }
@@ -46,20 +50,24 @@ impl<T: Debug> LiteralLookup<T> {
         let mut expected_str: AHashMap<String, usize> = AHashMap::new();
         let expected_py_dict = PyDict::new_bound(py);
         let mut expected_py_values = Vec::new();
+        let expected_py_primitives = PyDict::new_bound(py);
         let mut values = Vec::new();
         for (k, v) in expected {
             let id = values.len();
             values.push(v);
-            if let Ok(bool) = k.validate_bool(true) {
-                if bool.into_inner() {
+
+            if let Ok(bool_value) = k.validate_bool(true) {
+                if bool_value.into_inner() {
                     expected_bool.true_id = Some(id);
                 } else {
                     expected_bool.false_id = Some(id);
                 }
+                expected_py_primitives.set_item(&k, id)?;
             }
             if k.is_exact_instance_of::<PyInt>() {
                 if let Ok(int_64) = k.extract::<i64>() {
                     expected_int.insert(int_64, id);
+                    expected_py_primitives.set_item(&k, id)?;
                 } else {
                     // cover the case of an int that's > i64::MAX etc.
                     expected_py_dict.set_item(k, id)?;
@@ -69,32 +77,20 @@ impl<T: Debug> LiteralLookup<T> {
                     .as_cow()
                     .map_err(|_| py_schema_error_type!("error extracting str {:?}", k))?;
                 expected_str.insert(str.to_string(), id);
+                expected_py_primitives.set_item(&k, id)?;
             } else if expected_py_dict.set_item(&k, id).is_err() {
                 expected_py_values.push((k.as_unbound().clone_ref(py), id));
             }
         }
 
         Ok(Self {
-            expected_bool: match expected_bool.true_id.is_some() || expected_bool.false_id.is_some() {
-                true => Some(expected_bool),
-                false => None,
-            },
-            expected_int: match expected_int.is_empty() {
-                true => None,
-                false => Some(expected_int),
-            },
-            expected_str: match expected_str.is_empty() {
-                true => None,
-                false => Some(expected_str),
-            },
-            expected_py_dict: match expected_py_dict.is_empty() {
-                true => None,
-                false => Some(expected_py_dict.into()),
-            },
-            expected_py_values: match expected_py_values.is_empty() {
-                true => None,
-                false => Some(expected_py_values),
-            },
+            expected_bool: (expected_bool.true_id.is_some() || expected_bool.false_id.is_some())
+                .then_some(expected_bool),
+            expected_int: (!expected_int.is_empty()).then_some(expected_int),
+            expected_str: (!expected_str.is_empty()).then_some(expected_str),
+            expected_py_dict: (!expected_py_dict.is_empty()).then_some(expected_py_dict.into()),
+            expected_py_values: (!expected_py_values.is_empty()).then_some(expected_py_values),
+            expected_py_primitives: (!expected_py_primitives.is_empty()).then_some(expected_py_primitives.into()),
             values,
         })
     }
@@ -162,6 +158,19 @@ impl<T: Debug> LiteralLookup<T> {
                 }
             }
         };
+
+        // this one must be last to avoid conflicts with the other lookups, think of this
+        // almost as a lax fallback
+        if let Some(expected_py_primitives) = &self.expected_py_primitives {
+            let py_input = py_input.get_or_insert_with(|| input.to_object(py));
+            // We don't use ? to unpack the result of `get_item` in the next line because unhashable
+            // inputs will produce a TypeError, which in this case we just want to treat equivalently
+            // to a failed lookup
+            if let Ok(Some(v)) = expected_py_primitives.bind(py).get_item(&*py_input) {
+                let id: usize = v.extract().unwrap();
+                return Ok(Some((input, &self.values[id])));
+            }
+        };
         Ok(None)
     }
 
diff --git a/tests/validators/test_literal.py b/tests/validators/test_literal.py
index 5f9f942e2..d0d1af279 100644
--- a/tests/validators/test_literal.py
+++ b/tests/validators/test_literal.py
@@ -389,3 +389,15 @@ def test_big_int():
     m = r'Input should be 18446744073709551617 or 340282366920938463463374607431768211457 \[type=literal_error'
     with pytest.raises(ValidationError, match=m):
         v.validate_python(37)
+
+
+def test_enum_for_str() -> None:
+    class S(str, Enum):
+        a = 'a'
+
+    val_enum = SchemaValidator(core_schema.literal_schema([S.a]))
+    val_str = SchemaValidator(core_schema.literal_schema(['a']))
+
+    for val in [val_enum, val_str]:
+        assert val.validate_python('a') == 'a'
+        assert val.validate_python(S.a) == 'a'

From a8303e53f04579108cf45d8c1c886e1402b4a124 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 1 Oct 2024 12:53:34 +0100
Subject: [PATCH 383/550] Bump pyo3 from 0.22.2 to 0.22.3 (#1472)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 20 ++++++++++----------
 Cargo.toml |  4 ++--
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index a25fe1bbb..d87be9a9e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -451,9 +451,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.22.2"
+version = "0.22.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "831e8e819a138c36e212f3af3fd9eeffed6bf1510a805af35b0edee5ffa59433"
+checksum = "15ee168e30649f7f234c3d49ef5a7a6cbf5134289bc46c29ff3155fa3221c225"
 dependencies = [
  "cfg-if",
  "indoc",
@@ -470,9 +470,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.22.2"
+version = "0.22.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1e8730e591b14492a8945cdff32f089250b05f5accecf74aeddf9e8272ce1fa8"
+checksum = "e61cef80755fe9e46bb8a0b8f20752ca7676dcc07a5277d8b7768c6172e529b3"
 dependencies = [
  "once_cell",
  "python3-dll-a",
@@ -481,9 +481,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.22.2"
+version = "0.22.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5e97e919d2df92eb88ca80a037969f44e5e70356559654962cbb3316d00300c6"
+checksum = "67ce096073ec5405f5ee2b8b31f03a68e02aa10d5d4f565eca04acc41931fa1c"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -491,9 +491,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.22.2"
+version = "0.22.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb57983022ad41f9e683a599f2fd13c3664d7063a3ac5714cae4b7bee7d3f206"
+checksum = "2440c6d12bc8f3ae39f1e775266fa5122fd0c8891ce7520fa6048e683ad3de28"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -503,9 +503,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.22.2"
+version = "0.22.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ec480c0c51ddec81019531705acac51bcdbeae563557c982aa8263bb96880372"
+checksum = "1be962f0e06da8f8465729ea2cb71a416d2257dff56cbe40a70d3e62a93ae5d1"
 dependencies = [
  "heck",
  "proc-macro2",
diff --git a/Cargo.toml b/Cargo.toml
index eacc43127..a78cd7af5 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -29,7 +29,7 @@ rust-version = "1.75"
 [dependencies]
 # TODO it would be very nice to remove the "py-clone" feature as it can panic,
 # but needs a bit of work to make sure it's not used in the codebase
-pyo3 = { version = "0.22.2", features = ["generate-import-lib", "num-bigint", "py-clone"] }
+pyo3 = { version = "0.22.3", features = ["generate-import-lib", "num-bigint", "py-clone"] }
 regex = "1.10.6"
 strum = { version = "0.26.3", features = ["derive"] }
 strum_macros = "0.26.4"
@@ -74,7 +74,7 @@ debug = true
 strip = false
 
 [dev-dependencies]
-pyo3 = { version = "0.22.2", features = ["auto-initialize"] }
+pyo3 = { version = "0.22.3", features = ["auto-initialize"] }
 
 [build-dependencies]
 version_check = "0.9.5"

From 019104338a5dcf450f60fbd9c03129d56161da61 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 1 Oct 2024 12:54:11 +0100
Subject: [PATCH 384/550] Bump serde from 1.0.209 to 1.0.210 (#1471)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 8 ++++----
 Cargo.toml | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index d87be9a9e..c7cb95708 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -581,18 +581,18 @@ checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
 
 [[package]]
 name = "serde"
-version = "1.0.209"
+version = "1.0.210"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "99fce0ffe7310761ca6bf9faf5115afbc19688edd00171d81b1bb1b116c63e09"
+checksum = "c8e3592472072e6e22e0a54d5904d9febf8508f65fb8552499a1abc7d1078c3a"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.209"
+version = "1.0.210"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5831b979fd7b5439637af1752d535ff49f4860c0f341d1baeb6faf0f4242170"
+checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/Cargo.toml b/Cargo.toml
index a78cd7af5..df40b147f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -35,7 +35,7 @@ strum = { version = "0.26.3", features = ["derive"] }
 strum_macros = "0.26.4"
 serde_json = {version = "1.0.128", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.13"
-serde = { version = "1.0.209", features = ["derive"] }
+serde = { version = "1.0.210", features = ["derive"] }
 speedate = "0.14.4"
 smallvec = "1.13.2"
 ahash = "0.8.10"

From e3eff5cb8a6dae8914e3831b00c690d9dee4b740 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 1 Oct 2024 12:06:06 +0000
Subject: [PATCH 385/550] Bump regex from 1.10.6 to 1.11.0 (#1470)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 12 ++++++------
 Cargo.toml |  2 +-
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index c7cb95708..18fa96090 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -540,9 +540,9 @@ checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
 
 [[package]]
 name = "regex"
-version = "1.10.6"
+version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "4219d74c6b67a3654a9fbebc4b419e22126d13d2f3c4a07ee0cb61ff79a79619"
+checksum = "38200e5ee88914975b69f657f0801b6f6dccafd44fd9326302a4aaeecfacb1d8"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -552,9 +552,9 @@ dependencies = [
 
 [[package]]
 name = "regex-automata"
-version = "0.4.7"
+version = "0.4.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38caf58cc5ef2fed281f89292ef23f6365465ed9a41b7a7754eb4e26496c92df"
+checksum = "368758f23274712b504848e9d5a6f010445cc8b87a7cdb4d7cbee666c1288da3"
 dependencies = [
  "aho-corasick",
  "memchr",
@@ -563,9 +563,9 @@ dependencies = [
 
 [[package]]
 name = "regex-syntax"
-version = "0.8.4"
+version = "0.8.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7a66a03ae7c801facd77a29370b4faec201768915ac14a721ba36f20bc9c209b"
+checksum = "2b15c43186be67a4fd63bee50d0303afffcef381492ebe2c5d87f324e1b8815c"
 
 [[package]]
 name = "rustversion"
diff --git a/Cargo.toml b/Cargo.toml
index df40b147f..60e7ef450 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -30,7 +30,7 @@ rust-version = "1.75"
 # TODO it would be very nice to remove the "py-clone" feature as it can panic,
 # but needs a bit of work to make sure it's not used in the codebase
 pyo3 = { version = "0.22.3", features = ["generate-import-lib", "num-bigint", "py-clone"] }
-regex = "1.10.6"
+regex = "1.11.0"
 strum = { version = "0.26.3", features = ["derive"] }
 strum_macros = "0.26.4"
 serde_json = {version = "1.0.128", features = ["arbitrary_precision", "preserve_order"]}

From 0af18c4172d5855547d54f2b09506a5cf8ac69ae Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Mon, 7 Oct 2024 11:30:57 -0400
Subject: [PATCH 386/550] Add `invalid` schema placeholder (#1469)

---
 python/pydantic_core/core_schema.py | 22 ++++++++++++++++++++++
 src/validators/mod.rs               |  1 +
 tests/test_schema_functions.py      |  8 +++++++-
 3 files changed, 30 insertions(+), 1 deletion(-)

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index 922900170..b1c4c13b5 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -435,6 +435,26 @@ def model_ser_schema(cls: Type[Any], schema: CoreSchema) -> ModelSerSchema:
 ]
 
 
+class InvalidSchema(TypedDict, total=False):
+    type: Required[Literal['invalid']]
+    ref: str
+    metadata: Dict[str, Any]
+
+
+def invalid_schema(ref: str | None = None, metadata: Dict[str, Any] | None = None) -> InvalidSchema:
+    """
+    Returns an invalid schema, used to indicate that a schema is invalid.
+
+        Returns a schema that matches any value, e.g.:
+
+    Args:
+        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
+    """
+
+    return _dict_not_none(type='invalid', ref=ref, metadata=metadata)
+
+
 class ComputedField(TypedDict, total=False):
     type: Required[Literal['computed-field']]
     property_name: Required[str]
@@ -3826,6 +3846,7 @@ def definition_reference_schema(
 # union which kills performance not just for pydantic, but even for code using pydantic
 if not MYPY:
     CoreSchema = Union[
+        InvalidSchema,
         AnySchema,
         NoneSchema,
         BoolSchema,
@@ -3882,6 +3903,7 @@ def definition_reference_schema(
 
 # to update this, call `pytest -k test_core_schema_type_literal` and copy the output
 CoreSchemaType = Literal[
+    'invalid',
     'any',
     'none',
     'bool',
diff --git a/src/validators/mod.rs b/src/validators/mod.rs
index 5f88d5dc8..fcd64ebf2 100644
--- a/src/validators/mod.rs
+++ b/src/validators/mod.rs
@@ -479,6 +479,7 @@ macro_rules! validator_match {
             $(
                 <$validator>::EXPECTED_TYPE => build_specific_validator::<$validator>($type, $dict, $config, $definitions),
             )+
+            "invalid" => return py_schema_err!("Cannot construct schema with `InvalidSchema` member."),
             _ => return py_schema_err!(r#"Unknown schema type: "{}""#, $type),
         }
     };
diff --git a/tests/test_schema_functions.py b/tests/test_schema_functions.py
index 6d96678c8..a15adfca5 100644
--- a/tests/test_schema_functions.py
+++ b/tests/test_schema_functions.py
@@ -291,6 +291,7 @@ def args(*args, **kwargs):
     (core_schema.decimal_schema, args(), {'type': 'decimal'}),
     (core_schema.decimal_schema, args(multiple_of=5, gt=1.2), {'type': 'decimal', 'multiple_of': 5, 'gt': 1.2}),
     (core_schema.complex_schema, args(), {'type': 'complex'}),
+    (core_schema.invalid_schema, args(), {'type': 'invalid'}),
 ]
 
 
@@ -299,7 +300,7 @@ def test_schema_functions(function, args_kwargs, expected_schema):
     args, kwargs = args_kwargs
     schema = function(*args, **kwargs)
     assert schema == expected_schema
-    if schema.get('type') in {None, 'definition-ref', 'typed-dict-field', 'model-field'}:
+    if schema.get('type') in {None, 'definition-ref', 'typed-dict-field', 'model-field', 'invalid'}:
         return
 
     v = SchemaValidator(schema)
@@ -354,3 +355,8 @@ def test_expected_serialization_types(return_schema):
             )
         )
     )
+
+
+def test_err_on_invalid() -> None:
+    with pytest.raises(SchemaError, match='Cannot construct schema with `InvalidSchema` member.'):
+        SchemaValidator(core_schema.invalid_schema())

From 903a1a98b1efd2e44501863ba1d4bb2a4fb3d4c4 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Wed, 9 Oct 2024 15:40:02 +0100
Subject: [PATCH 387/550] ci: add prebuilt musl for armv7 (#1477)

---
 .github/workflows/ci.yml | 30 ++++++++++++++++--------------
 1 file changed, 16 insertions(+), 14 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 48d6526c3..d8cbcbfe1 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -152,8 +152,7 @@ jobs:
 
       - name: resolve MSRV
         id: resolve-msrv
-        run:
-          echo MSRV=`python -c 'import tomllib; print(tomllib.load(open("Cargo.toml", "rb"))["package"]["rust-version"])'` >> $GITHUB_OUTPUT
+        run: echo MSRV=`python -c 'import tomllib; print(tomllib.load(open("Cargo.toml", "rb"))["package"]["rust-version"])'` >> $GITHUB_OUTPUT
 
       - name: install rust MSRV
         uses: dtolnay/rust-toolchain@master
@@ -357,8 +356,8 @@ jobs:
       - run: npm run test
 
       - run: |
-         ls -lh dist/
-         ls -l dist/
+          ls -lh dist/
+          ls -l dist/
 
       - uses: actions/upload-artifact@v4
         with:
@@ -434,6 +433,9 @@ jobs:
           - os: linux
             manylinux: musllinux_1_1
             target: aarch64
+          - os: linux
+            manylinux: musllinux_1_1
+            target: armv7
 
           # macos;
           # all versions x86_64
@@ -559,7 +561,7 @@ jobs:
           rust-toolchain: ${{ steps.rust-toolchain.outputs.name }}
           docker-options: -e CI
         env:
-          RUSTFLAGS: "-Cprofile-generate=${{ github.workspace }}/profdata"
+          RUSTFLAGS: '-Cprofile-generate=${{ github.workspace }}/profdata'
 
       - name: detect rust host
         run: echo RUST_HOST=$(rustc -Vv | grep host | cut -d ' ' -f 2) >> "$GITHUB_ENV"
@@ -587,7 +589,7 @@ jobs:
           rust-toolchain: ${{steps.rust-toolchain.outputs.name}}
           docker-options: -e CI
         env:
-          RUSTFLAGS: "-Cprofile-use=${{ github.workspace }}/merged.profdata"
+          RUSTFLAGS: '-Cprofile-use=${{ github.workspace }}/merged.profdata'
 
       - run: ${{ matrix.ls || 'ls -lh' }} dist/
 
@@ -612,20 +614,20 @@ jobs:
 
       - name: list dist files
         run: |
-         ls -lh dist/
-         ls -l dist/
-         echo "`ls dist | wc -l` files"
+          ls -lh dist/
+          ls -l dist/
+          echo "`ls dist | wc -l` files"
 
       - name: extract and list sdist file
         run: |
-         mkdir sdist-files
-         tar -xvf dist/*.tar.gz -C sdist-files
-         tree -a sdist-files
+          mkdir sdist-files
+          tar -xvf dist/*.tar.gz -C sdist-files
+          tree -a sdist-files
 
       - name: extract and list wheel file
         run: |
-         ls dist/*cp310-manylinux*x86_64.whl | head -n 1
-         python -m zipfile --list `ls dist/*cp310-manylinux*x86_64.whl | head -n 1`
+          ls dist/*cp310-manylinux*x86_64.whl | head -n 1
+          python -m zipfile --list `ls dist/*cp310-manylinux*x86_64.whl | head -n 1`
 
   test-builds-arch:
     name: test build on ${{ matrix.target }}-${{ matrix.distro }}

From dc4846e5082634fb3cc993447f9a1142e0aa802f Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Thu, 10 Oct 2024 11:21:55 +0100
Subject: [PATCH 388/550] ci: add flag to integration tests to mitigate schema
 changes (#1480)

---
 .github/workflows/ci.yml | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index d8cbcbfe1..056f40c34 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -245,6 +245,8 @@ jobs:
         # which xfail on a pending release of pydantic-core
       - run: pdm run pytest --override-ini=xfail_strict=False
         working-directory: pydantic
+        env:
+          PYDANTIC_PRIVATE_ALLOW_UNHANDLED_SCHEMA_TYPES: 1
 
   lint:
     runs-on: ubuntu-latest

From b773c9d44154b78869c5869ad29d8eec4226110c Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Thu, 10 Oct 2024 09:02:18 -0400
Subject: [PATCH 389/550] Relax intensity of error for `issubclass` and
 `isinstance` schemas from json (#1479)

---
 python/pydantic_core/core_schema.py  |  1 +
 src/errors/types.rs                  |  3 +++
 src/validators/is_instance.rs        | 13 ++++++++-----
 src/validators/is_subclass.rs        | 13 ++++++++-----
 tests/test_errors.py                 | 13 +++++++++----
 tests/validators/test_is_instance.py |  9 ++++-----
 tests/validators/test_is_subclass.py |  7 +++++++
 7 files changed, 40 insertions(+), 19 deletions(-)

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index b1c4c13b5..cd1525b6a 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -3964,6 +3964,7 @@ def definition_reference_schema(
     'no_such_attribute',
     'json_invalid',
     'json_type',
+    'needs_python_object',
     'recursion_loop',
     'missing',
     'frozen_field',
diff --git a/src/errors/types.rs b/src/errors/types.rs
index ec129a63a..07186003d 100644
--- a/src/errors/types.rs
+++ b/src/errors/types.rs
@@ -167,6 +167,7 @@ error_types! {
         error: {ctx_type: String, ctx_fn: field_from_context},
     },
     JsonType {},
+    NeedsPythonObject { method_name: {ctx_type: String, ctx_fn: field_from_context} },
     // ---------------------
     // recursion error
     RecursionLoop {},
@@ -477,6 +478,7 @@ impl ErrorType {
             Self::NoSuchAttribute {..} => "Object has no attribute '{attribute}'",
             Self::JsonInvalid {..} => "Invalid JSON: {error}",
             Self::JsonType {..} => "JSON input should be string, bytes or bytearray",
+            Self::NeedsPythonObject {..} => "Cannot check `{method_name}` when validating from json, use a JsonOrPython validator instead",
             Self::RecursionLoop {..} => "Recursion error - cyclic reference detected",
             Self::Missing {..} => "Field required",
             Self::FrozenField {..} => "Field is frozen",
@@ -626,6 +628,7 @@ impl ErrorType {
         match self {
             Self::NoSuchAttribute { attribute, .. } => render!(tmpl, attribute),
             Self::JsonInvalid { error, .. } => render!(tmpl, error),
+            Self::NeedsPythonObject { method_name, .. } => render!(tmpl, method_name),
             Self::GetAttributeError { error, .. } => render!(tmpl, error),
             Self::ModelType { class_name, .. } => render!(tmpl, class_name),
             Self::DataclassType { class_name, .. } => render!(tmpl, class_name),
diff --git a/src/validators/is_instance.rs b/src/validators/is_instance.rs
index d9190f33c..e62301587 100644
--- a/src/validators/is_instance.rs
+++ b/src/validators/is_instance.rs
@@ -1,4 +1,3 @@
-use pyo3::exceptions::PyNotImplementedError;
 use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyType};
@@ -56,10 +55,14 @@ impl Validator for IsInstanceValidator {
         _state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let Some(obj) = input.as_python() else {
-            return Err(ValError::InternalErr(PyNotImplementedError::new_err(
-                "Cannot check isinstance when validating from json, \
-                            use a JsonOrPython validator instead.",
-            )));
+            let method_name = "isinstance".to_string();
+            return Err(ValError::new(
+                ErrorType::NeedsPythonObject {
+                    context: None,
+                    method_name,
+                },
+                input,
+            ));
         };
         match obj.is_instance(self.class.bind(py))? {
             true => Ok(obj.clone().unbind()),
diff --git a/src/validators/is_subclass.rs b/src/validators/is_subclass.rs
index fdfea5b75..ed587a50c 100644
--- a/src/validators/is_subclass.rs
+++ b/src/validators/is_subclass.rs
@@ -1,4 +1,3 @@
-use pyo3::exceptions::PyNotImplementedError;
 use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyType};
@@ -51,10 +50,14 @@ impl Validator for IsSubclassValidator {
         _state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let Some(obj) = input.as_python() else {
-            return Err(ValError::InternalErr(PyNotImplementedError::new_err(
-                "Cannot check issubclass when validating from json, \
-                            use a JsonOrPython validator instead.",
-            )));
+            let method_name = "issubclass".to_string();
+            return Err(ValError::new(
+                ErrorType::NeedsPythonObject {
+                    context: None,
+                    method_name,
+                },
+                input,
+            ));
         };
         match obj.downcast::<PyType>() {
             Ok(py_type) if py_type.is_subclass(self.class.bind(py))? => Ok(obj.clone().unbind()),
diff --git a/tests/test_errors.py b/tests/test_errors.py
index b8265f04e..9ac993031 100644
--- a/tests/test_errors.py
+++ b/tests/test_errors.py
@@ -257,6 +257,11 @@ def f(input_value, info):
     ('no_such_attribute', "Object has no attribute 'wrong_name'", {'attribute': 'wrong_name'}),
     ('json_invalid', 'Invalid JSON: foobar', {'error': 'foobar'}),
     ('json_type', 'JSON input should be string, bytes or bytearray', None),
+    (
+        'needs_python_object',
+        'Cannot check `isinstance` when validating from json, use a JsonOrPython validator instead',
+        {'method_name': 'isinstance'},
+    ),
     ('recursion_loop', 'Recursion error - cyclic reference detected', None),
     ('model_type', 'Input should be a valid dictionary or instance of Foobar', {'class_name': 'Foobar'}),
     ('model_attributes_type', 'Input should be a valid dictionary or object to extract fields from', None),
@@ -506,10 +511,10 @@ def test_all_errors():
             'example_context': None,
         },
         {
-            'type': 'recursion_loop',
-            'message_template_python': 'Recursion error - cyclic reference detected',
-            'example_message_python': 'Recursion error - cyclic reference detected',
-            'example_context': None,
+            'type': 'needs_python_object',
+            'message_template_python': 'Cannot check `{method_name}` when validating from json, use a JsonOrPython validator instead',
+            'example_message_python': 'Cannot check `` when validating from json, use a JsonOrPython validator instead',
+            'example_context': {'method_name': ''},
         },
     ]
 
diff --git a/tests/validators/test_is_instance.py b/tests/validators/test_is_instance.py
index 7a5351554..9bce323a7 100644
--- a/tests/validators/test_is_instance.py
+++ b/tests/validators/test_is_instance.py
@@ -19,8 +19,9 @@ class Spam:
 
 def test_validate_json() -> None:
     v = SchemaValidator({'type': 'is-instance', 'cls': Foo})
-    with pytest.raises(NotImplementedError, match='use a JsonOrPython validator instead'):
+    with pytest.raises(ValidationError) as exc_info:
         v.validate_json('"foo"')
+        assert exc_info.value.errors()[0]['type'] == 'needs_python_object'
 
 
 def test_is_instance():
@@ -175,11 +176,9 @@ def test_is_instance_json_type_before_validator():
     schema = core_schema.is_instance_schema(type)
     v = SchemaValidator(schema)
 
-    with pytest.raises(
-        NotImplementedError,
-        match='Cannot check isinstance when validating from json, use a JsonOrPython validator instead.',
-    ):
+    with pytest.raises(ValidationError) as exc_info:
         v.validate_json('null')
+        assert exc_info.value.errors()[0]['type'] == 'needs_python_object'
 
     # now wrap in a before validator
     def set_type_to_int(input: None) -> type:
diff --git a/tests/validators/test_is_subclass.py b/tests/validators/test_is_subclass.py
index cb940ab34..43e65b6b1 100644
--- a/tests/validators/test_is_subclass.py
+++ b/tests/validators/test_is_subclass.py
@@ -77,3 +77,10 @@ def test_custom_repr():
             'ctx': {'class': 'Spam'},
         }
     ]
+
+
+def test_is_subclass_json() -> None:
+    v = SchemaValidator(core_schema.is_subclass_schema(Foo))
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_json("'Foo'")
+        assert exc_info.value.errors()[0]['type'] == 'needs_python_object'

From 10374e2dbe431a556da518baf23a2fc14b36a3fa Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Fri, 11 Oct 2024 10:00:04 -0400
Subject: [PATCH 390/550] Bump version to v2.24.1 (#1481)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 18fa96090..84ba82432 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -425,7 +425,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.24.0"
+version = "2.24.1"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index 60e7ef450..fb2fbeb56 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.24.0"
+version = "2.24.1"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From bbd4de5286fcd8b404b278e08b569dd127d95ae2 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Tue, 15 Oct 2024 15:36:11 +0100
Subject: [PATCH 391/550] ci: fix for ubuntu 24.04, use Python 3.13 for scripts
 (#1484)

---
 .github/workflows/ci.yml       | 25 ++++++++++++++-----------
 .github/workflows/codspeed.yml |  2 +-
 2 files changed, 15 insertions(+), 12 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 056f40c34..5476191fe 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -33,7 +33,7 @@ jobs:
       - name: set up python
         uses: actions/setup-python@v5
         with:
-          python-version: '3.11'
+          python-version: '3.13'
 
       - run: pip install -r tests/requirements.txt
 
@@ -124,7 +124,7 @@ jobs:
       - name: set up python
         uses: actions/setup-python@v5
         with:
-          python-version: '3.11'
+          python-version: '3.13'
 
       - run: pip install -r tests/requirements.txt
 
@@ -148,7 +148,7 @@ jobs:
       - name: set up python
         uses: actions/setup-python@v5
         with:
-          python-version: '3.11'
+          python-version: '3.13'
 
       - name: resolve MSRV
         id: resolve-msrv
@@ -183,7 +183,7 @@ jobs:
       fail-fast: false
       matrix:
         python-version:
-          - '3.11'
+          - '3.13'
           - 'pypy3.10'
 
     steps:
@@ -222,7 +222,7 @@ jobs:
       - name: set up python
         uses: actions/setup-python@v5
         with:
-          python-version: '3.11'
+          python-version: '3.13'
 
       - name: install rust stable
         uses: dtolnay/rust-toolchain@stable
@@ -264,7 +264,7 @@ jobs:
 
       - uses: actions/setup-python@v5
         with:
-          python-version: '3.11'
+          python-version: '3.13'
 
       # used to lint js code
       - uses: actions/setup-node@v4
@@ -310,7 +310,7 @@ jobs:
 
       - uses: actions/setup-python@v5
         with:
-          python-version: '3.10'
+          python-version: '3.13'
 
       - run: pip install typing_extensions
 
@@ -325,7 +325,7 @@ jobs:
         id: setup-python
         uses: actions/setup-python@v5
         with:
-          python-version: '3.11'
+          python-version: '3.13'
 
       - name: install rust nightly
         uses: dtolnay/rust-toolchain@nightly
@@ -383,6 +383,9 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: '3.13'
       - uses: PyO3/maturin-action@v1
         with:
           command: sdist
@@ -475,7 +478,7 @@ jobs:
       - name: set up python
         uses: actions/setup-python@v5
         with:
-          python-version: '3.11'
+          python-version: '3.13'
           architecture: ${{ matrix.python-architecture || 'x64' }}
 
       - run: pip install -U twine 'ruff==0.5.0' typing_extensions
@@ -697,7 +700,7 @@ jobs:
       - name: set up python
         uses: actions/setup-python@v5
         with:
-          python-version: '3.11'
+          python-version: '3.13'
 
       - name: get dist artifacts
         uses: actions/download-artifact@v4
@@ -721,7 +724,7 @@ jobs:
       - name: set up python
         uses: actions/setup-python@v5
         with:
-          python-version: '3.10'
+          python-version: '3.13'
 
       - run: pip install -U twine
 
diff --git a/.github/workflows/codspeed.yml b/.github/workflows/codspeed.yml
index b4851c286..796d44994 100644
--- a/.github/workflows/codspeed.yml
+++ b/.github/workflows/codspeed.yml
@@ -18,7 +18,7 @@ jobs:
 
       - uses: actions/setup-python@v5
         with:
-          python-version: '3.12'
+          python-version: '3.13'
 
       - uses: actions/cache@v4
         id: cache-py

From c38a68d85a2837c7a5a00dec0a0eb41d3175347e Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Tue, 15 Oct 2024 10:49:55 -0400
Subject: [PATCH 392/550] Add `serialization` key to `InvalidSchema` (#1482)

---
 python/pydantic_core/core_schema.py | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index cd1525b6a..2d51d544d 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -439,6 +439,9 @@ class InvalidSchema(TypedDict, total=False):
     type: Required[Literal['invalid']]
     ref: str
     metadata: Dict[str, Any]
+    # note, we never plan to use this, but include it for type checking purposes to match
+    # all other CoreSchema union members
+    serialization: SerSchema
 
 
 def invalid_schema(ref: str | None = None, metadata: Dict[str, Any] | None = None) -> InvalidSchema:

From 92a259ea10113e0d41dea5b14dc8745e3bf671ef Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Tue, 15 Oct 2024 10:57:11 -0400
Subject: [PATCH 393/550] Version bump to v2.24.2 (#1485)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 84ba82432..26acf7dd4 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -425,7 +425,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.24.1"
+version = "2.24.2"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index fb2fbeb56..99b9db13e 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.24.1"
+version = "2.24.2"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From 1ced3e6b4e87b03c460952f1970a97b1c8cbc605 Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Mon, 21 Oct 2024 13:24:46 +0200
Subject: [PATCH 394/550] Properly enforce `host_required` for URLs (#1488)

---
 .github/workflows/codspeed.yml | 2 +-
 src/validators/url.rs          | 5 +++--
 tests/validators/test_url.py   | 6 ++++++
 3 files changed, 10 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/codspeed.yml b/.github/workflows/codspeed.yml
index 796d44994..6bb94fc1c 100644
--- a/.github/workflows/codspeed.yml
+++ b/.github/workflows/codspeed.yml
@@ -11,7 +11,7 @@ on:
 
 jobs:
   benchmarks:
-    runs-on: ubuntu-latest
+    runs-on: ubuntu-22.04
 
     steps:
       - uses: actions/checkout@v4
diff --git a/src/validators/url.rs b/src/validators/url.rs
index 634d1ce43..46bab20c1 100644
--- a/src/validators/url.rs
+++ b/src/validators/url.rs
@@ -544,8 +544,9 @@ fn check_sub_defaults(
         error: e.to_string(),
         context: None,
     };
-    if let Some(ref default_host) = default_host {
-        if !url.url().has_host() {
+
+    if !url.url().has_host() {
+        if let Some(ref default_host) = default_host {
             url.url_mut().set_host(Some(default_host)).map_err(map_parse_err)?;
         } else if host_required {
             return Err(ErrorType::UrlParsing {
diff --git a/tests/validators/test_url.py b/tests/validators/test_url.py
index 1c349885e..59489dd00 100644
--- a/tests/validators/test_url.py
+++ b/tests/validators/test_url.py
@@ -287,6 +287,12 @@ def test_url_defaults_single_url(validator_kwargs, url, expected):
     url_test_case_helper(url, expected, SCHEMA_VALIDATOR_MODE, s)
 
 
+def test_url_host_required():
+    s = SchemaValidator(core_schema.url_schema(host_required=True))
+    url_test_case_helper('test:', Err('empty host'), SCHEMA_VALIDATOR_MODE, s)
+    url_test_case_helper('sftp://', Err('empty host'), SCHEMA_VALIDATOR_MODE, s)
+
+
 @pytest.mark.parametrize(
     'validator_kwargs,url,expected',
     [

From 288dd1c879b3a560cdbf2f178ceb2a6ce2e60d9a Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Wed, 23 Oct 2024 06:23:01 -0400
Subject: [PATCH 395/550] Support revalidation of parametrized generics (#1489)

---
 python/pydantic_core/core_schema.py | 10 +++++++++
 src/validators/dataclass.rs         | 35 +++++++++++++++++++++++++----
 src/validators/model.rs             | 35 +++++++++++++++++++++++++----
 3 files changed, 72 insertions(+), 8 deletions(-)

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index 2d51d544d..eeebba834 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -3056,6 +3056,7 @@ def model_fields_schema(
 class ModelSchema(TypedDict, total=False):
     type: Required[Literal['model']]
     cls: Required[Type[Any]]
+    generic_origin: Type[Any]
     schema: Required[CoreSchema]
     custom_init: bool
     root_model: bool
@@ -3074,6 +3075,7 @@ def model_schema(
     cls: Type[Any],
     schema: CoreSchema,
     *,
+    generic_origin: Type[Any] | None = None,
     custom_init: bool | None = None,
     root_model: bool | None = None,
     post_init: str | None = None,
@@ -3120,6 +3122,8 @@ class MyModel:
     Args:
         cls: The class to use for the model
         schema: The schema to use for the model
+        generic_origin: The origin type used for this model, if it's a parametrized generic. Ex,
+            if this model schema represents `SomeModel[int]`, generic_origin is `SomeModel`
         custom_init: Whether the model has a custom init method
         root_model: Whether the model is a `RootModel`
         post_init: The call after init to use for the model
@@ -3136,6 +3140,7 @@ class MyModel:
     return _dict_not_none(
         type='model',
         cls=cls,
+        generic_origin=generic_origin,
         schema=schema,
         custom_init=custom_init,
         root_model=root_model,
@@ -3289,6 +3294,7 @@ def dataclass_args_schema(
 class DataclassSchema(TypedDict, total=False):
     type: Required[Literal['dataclass']]
     cls: Required[Type[Any]]
+    generic_origin: Type[Any]
     schema: Required[CoreSchema]
     fields: Required[List[str]]
     cls_name: str
@@ -3308,6 +3314,7 @@ def dataclass_schema(
     schema: CoreSchema,
     fields: List[str],
     *,
+    generic_origin: Type[Any] | None = None,
     cls_name: str | None = None,
     post_init: bool | None = None,
     revalidate_instances: Literal['always', 'never', 'subclass-instances'] | None = None,
@@ -3328,6 +3335,8 @@ def dataclass_schema(
         schema: The schema to use for the dataclass fields
         fields: Fields of the dataclass, this is used in serialization and in validation during re-validation
             and while validating assignment
+        generic_origin: The origin type used for this dataclass, if it's a parametrized generic. Ex,
+            if this model schema represents `SomeDataclass[int]`, generic_origin is `SomeDataclass`
         cls_name: The name to use in error locs, etc; this is useful for generics (default: `cls.__name__`)
         post_init: Whether to call `__post_init__` after validation
         revalidate_instances: whether instances of models and dataclasses (including subclass instances)
@@ -3343,6 +3352,7 @@ def dataclass_schema(
     return _dict_not_none(
         type='dataclass',
         cls=cls,
+        generic_origin=generic_origin,
         fields=fields,
         cls_name=cls_name,
         schema=schema,
diff --git a/src/validators/dataclass.rs b/src/validators/dataclass.rs
index 4ff82a467..4bece7ea5 100644
--- a/src/validators/dataclass.rs
+++ b/src/validators/dataclass.rs
@@ -438,6 +438,7 @@ pub struct DataclassValidator {
     strict: bool,
     validator: Box<CombinedValidator>,
     class: Py<PyType>,
+    generic_origin: Option<Py<PyType>>,
     fields: Vec<Py<PyString>>,
     post_init: Option<Py<PyString>>,
     revalidate: Revalidate,
@@ -461,6 +462,7 @@ impl BuildValidator for DataclassValidator {
         let config = config.as_ref();
 
         let class = schema.get_as_req::<Bound<'_, PyType>>(intern!(py, "cls"))?;
+        let generic_origin: Option<Bound<'_, PyType>> = schema.get_as(intern!(py, "generic_origin"))?;
         let name = match schema.get_as_req::<String>(intern!(py, "cls_name")) {
             Ok(name) => name,
             Err(_) => class.getattr(intern!(py, "__name__"))?.extract()?,
@@ -480,6 +482,7 @@ impl BuildValidator for DataclassValidator {
             strict: is_strict(schema, config)?,
             validator: Box::new(validator),
             class: class.into(),
+            generic_origin: generic_origin.map(std::convert::Into::into),
             fields,
             post_init,
             revalidate: Revalidate::from_str(
@@ -496,7 +499,11 @@ impl BuildValidator for DataclassValidator {
     }
 }
 
-impl_py_gc_traverse!(DataclassValidator { class, validator });
+impl_py_gc_traverse!(DataclassValidator {
+    class,
+    generic_origin,
+    validator
+});
 
 impl Validator for DataclassValidator {
     fn validate<'py>(
@@ -510,10 +517,30 @@ impl Validator for DataclassValidator {
             return self.validate_init(py, self_instance, input, state);
         }
 
-        // same logic as on models
+        // same logic as on models, see more explicit comment in model.rs
         let class = self.class.bind(py);
-        if let Some(py_input) = input_as_python_instance(input, class) {
-            if self.revalidate.should_revalidate(py_input, class) {
+        let generic_origin_class = self.generic_origin.as_ref().map(|go| go.bind(py));
+
+        let (py_instance_input, force_revalidate): (Option<&Bound<'_, PyAny>>, bool) =
+            match input_as_python_instance(input, class) {
+                Some(x) => (Some(x), false),
+                None => {
+                    // if the model has a generic origin, we allow input data to be instances of the generic origin rather than the class,
+                    // as cases like isinstance(SomeModel[Int], SomeModel[Any]) fail the isinstance check, but are valid, we just have to enforce
+                    // that the data is revalidated, hence we set force_revalidate to true
+                    if generic_origin_class.is_some() {
+                        match input_as_python_instance(input, generic_origin_class.unwrap()) {
+                            Some(x) => (Some(x), true),
+                            None => (None, false),
+                        }
+                    } else {
+                        (None, false)
+                    }
+                }
+            };
+
+        if let Some(py_input) = py_instance_input {
+            if self.revalidate.should_revalidate(py_input, class) || force_revalidate {
                 let input_dict = self.dataclass_to_dict(py_input)?;
                 let val_output = self.validator.validate(py, input_dict.as_any(), state)?;
                 let dc = create_class(self.class.bind(py))?;
diff --git a/src/validators/model.rs b/src/validators/model.rs
index 2c0cef6fd..1564e7e31 100644
--- a/src/validators/model.rs
+++ b/src/validators/model.rs
@@ -55,6 +55,7 @@ pub struct ModelValidator {
     revalidate: Revalidate,
     validator: Box<CombinedValidator>,
     class: Py<PyType>,
+    generic_origin: Option<Py<PyType>>,
     post_init: Option<Py<PyString>>,
     frozen: bool,
     custom_init: bool,
@@ -76,6 +77,7 @@ impl BuildValidator for ModelValidator {
         let config = schema.get_as(intern!(py, "config"))?;
 
         let class: Bound<'_, PyType> = schema.get_as_req(intern!(py, "cls"))?;
+        let generic_origin: Option<Bound<'_, PyType>> = schema.get_as(intern!(py, "generic_origin"))?;
         let sub_schema = schema.get_as_req(intern!(py, "schema"))?;
         let validator = build_validator(&sub_schema, config.as_ref(), definitions)?;
         let name = class.getattr(intern!(py, "__name__"))?.extract()?;
@@ -93,6 +95,7 @@ impl BuildValidator for ModelValidator {
             )?,
             validator: Box::new(validator),
             class: class.into(),
+            generic_origin: generic_origin.map(std::convert::Into::into),
             post_init: schema.get_as(intern!(py, "post_init"))?,
             frozen: schema.get_as(intern!(py, "frozen"))?.unwrap_or(false),
             custom_init: schema.get_as(intern!(py, "custom_init"))?.unwrap_or(false),
@@ -105,7 +108,11 @@ impl BuildValidator for ModelValidator {
     }
 }
 
-impl_py_gc_traverse!(ModelValidator { class, validator });
+impl_py_gc_traverse!(ModelValidator {
+    class,
+    generic_origin,
+    validator
+});
 
 impl Validator for ModelValidator {
     fn validate<'py>(
@@ -119,13 +126,33 @@ impl Validator for ModelValidator {
             return self.validate_init(py, self_instance, input, state);
         }
 
+        let class = self.class.bind(py);
+        let generic_origin_class = self.generic_origin.as_ref().map(|go| go.bind(py));
+
         // if we're in strict mode, we require an exact instance of the class (from python, with JSON an object is ok)
         // if we're not in strict mode, instances subclasses are okay, as well as dicts, mappings, from attributes etc.
         // if the input is an instance of the class, we "revalidate" it - e.g. we extract and reuse `__pydantic_fields_set__`
         // but use from attributes to create a new instance of the model field type
-        let class = self.class.bind(py);
-        if let Some(py_input) = input_as_python_instance(input, class) {
-            if self.revalidate.should_revalidate(py_input, class) {
+        let (py_instance_input, force_revalidate): (Option<&Bound<'_, PyAny>>, bool) =
+            match input_as_python_instance(input, class) {
+                Some(x) => (Some(x), false),
+                None => {
+                    // if the model has a generic origin, we allow input data to be instances of the generic origin rather than the class,
+                    // as cases like isinstance(SomeModel[Int], SomeModel[Any]) fail the isinstance check, but are valid, we just have to enforce
+                    // that the data is revalidated, hence we set force_revalidate to true
+                    if generic_origin_class.is_some() {
+                        match input_as_python_instance(input, generic_origin_class.unwrap()) {
+                            Some(x) => (Some(x), true),
+                            None => (None, false),
+                        }
+                    } else {
+                        (None, false)
+                    }
+                }
+            };
+
+        if let Some(py_input) = py_instance_input {
+            if self.revalidate.should_revalidate(py_input, class) || force_revalidate {
                 let fields_set = py_input.getattr(intern!(py, DUNDER_FIELDS_SET_KEY))?;
                 if self.root_model {
                     let inner_input = py_input.getattr(intern!(py, ROOT_FIELD))?;

From ff08c20f5708db1cc9ee17c0e43197ea1a5018e0 Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Wed, 23 Oct 2024 12:35:45 +0200
Subject: [PATCH 396/550] Support default factories taking validated data as an
 argument (#1491)

---
 python/pydantic_core/core_schema.py           | 10 +++++--
 .../type_serializers/with_default.rs          | 10 ++++++-
 src/validators/with_default.rs                | 29 +++++++++++++++----
 tests/validators/test_with_default.py         | 10 +++++--
 4 files changed, 47 insertions(+), 12 deletions(-)

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index eeebba834..98ff0c61d 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -2375,7 +2375,8 @@ class WithDefaultSchema(TypedDict, total=False):
     type: Required[Literal['default']]
     schema: Required[CoreSchema]
     default: Any
-    default_factory: Callable[[], Any]
+    default_factory: Union[Callable[[], Any], Callable[[Dict[str, Any]], Any]]
+    default_factory_takes_data: bool
     on_error: Literal['raise', 'omit', 'default']  # default: 'raise'
     validate_default: bool  # default: False
     strict: bool
@@ -2388,7 +2389,8 @@ def with_default_schema(
     schema: CoreSchema,
     *,
     default: Any = PydanticUndefined,
-    default_factory: Callable[[], Any] | None = None,
+    default_factory: Union[Callable[[], Any], Callable[[Dict[str, Any]], Any], None] = None,
+    default_factory_takes_data: bool | None = None,
     on_error: Literal['raise', 'omit', 'default'] | None = None,
     validate_default: bool | None = None,
     strict: bool | None = None,
@@ -2413,7 +2415,8 @@ def with_default_schema(
     Args:
         schema: The schema to add a default value to
         default: The default value to use
-        default_factory: A function that returns the default value to use
+        default_factory: A callable that returns the default value to use
+        default_factory_takes_data: Whether the default factory takes a validated data argument
         on_error: What to do if the schema validation fails. One of 'raise', 'omit', 'default'
         validate_default: Whether the default value should be validated
         strict: Whether the underlying schema should be validated with strict mode
@@ -2425,6 +2428,7 @@ def with_default_schema(
         type='default',
         schema=schema,
         default_factory=default_factory,
+        default_factory_takes_data=default_factory_takes_data,
         on_error=on_error,
         validate_default=validate_default,
         strict=strict,
diff --git a/src/serializers/type_serializers/with_default.rs b/src/serializers/type_serializers/with_default.rs
index 6d510ce55..7a4225d26 100644
--- a/src/serializers/type_serializers/with_default.rs
+++ b/src/serializers/type_serializers/with_default.rs
@@ -72,6 +72,14 @@ impl TypeSerializer for WithDefaultSerializer {
     }
 
     fn get_default(&self, py: Python) -> PyResult<Option<PyObject>> {
-        self.default.default_value(py)
+        if let DefaultType::DefaultFactory(_, _takes_data @ true) = self.default {
+            // We currently don't compute the default if the default factory takes
+            // the data from other fields.
+            Ok(None)
+        } else {
+            self.default.default_value(
+                py, &None, // Won't be used.
+            )
+        }
     }
 }
diff --git a/src/validators/with_default.rs b/src/validators/with_default.rs
index e03830e77..565c31060 100644
--- a/src/validators/with_default.rs
+++ b/src/validators/with_default.rs
@@ -25,7 +25,7 @@ fn get_deepcopy(py: Python) -> PyResult<PyObject> {
 pub enum DefaultType {
     None,
     Default(PyObject),
-    DefaultFactory(PyObject),
+    DefaultFactory(PyObject, bool),
 }
 
 impl DefaultType {
@@ -37,15 +37,32 @@ impl DefaultType {
         ) {
             (Some(_), Some(_)) => py_schema_err!("'default' and 'default_factory' cannot be used together"),
             (Some(default), None) => Ok(Self::Default(default)),
-            (None, Some(default_factory)) => Ok(Self::DefaultFactory(default_factory)),
+            (None, Some(default_factory)) => Ok(Self::DefaultFactory(
+                default_factory,
+                schema
+                    .get_as::<bool>(intern!(py, "default_factory_takes_data"))?
+                    .unwrap_or(false),
+            )),
             (None, None) => Ok(Self::None),
         }
     }
 
-    pub fn default_value(&self, py: Python) -> PyResult<Option<PyObject>> {
+    pub fn default_value(&self, py: Python, validated_data: &Option<Bound<PyDict>>) -> PyResult<Option<PyObject>> {
         match self {
             Self::Default(ref default) => Ok(Some(default.clone_ref(py))),
-            Self::DefaultFactory(ref default_factory) => Ok(Some(default_factory.call0(py)?)),
+            Self::DefaultFactory(ref default_factory, ref takes_data) => {
+                let result = if *takes_data {
+                    if validated_data.is_none() {
+                        default_factory.call1(py, ({},))
+                    } else {
+                        default_factory.call1(py, (validated_data.as_deref().unwrap(),))
+                    }
+                } else {
+                    default_factory.call0(py)
+                };
+
+                Ok(Some(result?))
+            }
             Self::None => Ok(None),
         }
     }
@@ -53,7 +70,7 @@ impl DefaultType {
 
 impl PyGcTraverse for DefaultType {
     fn py_gc_traverse(&self, visit: &PyVisit<'_>) -> Result<(), PyTraverseError> {
-        if let Self::Default(obj) | Self::DefaultFactory(obj) = self {
+        if let Self::Default(obj) | Self::DefaultFactory(obj, _) = self {
             visit.call(obj)?;
         }
         Ok(())
@@ -163,7 +180,7 @@ impl Validator for WithDefaultValidator {
         outer_loc: Option<impl Into<LocItem>>,
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<Option<PyObject>> {
-        match self.default.default_value(py)? {
+        match self.default.default_value(py, &state.extra().data)? {
             Some(stored_dft) => {
                 let dft: Py<PyAny> = if self.copy_default {
                     let deepcopy_func = COPY_DEEPCOPY.get_or_init(py, || get_deepcopy(py).unwrap());
diff --git a/tests/validators/test_with_default.py b/tests/validators/test_with_default.py
index 189a555bb..105241140 100644
--- a/tests/validators/test_with_default.py
+++ b/tests/validators/test_with_default.py
@@ -227,12 +227,18 @@ def broken():
         v.validate_python('wrong')
 
 
-def test_factory_type_error():
+def test_factory_missing_arg():
     def broken(x):
         return 7
 
     v = SchemaValidator(
-        {'type': 'default', 'schema': {'type': 'int'}, 'on_error': 'default', 'default_factory': broken}
+        {
+            'type': 'default',
+            'schema': {'type': 'int'},
+            'on_error': 'default',
+            'default_factory': broken,
+            'default_factory_takes_data': False,
+        }
     )
     assert v.validate_python(42) == 42
     assert v.validate_python('42') == 42

From e49c549f6fe1c0c9ff5314238aa36f7629101446 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Wed, 23 Oct 2024 06:51:35 -0400
Subject: [PATCH 397/550] Bump version to v2.25.0 (#1492)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 26acf7dd4..eef740ed2 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -425,7 +425,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.24.2"
+version = "2.25.0"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index 99b9db13e..807479406 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.24.2"
+version = "2.25.0"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From d1aff8970e3c3226783817374a2a7852b763b9c2 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 23 Oct 2024 13:33:24 +0000
Subject: [PATCH 398/550] Bump uraimo/run-on-arch-action from 2.7.2 to 2.8.1
 (#1493)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 5476191fe..7d2714e13 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -658,7 +658,7 @@ jobs:
           merge-multiple: true
           path: dist
 
-      - uses: uraimo/run-on-arch-action@v2.7.2
+      - uses: uraimo/run-on-arch-action@v2.8.1
         name: install & test
         with:
           arch: ${{ matrix.target }}

From e62befe2c7cbb0ac54267562115fb468acd403a4 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 23 Oct 2024 13:33:38 +0000
Subject: [PATCH 399/550] Bump serde_json from 1.0.128 to 1.0.132 (#1494)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index eef740ed2..9d4dd223e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -601,9 +601,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.128"
+version = "1.0.132"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6ff5456707a1de34e7e37f2a6fd3d3f808c318259cbd01ab6377795054b483d8"
+checksum = "d726bfaff4b320266d395898905d0eba0345aae23b54aee3a737e260fd46db03"
 dependencies = [
  "indexmap",
  "itoa",
diff --git a/Cargo.toml b/Cargo.toml
index 807479406..4f850f4ab 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -33,7 +33,7 @@ pyo3 = { version = "0.22.3", features = ["generate-import-lib", "num-bigint", "p
 regex = "1.11.0"
 strum = { version = "0.26.3", features = ["derive"] }
 strum_macros = "0.26.4"
-serde_json = {version = "1.0.128", features = ["arbitrary_precision", "preserve_order"]}
+serde_json = {version = "1.0.132", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.13"
 serde = { version = "1.0.210", features = ["derive"] }
 speedate = "0.14.4"

From 75738b006ff5ce89efe8988b567fe705830344fc Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 23 Oct 2024 13:40:29 +0000
Subject: [PATCH 400/550] Bump serde from 1.0.210 to 1.0.213 (#1495)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 12 ++++++------
 Cargo.toml |  2 +-
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 9d4dd223e..e53ce4499 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -581,18 +581,18 @@ checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
 
 [[package]]
 name = "serde"
-version = "1.0.210"
+version = "1.0.213"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8e3592472072e6e22e0a54d5904d9febf8508f65fb8552499a1abc7d1078c3a"
+checksum = "3ea7893ff5e2466df8d720bb615088341b295f849602c6956047f8f80f0e9bc1"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.210"
+version = "1.0.213"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "243902eda00fad750862fc144cea25caca5e20d615af0a81bee94ca738f1df1f"
+checksum = "7e85ad2009c50b58e87caa8cd6dac16bdf511bbfb7af6c33df902396aa480fa5"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -664,9 +664,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.68"
+version = "2.0.82"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "901fa70d88b9d6c98022e23b4136f9f3e54e4662c3bc1bd1d84a42a9a0f0c1e9"
+checksum = "83540f837a8afc019423a8edb95b52a8effe46957ee402287f4292fae35be021"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/Cargo.toml b/Cargo.toml
index 4f850f4ab..a851d2fc9 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -35,7 +35,7 @@ strum = { version = "0.26.3", features = ["derive"] }
 strum_macros = "0.26.4"
 serde_json = {version = "1.0.132", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.13"
-serde = { version = "1.0.210", features = ["derive"] }
+serde = { version = "1.0.213", features = ["derive"] }
 speedate = "0.14.4"
 smallvec = "1.13.2"
 ahash = "0.8.10"

From ed8f2e1b51e4b8de82fa104ae08ff6399af35593 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 23 Oct 2024 13:40:43 +0000
Subject: [PATCH 401/550] Bump uuid from 1.10.0 to 1.11.0 (#1496)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index e53ce4499..8f15bb376 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -773,9 +773,9 @@ checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
 
 [[package]]
 name = "uuid"
-version = "1.10.0"
+version = "1.11.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "81dfa00651efa65069b0b6b651f4aaa31ba9e3c3ce0137aaad053604ee7e0314"
+checksum = "f8c5f0a0af699448548ad1a2fbf920fb4bee257eae39953ba95cb84891a0446a"
 
 [[package]]
 name = "version_check"
diff --git a/Cargo.toml b/Cargo.toml
index a851d2fc9..f0b5364ca 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -45,7 +45,7 @@ idna = "1.0.2"
 base64 = "0.22.1"
 num-bigint = "0.4.6"
 python3-dll-a = "0.2.10"
-uuid = "1.10.0"
+uuid = "1.11.0"
 jiter = { version = "0.5", features = ["python"] }
 hex = "0.4.3"
 

From e161980670f3dbbefb11d0f15268a7b21e5a1686 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 23 Oct 2024 13:58:06 +0000
Subject: [PATCH 402/550] Bump pyo3 from 0.22.3 to 0.22.5 (#1497)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 20 ++++++++++----------
 Cargo.toml |  4 ++--
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 8f15bb376..102979305 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -451,9 +451,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.22.3"
+version = "0.22.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "15ee168e30649f7f234c3d49ef5a7a6cbf5134289bc46c29ff3155fa3221c225"
+checksum = "3d922163ba1f79c04bc49073ba7b32fd5a8d3b76a87c955921234b8e77333c51"
 dependencies = [
  "cfg-if",
  "indoc",
@@ -470,9 +470,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.22.3"
+version = "0.22.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e61cef80755fe9e46bb8a0b8f20752ca7676dcc07a5277d8b7768c6172e529b3"
+checksum = "bc38c5feeb496c8321091edf3d63e9a6829eab4b863b4a6a65f26f3e9cc6b179"
 dependencies = [
  "once_cell",
  "python3-dll-a",
@@ -481,9 +481,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.22.3"
+version = "0.22.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "67ce096073ec5405f5ee2b8b31f03a68e02aa10d5d4f565eca04acc41931fa1c"
+checksum = "94845622d88ae274d2729fcefc850e63d7a3ddff5e3ce11bd88486db9f1d357d"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -491,9 +491,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.22.3"
+version = "0.22.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "2440c6d12bc8f3ae39f1e775266fa5122fd0c8891ce7520fa6048e683ad3de28"
+checksum = "e655aad15e09b94ffdb3ce3d217acf652e26bbc37697ef012f5e5e348c716e5e"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -503,9 +503,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.22.3"
+version = "0.22.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1be962f0e06da8f8465729ea2cb71a416d2257dff56cbe40a70d3e62a93ae5d1"
+checksum = "ae1e3f09eecd94618f60a455a23def79f79eba4dc561a97324bf9ac8c6df30ce"
 dependencies = [
  "heck",
  "proc-macro2",
diff --git a/Cargo.toml b/Cargo.toml
index f0b5364ca..87d625640 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -29,7 +29,7 @@ rust-version = "1.75"
 [dependencies]
 # TODO it would be very nice to remove the "py-clone" feature as it can panic,
 # but needs a bit of work to make sure it's not used in the codebase
-pyo3 = { version = "0.22.3", features = ["generate-import-lib", "num-bigint", "py-clone"] }
+pyo3 = { version = "0.22.5", features = ["generate-import-lib", "num-bigint", "py-clone"] }
 regex = "1.11.0"
 strum = { version = "0.26.3", features = ["derive"] }
 strum_macros = "0.26.4"
@@ -74,7 +74,7 @@ debug = true
 strip = false
 
 [dev-dependencies]
-pyo3 = { version = "0.22.3", features = ["auto-initialize"] }
+pyo3 = { version = "0.22.5", features = ["auto-initialize"] }
 
 [build-dependencies]
 version_check = "0.9.5"

From 7c70e3b33868eacfc68ce936a2dbf9ac4985affa Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 23 Oct 2024 14:10:27 +0000
Subject: [PATCH 403/550] Bump jiter from 0.5.0 to 0.6.1 (#1498)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock             | 4 ++--
 Cargo.toml             | 2 +-
 src/lib.rs             | 4 ++--
 src/validators/json.rs | 3 ++-
 4 files changed, 7 insertions(+), 6 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 102979305..c1ed5106b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -297,9 +297,9 @@ checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
 
 [[package]]
 name = "jiter"
-version = "0.5.0"
+version = "0.6.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02e23549143ef50eddffd46ba8cd0229b0a4500aef7518cf2eb0f41c9a09d22b"
+checksum = "a9d54b46955906f90a4ba92a18bb2d3c6dbaf1d95acbbd112da0657e5297b432"
 dependencies = [
  "ahash",
  "bitvec",
diff --git a/Cargo.toml b/Cargo.toml
index 87d625640..b35a10e67 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -46,7 +46,7 @@ base64 = "0.22.1"
 num-bigint = "0.4.6"
 python3-dll-a = "0.2.10"
 uuid = "1.11.0"
-jiter = { version = "0.5", features = ["python"] }
+jiter = { version = "0.6", features = ["python"] }
 hex = "0.4.3"
 
 [lib]
diff --git a/src/lib.rs b/src/lib.rs
index d1e042863..0fdb038ea 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -4,7 +4,7 @@ extern crate core;
 
 use std::sync::OnceLock;
 
-use jiter::{map_json_error, PartialMode, PythonParse, StringCacheMode};
+use jiter::{map_json_error, FloatMode, PartialMode, PythonParse, StringCacheMode};
 use pyo3::exceptions::PyTypeError;
 use pyo3::{prelude::*, sync::GILOnceCell};
 use serializers::BytesMode;
@@ -61,7 +61,7 @@ pub fn from_json<'py>(
         cache_mode: cache_strings,
         partial_mode: allow_partial,
         catch_duplicate_keys: false,
-        lossless_floats: false,
+        float_mode: FloatMode::Float,
     };
     parse_builder
         .python_parse(py, json_bytes)
diff --git a/src/validators/json.rs b/src/validators/json.rs
index f86cc4624..79a36e058 100644
--- a/src/validators/json.rs
+++ b/src/validators/json.rs
@@ -1,3 +1,4 @@
+use jiter::FloatMode;
 use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
@@ -71,7 +72,7 @@ impl Validator for JsonValidator {
                     cache_mode: state.cache_str(),
                     partial_mode: PartialMode::Off,
                     catch_duplicate_keys: false,
-                    lossless_floats: false,
+                    float_mode: FloatMode::Float,
                 };
                 let obj = parse_builder
                     .python_parse(py, json_bytes)

From 9b21b0f624701e9dca45366f8a5fcb4c38640c8d Mon Sep 17 00:00:00 2001
From: Youssef Fares <youssefe.fares@gmail.com>
Date: Thu, 24 Oct 2024 04:51:01 -0400
Subject: [PATCH 404/550] Allow subclassing ValidationError and
 PydanticCustomError (#1413)

---
 python/pydantic_core/_pydantic_core.pyi |   8 +-
 src/errors/validation_exception.rs      |  44 ++++---
 src/errors/value_exception.rs           |   2 +-
 tests/test_custom_errors.py             | 150 ++++++++++++++++++++++++
 4 files changed, 180 insertions(+), 24 deletions(-)
 create mode 100644 tests/test_custom_errors.py

diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index adff512c9..2b06ee54c 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -744,20 +744,19 @@ class SchemaError(Exception):
             A list of [`ErrorDetails`][pydantic_core.ErrorDetails] for each error in the schema.
         """
 
-@final
 class ValidationError(ValueError):
     """
     `ValidationError` is the exception raised by `pydantic-core` when validation fails, it contains a list of errors
     which detail why validation failed.
     """
-
-    @staticmethod
+    @classmethod
     def from_exception_data(
+        cls,
         title: str,
         line_errors: list[InitErrorDetails],
         input_type: Literal['python', 'json'] = 'python',
         hide_input: bool = False,
-    ) -> ValidationError:
+    ) -> Self:
         """
         Python constructor for a Validation Error.
 
@@ -828,7 +827,6 @@ class ValidationError(ValueError):
         before the first validation error is created.
         """
 
-@final
 class PydanticCustomError(ValueError):
     """A custom exception providing flexible error handling for Pydantic validators.
 
diff --git a/src/errors/validation_exception.rs b/src/errors/validation_exception.rs
index 8d3b4eca0..6fc0e96bd 100644
--- a/src/errors/validation_exception.rs
+++ b/src/errors/validation_exception.rs
@@ -7,7 +7,7 @@ use pyo3::ffi;
 use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::sync::GILOnceCell;
-use pyo3::types::{PyDict, PyList, PyString};
+use pyo3::types::{PyDict, PyList, PyString, PyType};
 use serde::ser::{Error, SerializeMap, SerializeSeq};
 use serde::{Serialize, Serializer};
 
@@ -26,7 +26,7 @@ use super::types::ErrorType;
 use super::value_exception::PydanticCustomError;
 use super::{InputValue, ValError};
 
-#[pyclass(extends=PyValueError, module="pydantic_core._pydantic_core")]
+#[pyclass(extends=PyValueError, module="pydantic_core._pydantic_core", subclass)]
 #[derive(Clone)]
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub struct ValidationError {
@@ -248,27 +248,35 @@ impl ValidationError {
 
 #[pymethods]
 impl ValidationError {
-    #[staticmethod]
+    #[new]
     #[pyo3(signature = (title, line_errors, input_type="python", hide_input=false))]
-    fn from_exception_data(
-        py: Python,
+    fn py_new(title: PyObject, line_errors: Vec<PyLineError>, input_type: &str, hide_input: bool) -> PyResult<Self> {
+        Ok(Self {
+            line_errors,
+            title,
+            input_type: InputType::try_from(input_type)?,
+            hide_input,
+        })
+    }
+
+    #[classmethod]
+    #[pyo3(signature = (title, line_errors, input_type="python", hide_input=false))]
+    fn from_exception_data<'py>(
+        cls: &Bound<'py, PyType>,
         title: PyObject,
         line_errors: Bound<'_, PyList>,
         input_type: &str,
         hide_input: bool,
-    ) -> PyResult<Py<Self>> {
-        Py::new(
-            py,
-            Self {
-                line_errors: line_errors
-                    .iter()
-                    .map(|error| PyLineError::try_from(&error))
-                    .collect::<PyResult<_>>()?,
-                title,
-                input_type: InputType::try_from(input_type)?,
-                hide_input,
-            },
-        )
+    ) -> PyResult<Bound<'py, PyAny>> {
+        cls.call1((
+            title,
+            line_errors
+                .iter()
+                .map(|error| PyLineError::try_from(&error))
+                .collect::<PyResult<Vec<PyLineError>>>()?,
+            InputType::try_from(input_type)?,
+            hide_input,
+        ))
     }
 
     #[getter]
diff --git a/src/errors/value_exception.rs b/src/errors/value_exception.rs
index 793bcd0b5..d428dc524 100644
--- a/src/errors/value_exception.rs
+++ b/src/errors/value_exception.rs
@@ -54,7 +54,7 @@ impl PydanticUseDefault {
     }
 }
 
-#[pyclass(extends=PyValueError, module="pydantic_core._pydantic_core")]
+#[pyclass(extends=PyValueError, module="pydantic_core._pydantic_core", subclass)]
 #[derive(Debug, Clone, Default)]
 pub struct PydanticCustomError {
     error_type: String,
diff --git a/tests/test_custom_errors.py b/tests/test_custom_errors.py
new file mode 100644
index 000000000..741ab9679
--- /dev/null
+++ b/tests/test_custom_errors.py
@@ -0,0 +1,150 @@
+from typing import Any, Dict, List, Optional
+from unittest import TestCase
+from unittest.mock import ANY
+
+import pytest
+from typing_extensions import LiteralString, Self, override
+
+from pydantic_core import ErrorDetails, InitErrorDetails, PydanticCustomError, ValidationError
+
+
+def test_validation_error_subclassable():
+    """Assert subclassable and inheritance hierarchy as expected"""
+
+    class CustomValidationError(ValidationError):
+        pass
+
+    with pytest.raises(ValidationError) as exception_info:
+        raise CustomValidationError.from_exception_data(
+            'My CustomError',
+            [
+                InitErrorDetails(
+                    type='value_error',
+                    loc=('myField',),
+                    msg='This is my custom error.',
+                    input='something invalid',
+                    ctx={
+                        'myField': 'something invalid',
+                        'error': "'something invalid' is not a valid value for 'myField'",
+                    },
+                )
+            ],
+        )
+    assert isinstance(exception_info.value, CustomValidationError)
+
+
+def test_validation_error_loc_overrides():
+    """Override methods in rust pyclass and assert change in behavior: ValidationError.errors"""
+
+    class CustomLocOverridesError(ValidationError):
+        """Unnests some errors"""
+
+        @override
+        def errors(
+            self, *, include_url: bool = True, include_context: bool = True, include_input: bool = True
+        ) -> List[ErrorDetails]:
+            errors = super().errors(
+                include_url=include_url, include_context=include_context, include_input=include_input
+            )
+            return [{**error, 'loc': error['loc'][1:]} for error in errors]
+
+    with pytest.raises(CustomLocOverridesError) as exception_info:
+        raise CustomLocOverridesError.from_exception_data(
+            'My CustomError',
+            [
+                InitErrorDetails(
+                    type='value_error',
+                    loc=(
+                        'hide_this',
+                        'myField',
+                    ),
+                    msg='This is my custom error.',
+                    input='something invalid',
+                    ctx={
+                        'myField': 'something invalid',
+                        'error': "'something invalid' is not a valid value for 'myField'",
+                    },
+                ),
+                InitErrorDetails(
+                    type='value_error',
+                    loc=(
+                        'hide_this',
+                        'myFieldToo',
+                    ),
+                    msg='This is my custom error.',
+                    input='something invalid',
+                    ctx={
+                        'myFieldToo': 'something invalid',
+                        'error': "'something invalid' is not a valid value for 'myFieldToo'",
+                    },
+                ),
+            ],
+        )
+
+    TestCase().assertCountEqual(
+        exception_info.value.errors(),
+        [
+            {
+                'type': 'value_error',
+                'loc': ('myField',),
+                'msg': "Value error, 'something invalid' is not a valid value for 'myField'",
+                'input': 'something invalid',
+                'ctx': {
+                    'error': "'something invalid' is not a valid value for 'myField'",
+                    'myField': 'something invalid',
+                },
+                'url': ANY,
+            },
+            {
+                'type': 'value_error',
+                'loc': ('myFieldToo',),
+                'msg': "Value error, 'something invalid' is not a valid value for 'myFieldToo'",
+                'input': 'something invalid',
+                'ctx': {
+                    'error': "'something invalid' is not a valid value for 'myFieldToo'",
+                    'myFieldToo': 'something invalid',
+                },
+                'url': ANY,
+            },
+        ],
+    )
+
+
+def test_custom_pydantic_error_subclassable():
+    """Assert subclassable and inheritance hierarchy as expected"""
+
+    class MyCustomError(PydanticCustomError):
+        pass
+
+    with pytest.raises(PydanticCustomError) as exception_info:
+        raise MyCustomError(
+            'not_my_custom_thing',
+            "value is not compatible with my custom field, got '{wrong_value}'",
+            {'wrong_value': 'non compatible value'},
+        )
+    assert isinstance(exception_info.value, MyCustomError)
+
+
+def test_custom_pydantic_error_overrides():
+    """Override methods in rust pyclass and assert change in behavior: PydanticCustomError.__new__"""
+
+    class CustomErrorWithCustomTemplate(PydanticCustomError):
+        @override
+        def __new__(
+            cls, error_type: LiteralString, my_custom_setting: str, context: Optional[Dict[str, Any]] = None
+        ) -> Self:
+            message_template = (
+                "'{my_custom_value}' setting requires a specific my custom field value, got '{wrong_value}'"
+            )
+            context = {**context, 'my_custom_value': my_custom_setting}
+            return super().__new__(cls, error_type, message_template, context)
+
+    with pytest.raises(CustomErrorWithCustomTemplate) as exception_info:
+        raise CustomErrorWithCustomTemplate(
+            'not_my_custom_thing', 'my_setting', {'wrong_value': 'non compatible value'}
+        )
+
+    assert (
+        exception_info.value.message()
+        == "'my_setting' setting requires a specific my custom field value, got 'non compatible value'"
+    )

From 9b29661c23c01982e74ab12099017cecccd5c657 Mon Sep 17 00:00:00 2001
From: Riya Sinha <33243383+riyavsinha@users.noreply.github.com>
Date: Tue, 29 Oct 2024 04:00:13 -0700
Subject: [PATCH 405/550] Update Pyodide to v0.26.3 (#1507)

---
 .github/workflows/ci.yml  | 2 +-
 Makefile                  | 4 ++--
 package.json              | 2 +-
 wasm-preview/run_tests.py | 2 +-
 wasm-preview/worker.js    | 2 +-
 5 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 7d2714e13..1338b812d 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -341,7 +341,7 @@ jobs:
           # NOTE!: as per https://github.com/pydantic/pydantic-core/pull/149 this version needs to match the version
           # in node_modules/pyodide/repodata.json, to get the version, run:
           # `cat node_modules/pyodide/repodata.json | python -m json.tool | rg platform`
-          version: '3.1.46'
+          version: '3.1.58'
           actions-cache-folder: emsdk-cache
 
       - run: pip install 'maturin>=1,<2' 'ruff==0.5.0' typing_extensions
diff --git a/Makefile b/Makefile
index f860ae6aa..ad9de667b 100644
--- a/Makefile
+++ b/Makefile
@@ -84,8 +84,8 @@ endif
 
 .PHONY: build-wasm
 build-wasm:
-	@echo 'This requires python 3.11, maturin and emsdk to be installed'
-	maturin build --release --target wasm32-unknown-emscripten --out dist -i 3.11
+	@echo 'This requires python 3.12, maturin and emsdk to be installed'
+	maturin build --release --target wasm32-unknown-emscripten --out dist -i 3.12
 	ls -lh dist
 
 .PHONY: format
diff --git a/package.json b/package.json
index 8bb850741..ecfc0372e 100644
--- a/package.json
+++ b/package.json
@@ -8,7 +8,7 @@
   "main": "tests/emscripten_runner.js",
   "dependencies": {
     "prettier": "^2.7.1",
-    "pyodide": "^0.25.0"
+    "pyodide": "^0.26.3"
   },
   "scripts": {
     "test": "node tests/emscripten_runner.js",
diff --git a/wasm-preview/run_tests.py b/wasm-preview/run_tests.py
index 776f7a8e2..03a26e088 100644
--- a/wasm-preview/run_tests.py
+++ b/wasm-preview/run_tests.py
@@ -21,7 +21,7 @@ async def main(tests_zip: str, tag_name: str):
     # File saved on the GH release
     pydantic_core_wheel = (
         'https://githubproxy.samuelcolvin.workers.dev/pydantic/pydantic-core/releases/'
-        f'download/{tag_name}/pydantic_core-{tag_name.lstrip("v")}-cp311-cp311-emscripten_3_1_46_wasm32.whl'
+        f'download/{tag_name}/pydantic_core-{tag_name.lstrip("v")}-cp312-cp312-emscripten_3_1_58_wasm32.whl'
     )
     zip_file = ZipFile(BytesIO(base64.b64decode(tests_zip)))
     count = 0
diff --git a/wasm-preview/worker.js b/wasm-preview/worker.js
index c6223ecbd..93508f1c2 100644
--- a/wasm-preview/worker.js
+++ b/wasm-preview/worker.js
@@ -89,7 +89,7 @@ async function main() {
       get(`./run_tests.py?v=${Date.now()}`, 'text'),
       // e4cf2e2 commit matches the pydantic-core wheel being used, so tests should pass
       get(zip_url, 'blob'),
-      importScripts('https://cdn.jsdelivr.net/pyodide/v0.25.0/full/pyodide.js'),
+      importScripts('https://cdn.jsdelivr.net/pyodide/v0.26.3/full/pyodide.js'),
     ]);
 
     const pyodide = await loadPyodide();

From 8568136ee9abdca8a1c8b631750a4896bb25522e Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Tue, 29 Oct 2024 08:33:26 -0400
Subject: [PATCH 406/550] Revert "feat: add 'millisecond' option to
 `ser_json_timedelta`" (#1503)

---
 python/pydantic_core/_pydantic_core.pyi       |   8 +-
 python/pydantic_core/core_schema.py           |   2 +-
 src/input/datetime.rs                         |  87 ----------
 src/serializers/config.rs                     |  42 +++--
 src/serializers/infer.rs                      |   4 +-
 src/serializers/type_serializers/timedelta.rs |   6 +-
 tests/serializers/test_any.py                 | 161 +++---------------
 tests/serializers/test_pickling.py            |   2 +-
 tests/serializers/test_timedelta.py           |   2 +-
 tests/test_garbage_collection.py              |   2 +-
 10 files changed, 57 insertions(+), 259 deletions(-)

diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index 2b06ee54c..d696ac407 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -357,7 +357,7 @@ def to_json(
     by_alias: bool = True,
     exclude_none: bool = False,
     round_trip: bool = False,
-    timedelta_mode: Literal['iso8601', 'seconds_float', 'milliseconds_float'] = 'iso8601',
+    timedelta_mode: Literal['iso8601', 'float'] = 'iso8601',
     bytes_mode: Literal['utf8', 'base64', 'hex'] = 'utf8',
     inf_nan_mode: Literal['null', 'constants', 'strings'] = 'constants',
     serialize_unknown: bool = False,
@@ -378,7 +378,7 @@ def to_json(
         by_alias: Whether to use the alias names of fields.
         exclude_none: Whether to exclude fields that have a value of `None`.
         round_trip: Whether to enable serialization and validation round-trip support.
-        timedelta_mode: How to serialize `timedelta` objects, either `'iso8601'`, `'seconds_float'` or `'milliseconds_float'`.
+        timedelta_mode: How to serialize `timedelta` objects, either `'iso8601'` or `'float'`.
         bytes_mode: How to serialize `bytes` objects, either `'utf8'`, `'base64'`, or `'hex'`.
         inf_nan_mode: How to serialize `Infinity`, `-Infinity` and `NaN` values, either `'null'`, `'constants'`, or `'strings'`.
         serialize_unknown: Attempt to serialize unknown types, `str(value)` will be used, if that fails
@@ -432,7 +432,7 @@ def to_jsonable_python(
     by_alias: bool = True,
     exclude_none: bool = False,
     round_trip: bool = False,
-    timedelta_mode: Literal['iso8601', 'seconds_float', 'milliseconds_float'] = 'iso8601',
+    timedelta_mode: Literal['iso8601', 'float'] = 'iso8601',
     bytes_mode: Literal['utf8', 'base64', 'hex'] = 'utf8',
     inf_nan_mode: Literal['null', 'constants', 'strings'] = 'constants',
     serialize_unknown: bool = False,
@@ -453,7 +453,7 @@ def to_jsonable_python(
         by_alias: Whether to use the alias names of fields.
         exclude_none: Whether to exclude fields that have a value of `None`.
         round_trip: Whether to enable serialization and validation round-trip support.
-        timedelta_mode: How to serialize `timedelta` objects, either `'iso8601'`, `'seconds_float'`, or`'milliseconds_float'`.
+        timedelta_mode: How to serialize `timedelta` objects, either `'iso8601'` or `'float'`.
         bytes_mode: How to serialize `bytes` objects, either `'utf8'`, `'base64'`, or `'hex'`.
         inf_nan_mode: How to serialize `Infinity`, `-Infinity` and `NaN` values, either `'null'`, `'constants'`, or `'strings'`.
         serialize_unknown: Attempt to serialize unknown types, `str(value)` will be used, if that fails
diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index 98ff0c61d..5a8646fca 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -105,7 +105,7 @@ class CoreConfig(TypedDict, total=False):
     # fields related to float fields only
     allow_inf_nan: bool  # default: True
     # the config options are used to customise serialization to JSON
-    ser_json_timedelta: Literal['iso8601', 'seconds_float', 'milliseconds_float']  # default: 'iso8601'
+    ser_json_timedelta: Literal['iso8601', 'float']  # default: 'iso8601'
     ser_json_bytes: Literal['utf8', 'base64', 'hex']  # default: 'utf8'
     ser_json_inf_nan: Literal['null', 'constants', 'strings']  # default: 'null'
     val_json_bytes: Literal['utf8', 'base64', 'hex']  # default: 'utf8'
diff --git a/src/input/datetime.rs b/src/input/datetime.rs
index db5daff40..577a91014 100644
--- a/src/input/datetime.rs
+++ b/src/input/datetime.rs
@@ -109,93 +109,6 @@ impl<'a> EitherTimedelta<'a> {
             Self::Raw(duration) => duration_as_pytimedelta(py, duration),
         }
     }
-
-    pub fn total_seconds(&self) -> PyResult<f64> {
-        match self {
-            Self::Raw(timedelta) => {
-                let mut days: i64 = i64::from(timedelta.day);
-                let mut seconds: i64 = i64::from(timedelta.second);
-                let mut microseconds = i64::from(timedelta.microsecond);
-                if !timedelta.positive {
-                    days = -days;
-                    seconds = -seconds;
-                    microseconds = -microseconds;
-                }
-
-                let days_seconds = (86_400 * days) + seconds;
-                if let Some(days_seconds_as_micros) = days_seconds.checked_mul(1_000_000) {
-                    let total_microseconds = days_seconds_as_micros + microseconds;
-                    Ok(total_microseconds as f64 / 1_000_000.0)
-                } else {
-                    // Fall back to floating-point operations if the multiplication overflows
-                    let total_seconds = days_seconds as f64 + microseconds as f64 / 1_000_000.0;
-                    Ok(total_seconds)
-                }
-            }
-            Self::PyExact(py_timedelta) => {
-                let days: i64 = py_timedelta.get_days().into(); // -999999999 to 999999999
-                let seconds: i64 = py_timedelta.get_seconds().into(); // 0 through 86399
-                let microseconds = py_timedelta.get_microseconds(); // 0 through 999999
-                let days_seconds = (86_400 * days) + seconds;
-                if let Some(days_seconds_as_micros) = days_seconds.checked_mul(1_000_000) {
-                    let total_microseconds = days_seconds_as_micros + i64::from(microseconds);
-                    Ok(total_microseconds as f64 / 1_000_000.0)
-                } else {
-                    // Fall back to floating-point operations if the multiplication overflows
-                    let total_seconds = days_seconds as f64 + f64::from(microseconds) / 1_000_000.0;
-                    Ok(total_seconds)
-                }
-            }
-            Self::PySubclass(py_timedelta) => py_timedelta
-                .call_method0(intern!(py_timedelta.py(), "total_seconds"))?
-                .extract(),
-        }
-    }
-
-    pub fn total_milliseconds(&self) -> PyResult<f64> {
-        match self {
-            Self::Raw(timedelta) => {
-                let mut days: i64 = i64::from(timedelta.day);
-                let mut seconds: i64 = i64::from(timedelta.second);
-                let mut microseconds = i64::from(timedelta.microsecond);
-                if !timedelta.positive {
-                    days = -days;
-                    seconds = -seconds;
-                    microseconds = -microseconds;
-                }
-
-                let days_seconds = (86_400 * days) + seconds;
-                if let Some(days_seconds_as_micros) = days_seconds.checked_mul(1_000_000) {
-                    let total_microseconds = days_seconds_as_micros + microseconds;
-                    Ok(total_microseconds as f64 / 1_000.0)
-                } else {
-                    // Fall back to floating-point operations if the multiplication overflows
-                    let total_seconds = days_seconds as f64 + microseconds as f64 / 1_000.0;
-                    Ok(total_seconds)
-                }
-            }
-            Self::PyExact(py_timedelta) => {
-                let days: i64 = py_timedelta.get_days().into(); // -999999999 to 999999999
-                let seconds: i64 = py_timedelta.get_seconds().into(); // 0 through 86399
-                let microseconds = py_timedelta.get_microseconds(); // 0 through 999999
-                let days_seconds = (86_400 * days) + seconds;
-                if let Some(days_seconds_as_micros) = days_seconds.checked_mul(1_000_000) {
-                    let total_microseconds = days_seconds_as_micros + i64::from(microseconds);
-                    Ok(total_microseconds as f64 / 1_000.0)
-                } else {
-                    // Fall back to floating-point operations if the multiplication overflows
-                    let total_milliseconds = days_seconds as f64 * 1_000.0 + f64::from(microseconds) / 1_000.0;
-                    Ok(total_milliseconds)
-                }
-            }
-            Self::PySubclass(py_timedelta) => {
-                let total_seconds: f64 = py_timedelta
-                    .call_method0(intern!(py_timedelta.py(), "total_seconds"))?
-                    .extract()?;
-                Ok(total_seconds / 1000.0)
-            }
-        }
-    }
 }
 
 impl<'a> TryFrom<&'_ Bound<'a, PyAny>> for EitherTimedelta<'a> {
diff --git a/src/serializers/config.rs b/src/serializers/config.rs
index 8b1367958..13a833176 100644
--- a/src/serializers/config.rs
+++ b/src/serializers/config.rs
@@ -4,7 +4,7 @@ use std::str::{from_utf8, FromStr, Utf8Error};
 use base64::Engine;
 use pyo3::intern;
 use pyo3::prelude::*;
-use pyo3::types::{PyDict, PyString};
+use pyo3::types::{PyDelta, PyDict, PyString};
 
 use serde::ser::Error;
 
@@ -88,8 +88,7 @@ serialization_mode! {
     TimedeltaMode,
     "ser_json_timedelta",
     Iso8601 => "iso8601",
-    SecondsFloat => "seconds_float",
-    MillisecondsFloat => "milliseconds_float"
+    Float => "float",
 }
 
 serialization_mode! {
@@ -109,42 +108,43 @@ serialization_mode! {
 }
 
 impl TimedeltaMode {
+    fn total_seconds<'py>(py_timedelta: &Bound<'py, PyDelta>) -> PyResult<Bound<'py, PyAny>> {
+        py_timedelta.call_method0(intern!(py_timedelta.py(), "total_seconds"))
+    }
+
     pub fn either_delta_to_json(self, py: Python, either_delta: &EitherTimedelta) -> PyResult<PyObject> {
         match self {
             Self::Iso8601 => {
                 let d = either_delta.to_duration()?;
                 Ok(d.to_string().into_py(py))
             }
-            Self::SecondsFloat => {
-                let seconds: f64 = either_delta.total_seconds()?;
+            Self::Float => {
+                // convert to int via a py timedelta not duration since we know this this case the input would have
+                // been a py timedelta
+                let py_timedelta = either_delta.try_into_py(py)?;
+                let seconds = Self::total_seconds(&py_timedelta)?;
                 Ok(seconds.into_py(py))
             }
-            Self::MillisecondsFloat => {
-                let milliseconds: f64 = either_delta.total_milliseconds()?;
-                Ok(milliseconds.into_py(py))
-            }
         }
     }
 
-    pub fn json_key<'py>(self, either_delta: &EitherTimedelta) -> PyResult<Cow<'py, str>> {
+    pub fn json_key<'py>(self, py: Python, either_delta: &EitherTimedelta) -> PyResult<Cow<'py, str>> {
         match self {
             Self::Iso8601 => {
                 let d = either_delta.to_duration()?;
                 Ok(d.to_string().into())
             }
-            Self::SecondsFloat => {
-                let seconds: f64 = either_delta.total_seconds()?;
+            Self::Float => {
+                let py_timedelta = either_delta.try_into_py(py)?;
+                let seconds: f64 = Self::total_seconds(&py_timedelta)?.extract()?;
                 Ok(seconds.to_string().into())
             }
-            Self::MillisecondsFloat => {
-                let milliseconds: f64 = either_delta.total_milliseconds()?;
-                Ok(milliseconds.to_string().into())
-            }
         }
     }
 
     pub fn timedelta_serialize<S: serde::ser::Serializer>(
         self,
+        py: Python,
         either_delta: &EitherTimedelta,
         serializer: S,
     ) -> Result<S::Ok, S::Error> {
@@ -153,14 +153,12 @@ impl TimedeltaMode {
                 let d = either_delta.to_duration().map_err(py_err_se_err)?;
                 serializer.serialize_str(&d.to_string())
             }
-            Self::SecondsFloat => {
-                let seconds: f64 = either_delta.total_seconds().map_err(py_err_se_err)?;
+            Self::Float => {
+                let py_timedelta = either_delta.try_into_py(py).map_err(py_err_se_err)?;
+                let seconds = Self::total_seconds(&py_timedelta).map_err(py_err_se_err)?;
+                let seconds: f64 = seconds.extract().map_err(py_err_se_err)?;
                 serializer.serialize_f64(seconds)
             }
-            Self::MillisecondsFloat => {
-                let milliseconds: f64 = either_delta.total_milliseconds().map_err(py_err_se_err)?;
-                serializer.serialize_f64(milliseconds)
-            }
         }
     }
 }
diff --git a/src/serializers/infer.rs b/src/serializers/infer.rs
index f03e890d5..4e6bb504f 100644
--- a/src/serializers/infer.rs
+++ b/src/serializers/infer.rs
@@ -477,7 +477,7 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
             extra
                 .config
                 .timedelta_mode
-                .timedelta_serialize(&either_delta, serializer)
+                .timedelta_serialize(value.py(), &either_delta, serializer)
         }
         ObType::Url => {
             let py_url: PyUrl = value.extract().map_err(py_err_se_err)?;
@@ -655,7 +655,7 @@ pub(crate) fn infer_json_key_known<'a>(
         }
         ObType::Timedelta => {
             let either_delta = EitherTimedelta::try_from(key)?;
-            extra.config.timedelta_mode.json_key(&either_delta)
+            extra.config.timedelta_mode.json_key(key.py(), &either_delta)
         }
         ObType::Url => {
             let py_url: PyUrl = key.extract()?;
diff --git a/src/serializers/type_serializers/timedelta.rs b/src/serializers/type_serializers/timedelta.rs
index acc604732..a62b595d0 100644
--- a/src/serializers/type_serializers/timedelta.rs
+++ b/src/serializers/type_serializers/timedelta.rs
@@ -54,7 +54,7 @@ impl TypeSerializer for TimeDeltaSerializer {
 
     fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         match EitherTimedelta::try_from(key) {
-            Ok(either_timedelta) => self.timedelta_mode.json_key(&either_timedelta),
+            Ok(either_timedelta) => self.timedelta_mode.json_key(key.py(), &either_timedelta),
             Err(_) => {
                 extra.warnings.on_fallback_py(self.get_name(), key, extra)?;
                 infer_json_key(key, extra)
@@ -71,7 +71,9 @@ impl TypeSerializer for TimeDeltaSerializer {
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         match EitherTimedelta::try_from(value) {
-            Ok(either_timedelta) => self.timedelta_mode.timedelta_serialize(&either_timedelta, serializer),
+            Ok(either_timedelta) => self
+                .timedelta_mode
+                .timedelta_serialize(value.py(), &either_timedelta, serializer),
             Err(_) => {
                 extra.warnings.on_fallback_ser::<S>(self.get_name(), value, extra)?;
                 infer_serialize(value, serializer, include, exclude, extra)
diff --git a/tests/serializers/test_any.py b/tests/serializers/test_any.py
index 9fbc8ac03..344e0ff02 100644
--- a/tests/serializers/test_any.py
+++ b/tests/serializers/test_any.py
@@ -177,139 +177,28 @@ def test_any_with_timedelta_serializer():
     ]
 
 
-@pytest.mark.parametrize(
-    'td,expected_to_python,expected_to_json,expected_to_python_dict,expected_to_json_dict,mode',
-    [
-        (timedelta(hours=2), 7200000.0, b'7200000.0', {'7200000': 'foo'}, b'{"7200000":"foo"}', 'milliseconds_float'),
-        (
-            timedelta(hours=-2),
-            -7200000.0,
-            b'-7200000.0',
-            {'-7200000': 'foo'},
-            b'{"-7200000":"foo"}',
-            'milliseconds_float',
-        ),
-        (timedelta(seconds=1.5), 1500.0, b'1500.0', {'1500': 'foo'}, b'{"1500":"foo"}', 'milliseconds_float'),
-        (timedelta(seconds=-1.5), -1500.0, b'-1500.0', {'-1500': 'foo'}, b'{"-1500":"foo"}', 'milliseconds_float'),
-        (timedelta(microseconds=1), 0.001, b'0.001', {'0.001': 'foo'}, b'{"0.001":"foo"}', 'milliseconds_float'),
-        (
-            timedelta(microseconds=-1),
-            -0.001,
-            b'-0.001',
-            {'-0.001': 'foo'},
-            b'{"-0.001":"foo"}',
-            'milliseconds_float',
-        ),
-        (
-            timedelta(days=1),
-            86400000.0,
-            b'86400000.0',
-            {'86400000': 'foo'},
-            b'{"86400000":"foo"}',
-            'milliseconds_float',
-        ),
-        (
-            timedelta(days=-1),
-            -86400000.0,
-            b'-86400000.0',
-            {'-86400000': 'foo'},
-            b'{"-86400000":"foo"}',
-            'milliseconds_float',
-        ),
-        (
-            timedelta(days=1, seconds=1),
-            86401000.0,
-            b'86401000.0',
-            {'86401000': 'foo'},
-            b'{"86401000":"foo"}',
-            'milliseconds_float',
-        ),
-        (
-            timedelta(days=-1, seconds=-1),
-            -86401000.0,
-            b'-86401000.0',
-            {'-86401000': 'foo'},
-            b'{"-86401000":"foo"}',
-            'milliseconds_float',
-        ),
-        (
-            timedelta(days=1, seconds=-1),
-            86399000.0,
-            b'86399000.0',
-            {'86399000': 'foo'},
-            b'{"86399000":"foo"}',
-            'milliseconds_float',
-        ),
-        (
-            timedelta(days=1, seconds=1, microseconds=1),
-            86401000.001,
-            b'86401000.001',
-            {'86401000.001': 'foo'},
-            b'{"86401000.001":"foo"}',
-            'milliseconds_float',
-        ),
-        (
-            timedelta(days=-1, seconds=-1, microseconds=-1),
-            -86401000.001,
-            b'-86401000.001',
-            {'-86401000.001': 'foo'},
-            b'{"-86401000.001":"foo"}',
-            'milliseconds_float',
-        ),
-        (timedelta(hours=2), 7200.0, b'7200.0', {'7200': 'foo'}, b'{"7200":"foo"}', 'seconds_float'),
-        (timedelta(hours=-2), -7200.0, b'-7200.0', {'-7200': 'foo'}, b'{"-7200":"foo"}', 'seconds_float'),
-        (timedelta(seconds=1.5), 1.5, b'1.5', {'1.5': 'foo'}, b'{"1.5":"foo"}', 'seconds_float'),
-        (timedelta(seconds=-1.5), -1.5, b'-1.5', {'-1.5': 'foo'}, b'{"-1.5":"foo"}', 'seconds_float'),
-        (timedelta(microseconds=1), 1e-6, b'1e-6', {'0.000001': 'foo'}, b'{"0.000001":"foo"}', 'seconds_float'),
-        (
-            timedelta(microseconds=-1),
-            -1e-6,
-            b'-1e-6',
-            {'-0.000001': 'foo'},
-            b'{"-0.000001":"foo"}',
-            'seconds_float',
-        ),
-        (timedelta(days=1), 86400.0, b'86400.0', {'86400': 'foo'}, b'{"86400":"foo"}', 'seconds_float'),
-        (timedelta(days=-1), -86400.0, b'-86400.0', {'-86400': 'foo'}, b'{"-86400":"foo"}', 'seconds_float'),
-        (timedelta(days=1, seconds=1), 86401.0, b'86401.0', {'86401': 'foo'}, b'{"86401":"foo"}', 'seconds_float'),
-        (
-            timedelta(days=-1, seconds=-1),
-            -86401.0,
-            b'-86401.0',
-            {'-86401': 'foo'},
-            b'{"-86401":"foo"}',
-            'seconds_float',
-        ),
-        (timedelta(days=1, seconds=-1), 86399.0, b'86399.0', {'86399': 'foo'}, b'{"86399":"foo"}', 'seconds_float'),
-        (
-            timedelta(days=1, seconds=1, microseconds=1),
-            86401.000001,
-            b'86401.000001',
-            {'86401.000001': 'foo'},
-            b'{"86401.000001":"foo"}',
-            'seconds_float',
-        ),
-        (
-            timedelta(days=-1, seconds=-1, microseconds=-1),
-            -86401.000001,
-            b'-86401.000001',
-            {'-86401.000001': 'foo'},
-            b'{"-86401.000001":"foo"}',
-            'seconds_float',
-        ),
-    ],
-)
-def test_any_config_timedelta(
-    td: timedelta, expected_to_python, expected_to_json, expected_to_python_dict, expected_to_json_dict, mode
-):
-    s = SchemaSerializer(core_schema.any_schema(), config={'ser_json_timedelta': mode})
-    assert s.to_python(td) == td
-    assert s.to_python(td, mode='json') == expected_to_python
-    assert s.to_json(td) == expected_to_json
+def test_any_config_timedelta_float():
+    s = SchemaSerializer(core_schema.any_schema(), config={'ser_json_timedelta': 'float'})
+    h2 = timedelta(hours=2)
+    assert s.to_python(h2) == h2
+    assert s.to_python(h2, mode='json') == 7200.0
+    assert s.to_json(h2) == b'7200.0'
+
+    assert s.to_python({h2: 'foo'}) == {h2: 'foo'}
+    assert s.to_python({h2: 'foo'}, mode='json') == {'7200': 'foo'}
+    assert s.to_json({h2: 'foo'}) == b'{"7200":"foo"}'
+
 
-    assert s.to_python({td: 'foo'}) == {td: 'foo'}
-    assert s.to_python({td: 'foo'}, mode='json') == expected_to_python_dict
-    assert s.to_json({td: 'foo'}) == expected_to_json_dict
+def test_any_config_timedelta_float_faction():
+    s = SchemaSerializer(core_schema.any_schema(), config={'ser_json_timedelta': 'float'})
+    one_half_s = timedelta(seconds=1.5)
+    assert s.to_python(one_half_s) == one_half_s
+    assert s.to_python(one_half_s, mode='json') == 1.5
+    assert s.to_json(one_half_s) == b'1.5'
+
+    assert s.to_python({one_half_s: 'foo'}) == {one_half_s: 'foo'}
+    assert s.to_python({one_half_s: 'foo'}, mode='json') == {'1.5': 'foo'}
+    assert s.to_json({one_half_s: 'foo'}) == b'{"1.5":"foo"}'
 
 
 def test_recursion(any_serializer):
@@ -533,13 +422,9 @@ def test_base64():
         (lambda: datetime(2032, 1, 1), {}, b'"2032-01-01T00:00:00"'),
         (lambda: time(12, 34, 56), {}, b'"12:34:56"'),
         (lambda: timedelta(days=12, seconds=34, microseconds=56), {}, b'"P12DT34.000056S"'),
-        (
-            lambda: timedelta(days=12, seconds=34, microseconds=56),
-            dict(timedelta_mode='seconds_float'),
-            b'1036834.000056',
-        ),
+        (lambda: timedelta(days=12, seconds=34, microseconds=56), dict(timedelta_mode='float'), b'1036834.000056'),
         (lambda: timedelta(seconds=-1), {}, b'"-PT1S"'),
-        (lambda: timedelta(seconds=-1), dict(timedelta_mode='seconds_float'), b'-1.0'),
+        (lambda: timedelta(seconds=-1), dict(timedelta_mode='float'), b'-1.0'),
         (lambda: {1, 2, 3}, {}, b'[1,2,3]'),
         (lambda: frozenset([1, 2, 3]), {}, b'[1,2,3]'),
         (lambda: (v for v in range(4)), {}, b'[0,1,2,3]'),
diff --git a/tests/serializers/test_pickling.py b/tests/serializers/test_pickling.py
index b6bc105d5..2ca230313 100644
--- a/tests/serializers/test_pickling.py
+++ b/tests/serializers/test_pickling.py
@@ -42,7 +42,7 @@ def test_schema_serializer_capturing_function(value, expected_python, expected_j
 
 
 def test_schema_serializer_containing_config():
-    s = SchemaSerializer(core_schema.timedelta_schema(), config={'ser_json_timedelta': 'seconds_float'})
+    s = SchemaSerializer(core_schema.timedelta_schema(), config={'ser_json_timedelta': 'float'})
     s = pickle.loads(pickle.dumps(s))
 
     assert s.to_python(timedelta(seconds=4, microseconds=500_000)) == timedelta(seconds=4, microseconds=500_000)
diff --git a/tests/serializers/test_timedelta.py b/tests/serializers/test_timedelta.py
index 9fcc9d362..19abb673d 100644
--- a/tests/serializers/test_timedelta.py
+++ b/tests/serializers/test_timedelta.py
@@ -31,7 +31,7 @@ def test_timedelta():
 
 
 def test_timedelta_float():
-    v = SchemaSerializer(core_schema.timedelta_schema(), config={'ser_json_timedelta': 'seconds_float'})
+    v = SchemaSerializer(core_schema.timedelta_schema(), config={'ser_json_timedelta': 'float'})
     assert v.to_python(timedelta(seconds=4, microseconds=500_000)) == timedelta(seconds=4, microseconds=500_000)
 
     assert v.to_python(timedelta(seconds=4, microseconds=500_000), mode='json') == 4.5
diff --git a/tests/test_garbage_collection.py b/tests/test_garbage_collection.py
index 803979aa9..f4e178f26 100644
--- a/tests/test_garbage_collection.py
+++ b/tests/test_garbage_collection.py
@@ -28,7 +28,7 @@ class BaseModel:
 
         def __init_subclass__(cls) -> None:
             cls.__schema__ = SchemaSerializer(
-                core_schema.model_schema(cls, GC_TEST_SCHEMA_INNER), config={'ser_json_timedelta': 'seconds_float'}
+                core_schema.model_schema(cls, GC_TEST_SCHEMA_INNER), config={'ser_json_timedelta': 'float'}
             )
 
     cache: 'WeakValueDictionary[int, Any]' = WeakValueDictionary()

From fe736529f25980a8e29d28ab375d7b844e217a65 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Wed, 30 Oct 2024 06:59:15 -0400
Subject: [PATCH 407/550] Support subclass inits for `Url` and `MultiHostUrl`
 (#1508)

---
 python/pydantic_core/__init__.py        |  2 +-
 python/pydantic_core/_pydantic_core.pyi |  4 +-
 python/pydantic_core/core_schema.py     |  8 +++
 src/url.rs                              | 16 +++---
 src/validators/url.rs                   | 69 +++++++++++++++++++++++--
 tests/validators/test_url.py            | 16 ++++++
 6 files changed, 100 insertions(+), 15 deletions(-)

diff --git a/python/pydantic_core/__init__.py b/python/pydantic_core/__init__.py
index 791de9d92..9884c79ed 100644
--- a/python/pydantic_core/__init__.py
+++ b/python/pydantic_core/__init__.py
@@ -124,7 +124,7 @@ class ErrorTypeInfo(_TypedDict):
     """Example of context values."""
 
 
-class MultiHostHost(_TypedDict):
+class MultiHostHost(_TypedDict, total=False):
     """
     A host part of a multi-host URL.
     """
diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index d696ac407..fabd92b3a 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -583,7 +583,7 @@ class Url(SupportsAllComparisons):
         scheme: str,
         username: str | None = None,
         password: str | None = None,
-        host: str,
+        host: str | None = None,
         port: int | None = None,
         path: str | None = None,
         query: str | None = None,
@@ -596,7 +596,7 @@ class Url(SupportsAllComparisons):
             scheme: The scheme part of the URL.
             username: The username part of the URL, or omit for no username.
             password: The password part of the URL, or omit for no password.
-            host: The host part of the URL.
+            host: The host part of the URL, or omit for no host.
             port: The port part of the URL, or omit for no port.
             path: The path part of the URL, or omit for no path.
             query: The query part of the URL, or omit for no query.
diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index 5a8646fca..23e384af1 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -3655,6 +3655,7 @@ class MyModel:
 
 class UrlSchema(TypedDict, total=False):
     type: Required[Literal['url']]
+    cls: Type[Any]
     max_length: int
     allowed_schemes: List[str]
     host_required: bool  # default False
@@ -3669,6 +3670,7 @@ class UrlSchema(TypedDict, total=False):
 
 def url_schema(
     *,
+    cls: Type[Any] | None = None,
     max_length: int | None = None,
     allowed_schemes: list[str] | None = None,
     host_required: bool | None = None,
@@ -3693,6 +3695,7 @@ def url_schema(
     ```
 
     Args:
+        cls: The class to use for the URL build (a subclass of `pydantic_core.Url`)
         max_length: The maximum length of the URL
         allowed_schemes: The allowed URL schemes
         host_required: Whether the URL must have a host
@@ -3706,6 +3709,7 @@ def url_schema(
     """
     return _dict_not_none(
         type='url',
+        cls=cls,
         max_length=max_length,
         allowed_schemes=allowed_schemes,
         host_required=host_required,
@@ -3721,6 +3725,7 @@ def url_schema(
 
 class MultiHostUrlSchema(TypedDict, total=False):
     type: Required[Literal['multi-host-url']]
+    cls: Type[Any]
     max_length: int
     allowed_schemes: List[str]
     host_required: bool  # default False
@@ -3735,6 +3740,7 @@ class MultiHostUrlSchema(TypedDict, total=False):
 
 def multi_host_url_schema(
     *,
+    cls: Type[Any] | None = None,
     max_length: int | None = None,
     allowed_schemes: list[str] | None = None,
     host_required: bool | None = None,
@@ -3759,6 +3765,7 @@ def multi_host_url_schema(
     ```
 
     Args:
+        cls: The class to use for the URL build (a subclass of `pydantic_core.MultiHostUrl`)
         max_length: The maximum length of the URL
         allowed_schemes: The allowed URL schemes
         host_required: Whether the URL must have a host
@@ -3772,6 +3779,7 @@ def multi_host_url_schema(
     """
     return _dict_not_none(
         type='multi-host-url',
+        cls=cls,
         max_length=max_length,
         allowed_schemes=allowed_schemes,
         host_required=host_required,
diff --git a/src/url.rs b/src/url.rs
index 881347f25..faaab9c63 100644
--- a/src/url.rs
+++ b/src/url.rs
@@ -156,12 +156,12 @@ impl PyUrl {
     }
 
     #[classmethod]
-    #[pyo3(signature=(*, scheme, host, username=None, password=None, port=None, path=None, query=None, fragment=None))]
+    #[pyo3(signature=(*, scheme, host=None, username=None, password=None, port=None, path=None, query=None, fragment=None))]
     #[allow(clippy::too_many_arguments)]
     pub fn build<'py>(
         cls: &Bound<'py, PyType>,
         scheme: &str,
-        host: &str,
+        host: Option<&str>,
         username: Option<&str>,
         password: Option<&str>,
         port: Option<u16>,
@@ -172,7 +172,7 @@ impl PyUrl {
         let url_host = UrlHostParts {
             username: username.map(Into::into),
             password: password.map(Into::into),
-            host: Some(host.into()),
+            host: host.map(Into::into),
             port,
         };
         let mut url = format!("{scheme}://{url_host}");
@@ -423,6 +423,7 @@ impl PyMultiHostUrl {
     }
 }
 
+#[cfg_attr(debug_assertions, derive(Debug))]
 pub struct UrlHostParts {
     username: Option<String>,
     password: Option<String>,
@@ -440,11 +441,12 @@ impl FromPyObject<'_> for UrlHostParts {
     fn extract_bound(ob: &Bound<'_, PyAny>) -> PyResult<Self> {
         let py = ob.py();
         let dict = ob.downcast::<PyDict>()?;
+
         Ok(UrlHostParts {
-            username: dict.get_as(intern!(py, "username"))?,
-            password: dict.get_as(intern!(py, "password"))?,
-            host: dict.get_as(intern!(py, "host"))?,
-            port: dict.get_as(intern!(py, "port"))?,
+            username: dict.get_as::<Option<_>>(intern!(py, "username"))?.flatten(),
+            password: dict.get_as::<Option<_>>(intern!(py, "password"))?.flatten(),
+            host: dict.get_as::<Option<_>>(intern!(py, "host"))?.flatten(),
+            port: dict.get_as::<Option<_>>(intern!(py, "port"))?.flatten(),
         })
     }
 }
diff --git a/src/validators/url.rs b/src/validators/url.rs
index 46bab20c1..92c482b46 100644
--- a/src/validators/url.rs
+++ b/src/validators/url.rs
@@ -4,7 +4,7 @@ use std::str::Chars;
 
 use pyo3::intern;
 use pyo3::prelude::*;
-use pyo3::types::{PyDict, PyList};
+use pyo3::types::{PyDict, PyList, PyType};
 
 use ahash::AHashSet;
 use url::{ParseError, SyntaxViolation, Url};
@@ -26,6 +26,7 @@ type AllowedSchemas = Option<(AHashSet<String>, String)>;
 #[derive(Debug, Clone)]
 pub struct UrlValidator {
     strict: bool,
+    cls: Option<Py<PyType>>,
     max_length: Option<usize>,
     allowed_schemes: AllowedSchemas,
     host_required: bool,
@@ -47,6 +48,7 @@ impl BuildValidator for UrlValidator {
 
         Ok(Self {
             strict: is_strict(schema, config)?,
+            cls: schema.get_as(intern!(schema.py(), "cls"))?,
             max_length: schema.get_as(intern!(schema.py(), "max_length"))?,
             host_required: schema.get_as(intern!(schema.py(), "host_required"))?.unwrap_or(false),
             default_host: schema.get_as(intern!(schema.py(), "default_host"))?,
@@ -59,7 +61,7 @@ impl BuildValidator for UrlValidator {
     }
 }
 
-impl_py_gc_traverse!(UrlValidator {});
+impl_py_gc_traverse!(UrlValidator { cls });
 
 impl Validator for UrlValidator {
     fn validate<'py>(
@@ -93,7 +95,31 @@ impl Validator for UrlValidator {
             Ok(()) => {
                 // Lax rather than strict to preserve V2.4 semantic that str wins over url in union
                 state.floor_exactness(Exactness::Lax);
-                Ok(either_url.into_py(py))
+
+                if let Some(url_subclass) = &self.cls {
+                    // TODO: we do an extra build for a subclass here, we should avoid this
+                    // in v2.11 for perf reasons, but this is a worthwhile patch for now
+                    // given that we want isinstance to work properly for subclasses of Url
+                    let py_url = match either_url {
+                        EitherUrl::Py(py_url) => py_url.get().clone(),
+                        EitherUrl::Rust(rust_url) => PyUrl::new(rust_url),
+                    };
+
+                    let py_url = PyUrl::build(
+                        url_subclass.bind(py),
+                        py_url.scheme(),
+                        py_url.host(),
+                        py_url.username(),
+                        py_url.password(),
+                        py_url.port(),
+                        py_url.path().filter(|path| *path != "/"),
+                        py_url.query(),
+                        py_url.fragment(),
+                    )?;
+                    Ok(py_url.into_py(py))
+                } else {
+                    Ok(either_url.into_py(py))
+                }
             }
             Err(error_type) => Err(ValError::new(error_type, input)),
         }
@@ -186,6 +212,7 @@ impl CopyFromPyUrl for EitherUrl<'_> {
 #[derive(Debug, Clone)]
 pub struct MultiHostUrlValidator {
     strict: bool,
+    cls: Option<Py<PyType>>,
     max_length: Option<usize>,
     allowed_schemes: AllowedSchemas,
     host_required: bool,
@@ -213,6 +240,7 @@ impl BuildValidator for MultiHostUrlValidator {
         }
         Ok(Self {
             strict: is_strict(schema, config)?,
+            cls: schema.get_as(intern!(schema.py(), "cls"))?,
             max_length: schema.get_as(intern!(schema.py(), "max_length"))?,
             allowed_schemes,
             host_required: schema.get_as(intern!(schema.py(), "host_required"))?.unwrap_or(false),
@@ -225,7 +253,7 @@ impl BuildValidator for MultiHostUrlValidator {
     }
 }
 
-impl_py_gc_traverse!(MultiHostUrlValidator {});
+impl_py_gc_traverse!(MultiHostUrlValidator { cls });
 
 impl Validator for MultiHostUrlValidator {
     fn validate<'py>(
@@ -258,7 +286,38 @@ impl Validator for MultiHostUrlValidator {
             Ok(()) => {
                 // Lax rather than strict to preserve V2.4 semantic that str wins over url in union
                 state.floor_exactness(Exactness::Lax);
-                Ok(multi_url.into_py(py))
+
+                if let Some(url_subclass) = &self.cls {
+                    // TODO: we do an extra build for a subclass here, we should avoid this
+                    // in v2.11 for perf reasons, but this is a worthwhile patch for now
+                    // given that we want isinstance to work properly for subclasses of Url
+                    let py_url = match multi_url {
+                        EitherMultiHostUrl::Py(py_url) => py_url.get().clone(),
+                        EitherMultiHostUrl::Rust(rust_url) => rust_url,
+                    };
+
+                    let hosts = py_url
+                        .hosts(py)?
+                        .into_iter()
+                        .map(|host| host.extract().expect("host should be a valid UrlHostParts"))
+                        .collect();
+
+                    let py_url = PyMultiHostUrl::build(
+                        url_subclass.bind(py),
+                        py_url.scheme(),
+                        Some(hosts),
+                        py_url.path().filter(|path| *path != "/"),
+                        py_url.query(),
+                        py_url.fragment(),
+                        None,
+                        None,
+                        None,
+                        None,
+                    )?;
+                    Ok(py_url.into_py(py))
+                } else {
+                    Ok(multi_url.into_py(py))
+                }
             }
             Err(error_type) => Err(ValError::new(error_type, input)),
         }
diff --git a/tests/validators/test_url.py b/tests/validators/test_url.py
index 59489dd00..112046090 100644
--- a/tests/validators/test_url.py
+++ b/tests/validators/test_url.py
@@ -1305,3 +1305,19 @@ def test_url_build() -> None:
     )
     assert url == Url('postgresql://testuser:testpassword@127.0.0.1:5432/database?sslmode=require#test')
     assert str(url) == 'postgresql://testuser:testpassword@127.0.0.1:5432/database?sslmode=require#test'
+
+
+def test_url_subclass() -> None:
+    class UrlSubclass(Url):
+        pass
+
+    validator = SchemaValidator(core_schema.url_schema(cls=UrlSubclass))
+    assert isinstance(validator.validate_python('http://example.com'), UrlSubclass)
+
+
+def test_multi_host_url_subclass() -> None:
+    class MultiHostUrlSubclass(MultiHostUrl):
+        pass
+
+    validator = SchemaValidator(core_schema.multi_host_url_schema(cls=MultiHostUrlSubclass))
+    assert isinstance(validator.validate_python('http://example.com'), MultiHostUrlSubclass)

From 921701990ee6161959868d1b32c1d625e01368e3 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Wed, 30 Oct 2024 07:06:31 -0400
Subject: [PATCH 408/550] Patch version bump -> v2.25.1 (#1509)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index c1ed5106b..04f019749 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -425,7 +425,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.25.0"
+version = "2.25.1"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index b35a10e67..8af9f9311 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.25.0"
+version = "2.25.1"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From 89bdee10c1cb1a88c220e2ec6ca69379b387fbbb Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Thu, 31 Oct 2024 11:28:54 -0400
Subject: [PATCH 409/550] Revert changes to url schemas that support `cls`, the
 2x validation isn't worth it (and is breaking) (#1514)

---
 python/pydantic_core/__init__.py        |  2 +-
 python/pydantic_core/_pydantic_core.pyi |  4 +-
 python/pydantic_core/core_schema.py     |  8 ---
 src/url.rs                              | 16 +++---
 src/validators/url.rs                   | 69 ++-----------------------
 tests/validators/test_url.py            | 16 ------
 6 files changed, 15 insertions(+), 100 deletions(-)

diff --git a/python/pydantic_core/__init__.py b/python/pydantic_core/__init__.py
index 9884c79ed..791de9d92 100644
--- a/python/pydantic_core/__init__.py
+++ b/python/pydantic_core/__init__.py
@@ -124,7 +124,7 @@ class ErrorTypeInfo(_TypedDict):
     """Example of context values."""
 
 
-class MultiHostHost(_TypedDict, total=False):
+class MultiHostHost(_TypedDict):
     """
     A host part of a multi-host URL.
     """
diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index fabd92b3a..d696ac407 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -583,7 +583,7 @@ class Url(SupportsAllComparisons):
         scheme: str,
         username: str | None = None,
         password: str | None = None,
-        host: str | None = None,
+        host: str,
         port: int | None = None,
         path: str | None = None,
         query: str | None = None,
@@ -596,7 +596,7 @@ class Url(SupportsAllComparisons):
             scheme: The scheme part of the URL.
             username: The username part of the URL, or omit for no username.
             password: The password part of the URL, or omit for no password.
-            host: The host part of the URL, or omit for no host.
+            host: The host part of the URL.
             port: The port part of the URL, or omit for no port.
             path: The path part of the URL, or omit for no path.
             query: The query part of the URL, or omit for no query.
diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index 23e384af1..5a8646fca 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -3655,7 +3655,6 @@ class MyModel:
 
 class UrlSchema(TypedDict, total=False):
     type: Required[Literal['url']]
-    cls: Type[Any]
     max_length: int
     allowed_schemes: List[str]
     host_required: bool  # default False
@@ -3670,7 +3669,6 @@ class UrlSchema(TypedDict, total=False):
 
 def url_schema(
     *,
-    cls: Type[Any] | None = None,
     max_length: int | None = None,
     allowed_schemes: list[str] | None = None,
     host_required: bool | None = None,
@@ -3695,7 +3693,6 @@ def url_schema(
     ```
 
     Args:
-        cls: The class to use for the URL build (a subclass of `pydantic_core.Url`)
         max_length: The maximum length of the URL
         allowed_schemes: The allowed URL schemes
         host_required: Whether the URL must have a host
@@ -3709,7 +3706,6 @@ def url_schema(
     """
     return _dict_not_none(
         type='url',
-        cls=cls,
         max_length=max_length,
         allowed_schemes=allowed_schemes,
         host_required=host_required,
@@ -3725,7 +3721,6 @@ def url_schema(
 
 class MultiHostUrlSchema(TypedDict, total=False):
     type: Required[Literal['multi-host-url']]
-    cls: Type[Any]
     max_length: int
     allowed_schemes: List[str]
     host_required: bool  # default False
@@ -3740,7 +3735,6 @@ class MultiHostUrlSchema(TypedDict, total=False):
 
 def multi_host_url_schema(
     *,
-    cls: Type[Any] | None = None,
     max_length: int | None = None,
     allowed_schemes: list[str] | None = None,
     host_required: bool | None = None,
@@ -3765,7 +3759,6 @@ def multi_host_url_schema(
     ```
 
     Args:
-        cls: The class to use for the URL build (a subclass of `pydantic_core.MultiHostUrl`)
         max_length: The maximum length of the URL
         allowed_schemes: The allowed URL schemes
         host_required: Whether the URL must have a host
@@ -3779,7 +3772,6 @@ def multi_host_url_schema(
     """
     return _dict_not_none(
         type='multi-host-url',
-        cls=cls,
         max_length=max_length,
         allowed_schemes=allowed_schemes,
         host_required=host_required,
diff --git a/src/url.rs b/src/url.rs
index faaab9c63..881347f25 100644
--- a/src/url.rs
+++ b/src/url.rs
@@ -156,12 +156,12 @@ impl PyUrl {
     }
 
     #[classmethod]
-    #[pyo3(signature=(*, scheme, host=None, username=None, password=None, port=None, path=None, query=None, fragment=None))]
+    #[pyo3(signature=(*, scheme, host, username=None, password=None, port=None, path=None, query=None, fragment=None))]
     #[allow(clippy::too_many_arguments)]
     pub fn build<'py>(
         cls: &Bound<'py, PyType>,
         scheme: &str,
-        host: Option<&str>,
+        host: &str,
         username: Option<&str>,
         password: Option<&str>,
         port: Option<u16>,
@@ -172,7 +172,7 @@ impl PyUrl {
         let url_host = UrlHostParts {
             username: username.map(Into::into),
             password: password.map(Into::into),
-            host: host.map(Into::into),
+            host: Some(host.into()),
             port,
         };
         let mut url = format!("{scheme}://{url_host}");
@@ -423,7 +423,6 @@ impl PyMultiHostUrl {
     }
 }
 
-#[cfg_attr(debug_assertions, derive(Debug))]
 pub struct UrlHostParts {
     username: Option<String>,
     password: Option<String>,
@@ -441,12 +440,11 @@ impl FromPyObject<'_> for UrlHostParts {
     fn extract_bound(ob: &Bound<'_, PyAny>) -> PyResult<Self> {
         let py = ob.py();
         let dict = ob.downcast::<PyDict>()?;
-
         Ok(UrlHostParts {
-            username: dict.get_as::<Option<_>>(intern!(py, "username"))?.flatten(),
-            password: dict.get_as::<Option<_>>(intern!(py, "password"))?.flatten(),
-            host: dict.get_as::<Option<_>>(intern!(py, "host"))?.flatten(),
-            port: dict.get_as::<Option<_>>(intern!(py, "port"))?.flatten(),
+            username: dict.get_as(intern!(py, "username"))?,
+            password: dict.get_as(intern!(py, "password"))?,
+            host: dict.get_as(intern!(py, "host"))?,
+            port: dict.get_as(intern!(py, "port"))?,
         })
     }
 }
diff --git a/src/validators/url.rs b/src/validators/url.rs
index 92c482b46..46bab20c1 100644
--- a/src/validators/url.rs
+++ b/src/validators/url.rs
@@ -4,7 +4,7 @@ use std::str::Chars;
 
 use pyo3::intern;
 use pyo3::prelude::*;
-use pyo3::types::{PyDict, PyList, PyType};
+use pyo3::types::{PyDict, PyList};
 
 use ahash::AHashSet;
 use url::{ParseError, SyntaxViolation, Url};
@@ -26,7 +26,6 @@ type AllowedSchemas = Option<(AHashSet<String>, String)>;
 #[derive(Debug, Clone)]
 pub struct UrlValidator {
     strict: bool,
-    cls: Option<Py<PyType>>,
     max_length: Option<usize>,
     allowed_schemes: AllowedSchemas,
     host_required: bool,
@@ -48,7 +47,6 @@ impl BuildValidator for UrlValidator {
 
         Ok(Self {
             strict: is_strict(schema, config)?,
-            cls: schema.get_as(intern!(schema.py(), "cls"))?,
             max_length: schema.get_as(intern!(schema.py(), "max_length"))?,
             host_required: schema.get_as(intern!(schema.py(), "host_required"))?.unwrap_or(false),
             default_host: schema.get_as(intern!(schema.py(), "default_host"))?,
@@ -61,7 +59,7 @@ impl BuildValidator for UrlValidator {
     }
 }
 
-impl_py_gc_traverse!(UrlValidator { cls });
+impl_py_gc_traverse!(UrlValidator {});
 
 impl Validator for UrlValidator {
     fn validate<'py>(
@@ -95,31 +93,7 @@ impl Validator for UrlValidator {
             Ok(()) => {
                 // Lax rather than strict to preserve V2.4 semantic that str wins over url in union
                 state.floor_exactness(Exactness::Lax);
-
-                if let Some(url_subclass) = &self.cls {
-                    // TODO: we do an extra build for a subclass here, we should avoid this
-                    // in v2.11 for perf reasons, but this is a worthwhile patch for now
-                    // given that we want isinstance to work properly for subclasses of Url
-                    let py_url = match either_url {
-                        EitherUrl::Py(py_url) => py_url.get().clone(),
-                        EitherUrl::Rust(rust_url) => PyUrl::new(rust_url),
-                    };
-
-                    let py_url = PyUrl::build(
-                        url_subclass.bind(py),
-                        py_url.scheme(),
-                        py_url.host(),
-                        py_url.username(),
-                        py_url.password(),
-                        py_url.port(),
-                        py_url.path().filter(|path| *path != "/"),
-                        py_url.query(),
-                        py_url.fragment(),
-                    )?;
-                    Ok(py_url.into_py(py))
-                } else {
-                    Ok(either_url.into_py(py))
-                }
+                Ok(either_url.into_py(py))
             }
             Err(error_type) => Err(ValError::new(error_type, input)),
         }
@@ -212,7 +186,6 @@ impl CopyFromPyUrl for EitherUrl<'_> {
 #[derive(Debug, Clone)]
 pub struct MultiHostUrlValidator {
     strict: bool,
-    cls: Option<Py<PyType>>,
     max_length: Option<usize>,
     allowed_schemes: AllowedSchemas,
     host_required: bool,
@@ -240,7 +213,6 @@ impl BuildValidator for MultiHostUrlValidator {
         }
         Ok(Self {
             strict: is_strict(schema, config)?,
-            cls: schema.get_as(intern!(schema.py(), "cls"))?,
             max_length: schema.get_as(intern!(schema.py(), "max_length"))?,
             allowed_schemes,
             host_required: schema.get_as(intern!(schema.py(), "host_required"))?.unwrap_or(false),
@@ -253,7 +225,7 @@ impl BuildValidator for MultiHostUrlValidator {
     }
 }
 
-impl_py_gc_traverse!(MultiHostUrlValidator { cls });
+impl_py_gc_traverse!(MultiHostUrlValidator {});
 
 impl Validator for MultiHostUrlValidator {
     fn validate<'py>(
@@ -286,38 +258,7 @@ impl Validator for MultiHostUrlValidator {
             Ok(()) => {
                 // Lax rather than strict to preserve V2.4 semantic that str wins over url in union
                 state.floor_exactness(Exactness::Lax);
-
-                if let Some(url_subclass) = &self.cls {
-                    // TODO: we do an extra build for a subclass here, we should avoid this
-                    // in v2.11 for perf reasons, but this is a worthwhile patch for now
-                    // given that we want isinstance to work properly for subclasses of Url
-                    let py_url = match multi_url {
-                        EitherMultiHostUrl::Py(py_url) => py_url.get().clone(),
-                        EitherMultiHostUrl::Rust(rust_url) => rust_url,
-                    };
-
-                    let hosts = py_url
-                        .hosts(py)?
-                        .into_iter()
-                        .map(|host| host.extract().expect("host should be a valid UrlHostParts"))
-                        .collect();
-
-                    let py_url = PyMultiHostUrl::build(
-                        url_subclass.bind(py),
-                        py_url.scheme(),
-                        Some(hosts),
-                        py_url.path().filter(|path| *path != "/"),
-                        py_url.query(),
-                        py_url.fragment(),
-                        None,
-                        None,
-                        None,
-                        None,
-                    )?;
-                    Ok(py_url.into_py(py))
-                } else {
-                    Ok(multi_url.into_py(py))
-                }
+                Ok(multi_url.into_py(py))
             }
             Err(error_type) => Err(ValError::new(error_type, input)),
         }
diff --git a/tests/validators/test_url.py b/tests/validators/test_url.py
index 112046090..59489dd00 100644
--- a/tests/validators/test_url.py
+++ b/tests/validators/test_url.py
@@ -1305,19 +1305,3 @@ def test_url_build() -> None:
     )
     assert url == Url('postgresql://testuser:testpassword@127.0.0.1:5432/database?sslmode=require#test')
     assert str(url) == 'postgresql://testuser:testpassword@127.0.0.1:5432/database?sslmode=require#test'
-
-
-def test_url_subclass() -> None:
-    class UrlSubclass(Url):
-        pass
-
-    validator = SchemaValidator(core_schema.url_schema(cls=UrlSubclass))
-    assert isinstance(validator.validate_python('http://example.com'), UrlSubclass)
-
-
-def test_multi_host_url_subclass() -> None:
-    class MultiHostUrlSubclass(MultiHostUrl):
-        pass
-
-    validator = SchemaValidator(core_schema.multi_host_url_schema(cls=MultiHostUrlSubclass))
-    assert isinstance(validator.validate_python('http://example.com'), MultiHostUrlSubclass)

From 5dd2992f485de5bdbc0a168f3ceb5fac87cb7e70 Mon Sep 17 00:00:00 2001
From: Andrei Berenda <berenda.andrey@gmail.com>
Date: Fri, 1 Nov 2024 12:12:19 +0100
Subject: [PATCH 410/550] Fix when coerce_numbers_to_str enabled and string has
 invalid unicode character (#1515)

Co-authored-by: Andrei Berenda <aberenda@optifino.com>
---
 src/validators/string.rs        | 3 +--
 tests/validators/test_string.py | 8 ++++++++
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/src/validators/string.rs b/src/validators/string.rs
index a1f7765ad..985aa1068 100644
--- a/src/validators/string.rs
+++ b/src/validators/string.rs
@@ -200,7 +200,7 @@ impl StrConstrainedValidator {
     }
 
     // whether any of the constraints/customisations are actually enabled
-    // except strict which can be set on StrValidator
+    // except strict and coerce_numbers_to_str which can be set on StrValidator
     fn has_constraints_set(&self) -> bool {
         self.pattern.is_some()
             || self.max_length.is_some()
@@ -208,7 +208,6 @@ impl StrConstrainedValidator {
             || self.strip_whitespace
             || self.to_lower
             || self.to_upper
-            || self.coerce_numbers_to_str
     }
 }
 
diff --git a/tests/validators/test_string.py b/tests/validators/test_string.py
index 50afc878a..ae5ced611 100644
--- a/tests/validators/test_string.py
+++ b/tests/validators/test_string.py
@@ -286,6 +286,14 @@ class StrSubclass(str):
     assert not isinstance(v.validate_python(StrSubclass(''), strict=True), StrSubclass)
 
 
+@pytest.mark.parametrize('string', [True, False])
+def test_coerce_numbers_to_str_with_invalid_unicode_character(string) -> None:
+    config = core_schema.CoreConfig(coerce_numbers_to_str=True)
+
+    v = SchemaValidator(core_schema.str_schema(strict=string), config)
+    assert v.validate_python('\ud835') == '\ud835'
+
+
 def test_coerce_numbers_to_str_disabled_in_strict_mode() -> None:
     config = core_schema.CoreConfig(coerce_numbers_to_str=True)
 

From 4d90f4407cb9bb6dc6bb136f3491ef2d253773c4 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 1 Nov 2024 11:50:29 +0000
Subject: [PATCH 411/550] Bump serde from 1.0.213 to 1.0.214 (#1519)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 8 ++++----
 Cargo.toml | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 04f019749..0e46998d1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -581,18 +581,18 @@ checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
 
 [[package]]
 name = "serde"
-version = "1.0.213"
+version = "1.0.214"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3ea7893ff5e2466df8d720bb615088341b295f849602c6956047f8f80f0e9bc1"
+checksum = "f55c3193aca71c12ad7890f1785d2b73e1b9f63a0bbc353c08ef26fe03fc56b5"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.213"
+version = "1.0.214"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7e85ad2009c50b58e87caa8cd6dac16bdf511bbfb7af6c33df902396aa480fa5"
+checksum = "de523f781f095e28fa605cdce0f8307e451cc0fd14e2eb4cd2e98a355b147766"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/Cargo.toml b/Cargo.toml
index 8af9f9311..512fd847c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -35,7 +35,7 @@ strum = { version = "0.26.3", features = ["derive"] }
 strum_macros = "0.26.4"
 serde_json = {version = "1.0.132", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.13"
-serde = { version = "1.0.213", features = ["derive"] }
+serde = { version = "1.0.214", features = ["derive"] }
 speedate = "0.14.4"
 smallvec = "1.13.2"
 ahash = "0.8.10"

From 184e7be2d51b1b677455597dd74507c5c53d3027 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 1 Nov 2024 11:50:39 +0000
Subject: [PATCH 412/550] Bump regex from 1.11.0 to 1.11.1 (#1520)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 0e46998d1..cde441973 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -540,9 +540,9 @@ checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
 
 [[package]]
 name = "regex"
-version = "1.11.0"
+version = "1.11.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38200e5ee88914975b69f657f0801b6f6dccafd44fd9326302a4aaeecfacb1d8"
+checksum = "b544ef1b4eac5dc2db33ea63606ae9ffcfac26c1416a2806ae0bf5f56b201191"
 dependencies = [
  "aho-corasick",
  "memchr",
diff --git a/Cargo.toml b/Cargo.toml
index 512fd847c..6f0210075 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -30,7 +30,7 @@ rust-version = "1.75"
 # TODO it would be very nice to remove the "py-clone" feature as it can panic,
 # but needs a bit of work to make sure it's not used in the codebase
 pyo3 = { version = "0.22.5", features = ["generate-import-lib", "num-bigint", "py-clone"] }
-regex = "1.11.0"
+regex = "1.11.1"
 strum = { version = "0.26.3", features = ["derive"] }
 strum_macros = "0.26.4"
 serde_json = {version = "1.0.132", features = ["arbitrary_precision", "preserve_order"]}

From 2ee8fa8807126d34fc8f8a5e15fcd9d81f7456ce Mon Sep 17 00:00:00 2001
From: Huan-Cheng Chang <changhc84@gmail.com>
Date: Mon, 4 Nov 2024 09:18:58 +0000
Subject: [PATCH 413/550] Fix serializing complex values in enums (#1524)

---
 src/serializers/infer.rs                    | 28 ++++++-------
 src/serializers/ob_type.rs                  |  2 +
 src/serializers/type_serializers/complex.rs | 45 +++++++++------------
 tests/serializers/test_infer.py             | 28 +++++++++++++
 4 files changed, 62 insertions(+), 41 deletions(-)
 create mode 100644 tests/serializers/test_infer.py

diff --git a/src/serializers/infer.rs b/src/serializers/infer.rs
index 4e6bb504f..d358682ff 100644
--- a/src/serializers/infer.rs
+++ b/src/serializers/infer.rs
@@ -231,11 +231,9 @@ pub(crate) fn infer_to_python_known(
                 PyList::new_bound(py, items).into_py(py)
             }
             ObType::Complex => {
-                let dict = value.downcast::<PyDict>()?;
-                let new_dict = PyDict::new_bound(py);
-                let _ = new_dict.set_item("real", dict.get_item("real")?);
-                let _ = new_dict.set_item("imag", dict.get_item("imag")?);
-                new_dict.into_py(py)
+                let v = value.downcast::<PyComplex>()?;
+                let complex_str = type_serializers::complex::complex_to_str(v);
+                complex_str.into_py(py)
             }
             ObType::Path => value.str()?.into_py(py),
             ObType::Pattern => value.getattr(intern!(py, "pattern"))?.into_py(py),
@@ -286,11 +284,9 @@ pub(crate) fn infer_to_python_known(
                 iter.into_py(py)
             }
             ObType::Complex => {
-                let dict = value.downcast::<PyDict>()?;
-                let new_dict = PyDict::new_bound(py);
-                let _ = new_dict.set_item("real", dict.get_item("real")?);
-                let _ = new_dict.set_item("imag", dict.get_item("imag")?);
-                new_dict.into_py(py)
+                let v = value.downcast::<PyComplex>()?;
+                let complex_str = type_serializers::complex::complex_to_str(v);
+                complex_str.into_py(py)
             }
             ObType::Unknown => {
                 if let Some(fallback) = extra.fallback {
@@ -422,10 +418,8 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
         ObType::Bool => serialize!(bool),
         ObType::Complex => {
             let v = value.downcast::<PyComplex>().map_err(py_err_se_err)?;
-            let mut map = serializer.serialize_map(Some(2))?;
-            map.serialize_entry(&"real", &v.real())?;
-            map.serialize_entry(&"imag", &v.imag())?;
-            map.end()
+            let complex_str = type_serializers::complex::complex_to_str(v);
+            Ok(serializer.collect_str::<String>(&complex_str)?)
         }
         ObType::Float | ObType::FloatSubclass => {
             let v = value.extract::<f64>().map_err(py_err_se_err)?;
@@ -672,7 +666,7 @@ pub(crate) fn infer_json_key_known<'a>(
             }
             Ok(Cow::Owned(key_build.finish()))
         }
-        ObType::List | ObType::Set | ObType::Frozenset | ObType::Dict | ObType::Generator | ObType::Complex => {
+        ObType::List | ObType::Set | ObType::Frozenset | ObType::Dict | ObType::Generator => {
             py_err!(PyTypeError; "`{}` not valid as object key", ob_type)
         }
         ObType::Dataclass | ObType::PydanticSerializable => {
@@ -689,6 +683,10 @@ pub(crate) fn infer_json_key_known<'a>(
             // FIXME it would be nice to have a "PyCow" which carries ownership of the Python type too
             Ok(Cow::Owned(key.str()?.to_string_lossy().into_owned()))
         }
+        ObType::Complex => {
+            let v = key.downcast::<PyComplex>()?;
+            Ok(type_serializers::complex::complex_to_str(v).into())
+        }
         ObType::Pattern => Ok(Cow::Owned(
             key.getattr(intern!(key.py(), "pattern"))?
                 .str()?
diff --git a/src/serializers/ob_type.rs b/src/serializers/ob_type.rs
index 8d20efaa9..4fddc8790 100644
--- a/src/serializers/ob_type.rs
+++ b/src/serializers/ob_type.rs
@@ -252,6 +252,8 @@ impl ObTypeLookup {
             ObType::Url
         } else if ob_type == self.multi_host_url {
             ObType::MultiHostUrl
+        } else if ob_type == self.complex {
+            ObType::Complex
         } else if ob_type == self.uuid_object.as_ptr() as usize {
             ObType::Uuid
         } else if is_pydantic_serializable(op_value) {
diff --git a/src/serializers/type_serializers/complex.rs b/src/serializers/type_serializers/complex.rs
index 5a525476e..57c5ba069 100644
--- a/src/serializers/type_serializers/complex.rs
+++ b/src/serializers/type_serializers/complex.rs
@@ -33,22 +33,10 @@ impl TypeSerializer for ComplexSerializer {
     ) -> PyResult<PyObject> {
         let py = value.py();
         match value.downcast::<PyComplex>() {
-            Ok(py_complex) => match extra.mode {
-                SerMode::Json => {
-                    let re = py_complex.real();
-                    let im = py_complex.imag();
-                    let mut s = format!("{im}j");
-                    if re != 0.0 {
-                        let mut sign = "";
-                        if im >= 0.0 {
-                            sign = "+";
-                        }
-                        s = format!("{re}{sign}{s}");
-                    }
-                    Ok(s.into_py(py))
-                }
-                _ => Ok(value.into_py(py)),
-            },
+            Ok(py_complex) => Ok(match extra.mode {
+                SerMode::Json => complex_to_str(py_complex).into_py(py),
+                _ => value.into_py(py),
+            }),
             Err(_) => {
                 extra.warnings.on_fallback_py(self.get_name(), value, extra)?;
                 infer_to_python(value, include, exclude, extra)
@@ -70,16 +58,7 @@ impl TypeSerializer for ComplexSerializer {
     ) -> Result<S::Ok, S::Error> {
         match value.downcast::<PyComplex>() {
             Ok(py_complex) => {
-                let re = py_complex.real();
-                let im = py_complex.imag();
-                let mut s = format!("{im}j");
-                if re != 0.0 {
-                    let mut sign = "";
-                    if im >= 0.0 {
-                        sign = "+";
-                    }
-                    s = format!("{re}{sign}{s}");
-                }
+                let s = complex_to_str(py_complex);
                 Ok(serializer.collect_str::<String>(&s)?)
             }
             Err(_) => {
@@ -93,3 +72,17 @@ impl TypeSerializer for ComplexSerializer {
         "complex"
     }
 }
+
+pub fn complex_to_str(py_complex: &Bound<'_, PyComplex>) -> String {
+    let re = py_complex.real();
+    let im = py_complex.imag();
+    let mut s = format!("{im}j");
+    if re != 0.0 {
+        let mut sign = "";
+        if im >= 0.0 {
+            sign = "+";
+        }
+        s = format!("{re}{sign}{s}");
+    }
+    s
+}
diff --git a/tests/serializers/test_infer.py b/tests/serializers/test_infer.py
new file mode 100644
index 000000000..7762f68bc
--- /dev/null
+++ b/tests/serializers/test_infer.py
@@ -0,0 +1,28 @@
+from enum import Enum
+
+from pydantic_core import SchemaSerializer, core_schema
+
+
+# serializing enum calls methods in serializers::infer
+def test_infer_to_python():
+    class MyEnum(Enum):
+        complex_ = complex(1, 2)
+
+    v = SchemaSerializer(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values())))
+    assert v.to_python(MyEnum.complex_, mode='json') == '1+2j'
+
+
+def test_infer_serialize():
+    class MyEnum(Enum):
+        complex_ = complex(1, 2)
+
+    v = SchemaSerializer(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values())))
+    assert v.to_json(MyEnum.complex_) == b'"1+2j"'
+
+
+def test_infer_json_key():
+    class MyEnum(Enum):
+        complex_ = {complex(1, 2): 1}
+
+    v = SchemaSerializer(core_schema.enum_schema(MyEnum, list(MyEnum.__members__.values())))
+    assert v.to_json(MyEnum.complex_) == b'{"1+2j":1}'

From 5e95c05a5d15533be1b261326494ad15c4fbc9c8 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 4 Nov 2024 09:30:35 +0000
Subject: [PATCH 414/550] Bump jiter from 0.6.1 to 0.7.0 (#1521)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index cde441973..2bc0dd4e8 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -297,9 +297,9 @@ checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
 
 [[package]]
 name = "jiter"
-version = "0.6.1"
+version = "0.7.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a9d54b46955906f90a4ba92a18bb2d3c6dbaf1d95acbbd112da0657e5297b432"
+checksum = "f69107091dc861900882c599876b095d9db7f71064b6914d6c68b284d19f9ee8"
 dependencies = [
  "ahash",
  "bitvec",
diff --git a/Cargo.toml b/Cargo.toml
index 6f0210075..0b87e684f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -46,7 +46,7 @@ base64 = "0.22.1"
 num-bigint = "0.4.6"
 python3-dll-a = "0.2.10"
 uuid = "1.11.0"
-jiter = { version = "0.6", features = ["python"] }
+jiter = { version = "0.7", features = ["python"] }
 hex = "0.4.3"
 
 [lib]

From a1fa5962474ed53424d4c8586c6b2a7f14e2d287 Mon Sep 17 00:00:00 2001
From: Samuel Colvin <s@muelcolvin.com>
Date: Mon, 4 Nov 2024 10:55:30 +0000
Subject: [PATCH 415/550] Add `allow_partial` (#1512)

Co-authored-by: David Hewitt <david.hewitt@pydantic.dev>
---
 benches/main.rs                         | 270 ++++++++++++++++----
 python/pydantic_core/_pydantic_core.pyi |  17 +-
 python/pydantic_core/core_schema.py     |   4 +-
 src/errors/line_error.rs                |   8 +
 src/errors/location.rs                  |   2 +-
 src/input/input_abstract.rs             |   5 +
 src/input/input_json.rs                 |   4 +
 src/input/input_python.rs               |  15 ++
 src/input/input_string.rs               |   8 +
 src/input/return_enums.rs               |  22 +-
 src/serializers/fields.rs               |   2 +-
 src/url.rs                              |   4 +-
 src/validators/arguments.rs             |   3 +
 src/validators/dataclass.rs             |   3 +
 src/validators/definitions.rs           |   3 +
 src/validators/dict.rs                  |  16 +-
 src/validators/generator.rs             |   7 +-
 src/validators/json.rs                  |  12 +-
 src/validators/mod.rs                   |  39 ++-
 src/validators/model_fields.rs          |   3 +
 src/validators/tuple.rs                 |   3 +
 src/validators/typed_dict.rs            |  46 +++-
 src/validators/validation_state.rs      |  43 +++-
 tests/emscripten_runner.js              |   3 +-
 tests/requirements.txt                  |   1 +
 tests/test.rs                           |   2 +-
 tests/validators/test_allow_partial.py  | 313 ++++++++++++++++++++++++
 27 files changed, 758 insertions(+), 100 deletions(-)
 create mode 100644 tests/validators/test_allow_partial.py

diff --git a/benches/main.rs b/benches/main.rs
index 86812edb2..6d3fd0951 100644
--- a/benches/main.rs
+++ b/benches/main.rs
@@ -28,11 +28,19 @@ fn ints_json(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let validator = build_schema_validator(py, "{'type': 'int'}");
 
-        let result = validator.validate_json(py, &json(py, "123"), None, None, None).unwrap();
+        let result = validator
+            .validate_json(py, &json(py, "123"), None, None, None, false)
+            .unwrap();
         let result_int: i64 = result.extract(py).unwrap();
         assert_eq!(result_int, 123);
 
-        bench.iter(|| black_box(validator.validate_json(py, &json(py, "123"), None, None, None).unwrap()))
+        bench.iter(|| {
+            black_box(
+                validator
+                    .validate_json(py, &json(py, "123"), None, None, None, false)
+                    .unwrap(),
+            )
+        })
     })
 }
 
@@ -42,12 +50,20 @@ fn ints_python(bench: &mut Bencher) {
         let validator = build_schema_validator(py, "{'type': 'int'}");
 
         let input = 123_i64.into_py(py).into_bound(py);
-        let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
+        let result = validator
+            .validate_python(py, &input, None, None, None, None, false)
+            .unwrap();
         let result_int: i64 = result.extract(py).unwrap();
         assert_eq!(result_int, 123);
 
         let input = black_box(input);
-        bench.iter(|| black_box(validator.validate_python(py, &input, None, None, None, None).unwrap()))
+        bench.iter(|| {
+            black_box(
+                validator
+                    .validate_python(py, &input, None, None, None, None, false)
+                    .unwrap(),
+            )
+        })
     })
 }
 
@@ -60,7 +76,13 @@ fn list_int_json(bench: &mut Bencher) {
             (0..100).map(|x| x.to_string()).collect::<Vec<String>>().join(",")
         );
 
-        bench.iter(|| black_box(validator.validate_json(py, &json(py, &code), None, None, None).unwrap()))
+        bench.iter(|| {
+            black_box(
+                validator
+                    .validate_json(py, &json(py, &code), None, None, None, false)
+                    .unwrap(),
+            )
+        })
     })
 }
 
@@ -81,7 +103,9 @@ fn list_int_python(bench: &mut Bencher) {
         let (validator, input) = list_int_input(py);
         let input = black_box(input.bind(py));
         bench.iter(|| {
-            let v = validator.validate_python(py, &input, None, None, None, None).unwrap();
+            let v = validator
+                .validate_python(py, &input, None, None, None, None, false)
+                .unwrap();
             black_box(v)
         })
     })
@@ -114,7 +138,7 @@ fn list_error_json(bench: &mut Bencher) {
                 .join(", ")
         );
 
-        match validator.validate_json(py, &json(py, &code), None, None, None) {
+        match validator.validate_json(py, &json(py, &code), None, None, None, false) {
             Ok(_) => panic!("unexpectedly valid"),
             Err(e) => {
                 let v = e.value_bound(py);
@@ -126,7 +150,7 @@ fn list_error_json(bench: &mut Bencher) {
         };
 
         bench.iter(
-            || match validator.validate_json(py, &json(py, &code), None, None, None) {
+            || match validator.validate_json(py, &json(py, &code), None, None, None, false) {
                 Ok(_) => panic!("unexpectedly valid"),
                 Err(e) => black_box(e),
             },
@@ -146,7 +170,7 @@ fn list_error_python_input(py: Python<'_>) -> (SchemaValidator, PyObject) {
 
     let input = py.eval_bound(&code, None, None).unwrap().extract().unwrap();
 
-    match validator.validate_python(py, &input, None, None, None, None) {
+    match validator.validate_python(py, &input, None, None, None, None, false) {
         Ok(_) => panic!("unexpectedly valid"),
         Err(e) => {
             let v = e.value_bound(py);
@@ -166,7 +190,7 @@ fn list_error_python(bench: &mut Bencher) {
 
         let input = black_box(input.bind(py));
         bench.iter(|| {
-            let result = validator.validate_python(py, &input, None, None, None, None);
+            let result = validator.validate_python(py, &input, None, None, None, None, false);
 
             match result {
                 Ok(_) => panic!("unexpectedly valid"),
@@ -199,7 +223,13 @@ fn list_any_json(bench: &mut Bencher) {
             (0..100).map(|x| x.to_string()).collect::<Vec<String>>().join(",")
         );
 
-        bench.iter(|| black_box(validator.validate_json(py, &json(py, &code), None, None, None).unwrap()))
+        bench.iter(|| {
+            black_box(
+                validator
+                    .validate_json(py, &json(py, &code), None, None, None, false)
+                    .unwrap(),
+            )
+        })
     })
 }
 
@@ -214,7 +244,9 @@ fn list_any_python(bench: &mut Bencher) {
         let input = py.eval_bound(&code, None, None).unwrap().to_object(py);
         let input = black_box(input.bind(py));
         bench.iter(|| {
-            let v = validator.validate_python(py, &input, None, None, None, None).unwrap();
+            let v = validator
+                .validate_python(py, &input, None, None, None, None, false)
+                .unwrap();
             black_box(v)
         })
     })
@@ -244,7 +276,13 @@ fn dict_json(bench: &mut Bencher) {
                 .join(", ")
         );
 
-        bench.iter(|| black_box(validator.validate_json(py, &json(py, &code), None, None, None).unwrap()))
+        bench.iter(|| {
+            black_box(
+                validator
+                    .validate_json(py, &json(py, &code), None, None, None, false)
+                    .unwrap(),
+            )
+        })
     })
 }
 
@@ -266,7 +304,9 @@ fn dict_python(bench: &mut Bencher) {
         let input = py.eval_bound(&code, None, None).unwrap().to_object(py);
         let input = black_box(input.bind(py));
         bench.iter(|| {
-            let v = validator.validate_python(py, &input, None, None, None, None).unwrap();
+            let v = validator
+                .validate_python(py, &input, None, None, None, None, false)
+                .unwrap();
             black_box(v)
         })
     })
@@ -294,7 +334,7 @@ fn dict_value_error(bench: &mut Bencher) {
 
         let input = py.eval_bound(&code, None, None).unwrap().to_object(py).into_bound(py);
 
-        match validator.validate_python(py, &input, None, None, None, None) {
+        match validator.validate_python(py, &input, None, None, None, None, false) {
             Ok(_) => panic!("unexpectedly valid"),
             Err(e) => {
                 let v = e.value_bound(py);
@@ -307,7 +347,7 @@ fn dict_value_error(bench: &mut Bencher) {
 
         let input = black_box(input);
         bench.iter(|| {
-            let result = validator.validate_python(py, &input, None, None, None, None);
+            let result = validator.validate_python(py, &input, None, None, None, None, false);
 
             match result {
                 Ok(_) => panic!("unexpectedly valid"),
@@ -342,7 +382,13 @@ fn typed_dict_json(bench: &mut Bencher) {
 
         let code = r#"{"a": 1, "b": 2, "c": 3, "d": 4, "e": 5, "f": 6, "g": 7, "h": 8, "i": 9, "j": 0}"#.to_string();
 
-        bench.iter(|| black_box(validator.validate_json(py, &json(py, &code), None, None, None).unwrap()))
+        bench.iter(|| {
+            black_box(
+                validator
+                    .validate_json(py, &json(py, &code), None, None, None, false)
+                    .unwrap(),
+            )
+        })
     })
 }
 
@@ -373,7 +419,9 @@ fn typed_dict_python(bench: &mut Bencher) {
         let input = py.eval_bound(&code, None, None).unwrap().to_object(py);
         let input = black_box(input.bind(py));
         bench.iter(|| {
-            let v = validator.validate_python(py, &input, None, None, None, None).unwrap();
+            let v = validator
+                .validate_python(py, &input, None, None, None, None, false)
+                .unwrap();
             black_box(v)
         })
     })
@@ -413,7 +461,7 @@ fn typed_dict_deep_error(bench: &mut Bencher) {
         let input = py.eval_bound(code, None, None).unwrap().to_object(py);
         let input = black_box(input.bind(py));
 
-        match validator.validate_python(py, &input, None, None, None, None) {
+        match validator.validate_python(py, &input, None, None, None, None, false) {
             Ok(_) => panic!("unexpectedly valid"),
             Err(e) => {
                 let v = e.value_bound(py);
@@ -425,7 +473,7 @@ fn typed_dict_deep_error(bench: &mut Bencher) {
         };
 
         bench.iter(|| {
-            let result = validator.validate_python(py, &input, None, None, None, None);
+            let result = validator.validate_python(py, &input, None, None, None, None, false);
 
             match result {
                 Ok(_) => panic!("unexpectedly valid"),
@@ -450,7 +498,11 @@ fn complete_model(bench: &mut Bencher) {
         let input = black_box(input);
 
         bench.iter(|| {
-            black_box(validator.validate_python(py, &input, None, None, None, None).unwrap());
+            black_box(
+                validator
+                    .validate_python(py, &input, None, None, None, None, false)
+                    .unwrap(),
+            );
         })
     })
 }
@@ -469,10 +521,16 @@ fn nested_model_using_definitions(bench: &mut Bencher) {
         let input = complete_schema.call_method0("input_data_valid").unwrap();
         let input = black_box(input);
 
-        validator.validate_python(py, &input, None, None, None, None).unwrap();
+        validator
+            .validate_python(py, &input, None, None, None, None, false)
+            .unwrap();
 
         bench.iter(|| {
-            black_box(validator.validate_python(py, &input, None, None, None, None).unwrap());
+            black_box(
+                validator
+                    .validate_python(py, &input, None, None, None, None, false)
+                    .unwrap(),
+            );
         })
     })
 }
@@ -491,10 +549,16 @@ fn nested_model_inlined(bench: &mut Bencher) {
         let input = complete_schema.call_method0("input_data_valid").unwrap();
         let input = black_box(input);
 
-        validator.validate_python(py, &input, None, None, None, None).unwrap();
+        validator
+            .validate_python(py, &input, None, None, None, None, false)
+            .unwrap();
 
         bench.iter(|| {
-            black_box(validator.validate_python(py, &input, None, None, None, None).unwrap());
+            black_box(
+                validator
+                    .validate_python(py, &input, None, None, None, None, false)
+                    .unwrap(),
+            );
         })
     })
 }
@@ -506,12 +570,20 @@ fn literal_ints_few_python(bench: &mut Bencher) {
 
         let input = 4_i64.into_py(py);
         let input = input.bind(py);
-        let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
+        let result = validator
+            .validate_python(py, &input, None, None, None, None, false)
+            .unwrap();
         let result_int: i64 = result.extract(py).unwrap();
         assert_eq!(result_int, 4);
 
         let input = black_box(input);
-        bench.iter(|| black_box(validator.validate_python(py, &input, None, None, None, None).unwrap()))
+        bench.iter(|| {
+            black_box(
+                validator
+                    .validate_python(py, &input, None, None, None, None, false)
+                    .unwrap(),
+            )
+        })
     })
 }
 
@@ -523,12 +595,20 @@ fn literal_strings_few_small_python(bench: &mut Bencher) {
         let input = py.eval_bound("'4'", None, None).unwrap();
         let input = input.to_object(py).into_bound(py);
         let input_str: String = input.extract().unwrap();
-        let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
+        let result = validator
+            .validate_python(py, &input, None, None, None, None, false)
+            .unwrap();
         let result_str: String = result.extract(py).unwrap();
         assert_eq!(result_str, input_str);
 
         let input = black_box(input);
-        bench.iter(|| black_box(validator.validate_python(py, &input, None, None, None, None).unwrap()))
+        bench.iter(|| {
+            black_box(
+                validator
+                    .validate_python(py, &input, None, None, None, None, false)
+                    .unwrap(),
+            )
+        })
     })
 }
 
@@ -543,12 +623,20 @@ fn literal_strings_few_large_python(bench: &mut Bencher) {
         let input = py.eval_bound("'a' * 25 + '4'", None, None).unwrap();
         let input = input.to_object(py).into_bound(py);
         let input_str: String = input.extract().unwrap();
-        let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
+        let result = validator
+            .validate_python(py, &input, None, None, None, None, false)
+            .unwrap();
         let result_str: String = result.extract(py).unwrap();
         assert_eq!(result_str, input_str);
 
         let input = black_box(input);
-        bench.iter(|| black_box(validator.validate_python(py, &input, None, None, None, None).unwrap()))
+        bench.iter(|| {
+            black_box(
+                validator
+                    .validate_python(py, &input, None, None, None, None, false)
+                    .unwrap(),
+            )
+        })
     })
 }
 
@@ -579,11 +667,19 @@ class Foo(Enum):
 
         let input = py.eval_bound("Foo.v4", Some(&globals), None).unwrap();
         let input = input.to_object(py).into_bound(py);
-        let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
+        let result = validator
+            .validate_python(py, &input, None, None, None, None, false)
+            .unwrap();
         assert!(input.eq(result).unwrap());
 
         let input = black_box(input);
-        bench.iter(|| black_box(validator.validate_python(py, &input, None, None, None, None).unwrap()))
+        bench.iter(|| {
+            black_box(
+                validator
+                    .validate_python(py, &input, None, None, None, None, false)
+                    .unwrap(),
+            )
+        })
     })
 }
 
@@ -593,12 +689,20 @@ fn literal_ints_many_python(bench: &mut Bencher) {
         let validator = build_schema_validator(py, "{'type': 'literal', 'expected': list(range(100))}");
 
         let input = 99_i64.into_py(py).into_bound(py);
-        let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
+        let result = validator
+            .validate_python(py, &input, None, None, None, None, false)
+            .unwrap();
         let result_int: i64 = result.extract(py).unwrap();
         assert_eq!(result_int, 99);
 
         let input = black_box(input);
-        bench.iter(|| black_box(validator.validate_python(py, &input, None, None, None, None).unwrap()))
+        bench.iter(|| {
+            black_box(
+                validator
+                    .validate_python(py, &input, None, None, None, None, false)
+                    .unwrap(),
+            )
+        })
     })
 }
 
@@ -610,12 +714,20 @@ fn literal_strings_many_small_python(bench: &mut Bencher) {
         let input = py.eval_bound("'99'", None, None).unwrap();
         let input = input.to_object(py).into_bound(py);
         let input_str: String = input.extract().unwrap();
-        let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
+        let result = validator
+            .validate_python(py, &input, None, None, None, None, false)
+            .unwrap();
         let result_str: String = result.extract(py).unwrap();
         assert_eq!(result_str, input_str);
 
         let input = black_box(input);
-        bench.iter(|| black_box(validator.validate_python(py, &input, None, None, None, None).unwrap()))
+        bench.iter(|| {
+            black_box(
+                validator
+                    .validate_python(py, &input, None, None, None, None, false)
+                    .unwrap(),
+            )
+        })
     })
 }
 
@@ -630,12 +742,20 @@ fn literal_strings_many_large_python(bench: &mut Bencher) {
         let input = py.eval_bound("'a' * 25 + '99'", None, None).unwrap();
         let input = input.to_object(py).into_bound(py);
         let input_str: String = input.extract().unwrap();
-        let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
+        let result = validator
+            .validate_python(py, &input, None, None, None, None, false)
+            .unwrap();
         let result_str: String = result.extract(py).unwrap();
         assert_eq!(result_str, input_str);
 
         let input = black_box(input);
-        bench.iter(|| black_box(validator.validate_python(py, &input, None, None, None, None).unwrap()))
+        bench.iter(|| {
+            black_box(
+                validator
+                    .validate_python(py, &input, None, None, None, None, false)
+                    .unwrap(),
+            )
+        })
     })
 }
 
@@ -646,12 +766,20 @@ fn literal_ints_many_json(bench: &mut Bencher) {
 
         let input_json = py.eval_bound("'99'", None, None).unwrap();
         let input_json = input_json.to_object(py).into_bound(py);
-        let result = validator.validate_json(py, &input_json, None, None, None).unwrap();
+        let result = validator
+            .validate_json(py, &input_json, None, None, None, false)
+            .unwrap();
         let result_int: i64 = result.extract(py).unwrap();
         assert_eq!(result_int, 99);
 
         let input_json = black_box(input_json);
-        bench.iter(|| black_box(validator.validate_json(py, &input_json, None, None, None).unwrap()))
+        bench.iter(|| {
+            black_box(
+                validator
+                    .validate_json(py, &input_json, None, None, None, false)
+                    .unwrap(),
+            )
+        })
     })
 }
 
@@ -668,12 +796,20 @@ fn literal_strings_many_large_json(bench: &mut Bencher) {
         let input_json = py.eval_bound("'\"' + 'a' * 25 + '99' + '\"'", None, None).unwrap();
         let input_json = input_json.to_object(py).into_bound(py);
         let input_str: String = input.extract().unwrap();
-        let result = validator.validate_json(py, &input_json, None, None, None).unwrap();
+        let result = validator
+            .validate_json(py, &input_json, None, None, None, false)
+            .unwrap();
         let result_str: String = result.extract(py).unwrap();
         assert_eq!(result_str, input_str);
 
         let input_json = black_box(input_json);
-        bench.iter(|| black_box(validator.validate_json(py, &input_json, None, None, None).unwrap()))
+        bench.iter(|| {
+            black_box(
+                validator
+                    .validate_json(py, &input_json, None, None, None, false)
+                    .unwrap(),
+            )
+        })
     })
 }
 
@@ -706,12 +842,20 @@ class Foo(Enum):
             let input = py.eval_bound("'null'", None, None).unwrap();
             let input = input.to_object(py).into_bound(py);
             let input_str: String = input.extract().unwrap();
-            let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
+            let result = validator
+                .validate_python(py, &input, None, None, None, None, false)
+                .unwrap();
             let result_str: String = result.extract(py).unwrap();
             assert_eq!(result_str, input_str);
 
             let input = black_box(input);
-            bench.iter(|| black_box(validator.validate_python(py, &input, None, None, None, None).unwrap()))
+            bench.iter(|| {
+                black_box(
+                    validator
+                        .validate_python(py, &input, None, None, None, None, false)
+                        .unwrap(),
+                )
+            })
         }
 
         // Int
@@ -719,34 +863,58 @@ class Foo(Enum):
             let input = py.eval_bound("-1", None, None).unwrap();
             let input = input.to_object(py).into_bound(py);
             let input_int: i64 = input.extract().unwrap();
-            let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
+            let result = validator
+                .validate_python(py, &input, None, None, None, None, false)
+                .unwrap();
             let result_int: i64 = result.extract(py).unwrap();
             assert_eq!(result_int, input_int);
 
             let input = black_box(input);
-            bench.iter(|| black_box(validator.validate_python(py, &input, None, None, None, None).unwrap()))
+            bench.iter(|| {
+                black_box(
+                    validator
+                        .validate_python(py, &input, None, None, None, None, false)
+                        .unwrap(),
+                )
+            })
         }
 
         // None
         {
             let input = py.eval_bound("None", None, None).unwrap();
             let input = input.to_object(py).into_bound(py);
-            let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
+            let result = validator
+                .validate_python(py, &input, None, None, None, None, false)
+                .unwrap();
             assert!(input.eq(result).unwrap());
 
             let input = black_box(input);
-            bench.iter(|| black_box(validator.validate_python(py, &input, None, None, None, None).unwrap()))
+            bench.iter(|| {
+                black_box(
+                    validator
+                        .validate_python(py, &input, None, None, None, None, false)
+                        .unwrap(),
+                )
+            })
         }
 
         // Enum
         {
             let input = py.eval_bound("Foo.v4", Some(&globals), None).unwrap();
             let input = input.to_object(py).into_bound(py);
-            let result = validator.validate_python(py, &input, None, None, None, None).unwrap();
+            let result = validator
+                .validate_python(py, &input, None, None, None, None, false)
+                .unwrap();
             assert!(input.eq(result).unwrap());
 
             let input = black_box(input);
-            bench.iter(|| black_box(validator.validate_python(py, &input, None, None, None, None).unwrap()))
+            bench.iter(|| {
+                black_box(
+                    validator
+                        .validate_python(py, &input, None, None, None, None, false)
+                        .unwrap(),
+                )
+            })
         }
     })
 }
diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index d696ac407..69bfb64a8 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -96,6 +96,7 @@ class SchemaValidator:
         from_attributes: bool | None = None,
         context: Any | None = None,
         self_instance: Any | None = None,
+        allow_partial: bool = False,
     ) -> Any:
         """
         Validate a Python object against the schema and return the validated object.
@@ -110,6 +111,8 @@ class SchemaValidator:
                 [`info.context`][pydantic_core.core_schema.ValidationInfo.context].
             self_instance: An instance of a model set attributes on from validation, this is used when running
                 validation from the `__init__` method of a model.
+            allow_partial: Whether to allow partial validation; if `True` errors in the last element of sequences
+                and mappings are ignored.
 
         Raises:
             ValidationError: If validation fails.
@@ -143,6 +146,7 @@ class SchemaValidator:
         strict: bool | None = None,
         context: Any | None = None,
         self_instance: Any | None = None,
+        allow_partial: bool = False,
     ) -> Any:
         """
         Validate JSON data directly against the schema and return the validated Python object.
@@ -160,6 +164,8 @@ class SchemaValidator:
             context: The context to use for validation, this is passed to functional validators as
                 [`info.context`][pydantic_core.core_schema.ValidationInfo.context].
             self_instance: An instance of a model set attributes on from validation.
+            allow_partial: Whether to allow partial validation; if `True` incomplete JSON will be parsed successfully
+                and errors in the last element of sequences and mappings are ignored.
 
         Raises:
             ValidationError: If validation fails or if the JSON data is invalid.
@@ -168,7 +174,14 @@ class SchemaValidator:
         Returns:
             The validated Python object.
         """
-    def validate_strings(self, input: _StringInput, *, strict: bool | None = None, context: Any | None = None) -> Any:
+    def validate_strings(
+        self,
+        input: _StringInput,
+        *,
+        strict: bool | None = None,
+        context: Any | None = None,
+        allow_partial: bool = False,
+    ) -> Any:
         """
         Validate a string against the schema and return the validated Python object.
 
@@ -181,6 +194,8 @@ class SchemaValidator:
                 If `None`, the value of [`CoreConfig.strict`][pydantic_core.core_schema.CoreConfig] is used.
             context: The context to use for validation, this is passed to functional validators as
                 [`info.context`][pydantic_core.core_schema.ValidationInfo.context].
+            allow_partial: Whether to allow partial validation; if `True` errors in the last element of sequences
+                and mappings are ignored.
 
         Raises:
             ValidationError: If validation fails or if the JSON data is invalid.
diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index 5a8646fca..c023a5635 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -2840,7 +2840,7 @@ def typed_dict_field(
 
     Args:
         schema: The schema to use for the field
-        required: Whether the field is required
+        required: Whether the field is required, otherwise uses the value from `total` on the typed dict
         validation_alias: The alias(es) to use to find the field in the validation data
         serialization_alias: The alias to use as a key when serializing
         serialization_exclude: Whether to exclude the field when serializing
@@ -2916,7 +2916,7 @@ class MyTypedDict(TypedDict):
         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
         extra_behavior: The extra behavior to use for the typed dict
-        total: Whether the typed dict is total
+        total: Whether the typed dict is total, otherwise uses `typed_dict_total` from config
         populate_by_name: Whether the typed dict should populate by name
         serialization: Custom serialization schema
     """
diff --git a/src/errors/line_error.rs b/src/errors/line_error.rs
index c3d2b66dc..03e770cc3 100644
--- a/src/errors/line_error.rs
+++ b/src/errors/line_error.rs
@@ -145,6 +145,14 @@ impl ValLineError {
         self.error_type = error_type;
         self
     }
+
+    pub fn first_loc_item(&self) -> Option<&LocItem> {
+        match &self.location {
+            Location::Empty => None,
+            // last because order is reversed
+            Location::List(loc_items) => loc_items.last(),
+        }
+    }
 }
 
 #[cfg_attr(debug_assertions, derive(Debug))]
diff --git a/src/errors/location.rs b/src/errors/location.rs
index 07e1623d7..e9e20ab5d 100644
--- a/src/errors/location.rs
+++ b/src/errors/location.rs
@@ -12,7 +12,7 @@ use crate::lookup_key::{LookupPath, PathItem};
 
 /// Used to store individual items of the error location, e.g. a string for key/field names
 /// or a number for array indices.
-#[derive(Clone)]
+#[derive(Clone, Eq, PartialEq)]
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub enum LocItem {
     /// string type key, used to identify items from a dict or anything that implements `__getitem__`
diff --git a/src/input/input_abstract.rs b/src/input/input_abstract.rs
index 01deea4bc..05473c702 100644
--- a/src/input/input_abstract.rs
+++ b/src/input/input_abstract.rs
@@ -236,6 +236,8 @@ pub trait ValidatedDict<'py> {
         &'a self,
         consumer: impl ConsumeIterator<ValResult<(Self::Key<'a>, Self::Item<'a>)>, Output = R>,
     ) -> ValResult<R>;
+    // used in partial mode to check all errors occurred in the last value
+    fn last_key(&self) -> Option<Self::Key<'_>>;
 }
 
 /// For validations from a list
@@ -276,6 +278,9 @@ impl<'py> ValidatedDict<'py> for Never {
     ) -> ValResult<R> {
         unreachable!()
     }
+    fn last_key(&self) -> Option<Self::Key<'_>> {
+        unreachable!()
+    }
 }
 
 impl<'py> ValidatedList<'py> for Never {
diff --git a/src/input/input_json.rs b/src/input/input_json.rs
index 7c77928d0..d69874613 100644
--- a/src/input/input_json.rs
+++ b/src/input/input_json.rs
@@ -516,6 +516,10 @@ impl<'py, 'data> ValidatedDict<'py> for &'_ JsonObject<'data> {
     ) -> ValResult<R> {
         Ok(consumer.consume_iterator(LazyIndexMap::iter(self).map(|(k, v)| Ok((k.as_ref(), v)))))
     }
+
+    fn last_key(&self) -> Option<Self::Key<'_>> {
+        self.keys().last().map(AsRef::as_ref)
+    }
 }
 
 impl<'a, 'py, 'data> ValidatedList<'py> for &'a JsonArray<'data> {
diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index b9d95b8bf..4fb88e99c 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -823,6 +823,21 @@ impl<'py> ValidatedDict<'py> for GenericPyMapping<'_, 'py> {
             Self::GetAttr(obj, _) => Ok(consumer.consume_iterator(iterate_attributes(obj)?)),
         }
     }
+
+    fn last_key(&self) -> Option<Self::Key<'_>> {
+        match self {
+            Self::Dict(dict) => dict.keys().iter().last(),
+            // see https://github.com/pydantic/pydantic-core/pull/1512#discussion_r1826057970
+            Self::Mapping(mapping) => mapping
+                .call_method0(intern!(mapping.py(), "keys"))
+                .ok()?
+                .iter()
+                .ok()?
+                .last()?
+                .ok(),
+            Self::GetAttr(_, _) => None,
+        }
+    }
 }
 
 /// Container for all the collections (sized iterable containers) types, which
diff --git a/src/input/input_string.rs b/src/input/input_string.rs
index 1e6b14825..2ac218658 100644
--- a/src/input/input_string.rs
+++ b/src/input/input_string.rs
@@ -303,4 +303,12 @@ impl<'py> ValidatedDict<'py> for StringMappingDict<'py> {
                 .map(|(key, val)| Ok((StringMapping::new_key(key)?, StringMapping::new_value(val)?))),
         ))
     }
+
+    fn last_key(&self) -> Option<Self::Key<'_>> {
+        self.0
+            .keys()
+            .iter()
+            .last()
+            .and_then(|key| StringMapping::new_key(key).ok())
+    }
 }
diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index 888dff714..d5e31b97b 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -128,7 +128,9 @@ pub(crate) fn validate_iter_to_vec<'py>(
 ) -> ValResult<Vec<PyObject>> {
     let mut output: Vec<PyObject> = Vec::with_capacity(capacity);
     let mut errors: Vec<ValLineError> = Vec::new();
-    for (index, item_result) in iter.enumerate() {
+
+    for (index, is_last_partial, item_result) in state.enumerate_last_partial(iter) {
+        state.allow_partial = is_last_partial;
         let item = item_result.map_err(|e| any_next_error!(py, e, max_length_check.input, index))?;
         match validator.validate(py, item.borrow_input(), state) {
             Ok(item) => {
@@ -137,9 +139,11 @@ pub(crate) fn validate_iter_to_vec<'py>(
             }
             Err(ValError::LineErrors(line_errors)) => {
                 max_length_check.incr()?;
-                errors.extend(line_errors.into_iter().map(|err| err.with_outer_location(index)));
-                if fail_fast {
-                    break;
+                if !is_last_partial {
+                    errors.extend(line_errors.into_iter().map(|err| err.with_outer_location(index)));
+                    if fail_fast {
+                        return Err(ValError::LineErrors(errors));
+                    }
                 }
             }
             Err(ValError::Omit) => (),
@@ -197,7 +201,9 @@ pub(crate) fn validate_iter_to_set<'py>(
     fail_fast: bool,
 ) -> ValResult<()> {
     let mut errors: Vec<ValLineError> = Vec::new();
-    for (index, item_result) in iter.enumerate() {
+
+    for (index, is_last_partial, item_result) in state.enumerate_last_partial(iter) {
+        state.allow_partial = is_last_partial;
         let item = item_result.map_err(|e| any_next_error!(py, e, input, index))?;
         match validator.validate(py, item.borrow_input(), state) {
             Ok(item) => {
@@ -220,13 +226,15 @@ pub(crate) fn validate_iter_to_set<'py>(
                 }
             }
             Err(ValError::LineErrors(line_errors)) => {
-                errors.extend(line_errors.into_iter().map(|err| err.with_outer_location(index)));
+                if !is_last_partial {
+                    errors.extend(line_errors.into_iter().map(|err| err.with_outer_location(index)));
+                }
             }
             Err(ValError::Omit) => (),
             Err(err) => return Err(err),
         }
         if fail_fast && !errors.is_empty() {
-            break;
+            return Err(ValError::LineErrors(errors));
         }
     }
 
diff --git a/src/serializers/fields.rs b/src/serializers/fields.rs
index 32c16b18a..6cd76c36b 100644
--- a/src/serializers/fields.rs
+++ b/src/serializers/fields.rs
@@ -53,7 +53,7 @@ impl SerField {
         }
     }
 
-    pub fn get_key_py<'py>(&'py self, py: Python<'py>, extra: &Extra) -> &Bound<'py, PyAny> {
+    pub fn get_key_py<'py>(&self, py: Python<'py>, extra: &Extra) -> &Bound<'py, PyAny> {
         if extra.by_alias {
             if let Some(ref alias_py) = self.alias_py {
                 return alias_py.bind(py);
diff --git a/src/url.rs b/src/url.rs
index 881347f25..3ba2c8451 100644
--- a/src/url.rs
+++ b/src/url.rs
@@ -45,7 +45,7 @@ impl PyUrl {
     pub fn py_new(py: Python, url: &Bound<'_, PyAny>) -> PyResult<Self> {
         let schema_obj = SCHEMA_DEFINITION_URL
             .get_or_init(py, || build_schema_validator(py, "url"))
-            .validate_python(py, url, None, None, None, None)?;
+            .validate_python(py, url, None, None, None, None, false)?;
         schema_obj.extract(py)
     }
 
@@ -225,7 +225,7 @@ impl PyMultiHostUrl {
     pub fn py_new(py: Python, url: &Bound<'_, PyAny>) -> PyResult<Self> {
         let schema_obj = SCHEMA_DEFINITION_MULTI_HOST_URL
             .get_or_init(py, || build_schema_validator(py, "multi-host-url"))
-            .validate_python(py, url, None, None, None, None)?;
+            .validate_python(py, url, None, None, None, None, false)?;
         schema_obj.extract(py)
     }
 
diff --git a/src/validators/arguments.rs b/src/validators/arguments.rs
index 22f870c56..0d90af5d3 100644
--- a/src/validators/arguments.rs
+++ b/src/validators/arguments.rs
@@ -188,6 +188,9 @@ impl Validator for ArgumentsValidator {
         input: &(impl Input<'py> + ?Sized),
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
+        // this validator does not yet support partial validation, disable it to avoid incorrect results
+        state.allow_partial = false;
+
         let args = input.validate_args()?;
 
         let mut output_args: Vec<PyObject> = Vec::with_capacity(self.positional_params_count);
diff --git a/src/validators/dataclass.rs b/src/validators/dataclass.rs
index 4bece7ea5..86211b7b2 100644
--- a/src/validators/dataclass.rs
+++ b/src/validators/dataclass.rs
@@ -145,6 +145,9 @@ impl Validator for DataclassArgsValidator {
         input: &(impl Input<'py> + ?Sized),
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
+        // this validator does not yet support partial validation, disable it to avoid incorrect results
+        state.allow_partial = false;
+
         let args = input.validate_dataclass_args(&self.dataclass_name)?;
 
         let output_dict = PyDict::new_bound(py);
diff --git a/src/validators/definitions.rs b/src/validators/definitions.rs
index a96138c48..34d0edef4 100644
--- a/src/validators/definitions.rs
+++ b/src/validators/definitions.rs
@@ -75,6 +75,9 @@ impl Validator for DefinitionRefValidator {
         input: &(impl Input<'py> + ?Sized),
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
+        // this validator does not yet support partial validation, disable it to avoid incorrect results
+        state.allow_partial = false;
+
         self.definition.read(|validator| {
             let validator = validator.unwrap();
             if let Some(id) = input.as_python().map(py_identity) {
diff --git a/src/validators/dict.rs b/src/validators/dict.rs
index ea0000236..adfadc6fa 100644
--- a/src/validators/dict.rs
+++ b/src/validators/dict.rs
@@ -110,7 +110,8 @@ where
         let output = PyDict::new_bound(self.py);
         let mut errors: Vec<ValLineError> = Vec::new();
 
-        for item_result in iterator {
+        for (_, is_last_partial, item_result) in self.state.enumerate_last_partial(iterator) {
+            self.state.allow_partial = false;
             let (key, value) = item_result?;
             let output_key = match self.key_validator.validate(self.py, key.borrow_input(), self.state) {
                 Ok(value) => Some(value),
@@ -124,19 +125,20 @@ where
                 Err(ValError::Omit) => continue,
                 Err(err) => return Err(err),
             };
+            self.state.allow_partial = is_last_partial;
             let output_value = match self.value_validator.validate(self.py, value.borrow_input(), self.state) {
-                Ok(value) => Some(value),
+                Ok(value) => value,
                 Err(ValError::LineErrors(line_errors)) => {
-                    for err in line_errors {
-                        errors.push(err.with_outer_location(key.clone()));
+                    if !is_last_partial {
+                        errors.extend(line_errors.into_iter().map(|err| err.with_outer_location(key.clone())));
                     }
-                    None
+                    continue;
                 }
                 Err(ValError::Omit) => continue,
                 Err(err) => return Err(err),
             };
-            if let (Some(key), Some(value)) = (output_key, output_value) {
-                output.set_item(key, value)?;
+            if let Some(key) = output_key {
+                output.set_item(key, output_value)?;
             }
         }
 
diff --git a/src/validators/generator.rs b/src/validators/generator.rs
index de9949a8c..12241f205 100644
--- a/src/validators/generator.rs
+++ b/src/validators/generator.rs
@@ -66,6 +66,9 @@ impl Validator for GeneratorValidator {
         input: &(impl Input<'py> + ?Sized),
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
+        // this validator does not yet support partial validation, disable it to avoid incorrect results
+        state.allow_partial = false;
+
         let iterator = input.validate_iter()?.into_static();
         let validator = self.item_validator.as_ref().map(|v| {
             InternalValidator::new(
@@ -279,7 +282,7 @@ impl InternalValidator {
             self_instance: self.self_instance.as_ref().map(|data| data.bind(py)),
             cache_str: self.cache_str,
         };
-        let mut state = ValidationState::new(extra, &mut self.recursion_guard);
+        let mut state = ValidationState::new(extra, &mut self.recursion_guard, false);
         state.exactness = self.exactness;
         let result = self
             .validator
@@ -314,7 +317,7 @@ impl InternalValidator {
             self_instance: self.self_instance.as_ref().map(|data| data.bind(py)),
             cache_str: self.cache_str,
         };
-        let mut state = ValidationState::new(extra, &mut self.recursion_guard);
+        let mut state = ValidationState::new(extra, &mut self.recursion_guard, false);
         state.exactness = self.exactness;
         let result = self.validator.validate(py, input, &mut state).map_err(|e| {
             ValidationError::from_val_error(
diff --git a/src/validators/json.rs b/src/validators/json.rs
index 79a36e058..9ba13dca1 100644
--- a/src/validators/json.rs
+++ b/src/validators/json.rs
@@ -1,9 +1,8 @@
-use jiter::FloatMode;
 use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
 
-use jiter::{JsonValue, PartialMode, PythonParse};
+use jiter::{FloatMode, JsonValue, PartialMode, PythonParse};
 
 use crate::errors::{ErrorType, ErrorTypeDefaults, ValError, ValLineError, ValResult};
 use crate::input::{EitherBytes, Input, InputType, ValidationMatch};
@@ -60,7 +59,8 @@ impl Validator for JsonValidator {
         let json_bytes = json_either_bytes.as_slice();
         match self.validator {
             Some(ref validator) => {
-                let json_value = JsonValue::parse(json_bytes, true).map_err(|e| map_json_err(input, e, json_bytes))?;
+                let json_value = JsonValue::parse_with_config(json_bytes, true, state.allow_partial)
+                    .map_err(|e| map_json_err(input, e, json_bytes))?;
                 let mut json_state = state.rebind_extra(|e| {
                     e.input_type = InputType::Json;
                 });
@@ -70,7 +70,11 @@ impl Validator for JsonValidator {
                 let parse_builder = PythonParse {
                     allow_inf_nan: true,
                     cache_mode: state.cache_str(),
-                    partial_mode: PartialMode::Off,
+                    partial_mode: if state.allow_partial {
+                        PartialMode::TrailingStrings
+                    } else {
+                        PartialMode::Off
+                    },
                     catch_duplicate_keys: false,
                     float_mode: FloatMode::Float,
                 };
diff --git a/src/validators/mod.rs b/src/validators/mod.rs
index fcd64ebf2..c0c58adcf 100644
--- a/src/validators/mod.rs
+++ b/src/validators/mod.rs
@@ -164,7 +164,8 @@ impl SchemaValidator {
         Ok((cls, init_args))
     }
 
-    #[pyo3(signature = (input, *, strict=None, from_attributes=None, context=None, self_instance=None))]
+    #[allow(clippy::too_many_arguments)]
+    #[pyo3(signature = (input, *, strict=None, from_attributes=None, context=None, self_instance=None, allow_partial=false))]
     pub fn validate_python(
         &self,
         py: Python,
@@ -173,6 +174,7 @@ impl SchemaValidator {
         from_attributes: Option<bool>,
         context: Option<&Bound<'_, PyAny>>,
         self_instance: Option<&Bound<'_, PyAny>>,
+        allow_partial: bool,
     ) -> PyResult<PyObject> {
         self._validate(
             py,
@@ -182,6 +184,7 @@ impl SchemaValidator {
             from_attributes,
             context,
             self_instance,
+            allow_partial,
         )
         .map_err(|e| self.prepare_validation_err(py, e, InputType::Python))
     }
@@ -204,6 +207,7 @@ impl SchemaValidator {
             from_attributes,
             context,
             self_instance,
+            false,
         ) {
             Ok(_) => Ok(true),
             Err(ValError::InternalErr(err)) => Err(err),
@@ -213,7 +217,7 @@ impl SchemaValidator {
         }
     }
 
-    #[pyo3(signature = (input, *, strict=None, context=None, self_instance=None))]
+    #[pyo3(signature = (input, *, strict=None, context=None, self_instance=None, allow_partial=false))]
     pub fn validate_json(
         &self,
         py: Python,
@@ -221,6 +225,7 @@ impl SchemaValidator {
         strict: Option<bool>,
         context: Option<&Bound<'_, PyAny>>,
         self_instance: Option<&Bound<'_, PyAny>>,
+        allow_partial: bool,
     ) -> PyResult<PyObject> {
         let r = match json::validate_json_bytes(input) {
             Ok(v_match) => self._validate_json(
@@ -230,24 +235,26 @@ impl SchemaValidator {
                 strict,
                 context,
                 self_instance,
+                allow_partial,
             ),
             Err(err) => Err(err),
         };
         r.map_err(|e| self.prepare_validation_err(py, e, InputType::Json))
     }
 
-    #[pyo3(signature = (input, *, strict=None, context=None))]
+    #[pyo3(signature = (input, *, strict=None, context=None, allow_partial=false))]
     pub fn validate_strings(
         &self,
         py: Python,
         input: Bound<'_, PyAny>,
         strict: Option<bool>,
         context: Option<&Bound<'_, PyAny>>,
+        allow_partial: bool,
     ) -> PyResult<PyObject> {
         let t = InputType::String;
         let string_mapping = StringMapping::new_value(input).map_err(|e| self.prepare_validation_err(py, e, t))?;
 
-        match self._validate(py, &string_mapping, t, strict, None, context, None) {
+        match self._validate(py, &string_mapping, t, strict, None, context, None, allow_partial) {
             Ok(r) => Ok(r),
             Err(e) => Err(self.prepare_validation_err(py, e, t)),
         }
@@ -276,7 +283,7 @@ impl SchemaValidator {
         };
 
         let guard = &mut RecursionState::default();
-        let mut state = ValidationState::new(extra, guard);
+        let mut state = ValidationState::new(extra, guard, false);
         self.validator
             .validate_assignment(py, &obj, field_name, &field_value, &mut state)
             .map_err(|e| self.prepare_validation_err(py, e, InputType::Python))
@@ -299,7 +306,7 @@ impl SchemaValidator {
             cache_str: self.cache_str,
         };
         let recursion_guard = &mut RecursionState::default();
-        let mut state = ValidationState::new(extra, recursion_guard);
+        let mut state = ValidationState::new(extra, recursion_guard, false);
         let r = self.validator.default_value(py, None::<i64>, &mut state);
         match r {
             Ok(maybe_default) => match maybe_default {
@@ -345,6 +352,7 @@ impl SchemaValidator {
         from_attributes: Option<bool>,
         context: Option<&Bound<'py, PyAny>>,
         self_instance: Option<&Bound<'py, PyAny>>,
+        allow_partial: bool,
     ) -> ValResult<PyObject> {
         let mut recursion_guard = RecursionState::default();
         let mut state = ValidationState::new(
@@ -357,10 +365,12 @@ impl SchemaValidator {
                 self.cache_str,
             ),
             &mut recursion_guard,
+            allow_partial,
         );
         self.validator.validate(py, input, &mut state)
     }
 
+    #[allow(clippy::too_many_arguments)]
     fn _validate_json(
         &self,
         py: Python,
@@ -369,10 +379,20 @@ impl SchemaValidator {
         strict: Option<bool>,
         context: Option<&Bound<'_, PyAny>>,
         self_instance: Option<&Bound<'_, PyAny>>,
+        allow_partial: bool,
     ) -> ValResult<PyObject> {
-        let json_value =
-            jiter::JsonValue::parse(json_data, true).map_err(|e| json::map_json_err(input, e, json_data))?;
-        self._validate(py, &json_value, InputType::Json, strict, None, context, self_instance)
+        let json_value = jiter::JsonValue::parse_with_config(json_data, true, allow_partial)
+            .map_err(|e| json::map_json_err(input, e, json_data))?;
+        self._validate(
+            py,
+            &json_value,
+            InputType::Json,
+            strict,
+            None,
+            context,
+            self_instance,
+            allow_partial,
+        )
     }
 
     fn prepare_validation_err(&self, py: Python, error: ValError, input_type: InputType) -> PyErr {
@@ -410,6 +430,7 @@ impl<'py> SelfValidator<'py> {
         let mut state = ValidationState::new(
             Extra::new(strict, None, None, None, InputType::Python, true.into()),
             &mut recursion_guard,
+            false,
         );
         match self.validator.validator.validate(py, schema, &mut state) {
             Ok(schema_obj) => Ok(schema_obj.into_bound(py)),
diff --git a/src/validators/model_fields.rs b/src/validators/model_fields.rs
index 7ecd1d353..eb4829c7f 100644
--- a/src/validators/model_fields.rs
+++ b/src/validators/model_fields.rs
@@ -120,6 +120,9 @@ impl Validator for ModelFieldsValidator {
         input: &(impl Input<'py> + ?Sized),
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
+        // this validator does not yet support partial validation, disable it to avoid incorrect results
+        state.allow_partial = false;
+
         let strict = state.strict_or(self.strict);
         let from_attributes = state.extra().from_attributes.unwrap_or(self.from_attributes);
 
diff --git a/src/validators/tuple.rs b/src/validators/tuple.rs
index 8acbf2beb..2b544d417 100644
--- a/src/validators/tuple.rs
+++ b/src/validators/tuple.rs
@@ -272,6 +272,9 @@ impl Validator for TupleValidator {
         input: &(impl Input<'py> + ?Sized),
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
+        // this validator does not yet support partial validation, disable it to avoid incorrect results
+        state.allow_partial = false;
+
         let collection = input.validate_tuple(state.strict_or(self.strict))?.unpack(state);
         let actual_length = collection.len();
 
diff --git a/src/validators/typed_dict.rs b/src/validators/typed_dict.rs
index f72d969a8..949cff9a5 100644
--- a/src/validators/typed_dict.rs
+++ b/src/validators/typed_dict.rs
@@ -124,7 +124,6 @@ impl BuildValidator for TypedDictValidator {
                 required,
             });
         }
-
         Ok(Self {
             fields,
             extra_behavior,
@@ -154,6 +153,12 @@ impl Validator for TypedDictValidator {
         let output_dict = PyDict::new_bound(py);
         let mut errors: Vec<ValLineError> = Vec::with_capacity(self.fields.len());
 
+        let partial_last_key = if state.allow_partial {
+            dict.last_key().map(Into::into)
+        } else {
+            None
+        };
+
         // we only care about which keys have been used if we're iterating over the object for extra after
         // the first pass
         let mut used_keys: Option<AHashSet<&str>> =
@@ -171,8 +176,11 @@ impl Validator for TypedDictValidator {
                 let op_key_value = match dict.get_item(&field.lookup_key) {
                     Ok(v) => v,
                     Err(ValError::LineErrors(line_errors)) => {
-                        for err in line_errors {
-                            errors.push(err.with_outer_location(&field.name));
+                        let field_loc: LocItem = field.name.clone().into();
+                        if partial_last_key.as_ref() == Some(&field_loc) {
+                            for err in line_errors {
+                                errors.push(err.with_outer_location(field_loc.clone()));
+                            }
                         }
                         continue;
                     }
@@ -184,6 +192,13 @@ impl Validator for TypedDictValidator {
                         // extra logic either way
                         used_keys.insert(lookup_path.first_key());
                     }
+                    let is_last_partial = if let Some(ref last_key) = partial_last_key {
+                        let first_key_loc: LocItem = lookup_path.first_key().into();
+                        &first_key_loc == last_key
+                    } else {
+                        false
+                    };
+                    state.allow_partial = is_last_partial;
                     match field.validator.validate(py, value.borrow_input(), state) {
                         Ok(value) => {
                             output_dict.set_item(&field.name_py, value)?;
@@ -191,8 +206,10 @@ impl Validator for TypedDictValidator {
                         }
                         Err(ValError::Omit) => continue,
                         Err(ValError::LineErrors(line_errors)) => {
-                            for err in line_errors {
-                                errors.push(lookup_path.apply_error_loc(err, self.loc_by_alias, &field.name));
+                            if !is_last_partial || field.required {
+                                for err in line_errors {
+                                    errors.push(lookup_path.apply_error_loc(err, self.loc_by_alias, &field.name));
+                                }
                             }
                         }
                         Err(err) => return Err(err),
@@ -242,6 +259,7 @@ impl Validator for TypedDictValidator {
                 output_dict: &'a Bound<'py, PyDict>,
                 state: &'a mut ValidationState<'s, 'py>,
                 extra_behavior: ExtraBehavior,
+                partial_last_key: Option<LocItem>,
             }
 
             impl<'py, Key, Value> ConsumeIterator<ValResult<(Key, Value)>> for ValidateExtras<'_, '_, 'py>
@@ -289,13 +307,20 @@ impl Validator for TypedDictValidator {
                             ExtraBehavior::Allow => {
                                 let py_key = either_str.as_py_string(self.py, self.state.cache_str());
                                 if let Some(validator) = self.extras_validator {
+                                    let last_partial = self.partial_last_key.as_ref().map_or(false, |last_key| {
+                                        let key_loc: LocItem = raw_key.clone().into();
+                                        &key_loc == last_key
+                                    });
+                                    self.state.allow_partial = last_partial;
                                     match validator.validate(self.py, value, self.state) {
                                         Ok(value) => {
                                             self.output_dict.set_item(py_key, value)?;
                                         }
                                         Err(ValError::LineErrors(line_errors)) => {
-                                            for err in line_errors {
-                                                self.errors.push(err.with_outer_location(raw_key.clone()));
+                                            if !last_partial {
+                                                for err in line_errors {
+                                                    self.errors.push(err.with_outer_location(raw_key.clone()));
+                                                }
                                             }
                                         }
                                         Err(err) => return Err(err),
@@ -319,13 +344,14 @@ impl Validator for TypedDictValidator {
                 output_dict: &output_dict,
                 state,
                 extra_behavior: self.extra_behavior,
+                partial_last_key,
             })??;
         }
 
-        if !errors.is_empty() {
-            Err(ValError::LineErrors(errors))
-        } else {
+        if errors.is_empty() {
             Ok(output_dict.to_object(py))
+        } else {
+            Err(ValError::LineErrors(errors))
         }
     }
 
diff --git a/src/validators/validation_state.rs b/src/validators/validation_state.rs
index b125cd316..b21284a99 100644
--- a/src/validators/validation_state.rs
+++ b/src/validators/validation_state.rs
@@ -23,16 +23,19 @@ pub struct ValidationState<'a, 'py> {
     // `model_fields_set` attached to a model. `model_fields_set` includes extra fields
     // when extra='allow', whereas this tally does not.
     pub fields_set_count: Option<usize>,
+    // True if `allow_partial=true` and we're validating the last element of a sequence or mapping.
+    pub allow_partial: bool,
     // deliberately make Extra readonly
     extra: Extra<'a, 'py>,
 }
 
 impl<'a, 'py> ValidationState<'a, 'py> {
-    pub fn new(extra: Extra<'a, 'py>, recursion_guard: &'a mut RecursionState) -> Self {
+    pub fn new(extra: Extra<'a, 'py>, recursion_guard: &'a mut RecursionState, allow_partial: bool) -> Self {
         Self {
             recursion_guard, // Don't care about exactness unless doing union validation
             exactness: None,
             fields_set_count: None,
+            allow_partial,
             extra,
         }
     }
@@ -53,6 +56,10 @@ impl<'a, 'py> ValidationState<'a, 'py> {
         &self.extra
     }
 
+    pub fn enumerate_last_partial<I>(&self, iter: impl Iterator<Item = I>) -> impl Iterator<Item = (usize, bool, I)> {
+        EnumerateLastPartial::new(iter, self.allow_partial)
+    }
+
     pub fn strict_or(&self, default: bool) -> bool {
         self.extra.strict.unwrap_or(default)
     }
@@ -117,3 +124,37 @@ impl Drop for ValidationStateWithReboundExtra<'_, '_, '_> {
         std::mem::swap(&mut self.state.extra, &mut self.old_extra);
     }
 }
+
+/// Similar to `iter.enumerate()` but also returns a bool indicating if we're at the last element.
+pub struct EnumerateLastPartial<I: Iterator> {
+    iter: I,
+    index: usize,
+    next_item: Option<I::Item>,
+    allow_partial: bool,
+}
+impl<I: Iterator> EnumerateLastPartial<I> {
+    pub fn new(mut iter: I, allow_partial: bool) -> Self {
+        let next_item = iter.next();
+        Self {
+            iter,
+            index: 0,
+            next_item,
+            allow_partial,
+        }
+    }
+}
+
+impl<I: Iterator> Iterator for EnumerateLastPartial<I> {
+    type Item = (usize, bool, I::Item);
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let a = std::mem::replace(&mut self.next_item, self.iter.next())?;
+        let i = self.index;
+        self.index += 1;
+        Some((i, self.allow_partial && self.next_item.is_none(), a))
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.iter.size_hint()
+    }
+}
diff --git a/tests/emscripten_runner.js b/tests/emscripten_runner.js
index c3c53834e..a49c1b6ad 100644
--- a/tests/emscripten_runner.js
+++ b/tests/emscripten_runner.js
@@ -86,7 +86,7 @@ async function main() {
     FS.mkdir('/test_dir');
     FS.mount(FS.filesystems.NODEFS, {root: path.join(root_dir, 'tests')}, '/test_dir');
     FS.chdir('/test_dir');
-    await pyodide.loadPackage(['micropip', 'pytest']);
+    await pyodide.loadPackage(['micropip', 'pytest', 'pygments']);
     // language=python
     errcode = await pyodide.runPythonAsync(`
 import micropip
@@ -98,6 +98,7 @@ import importlib
 
 await micropip.install([
     'dirty-equals',
+    'inline-snapshot',
     'hypothesis',
     'pytest-speed',
     'pytest-mock',
diff --git a/tests/requirements.txt b/tests/requirements.txt
index 5ee5ebfda..3fab8cc74 100644
--- a/tests/requirements.txt
+++ b/tests/requirements.txt
@@ -1,6 +1,7 @@
 backports.zoneinfo==0.2.1;python_version<"3.9"
 coverage==7.6.1
 dirty-equals==0.8.0
+inline-snapshot==0.13.3
 hypothesis==6.111.2
 # pandas doesn't offer prebuilt wheels for all versions and platforms we test in CI e.g. aarch64 musllinux
 pandas==2.1.3; python_version >= "3.9" and python_version < "3.13" and implementation_name == "cpython" and platform_machine == 'x86_64'
diff --git a/tests/test.rs b/tests/test.rs
index 1a4a87ef3..fb141d377 100644
--- a/tests/test.rs
+++ b/tests/test.rs
@@ -129,7 +129,7 @@ json_input = '{"a": "something"}'
             let json_input = locals.get_item("json_input").unwrap().unwrap();
             let binding = SchemaValidator::py_new(py, &schema, None)
                 .unwrap()
-                .validate_json(py, &json_input, None, None, None)
+                .validate_json(py, &json_input, None, None, None, false)
                 .unwrap();
             let validation_result: Bound<'_, PyAny> = binding.extract(py).unwrap();
             let repr = format!("{}", validation_result.repr().unwrap());
diff --git a/tests/validators/test_allow_partial.py b/tests/validators/test_allow_partial.py
new file mode 100644
index 000000000..e147ff62d
--- /dev/null
+++ b/tests/validators/test_allow_partial.py
@@ -0,0 +1,313 @@
+from typing import Mapping
+
+import pytest
+from dirty_equals import IsStrictDict
+from inline_snapshot import snapshot
+
+from pydantic_core import SchemaValidator, ValidationError, core_schema
+
+
+def test_list():
+    v = SchemaValidator(
+        core_schema.list_schema(
+            core_schema.tuple_positional_schema([core_schema.int_schema(), core_schema.int_schema()]),
+        )
+    )
+    assert v.validate_python([[1, 2], [3, 4]]) == [(1, 2), (3, 4)]
+    assert v.validate_python([[1, 2], [3, 4]], allow_partial=True) == [(1, 2), (3, 4)]
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_python([[1, 2], 'wrong'])
+    assert exc_info.value.errors(include_url=False) == snapshot(
+        [
+            {
+                'type': 'tuple_type',
+                'loc': (1,),
+                'msg': 'Input should be a valid tuple',
+                'input': 'wrong',
+            }
+        ]
+    )
+    assert v.validate_python([[1, 2], 'wrong'], allow_partial=True) == [(1, 2)]
+    assert v.validate_python([[1, 2], []], allow_partial=True) == [(1, 2)]
+    assert v.validate_python([[1, 2], [3]], allow_partial=True) == [(1, 2)]
+    assert v.validate_python([[1, 2], [3, 'x']], allow_partial=True) == [(1, 2)]
+    with pytest.raises(ValidationError, match='Input should be a valid tuple'):
+        v.validate_python([[1, 2], 'wrong', [3, 4]])
+    with pytest.raises(ValidationError, match='Input should be a valid tuple'):
+        v.validate_python([[1, 2], 'wrong', 'wrong'])
+    assert v.validate_json(b'[[1, 2], [3, 4]]', allow_partial=True) == [(1, 2), (3, 4)]
+    assert v.validate_json(b'[[1, 2], [3,', allow_partial=True) == [(1, 2)]
+
+
+@pytest.mark.parametrize('collection_type', [core_schema.set_schema, core_schema.frozenset_schema])
+def test_set_frozenset(collection_type):
+    v = SchemaValidator(
+        collection_type(
+            core_schema.tuple_positional_schema([core_schema.int_schema(), core_schema.int_schema()]),
+        )
+    )
+    assert v.validate_python([[1, 2], [3, 4]]) == snapshot({(1, 2), (3, 4)})
+    assert v.validate_python([[1, 2], [3, 4]], allow_partial=True) == snapshot({(1, 2), (3, 4)})
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_python([[1, 2], 'wrong'])
+    assert exc_info.value.errors(include_url=False) == snapshot(
+        [
+            {
+                'type': 'tuple_type',
+                'loc': (1,),
+                'msg': 'Input should be a valid tuple',
+                'input': 'wrong',
+            }
+        ]
+    )
+    assert v.validate_python([[1, 2], 'wrong'], allow_partial=True) == snapshot({(1, 2)})
+    assert v.validate_python([[1, 2], [3, 4], 'wrong'], allow_partial=True) == snapshot({(1, 2), (3, 4)})
+    assert v.validate_python([[1, 2], []], allow_partial=True) == snapshot({(1, 2)})
+    assert v.validate_python([[1, 2], [3]], allow_partial=True) == snapshot({(1, 2)})
+    assert v.validate_python([[1, 2], [3, 'x']], allow_partial=True) == snapshot({(1, 2)})
+    with pytest.raises(ValidationError, match='Input should be a valid tuple'):
+        v.validate_python([[1, 2], 'wrong', [3, 4]])
+    with pytest.raises(ValidationError, match='Input should be a valid tuple'):
+        v.validate_python([[1, 2], 'wrong', 'wrong'])
+
+
+class MyMapping(Mapping):
+    def __init__(self, d):
+        self._d = d
+
+    def __getitem__(self, key):
+        return self._d[key]
+
+    def __iter__(self):
+        return iter(self._d)
+
+    def __len__(self):
+        return len(self._d)
+
+
+def test_dict():
+    v = SchemaValidator(core_schema.dict_schema(core_schema.int_schema(), core_schema.int_schema()))
+    assert v.validate_python({'1': 2, 3: '4'}) == snapshot({1: 2, 3: 4})
+    assert v.validate_python({'1': 2, 3: '4'}, allow_partial=True) == snapshot({1: 2, 3: 4})
+    assert v.validate_python(MyMapping({'1': 2, 3: '4'}), allow_partial=True) == snapshot({1: 2, 3: 4})
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_python({'1': 2, 3: 'wrong'})
+    assert exc_info.value.errors(include_url=False) == snapshot(
+        [
+            {
+                'type': 'int_parsing',
+                'loc': (3,),
+                'msg': 'Input should be a valid integer, unable to parse string as an integer',
+                'input': 'wrong',
+            }
+        ]
+    )
+    assert v.validate_python({'1': 2, 3: 'x'}, allow_partial=True) == snapshot({1: 2})
+    assert v.validate_python(MyMapping({'1': 2, 3: 'x'}), allow_partial=True) == snapshot({1: 2})
+    assert v.validate_python({'1': 2, 3: 4, 5: '6', 7: 'x'}, allow_partial=True) == snapshot({1: 2, 3: 4, 5: 6})
+    with pytest.raises(ValidationError, match='Input should be a valid integer'):
+        v.validate_python({'1': 2, 3: 4, 5: 'x', 7: '8'})
+    with pytest.raises(ValidationError, match='Input should be a valid integer'):
+        v.validate_python({'1': 2, 3: 4, 5: 'x', 7: 'x'})
+    with pytest.raises(ValidationError, match='Input should be a valid integer'):
+        v.validate_python({'1': 2, 3: 4, 'x': 6})
+
+
+def test_dict_list():
+    v = SchemaValidator(
+        core_schema.dict_schema(core_schema.int_schema(), core_schema.list_schema(core_schema.int_schema(ge=10)))
+    )
+    assert v.validate_python({'1': [20, 30], 3: [40, '50']}, allow_partial=True) == snapshot({1: [20, 30], 3: [40, 50]})
+    assert v.validate_python({'1': [20, 30], 3: [40, 5]}, allow_partial=True) == snapshot({1: [20, 30], 3: [40]})
+
+    with pytest.raises(ValidationError, match=r'1\.1\s+Input should be greater than or equal to 10'):
+        v.validate_python({'1': [20, 3], 3: [40, 50]}, allow_partial=True)
+
+
+def test_partial_typed_dict():
+    v = SchemaValidator(
+        core_schema.typed_dict_schema(
+            {
+                'a': core_schema.typed_dict_field(core_schema.int_schema(gt=10)),
+                'b': core_schema.typed_dict_field(core_schema.int_schema(gt=10)),
+                'c': core_schema.typed_dict_field(core_schema.int_schema(gt=10)),
+            },
+            total=False,
+        )
+    )
+
+    assert v.validate_python({'a': 11, 'b': '12', 'c': 13}) == snapshot(IsStrictDict(a=11, b=12, c=13))
+    assert v.validate_python({'a': 11, 'c': 13, 'b': '12'}) == snapshot(IsStrictDict(a=11, b=12, c=13))
+    assert v.validate_python(MyMapping({'a': 11, 'c': 13, 'b': '12'})) == snapshot(IsStrictDict(a=11, b=12, c=13))
+
+    assert v.validate_python({'a': 11, 'b': '12', 'c': 13}, allow_partial=True) == snapshot({'a': 11, 'b': 12, 'c': 13})
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_python({'a': 11, 'b': '12', 'c': 1})
+    assert exc_info.value.errors(include_url=False) == snapshot(
+        [
+            {
+                'type': 'greater_than',
+                'loc': ('c',),
+                'msg': 'Input should be greater than 10',
+                'input': 1,
+                'ctx': {'gt': 10},
+            }
+        ]
+    )
+    assert v.validate_python({'a': 11, 'b': '12', 'c': 1}, allow_partial=True) == snapshot(IsStrictDict(a=11, b=12))
+    assert v.validate_python(MyMapping({'a': 11, 'b': '12', 'c': 1}), allow_partial=True) == snapshot(
+        IsStrictDict(a=11, b=12)
+    )
+    assert v.validate_python({'a': 11, 'c': 13, 'b': 1}, allow_partial=True) == snapshot(IsStrictDict(a=11, c=13))
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_python({'a': 11, 'c': 1, 'b': 12}, allow_partial=True)
+    assert exc_info.value.errors(include_url=False) == snapshot(
+        [
+            {
+                'type': 'greater_than',
+                'loc': ('c',),
+                'msg': 'Input should be greater than 10',
+                'input': 1,
+                'ctx': {'gt': 10},
+            }
+        ]
+    )
+    with pytest.raises(ValidationError, match=r'c\s+Input should be greater than 10'):
+        v.validate_python(MyMapping({'a': 11, 'c': 1, 'b': 12}), allow_partial=True)
+
+    # validate strings
+    assert v.validate_strings({'a': '11', 'b': '22'}) == snapshot({'a': 11, 'b': 22})
+    with pytest.raises(ValidationError, match='Input should be greater than 10'):
+        v.validate_strings({'a': '11', 'b': '2'})
+    assert v.validate_strings({'a': '11', 'b': '2'}, allow_partial=True) == snapshot({'a': 11})
+
+    assert v.validate_json(b'{"b": "12", "a": 11, "c": 13}', allow_partial=True) == IsStrictDict(a=11, b=12, c=13)
+    assert v.validate_json(b'{"b": "12", "a": 11, "c": 13', allow_partial=True) == IsStrictDict(a=11, b=12, c=13)
+    assert v.validate_json(b'{"a": 11, "b": "12", "c": 1', allow_partial=True) == IsStrictDict(a=11, b=12)
+    assert v.validate_json(b'{"a": 11, "b": "12", "c":', allow_partial=True) == IsStrictDict(a=11, b=12)
+    assert v.validate_json(b'{"a": 11, "b": "12", "c"', allow_partial=True) == IsStrictDict(a=11, b=12)
+    assert v.validate_json(b'{"a": 11, "b": "12", "c', allow_partial=True) == IsStrictDict(a=11, b=12)
+    assert v.validate_json(b'{"a": 11, "b": "12", "', allow_partial=True) == IsStrictDict(a=11, b=12)
+    assert v.validate_json(b'{"a": 11, "b": "12", ', allow_partial=True) == IsStrictDict(a=11, b=12)
+    assert v.validate_json(b'{"a": 11, "b": "12",', allow_partial=True) == IsStrictDict(a=11, b=12)
+    assert v.validate_json(b'{"a": 11, "b": "12"', allow_partial=True) == IsStrictDict(a=11, b=12)
+
+
+def test_non_partial_typed_dict():
+    v = SchemaValidator(
+        core_schema.typed_dict_schema(
+            {
+                'a': core_schema.typed_dict_field(core_schema.int_schema(gt=10)),
+                'b': core_schema.typed_dict_field(core_schema.int_schema(gt=10), required=True),
+                'c': core_schema.typed_dict_field(core_schema.int_schema(gt=10)),
+            },
+            total=False,
+        )
+    )
+
+    assert v.validate_python({'a': 11, 'b': '12', 'c': 13}) == snapshot({'a': 11, 'b': 12, 'c': 13})
+    with pytest.raises(ValidationError, match='Input should be greater than 10'):
+        v.validate_python({'a': 11, 'b': '12', 'c': 1})
+    assert v.validate_python({'a': 11, 'b': '12', 'c': 1}, allow_partial=True) == snapshot({'a': 11, 'b': 12})
+    with pytest.raises(ValidationError, match=r'b\s+Field required'):
+        v.validate_python({'a': 11, 'c': 12}, allow_partial=True)
+    with pytest.raises(ValidationError, match=r'b\s+Input should be greater than 10'):
+        v.validate_python({'a': 11, 'c': 12, 'b': 1}, allow_partial=True)
+
+
+def test_double_nested():
+    v = SchemaValidator(
+        core_schema.typed_dict_schema(
+            {
+                'a': core_schema.typed_dict_field(core_schema.int_schema(gt=10)),
+                'b': core_schema.typed_dict_field(
+                    core_schema.list_schema(
+                        core_schema.dict_schema(core_schema.str_schema(), core_schema.int_schema(ge=10))
+                    )
+                ),
+            },
+            total=False,
+        )
+    )
+    assert v.validate_python({'a': 11, 'b': [{'a': 10, 'b': 20}, {'a': 30, 'b': 40}]}) == snapshot(
+        {'a': 11, 'b': [{'a': 10, 'b': 20}, {'a': 30, 'b': 40}]}
+    )
+    assert v.validate_python({'a': 11, 'b': [{'a': 10, 'b': 20}, {'a': 30, 'b': 4}]}, allow_partial=True) == snapshot(
+        {'a': 11, 'b': [{'a': 10, 'b': 20}, {'a': 30}]}
+    )
+    assert v.validate_python({'a': 11, 'b': [{'a': 10, 'b': 20}, {'a': 30, 123: 4}]}, allow_partial=True) == snapshot(
+        {'a': 11, 'b': [{'a': 10, 'b': 20}]}
+    )
+    # the first element of the list is invalid, so the whole list is invalid
+    assert v.validate_python({'a': 11, 'b': [{'a': 10, 'b': 2}, {'a': 30}]}, allow_partial=True) == snapshot({'a': 11})
+    with pytest.raises(ValidationError, match=r'b\.0\.b\s+Input should be greater than or equal to 10'):
+        v.validate_python({'b': [{'a': 10, 'b': 2}, {'a': 30}], 'a': 11}, allow_partial=True)
+
+    with pytest.raises(ValidationError, match=r'b\.1\.a\s+Input should be greater than or equal to 10'):
+        v.validate_python({'b': [{'a': 10, 'b': 20}, {'a': 3}], 'a': 11}, allow_partial=True)
+
+    assert v.validate_python({'a': 11, 'b': [{'a': 1, 'b': 20}, {'a': 3, 'b': 40}]}, allow_partial=True) == snapshot(
+        {'a': 11}
+    )
+    json = b'{"a": 11, "b": [{"a": 10, "b": 20}, {"a": 30, "b": 40}]}'
+    assert v.validate_json(json, allow_partial=True) == snapshot(
+        {'a': 11, 'b': [{'a': 10, 'b': 20}, {'a': 30, 'b': 40}]}
+    )
+    for i in range(1, len(json)):
+        value = v.validate_json(json[:i], allow_partial=True)
+        assert isinstance(value, dict)
+
+
+def test_tuple_list():
+    """Tuples don't support partial, so behaviour should be disabled."""
+    v = SchemaValidator(
+        core_schema.tuple_positional_schema(
+            [core_schema.list_schema(core_schema.int_schema()), core_schema.int_schema()]
+        ),
+    )
+    assert v.validate_python([['1', '2'], '3'], allow_partial=True) == snapshot(([1, 2], 3))
+    with pytest.raises(ValidationError, match=r'1\s+Input should be a valid integer'):
+        v.validate_python([['1', '2'], 'x'], allow_partial=True)
+    with pytest.raises(ValidationError, match=r'0\.1\s+Input should be a valid integer'):
+        v.validate_python([['1', 'x'], '2'], allow_partial=True)
+
+
+def test_dataclass():
+    """Tuples don't support partial, so behaviour should be disabled."""
+
+    schema = core_schema.dataclass_args_schema(
+        'MyDataclass',
+        [
+            core_schema.dataclass_field(name='a', schema=core_schema.str_schema(), kw_only=False),
+            core_schema.dataclass_field(
+                name='b', schema=core_schema.list_schema(core_schema.str_schema(min_length=2)), kw_only=False
+            ),
+        ],
+    )
+    v = SchemaValidator(schema)
+    assert v.validate_python({'a': 'x', 'b': ['ab', 'cd']}) == snapshot(({'a': 'x', 'b': ['ab', 'cd']}, None))
+    assert v.validate_python({'a': 'x', 'b': ['ab', 'cd']}, allow_partial=True) == snapshot(
+        ({'a': 'x', 'b': ['ab', 'cd']}, None)
+    )
+    with pytest.raises(ValidationError, match=r'b\.1\s+String should have at least 2 characters'):
+        v.validate_python({'a': 'x', 'b': ['ab', 'c']}, allow_partial=True)
+
+
+def test_nullable():
+    v = SchemaValidator(core_schema.nullable_schema(core_schema.list_schema(core_schema.str_schema(min_length=2))))
+
+    assert v.validate_python(None, allow_partial=True) is None
+    assert v.validate_python(['ab', 'cd'], allow_partial=True) == ['ab', 'cd']
+    assert v.validate_python(['ab', 'c'], allow_partial=True) == ['ab']
+
+
+@pytest.mark.parametrize(
+    'json_nested_type', [None, core_schema.dict_schema(core_schema.str_schema(), core_schema.int_schema())]
+)
+def test_json(json_nested_type):
+    v = SchemaValidator(core_schema.list_schema(core_schema.json_schema(json_nested_type)))
+
+    assert v.validate_python(['{"a": 1}', '{"b": 2}']) == snapshot([{'a': 1}, {'b': 2}])
+    assert v.validate_python(['{"a": 1}', '{"b": 2}'], allow_partial=True) == snapshot([{'a': 1}, {'b': 2}])
+    assert v.validate_python(['{"a": 1}', 'xxx'], allow_partial=True) == snapshot([{'a': 1}])
+    assert v.validate_python(['{"a": 1}', '{"b": 2'], allow_partial=True) == snapshot([{'a': 1}, {'b': 2}])

From c864ff29732ae737ab581337fcc76a3f55568c7f Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Mon, 4 Nov 2024 12:40:39 +0000
Subject: [PATCH 416/550] bump speedate to 0.15 (#1526)

---
 Cargo.lock                        | 4 ++--
 Cargo.toml                        | 2 +-
 tests/validators/test_date.py     | 6 ++----
 tests/validators/test_datetime.py | 7 +++++--
 4 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 2bc0dd4e8..c4dd2db4d 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -620,9 +620,9 @@ checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
 
 [[package]]
 name = "speedate"
-version = "0.14.4"
+version = "0.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08a20480dbd4c693f0b0f3210f2cee5bfa21a176c1fa4df0e65cc0474e7fa557"
+checksum = "9a5e7adf4e07e7de39a64d77962ca14a09165e592d42d0c9f9acadb679f4f937"
 dependencies = [
  "strum",
  "strum_macros",
diff --git a/Cargo.toml b/Cargo.toml
index 0b87e684f..5ca1a5dce 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -36,7 +36,7 @@ strum_macros = "0.26.4"
 serde_json = {version = "1.0.132", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.13"
 serde = { version = "1.0.214", features = ["derive"] }
-speedate = "0.14.4"
+speedate = "0.15.0"
 smallvec = "1.13.2"
 ahash = "0.8.10"
 url = "2.5.0"
diff --git a/tests/validators/test_date.py b/tests/validators/test_date.py
index 9c61a69aa..3a1f77134 100644
--- a/tests/validators/test_date.py
+++ b/tests/validators/test_date.py
@@ -24,10 +24,8 @@
         pytest.param(1654646400.00, date(2022, 6, 8), id='float'),
         pytest.param('1654646400.00', date(2022, 6, 8), id='float-as-str'),
         pytest.param(Decimal('1654646400'), date(2022, 6, 8), id='decimal'),
-        # (253_402_300_800_000, Err('format YYYY-MM-DD, dates after 9999 are not supported as unix timestamps')),
         pytest.param(253_402_300_800_000, Err('Input should be a valid date'), id='int-too-high'),
-        # (-20_000_000_000, Err('format YYYY-MM-DD, dates before 1600 are not supported as unix timestamps')),
-        pytest.param(-20_000_000_000, Err('Input should be a valid date'), id='int-too-low'),
+        pytest.param(-80_000_000_000_000, Err('Input should be a valid date'), id='int-too-low'),
         pytest.param(datetime(2022, 6, 8), date(2022, 6, 8), id='datetime-exact'),
         pytest.param(
             datetime(2022, 6, 8, 12),
@@ -59,7 +57,7 @@
         pytest.param(
             float('-inf'),
             Err(
-                'Input should be a valid date or datetime, dates before 1600 are not supported as unix timestamps '
+                'Input should be a valid date or datetime, dates before 0000 are not supported as unix timestamps '
                 '[type=date_from_datetime_parsing,'
             ),
             id='-inf',
diff --git a/tests/validators/test_datetime.py b/tests/validators/test_datetime.py
index 9e1eef086..d98daa3c5 100644
--- a/tests/validators/test_datetime.py
+++ b/tests/validators/test_datetime.py
@@ -38,10 +38,13 @@
         (Decimal('1654646400.1234568'), datetime(2022, 6, 8, 0, 0, 0, 123457, tzinfo=timezone.utc)),
         ('1654646400.1234568', datetime(2022, 6, 8, 0, 0, 0, 123457, tzinfo=timezone.utc)),
         (253_402_300_800_000, Err('should be a valid datetime, dates after 9999 are not supported as unix timestamps')),
-        (-20_000_000_000, Err('should be a valid datetime, dates before 1600 are not supported as unix timestamps')),
+        (
+            -80_000_000_000_000,
+            Err('should be a valid datetime, dates before 0000 are not supported as unix timestamps'),
+        ),
         (float('nan'), Err('Input should be a valid datetime, NaN values not permitted [type=datetime_parsing,')),
         (float('inf'), Err('Input should be a valid datetime, dates after 9999')),
-        (float('-inf'), Err('Input should be a valid datetime, dates before 1600')),
+        (float('-inf'), Err('Input should be a valid datetime, dates before 0000')),
         ('-', Err('Input should be a valid datetime or date, input is too short [type=datetime_from_date_parsing,')),
         ('+', Err('Input should be a valid datetime or date, input is too short [type=datetime_from_date_parsing,')),
         (

From 96038dd873961ecbb64e1cd96f07ff2e20618c4c Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Mon, 4 Nov 2024 09:29:11 -0500
Subject: [PATCH 417/550] Bump version to prep release (#1527)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index c4dd2db4d..6381d4c5e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -425,7 +425,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.25.1"
+version = "2.26.0"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index 5ca1a5dce..625e474ec 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.25.1"
+version = "2.26.0"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From 815d2248663296856864ee9982c79a38b199ab35 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 4 Nov 2024 14:42:45 +0000
Subject: [PATCH 418/550] Bump the python-packages group across 1 directory
 with 7 updates (#1529)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: David Hewitt <mail@davidhewitt.dev>
---
 .github/workflows/codspeed.yml | 2 +-
 tests/requirements-linting.txt | 8 ++++----
 tests/requirements.txt         | 6 ++----
 tests/test_errors.py           | 6 +++---
 4 files changed, 10 insertions(+), 12 deletions(-)

diff --git a/.github/workflows/codspeed.yml b/.github/workflows/codspeed.yml
index 6bb94fc1c..9dd4bbc6e 100644
--- a/.github/workflows/codspeed.yml
+++ b/.github/workflows/codspeed.yml
@@ -37,7 +37,7 @@ jobs:
       - run: pip uninstall pytest-speed -y
         if: steps.cache-py.outputs.cache-hit != 'true'
 
-      - run: pip install pytest-benchmark==4.0.0
+      - run: pip install pytest-benchmark==4.0.0 pytest-codspeed
         if: steps.cache-py.outputs.cache-hit != 'true'
 
       - name: install rust stable
diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
index c614101d5..b3962930d 100644
--- a/tests/requirements-linting.txt
+++ b/tests/requirements-linting.txt
@@ -1,4 +1,4 @@
-griffe==1.2.0
-pyright==1.1.378
-ruff==0.6.3
-mypy==1.11.2
+griffe==1.5.1
+pyright==1.1.387
+ruff==0.7.2
+mypy==1.13.0
diff --git a/tests/requirements.txt b/tests/requirements.txt
index 3fab8cc74..837128b5a 100644
--- a/tests/requirements.txt
+++ b/tests/requirements.txt
@@ -5,9 +5,7 @@ inline-snapshot==0.13.3
 hypothesis==6.111.2
 # pandas doesn't offer prebuilt wheels for all versions and platforms we test in CI e.g. aarch64 musllinux
 pandas==2.1.3; python_version >= "3.9" and python_version < "3.13" and implementation_name == "cpython" and platform_machine == 'x86_64'
-pytest==8.3.2
-# we run codspeed benchmarks on x86_64 CPython (i.e. native github actions architecture)
-pytest-codspeed~=2.2.1; implementation_name == "cpython" and platform_machine == 'x86_64'
+pytest==8.3.3
 # pytest-examples currently depends on aiohttp via black; we don't want to build
 # it on platforms like aarch64 musllinux in CI
 pytest-examples==0.0.13; implementation_name == "cpython" and platform_machine == 'x86_64'
@@ -19,5 +17,5 @@ python-dateutil==2.9.0.post0
 # numpy doesn't offer prebuilt wheels for all versions and platforms we test in CI e.g. aarch64 musllinux
 numpy==1.26.2; python_version >= "3.9" and python_version < "3.13" and implementation_name == "cpython" and platform_machine == 'x86_64'
 exceptiongroup==1.1; python_version < "3.11"
-tzdata==2024.1
+tzdata==2024.2
 typing_extensions==4.12.2
diff --git a/tests/test_errors.py b/tests/test_errors.py
index 9ac993031..4760baad7 100644
--- a/tests/test_errors.py
+++ b/tests/test_errors.py
@@ -551,7 +551,7 @@ def multi_raise_py_error(v: Any) -> Any:
         s2.validate_python('anything')
 
     cause_group = exc_info.value.__cause__
-    assert isinstance(cause_group, BaseExceptionGroup)
+    assert isinstance(cause_group, BaseExceptionGroup)  # noqa: F821,RUF100  # gated on 3.11+ above
     assert len(cause_group.exceptions) == 1
 
     cause = cause_group.exceptions[0]
@@ -576,7 +576,7 @@ def outer_raise_py_error(v: Any) -> Any:
     with pytest.raises(ValidationError) as exc_info:
         s3.validate_python('anything')
 
-    assert isinstance(exc_info.value.__cause__, BaseExceptionGroup)
+    assert isinstance(exc_info.value.__cause__, BaseExceptionGroup)  # noqa: F821,RUF100  # gated on 3.11+ above
     assert len(exc_info.value.__cause__.exceptions) == 1
     cause = exc_info.value.__cause__.exceptions[0]
     assert cause.__notes__ and cause.__notes__[-1].startswith('\nPydantic: ')
@@ -585,7 +585,7 @@ def outer_raise_py_error(v: Any) -> Any:
     assert isinstance(subcause, ValidationError)
 
     cause_group = subcause.__cause__
-    assert isinstance(cause_group, BaseExceptionGroup)
+    assert isinstance(cause_group, BaseExceptionGroup)  # noqa: F821,RUF100  # gated on 3.11+ above
     assert len(cause_group.exceptions) == 1
 
     cause = cause_group.exceptions[0]

From 085e61dbaa89d917bbe5b7f5b1c5ab65ddf840d9 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Tue, 5 Nov 2024 09:40:47 -0500
Subject: [PATCH 419/550] Remove `Url` and `MultiHostUrl` docstrings, we moved
 them to pydantic (#1531)

---
 python/pydantic_core/_pydantic_core.pyi | 220 +++---------------------
 1 file changed, 24 insertions(+), 196 deletions(-)

diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index 69bfb64a8..7de91f773 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -492,104 +492,29 @@ class Url(SupportsAllComparisons):
     by Mozilla.
     """
 
-    def __init__(self, url: str) -> None:
-        """Initializes the `Url`.
-
-        Args:
-            url: String representation of a URL.
-
-        Returns:
-            A new `Url` instance.
-
-        Raises:
-            ValidationError: If the URL is invalid.
-        """
-
+    def __init__(self, url: str) -> None: ...
     def __new__(cls, url: str) -> Self: ...
     @property
-    def scheme(self) -> str:
-        """
-        The scheme part of the URL.
-
-        e.g. `https` in `https://user:pass@host:port/path?query#fragment`
-        """
+    def scheme(self) -> str: ...
     @property
-    def username(self) -> str | None:
-        """
-        The username part of the URL, or `None`.
-
-        e.g. `user` in `https://user:pass@host:port/path?query#fragment`
-        """
+    def username(self) -> str | None: ...
     @property
-    def password(self) -> str | None:
-        """
-        The password part of the URL, or `None`.
-
-        e.g. `pass` in `https://user:pass@host:port/path?query#fragment`
-        """
+    def password(self) -> str | None: ...
     @property
-    def host(self) -> str | None:
-        """
-        The host part of the URL, or `None`.
-
-        If the URL must be punycode encoded, this is the encoded host, e.g if the input URL is `https://£££.com`,
-        `host` will be `xn--9aaa.com`
-        """
-    def unicode_host(self) -> str | None:
-        """
-        The host part of the URL as a unicode string, or `None`.
-
-        e.g. `host` in `https://user:pass@host:port/path?query#fragment`
-
-        If the URL must be punycode encoded, this is the decoded host, e.g if the input URL is `https://£££.com`,
-        `unicode_host()` will be `£££.com`
-        """
+    def host(self) -> str | None: ...
+    def unicode_host(self) -> str | None: ...
     @property
-    def port(self) -> int | None:
-        """
-        The port part of the URL, or `None`.
-
-        e.g. `port` in `https://user:pass@host:port/path?query#fragment`
-        """
+    def port(self) -> int | None: ...
     @property
-    def path(self) -> str | None:
-        """
-        The path part of the URL, or `None`.
-
-        e.g. `/path` in `https://user:pass@host:port/path?query#fragment`
-        """
+    def path(self) -> str | None: ...
     @property
-    def query(self) -> str | None:
-        """
-        The query part of the URL, or `None`.
-
-        e.g. `query` in `https://user:pass@host:port/path?query#fragment`
-        """
-    def query_params(self) -> list[tuple[str, str]]:
-        """
-        The query part of the URL as a list of key-value pairs.
-
-        e.g. `[('foo', 'bar')]` in `https://user:pass@host:port/path?foo=bar#fragment`
-        """
+    def query(self) -> str | None: ...
+    def query_params(self) -> list[tuple[str, str]]: ...
     @property
-    def fragment(self) -> str | None:
-        """
-        The fragment part of the URL, or `None`.
-
-        e.g. `fragment` in `https://user:pass@host:port/path?query#fragment`
-        """
-    def unicode_string(self) -> str:
-        """
-        The URL as a unicode string, unlike `__str__()` this will not punycode encode the host.
-
-        If the URL must be punycode encoded, this is the decoded string, e.g if the input URL is `https://£££.com`,
-        `unicode_string()` will be `https://£££.com`
-        """
+    def fragment(self) -> str | None: ...
+    def unicode_string(self) -> str: ...
     def __repr__(self) -> str: ...
-    def __str__(self) -> str:
-        """
-        The URL as a string, this will punycode encode the host if required.
-        """
+    def __str__(self) -> str: ...
     def __deepcopy__(self, memo: dict) -> str: ...
     @classmethod
     def build(
@@ -603,23 +528,7 @@ class Url(SupportsAllComparisons):
         path: str | None = None,
         query: str | None = None,
         fragment: str | None = None,
-    ) -> Self:
-        """
-        Build a new `Url` instance from its component parts.
-
-        Args:
-            scheme: The scheme part of the URL.
-            username: The username part of the URL, or omit for no username.
-            password: The password part of the URL, or omit for no password.
-            host: The host part of the URL.
-            port: The port part of the URL, or omit for no port.
-            path: The path part of the URL, or omit for no path.
-            query: The query part of the URL, or omit for no query.
-            fragment: The fragment part of the URL, or omit for no fragment.
-
-        Returns:
-            An instance of URL
-        """
+    ) -> Self: ...
 
 class MultiHostUrl(SupportsAllComparisons):
     """
@@ -629,82 +538,21 @@ class MultiHostUrl(SupportsAllComparisons):
     by Mozilla.
     """
 
-    def __init__(self, url: str) -> None:
-        """Initializes the `MultiHostUrl`.
-
-        Args:
-            url: String representation of a URL.
-
-        Returns:
-            A new `MultiHostUrl` instance.
-
-        Raises:
-            ValidationError: If the URL is invalid.
-        """
-
+    def __init__(self, url: str) -> None: ...
     def __new__(cls, url: str) -> Self: ...
     @property
-    def scheme(self) -> str:
-        """
-        The scheme part of the URL.
-
-        e.g. `https` in `https://foo.com,bar.com/path?query#fragment`
-        """
+    def scheme(self) -> str: ...
     @property
-    def path(self) -> str | None:
-        """
-        The path part of the URL, or `None`.
-
-        e.g. `/path` in `https://foo.com,bar.com/path?query#fragment`
-        """
+    def path(self) -> str | None: ...
     @property
-    def query(self) -> str | None:
-        """
-        The query part of the URL, or `None`.
-
-        e.g. `query` in `https://foo.com,bar.com/path?query#fragment`
-        """
-    def query_params(self) -> list[tuple[str, str]]:
-        """
-        The query part of the URL as a list of key-value pairs.
-
-        e.g. `[('foo', 'bar')]` in `https://foo.com,bar.com/path?query#fragment`
-        """
+    def query(self) -> str | None: ...
+    def query_params(self) -> list[tuple[str, str]]: ...
     @property
-    def fragment(self) -> str | None:
-        """
-        The fragment part of the URL, or `None`.
-
-        e.g. `fragment` in `https://foo.com,bar.com/path?query#fragment`
-        """
-    def hosts(self) -> list[MultiHostHost]:
-        '''
-
-        The hosts of the `MultiHostUrl` as [`MultiHostHost`][pydantic_core.MultiHostHost] typed dicts.
-
-        ```py
-        from pydantic_core import MultiHostUrl
-
-        mhu = MultiHostUrl('https://foo.com:123,foo:bar@bar.com/path')
-        print(mhu.hosts())
-        """
-        [
-            {'username': None, 'password': None, 'host': 'foo.com', 'port': 123},
-            {'username': 'foo', 'password': 'bar', 'host': 'bar.com', 'port': 443}
-        ]
-        ```
-        Returns:
-            A list of dicts, each representing a host.
-        '''
-    def unicode_string(self) -> str:
-        """
-        The URL as a unicode string, unlike `__str__()` this will not punycode encode the hosts.
-        """
+    def fragment(self) -> str | None: ...
+    def hosts(self) -> list[MultiHostHost]: ...
+    def unicode_string(self) -> str: ...
     def __repr__(self) -> str: ...
-    def __str__(self) -> str:
-        """
-        The URL as a string, this will punycode encode the hosts if required.
-        """
+    def __str__(self) -> str: ...
     def __deepcopy__(self, memo: dict) -> Self: ...
     @classmethod
     def build(
@@ -719,27 +567,7 @@ class MultiHostUrl(SupportsAllComparisons):
         path: str | None = None,
         query: str | None = None,
         fragment: str | None = None,
-    ) -> Self:
-        """
-        Build a new `MultiHostUrl` instance from its component parts.
-
-        This method takes either `hosts` - a list of `MultiHostHost` typed dicts, or the individual components
-        `username`, `password`, `host` and `port`.
-
-        Args:
-            scheme: The scheme part of the URL.
-            hosts: Multiple hosts to build the URL from.
-            username: The username part of the URL.
-            password: The password part of the URL.
-            host: The host part of the URL.
-            port: The port part of the URL.
-            path: The path part of the URL.
-            query: The query part of the URL, or omit for no query.
-            fragment: The fragment part of the URL, or omit for no fragment.
-
-        Returns:
-            An instance of `MultiHostUrl`
-        """
+    ) -> Self: ...
 
 @final
 class SchemaError(Exception):

From 4cb82bfb55b47c70601106cde2688b0e1973f87e Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Tue, 5 Nov 2024 16:08:31 +0000
Subject: [PATCH 420/550] fix panic in `validate_assignment` when field has
 gone missing (#1532)

---
 src/validators/model_fields.rs | 15 ++++++++++-----
 tests/validators/test_model.py | 26 ++++++++++++++++----------
 2 files changed, 26 insertions(+), 15 deletions(-)

diff --git a/src/validators/model_fields.rs b/src/validators/model_fields.rs
index eb4829c7f..39f905d84 100644
--- a/src/validators/model_fields.rs
+++ b/src/validators/model_fields.rs
@@ -421,11 +421,16 @@ impl Validator for ModelFieldsValidator {
         let new_extra = match &self.extra_behavior {
             ExtraBehavior::Allow => {
                 let non_extra_data = PyDict::new_bound(py);
-                self.fields.iter().for_each(|f| {
-                    let popped_value = PyAnyMethods::get_item(&**new_data, &f.name).unwrap();
-                    new_data.del_item(&f.name).unwrap();
-                    non_extra_data.set_item(&f.name, popped_value).unwrap();
-                });
+                self.fields.iter().try_for_each(|f| -> PyResult<()> {
+                    let Some(popped_value) = new_data.get_item(&f.name)? else {
+                        // field not present in __dict__ for some reason; let the rest of the
+                        // validation pipeline handle it later
+                        return Ok(());
+                    };
+                    new_data.del_item(&f.name)?;
+                    non_extra_data.set_item(&f.name, popped_value)?;
+                    Ok(())
+                })?;
                 let new_extra = new_data.copy()?;
                 new_data.clear();
                 new_data.update(non_extra_data.as_mapping())?;
diff --git a/tests/validators/test_model.py b/tests/validators/test_model.py
index b6a60f55c..8814a5e65 100644
--- a/tests/validators/test_model.py
+++ b/tests/validators/test_model.py
@@ -1036,17 +1036,17 @@ def __init__(self):
             self.__pydantic_extra__ = None
 
     v = SchemaValidator(
-        {
-            'type': 'model',
-            'cls': MyModel,
-            'schema': {
-                'type': 'model-fields',
-                'fields': {
-                    'field_a': {'type': 'model-field', 'schema': {'type': 'str'}},
-                    'field_b': {'type': 'model-field', 'schema': {'type': 'int'}},
+        core_schema.model_schema(
+            MyModel,
+            core_schema.model_fields_schema(
+                {
+                    'field_a': core_schema.model_field(core_schema.str_schema()),
+                    'field_b': core_schema.model_field(core_schema.int_schema()),
                 },
-            },
-        }
+                extra_behavior='allow',
+            ),
+            extra_behavior='allow',
+        )
     )
 
     m = MyModel()
@@ -1063,6 +1063,12 @@ def __init__(self):
     v.validate_assignment(m, 'field_b', '322', from_attributes=True)
     assert m.field_b == 322
 
+    # try deleting a field
+    del m.field_b
+    # assignment to `field_a` should not care about `field_b` missing
+    v.validate_assignment(m, 'field_a', 'hello world', from_attributes=True)
+    assert m.field_a == 'hello world'
+
 
 def test_validate_assignment_function():
     class MyModel:

From 2419981d9af71cd912ab17e595b2f84263cef209 Mon Sep 17 00:00:00 2001
From: Luka Peschke <mail@lukapeschke.com>
Date: Thu, 7 Nov 2024 11:53:30 +0100
Subject: [PATCH 421/550] fix(union_serializer): do not raise warnings in
 nested unions (#1513)

Signed-off-by: Luka Peschke <mail@lukapeschke.com>
---
 src/serializers/type_serializers/union.rs |  47 ++++-
 tests/serializers/test_union.py           | 222 ++++++++++++++++++++++
 2 files changed, 259 insertions(+), 10 deletions(-)

diff --git a/src/serializers/type_serializers/union.rs b/src/serializers/type_serializers/union.rs
index 24544a971..ac674ef34 100644
--- a/src/serializers/type_serializers/union.rs
+++ b/src/serializers/type_serializers/union.rs
@@ -9,6 +9,7 @@ use crate::build_tools::py_schema_err;
 use crate::common::union::{Discriminator, SMALL_UNION_THRESHOLD};
 use crate::definitions::DefinitionsBuilder;
 use crate::tools::{truncate_safe_repr, SchemaDict};
+use crate::PydanticSerializationUnexpectedValue;
 
 use super::{
     infer_json_key, infer_serialize, infer_to_python, BuildSerializer, CombinedSerializer, Extra, SerCheck,
@@ -89,7 +90,8 @@ fn to_python(
         }
     }
 
-    if retry_with_lax_check {
+    // If extra.check is SerCheck::Strict, we're in a nested union
+    if extra.check != SerCheck::Strict && retry_with_lax_check {
         new_extra.check = SerCheck::Lax;
         for comb_serializer in choices {
             if let Ok(v) = comb_serializer.to_python(value, include, exclude, &new_extra) {
@@ -98,8 +100,17 @@ fn to_python(
         }
     }
 
-    for err in &errors {
-        extra.warnings.custom_warning(err.to_string());
+    // If extra.check is SerCheck::None, we're in a top-level union. We should thus raise the warnings
+    if extra.check == SerCheck::None {
+        for err in &errors {
+            extra.warnings.custom_warning(err.to_string());
+        }
+    }
+    // Otherwise, if we've encountered errors, return them to the parent union, which should take
+    // care of the formatting for us
+    else if !errors.is_empty() {
+        let message = errors.iter().map(ToString::to_string).collect::<Vec<_>>().join("\n");
+        return Err(PydanticSerializationUnexpectedValue::new_err(Some(message)));
     }
 
     infer_to_python(value, include, exclude, extra)
@@ -122,7 +133,8 @@ fn json_key<'a>(
         }
     }
 
-    if retry_with_lax_check {
+    // If extra.check is SerCheck::Strict, we're in a nested union
+    if extra.check != SerCheck::Strict && retry_with_lax_check {
         new_extra.check = SerCheck::Lax;
         for comb_serializer in choices {
             if let Ok(v) = comb_serializer.json_key(key, &new_extra) {
@@ -131,10 +143,18 @@ fn json_key<'a>(
         }
     }
 
-    for err in &errors {
-        extra.warnings.custom_warning(err.to_string());
+    // If extra.check is SerCheck::None, we're in a top-level union. We should thus raise the warnings
+    if extra.check == SerCheck::None {
+        for err in &errors {
+            extra.warnings.custom_warning(err.to_string());
+        }
+    }
+    // Otherwise, if we've encountered errors, return them to the parent union, which should take
+    // care of the formatting for us
+    else if !errors.is_empty() {
+        let message = errors.iter().map(ToString::to_string).collect::<Vec<_>>().join("\n");
+        return Err(PydanticSerializationUnexpectedValue::new_err(Some(message)));
     }
-
     infer_json_key(key, extra)
 }
 
@@ -160,7 +180,8 @@ fn serde_serialize<S: serde::ser::Serializer>(
         }
     }
 
-    if retry_with_lax_check {
+    // If extra.check is SerCheck::Strict, we're in a nested union
+    if extra.check != SerCheck::Strict && retry_with_lax_check {
         new_extra.check = SerCheck::Lax;
         for comb_serializer in choices {
             if let Ok(v) = comb_serializer.to_python(value, include, exclude, &new_extra) {
@@ -169,8 +190,14 @@ fn serde_serialize<S: serde::ser::Serializer>(
         }
     }
 
-    for err in &errors {
-        extra.warnings.custom_warning(err.to_string());
+    // If extra.check is SerCheck::None, we're in a top-level union. We should thus raise the warnings
+    if extra.check == SerCheck::None {
+        for err in &errors {
+            extra.warnings.custom_warning(err.to_string());
+        }
+    } else {
+        // NOTE: if this function becomes recursive at some point, an `Err(_)` containing the errors
+        // will have to be returned here
     }
 
     infer_serialize(value, serializer, include, exclude, extra)
diff --git a/tests/serializers/test_union.py b/tests/serializers/test_union.py
index 8b6d6f128..66ec3b9b8 100644
--- a/tests/serializers/test_union.py
+++ b/tests/serializers/test_union.py
@@ -1,3 +1,5 @@
+from __future__ import annotations
+
 import dataclasses
 import json
 import uuid
@@ -778,3 +780,223 @@ class ModelB:
     model_b = ModelB(field=1)
     assert s.to_python(model_a) == {'field': 1, 'TAG': 'a'}
     assert s.to_python(model_b) == {'field': 1, 'TAG': 'b'}
+
+
+class ModelDog:
+    def __init__(self, type_: Literal['dog']) -> None:
+        self.type_ = 'dog'
+
+
+class ModelCat:
+    def __init__(self, type_: Literal['cat']) -> None:
+        self.type_ = 'cat'
+
+
+class ModelAlien:
+    def __init__(self, type_: Literal['alien']) -> None:
+        self.type_ = 'alien'
+
+
+@pytest.fixture
+def model_a_b_union_schema() -> core_schema.UnionSchema:
+    return core_schema.union_schema(
+        [
+            core_schema.model_schema(
+                cls=ModelA,
+                schema=core_schema.model_fields_schema(
+                    fields={
+                        'a': core_schema.model_field(core_schema.str_schema()),
+                        'b': core_schema.model_field(core_schema.str_schema()),
+                    },
+                ),
+            ),
+            core_schema.model_schema(
+                cls=ModelB,
+                schema=core_schema.model_fields_schema(
+                    fields={
+                        'c': core_schema.model_field(core_schema.str_schema()),
+                        'd': core_schema.model_field(core_schema.str_schema()),
+                    },
+                ),
+            ),
+        ]
+    )
+
+
+@pytest.fixture
+def union_of_unions_schema(model_a_b_union_schema: core_schema.UnionSchema) -> core_schema.UnionSchema:
+    return core_schema.union_schema(
+        [
+            model_a_b_union_schema,
+            core_schema.union_schema(
+                [
+                    core_schema.model_schema(
+                        cls=ModelCat,
+                        schema=core_schema.model_fields_schema(
+                            fields={
+                                'type_': core_schema.model_field(core_schema.literal_schema(['cat'])),
+                            },
+                        ),
+                    ),
+                    core_schema.model_schema(
+                        cls=ModelDog,
+                        schema=core_schema.model_fields_schema(
+                            fields={
+                                'type_': core_schema.model_field(core_schema.literal_schema(['dog'])),
+                            },
+                        ),
+                    ),
+                ]
+            ),
+        ]
+    )
+
+
+@pytest.mark.parametrize(
+    'input,expected',
+    [
+        (ModelA(a='a', b='b'), {'a': 'a', 'b': 'b'}),
+        (ModelB(c='c', d='d'), {'c': 'c', 'd': 'd'}),
+        (ModelCat(type_='cat'), {'type_': 'cat'}),
+        (ModelDog(type_='dog'), {'type_': 'dog'}),
+    ],
+)
+def test_union_of_unions_of_models(union_of_unions_schema: core_schema.UnionSchema, input: Any, expected: Any) -> None:
+    s = SchemaSerializer(union_of_unions_schema)
+    assert s.to_python(input, warnings='error') == expected
+
+
+def test_union_of_unions_of_models_invalid_variant(union_of_unions_schema: core_schema.UnionSchema) -> None:
+    s = SchemaSerializer(union_of_unions_schema)
+    # All warnings should be available
+    messages = [
+        'Expected `ModelA` but got `ModelAlien`',
+        'Expected `ModelB` but got `ModelAlien`',
+        'Expected `ModelCat` but got `ModelAlien`',
+        'Expected `ModelDog` but got `ModelAlien`',
+    ]
+
+    with warnings.catch_warnings(record=True) as w:
+        warnings.simplefilter('always')
+        s.to_python(ModelAlien(type_='alien'))
+        for m in messages:
+            assert m in str(w[0].message)
+
+
+@pytest.fixture
+def tagged_union_of_unions_schema(model_a_b_union_schema: core_schema.UnionSchema) -> core_schema.UnionSchema:
+    return core_schema.union_schema(
+        [
+            model_a_b_union_schema,
+            core_schema.tagged_union_schema(
+                discriminator='type_',
+                choices={
+                    'cat': core_schema.model_schema(
+                        cls=ModelCat,
+                        schema=core_schema.model_fields_schema(
+                            fields={
+                                'type_': core_schema.model_field(core_schema.literal_schema(['cat'])),
+                            },
+                        ),
+                    ),
+                    'dog': core_schema.model_schema(
+                        cls=ModelDog,
+                        schema=core_schema.model_fields_schema(
+                            fields={
+                                'type_': core_schema.model_field(core_schema.literal_schema(['dog'])),
+                            },
+                        ),
+                    ),
+                },
+            ),
+        ]
+    )
+
+
+@pytest.mark.parametrize(
+    'input,expected',
+    [
+        (ModelA(a='a', b='b'), {'a': 'a', 'b': 'b'}),
+        (ModelB(c='c', d='d'), {'c': 'c', 'd': 'd'}),
+        (ModelCat(type_='cat'), {'type_': 'cat'}),
+        (ModelDog(type_='dog'), {'type_': 'dog'}),
+    ],
+)
+def test_union_of_unions_of_models_with_tagged_union(
+    tagged_union_of_unions_schema: core_schema.UnionSchema, input: Any, expected: Any
+) -> None:
+    s = SchemaSerializer(tagged_union_of_unions_schema)
+    assert s.to_python(input, warnings='error') == expected
+
+
+def test_union_of_unions_of_models_with_tagged_union_invalid_variant(
+    tagged_union_of_unions_schema: core_schema.UnionSchema,
+) -> None:
+    s = SchemaSerializer(tagged_union_of_unions_schema)
+    # All warnings should be available
+    messages = [
+        'Expected `ModelA` but got `ModelAlien`',
+        'Expected `ModelB` but got `ModelAlien`',
+        'Expected `ModelCat` but got `ModelAlien`',
+        'Expected `ModelDog` but got `ModelAlien`',
+    ]
+
+    with warnings.catch_warnings(record=True) as w:
+        warnings.simplefilter('always')
+        s.to_python(ModelAlien(type_='alien'))
+        for m in messages:
+            assert m in str(w[0].message)
+
+
+@pytest.mark.parametrize(
+    'input,expected',
+    [
+        ({True: '1'}, b'{"true":"1"}'),
+        ({1: '1'}, b'{"1":"1"}'),
+        ({2.3: '1'}, b'{"2.3":"1"}'),
+        ({'a': 'b'}, b'{"a":"b"}'),
+    ],
+)
+def test_union_of_unions_of_models_with_tagged_union_json_key_serialization(
+    input: dict[bool | int | float | str, str], expected: bytes
+) -> None:
+    s = SchemaSerializer(
+        core_schema.dict_schema(
+            keys_schema=core_schema.union_schema(
+                [
+                    core_schema.union_schema([core_schema.bool_schema(), core_schema.int_schema()]),
+                    core_schema.union_schema([core_schema.float_schema(), core_schema.str_schema()]),
+                ]
+            ),
+            values_schema=core_schema.str_schema(),
+        )
+    )
+
+    assert s.to_json(input, warnings='error') == expected
+
+
+@pytest.mark.parametrize(
+    'input,expected',
+    [
+        ({'key': True}, b'{"key":true}'),
+        ({'key': 1}, b'{"key":1}'),
+        ({'key': 2.3}, b'{"key":2.3}'),
+        ({'key': 'a'}, b'{"key":"a"}'),
+    ],
+)
+def test_union_of_unions_of_models_with_tagged_union_json_serialization(
+    input: dict[str, bool | int | float | str], expected: bytes
+) -> None:
+    s = SchemaSerializer(
+        core_schema.dict_schema(
+            keys_schema=core_schema.str_schema(),
+            values_schema=core_schema.union_schema(
+                [
+                    core_schema.union_schema([core_schema.bool_schema(), core_schema.int_schema()]),
+                    core_schema.union_schema([core_schema.float_schema(), core_schema.str_schema()]),
+                ]
+            ),
+        )
+    )
+
+    assert s.to_json(input, warnings='error') == expected

From cd270e403c8c77a5b6c1f1a35ce886afe23a743e Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Mon, 11 Nov 2024 15:31:31 +0100
Subject: [PATCH 422/550] Fix `_IncEx` type alias to be compatible with mypy
 (#1537)

---
 python/pydantic_core/_pydantic_core.pyi | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index 7de91f773..718db625d 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -253,7 +253,9 @@ class SchemaValidator:
             `None` if the schema has no default value, otherwise a [`Some`][pydantic_core.Some] containing the default.
         """
 
-_IncEx: TypeAlias = set[int] | set[str] | Mapping[int, _IncEx | Literal[True]] | Mapping[str, _IncEx | Literal[True]]
+# In reality, `bool` should be replaced by `Literal[True]` but mypy fails to correctly apply bidirectional type inference
+# (e.g. when using `{'a': {'b': True}}`).
+_IncEx: TypeAlias = set[int] | set[str] | Mapping[int, _IncEx | bool] | Mapping[str, _IncEx | bool]
 
 @final
 class SchemaSerializer:

From cd0346d68bf7c15dcd73b56d5084d094b0dea351 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Mon, 11 Nov 2024 10:37:28 -0500
Subject: [PATCH 423/550]  More union serialization tidying (#1536)

---
 Makefile                                  |  2 +-
 src/serializers/type_serializers/union.rs | 31 ++++++++----
 tests/serializers/test_union.py           | 62 +++++++++++++++++++++++
 3 files changed, 85 insertions(+), 10 deletions(-)

diff --git a/Makefile b/Makefile
index ad9de667b..4186369a7 100644
--- a/Makefile
+++ b/Makefile
@@ -15,7 +15,7 @@ install:
 	pip install -U pip wheel pre-commit
 	pip install -r tests/requirements.txt
 	pip install -r tests/requirements-linting.txt
-	pip install -e .
+	pip install -v -e .
 	pre-commit install
 
 .PHONY: install-rust-coverage
diff --git a/src/serializers/type_serializers/union.rs b/src/serializers/type_serializers/union.rs
index ac674ef34..35a5c8bc7 100644
--- a/src/serializers/type_serializers/union.rs
+++ b/src/serializers/type_serializers/union.rs
@@ -422,19 +422,32 @@ impl TaggedUnionSerializer {
     fn get_discriminator_value(&self, value: &Bound<'_, PyAny>, extra: &Extra) -> Option<Py<PyAny>> {
         let py = value.py();
         let discriminator_value = match &self.discriminator {
-            Discriminator::LookupKey(lookup_key) => lookup_key
-                .simple_py_get_attr(value)
-                .ok()
-                .and_then(|opt| opt.map(|(_, bound)| bound.to_object(py))),
+            Discriminator::LookupKey(lookup_key) => {
+                // we're pretty lax here, we allow either dict[key] or object.key, as we very well could
+                // be doing a discriminator lookup on a typed dict, and there's no good way to check that
+                // at this point. we could be more strict and only do this in lax mode...
+                let getattr_result = match value.is_instance_of::<PyDict>() {
+                    true => {
+                        let value_dict = value.downcast::<PyDict>().unwrap();
+                        lookup_key.py_get_dict_item(value_dict).ok()
+                    }
+                    false => lookup_key.simple_py_get_attr(value).ok(),
+                };
+                getattr_result.and_then(|opt| opt.map(|(_, bound)| bound.to_object(py)))
+            }
             Discriminator::Function(func) => func.call1(py, (value,)).ok(),
         };
         if discriminator_value.is_none() {
             let value_str = truncate_safe_repr(value, None);
-            extra.warnings.custom_warning(
-                format!(
-                    "Failed to get discriminator value for tagged union serialization with value `{value_str}` - defaulting to left to right union serialization."
-                )
-            );
+
+            // If extra.check is SerCheck::None, we're in a top-level union. We should thus raise this warning
+            if extra.check == SerCheck::None {
+                extra.warnings.custom_warning(
+                    format!(
+                        "Failed to get discriminator value for tagged union serialization with value `{value_str}` - defaulting to left to right union serialization."
+                    )
+                );
+            }
         }
         discriminator_value
     }
diff --git a/tests/serializers/test_union.py b/tests/serializers/test_union.py
index 66ec3b9b8..b77f8cb8f 100644
--- a/tests/serializers/test_union.py
+++ b/tests/serializers/test_union.py
@@ -948,6 +948,43 @@ def test_union_of_unions_of_models_with_tagged_union_invalid_variant(
             assert m in str(w[0].message)
 
 
+def test_mixed_union_models_and_other_types() -> None:
+    s = SchemaSerializer(
+        core_schema.union_schema(
+            [
+                core_schema.tagged_union_schema(
+                    discriminator='type_',
+                    choices={
+                        'cat': core_schema.model_schema(
+                            cls=ModelCat,
+                            schema=core_schema.model_fields_schema(
+                                fields={
+                                    'type_': core_schema.model_field(core_schema.literal_schema(['cat'])),
+                                },
+                            ),
+                        ),
+                        'dog': core_schema.model_schema(
+                            cls=ModelDog,
+                            schema=core_schema.model_fields_schema(
+                                fields={
+                                    'type_': core_schema.model_field(core_schema.literal_schema(['dog'])),
+                                },
+                            ),
+                        ),
+                    },
+                ),
+                core_schema.str_schema(),
+            ]
+        )
+    )
+
+    assert s.to_python(ModelCat(type_='cat'), warnings='error') == {'type_': 'cat'}
+    assert s.to_python(ModelDog(type_='dog'), warnings='error') == {'type_': 'dog'}
+    # note, this fails as ModelCat and ModelDog (discriminator warnings, etc), but the warnings
+    # don't bubble up to this level :)
+    assert s.to_python('a string', warnings='error') == 'a string'
+
+
 @pytest.mark.parametrize(
     'input,expected',
     [
@@ -1000,3 +1037,28 @@ def test_union_of_unions_of_models_with_tagged_union_json_serialization(
     )
 
     assert s.to_json(input, warnings='error') == expected
+
+
+def test_discriminated_union_ser_with_typed_dict() -> None:
+    v = SchemaSerializer(
+        core_schema.tagged_union_schema(
+            {
+                'a': core_schema.typed_dict_schema(
+                    {
+                        'type': core_schema.typed_dict_field(core_schema.literal_schema(['a'])),
+                        'a': core_schema.typed_dict_field(core_schema.int_schema()),
+                    }
+                ),
+                'b': core_schema.typed_dict_schema(
+                    {
+                        'type': core_schema.typed_dict_field(core_schema.literal_schema(['b'])),
+                        'b': core_schema.typed_dict_field(core_schema.str_schema()),
+                    }
+                ),
+            },
+            discriminator='type',
+        )
+    )
+
+    assert v.to_python({'type': 'a', 'a': 1}, warnings='error') == {'type': 'a', 'a': 1}
+    assert v.to_python({'type': 'b', 'b': 'foo'}, warnings='error') == {'type': 'b', 'b': 'foo'}

From a3f13c737625e7cdeeb4c4f193d92f9e0a8984a1 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Tue, 12 Nov 2024 13:02:42 +0000
Subject: [PATCH 424/550] fix `wrap` serializer breaking union serialization in
 presence of extra fields (#1530)

---
 src/serializers/extra.rs                     |   4 +
 src/serializers/fields.rs                    |  23 +--
 src/serializers/type_serializers/function.rs |  15 ++
 tests/serializers/test_union.py              | 139 +++++++++++++------
 4 files changed, 124 insertions(+), 57 deletions(-)

diff --git a/src/serializers/extra.rs b/src/serializers/extra.rs
index ba47445b5..28aeea133 100644
--- a/src/serializers/extra.rs
+++ b/src/serializers/extra.rs
@@ -198,6 +198,10 @@ impl<'a> Extra<'a> {
     pub fn serialize_infer<'py>(&'py self, value: &'py Bound<'py, PyAny>) -> super::infer::SerializeInfer<'py> {
         super::infer::SerializeInfer::new(value, None, None, self)
     }
+
+    pub(crate) fn model_type_name(&self) -> Option<Bound<'a, PyString>> {
+        self.model.and_then(|model| model.get_type().name().ok())
+    }
 }
 
 #[derive(Clone, Copy, PartialEq, Eq)]
diff --git a/src/serializers/fields.rs b/src/serializers/fields.rs
index 6cd76c36b..4498d8fa7 100644
--- a/src/serializers/fields.rs
+++ b/src/serializers/fields.rs
@@ -200,7 +200,15 @@ impl GeneralFieldsSerializer {
                     };
                     output_dict.set_item(key, value)?;
                 } else if field_extra.check == SerCheck::Strict {
-                    return Err(PydanticSerializationUnexpectedValue::new_err(None));
+                    let type_name = field_extra.model_type_name();
+                    return Err(PydanticSerializationUnexpectedValue::new_err(Some(format!(
+                        "Unexpected field `{key}`{for_type_name}",
+                        for_type_name = if let Some(type_name) = type_name {
+                            format!(" for type `{type_name}`")
+                        } else {
+                            String::new()
+                        },
+                    ))));
                 }
             }
         }
@@ -212,22 +220,15 @@ impl GeneralFieldsSerializer {
             && self.required_fields > used_req_fields
         {
             let required_fields = self.required_fields;
-            let type_name = match extra.model {
-                Some(model) => model
-                    .get_type()
-                    .qualname()
-                    .ok()
-                    .unwrap_or_else(|| PyString::new_bound(py, "<unknown python object>"))
-                    .to_string(),
-                None => "<unknown python object>".to_string(),
-            };
+            let type_name = extra.model_type_name();
             let field_value = match extra.model {
                 Some(model) => truncate_safe_repr(model, Some(100)),
                 None => "<unknown python object>".to_string(),
             };
 
             Err(PydanticSerializationUnexpectedValue::new_err(Some(format!(
-                "Expected {required_fields} fields but got {used_req_fields} for type `{type_name}` with value `{field_value}` - serialized value may not be as expected."
+                "Expected {required_fields} fields but got {used_req_fields}{for_type_name} with value `{field_value}` - serialized value may not be as expected.",
+                for_type_name = if let Some(type_name) = type_name { format!(" for type `{type_name}`") } else { String::new() },
             ))))
         } else {
             Ok(output_dict)
diff --git a/src/serializers/type_serializers/function.rs b/src/serializers/type_serializers/function.rs
index d0fea665f..f01b0c556 100644
--- a/src/serializers/type_serializers/function.rs
+++ b/src/serializers/type_serializers/function.rs
@@ -179,6 +179,13 @@ impl FunctionPlainSerializer {
             .expect("fallback_serializer unexpectedly none")
             .as_ref()
     }
+
+    fn retry_with_lax_check(&self) -> bool {
+        self.fallback_serializer
+            .as_ref()
+            .map_or(false, |f| f.retry_with_lax_check())
+            || self.return_serializer.retry_with_lax_check()
+    }
 }
 
 fn on_error(py: Python, err: PyErr, function_name: &str, extra: &Extra) -> PyResult<()> {
@@ -271,6 +278,10 @@ macro_rules! function_type_serializer {
             fn get_name(&self) -> &str {
                 &self.name
             }
+
+            fn retry_with_lax_check(&self) -> bool {
+                self.retry_with_lax_check()
+            }
         }
     };
 }
@@ -409,6 +420,10 @@ impl FunctionWrapSerializer {
     fn get_fallback_serializer(&self) -> &CombinedSerializer {
         self.serializer.as_ref()
     }
+
+    fn retry_with_lax_check(&self) -> bool {
+        self.serializer.retry_with_lax_check() || self.return_serializer.retry_with_lax_check()
+    }
 }
 
 impl_py_gc_traverse!(FunctionWrapSerializer {
diff --git a/tests/serializers/test_union.py b/tests/serializers/test_union.py
index b77f8cb8f..3302741bb 100644
--- a/tests/serializers/test_union.py
+++ b/tests/serializers/test_union.py
@@ -62,53 +62,36 @@ def __init__(self, c, d):
 @pytest.fixture(scope='module')
 def model_serializer() -> SchemaSerializer:
     return SchemaSerializer(
-        {
-            'type': 'union',
-            'choices': [
-                {
-                    'type': 'model',
-                    'cls': ModelA,
-                    'schema': {
-                        'type': 'model-fields',
-                        'fields': {
-                            'a': {'type': 'model-field', 'schema': {'type': 'bytes'}},
-                            'b': {
-                                'type': 'model-field',
-                                'schema': {
-                                    'type': 'float',
-                                    'serialization': {
-                                        'type': 'format',
-                                        'formatting_string': '0.1f',
-                                        'when_used': 'unless-none',
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-                {
-                    'type': 'model',
-                    'cls': ModelB,
-                    'schema': {
-                        'type': 'model-fields',
-                        'fields': {
-                            'c': {'type': 'model-field', 'schema': {'type': 'bytes'}},
-                            'd': {
-                                'type': 'model-field',
-                                'schema': {
-                                    'type': 'float',
-                                    'serialization': {
-                                        'type': 'format',
-                                        'formatting_string': '0.2f',
-                                        'when_used': 'unless-none',
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
+        core_schema.union_schema(
+            [
+                core_schema.model_schema(
+                    ModelA,
+                    core_schema.model_fields_schema(
+                        {
+                            'a': core_schema.model_field(core_schema.bytes_schema()),
+                            'b': core_schema.model_field(
+                                core_schema.float_schema(
+                                    serialization=core_schema.format_ser_schema('0.1f', when_used='unless-none')
+                                )
+                            ),
+                        }
+                    ),
+                ),
+                core_schema.model_schema(
+                    ModelB,
+                    core_schema.model_fields_schema(
+                        {
+                            'c': core_schema.model_field(core_schema.bytes_schema()),
+                            'd': core_schema.model_field(
+                                core_schema.float_schema(
+                                    serialization=core_schema.format_ser_schema('0.2f', when_used='unless-none')
+                                )
+                            ),
+                        }
+                    ),
+                ),
             ],
-        }
+        )
     )
 
 
@@ -782,6 +765,70 @@ class ModelB:
     assert s.to_python(model_b) == {'field': 1, 'TAG': 'b'}
 
 
+def test_union_model_wrap_serializer():
+    def wrap_serializer(value, handler):
+        return handler(value)
+
+    class Data:
+        pass
+
+    class ModelA:
+        a: Data
+
+    class ModelB:
+        a: Data
+
+    model_serializer = SchemaSerializer(
+        core_schema.union_schema(
+            [
+                core_schema.model_schema(
+                    ModelA,
+                    core_schema.model_fields_schema(
+                        {
+                            'a': core_schema.model_field(
+                                core_schema.model_schema(
+                                    Data,
+                                    core_schema.model_fields_schema({}),
+                                )
+                            ),
+                        },
+                    ),
+                    serialization=core_schema.wrap_serializer_function_ser_schema(wrap_serializer),
+                ),
+                core_schema.model_schema(
+                    ModelB,
+                    core_schema.model_fields_schema(
+                        {
+                            'a': core_schema.model_field(
+                                core_schema.model_schema(
+                                    Data,
+                                    core_schema.model_fields_schema({}),
+                                )
+                            ),
+                        },
+                    ),
+                    serialization=core_schema.wrap_serializer_function_ser_schema(wrap_serializer),
+                ),
+            ],
+        )
+    )
+
+    input_value = ModelA()
+    input_value.a = Data()
+
+    assert model_serializer.to_python(input_value) == {'a': {}}
+    assert model_serializer.to_python(input_value, mode='json') == {'a': {}}
+    assert model_serializer.to_json(input_value) == b'{"a":{}}'
+
+    # add some additional attribute, should be ignored & not break serialization
+
+    input_value.a._a = 'foo'
+
+    assert model_serializer.to_python(input_value) == {'a': {}}
+    assert model_serializer.to_python(input_value, mode='json') == {'a': {}}
+    assert model_serializer.to_json(input_value) == b'{"a":{}}'
+
+
 class ModelDog:
     def __init__(self, type_: Literal['dog']) -> None:
         self.type_ = 'dog'

From be03c66bdb9f3a4712416a02e52e5a4d8f128b20 Mon Sep 17 00:00:00 2001
From: Samuel Colvin <s@muelcolvin.com>
Date: Tue, 12 Nov 2024 17:39:00 +0000
Subject: [PATCH 425/550] support `trailing-strings` with `allow_partial`
 (#1539)

---
 .mypy-stubtest-allowlist                |   5 +-
 Cargo.lock                              |   4 +-
 Cargo.toml                              |   2 +-
 benches/main.rs                         | 102 ++++++++++++------------
 pyproject.toml                          |   3 +
 python/pydantic_core/_pydantic_core.pyi |  10 ++-
 src/input/return_enums.rs               |  15 +++-
 src/url.rs                              |   4 +-
 src/validators/arguments.rs             |   3 +-
 src/validators/dataclass.rs             |   2 +-
 src/validators/definitions.rs           |   2 +-
 src/validators/dict.rs                  |   8 +-
 src/validators/generator.rs             |   6 +-
 src/validators/json.rs                  |   8 +-
 src/validators/mod.rs                   |  26 +++---
 src/validators/model_fields.rs          |   2 +-
 src/validators/tuple.rs                 |   5 +-
 src/validators/typed_dict.rs            |  19 +++--
 src/validators/validation_state.rs      |  12 +--
 tests/test.rs                           |   2 +-
 tests/validators/test_allow_partial.py  |  25 ++++++
 21 files changed, 159 insertions(+), 106 deletions(-)

diff --git a/.mypy-stubtest-allowlist b/.mypy-stubtest-allowlist
index 9c6f4bb3d..8c7d6666a 100644
--- a/.mypy-stubtest-allowlist
+++ b/.mypy-stubtest-allowlist
@@ -1,7 +1,10 @@
 # TODO: don't want to expose this staticmethod, requires https://github.com/PyO3/pyo3/issues/2384
 pydantic_core._pydantic_core.PydanticUndefinedType.new
-# As per #1240, from_json has custom logic to coverage the `cache_strings` kwarg
+# See #1540 for discussion
 pydantic_core._pydantic_core.from_json
+pydantic_core._pydantic_core.SchemaValidator.validate_python
+pydantic_core._pydantic_core.SchemaValidator.validate_json
+pydantic_core._pydantic_core.SchemaValidator.validate_strings
 # the `warnings` kwarg for SchemaSerializer functions has custom logic
 pydantic_core._pydantic_core.SchemaSerializer.to_python
 pydantic_core._pydantic_core.SchemaSerializer.to_json
diff --git a/Cargo.lock b/Cargo.lock
index 6381d4c5e..b34342509 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -297,9 +297,9 @@ checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
 
 [[package]]
 name = "jiter"
-version = "0.7.0"
+version = "0.7.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f69107091dc861900882c599876b095d9db7f71064b6914d6c68b284d19f9ee8"
+checksum = "07f69a121b68af57bc10f151f3f67444a64d1d3a0eb48b042801ea917a38dd25"
 dependencies = [
  "ahash",
  "bitvec",
diff --git a/Cargo.toml b/Cargo.toml
index 625e474ec..d68bd2701 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -46,7 +46,7 @@ base64 = "0.22.1"
 num-bigint = "0.4.6"
 python3-dll-a = "0.2.10"
 uuid = "1.11.0"
-jiter = { version = "0.7", features = ["python"] }
+jiter = { version = "0.7.1", features = ["python"] }
 hex = "0.4.3"
 
 [lib]
diff --git a/benches/main.rs b/benches/main.rs
index 6d3fd0951..69157e2d3 100644
--- a/benches/main.rs
+++ b/benches/main.rs
@@ -29,7 +29,7 @@ fn ints_json(bench: &mut Bencher) {
         let validator = build_schema_validator(py, "{'type': 'int'}");
 
         let result = validator
-            .validate_json(py, &json(py, "123"), None, None, None, false)
+            .validate_json(py, &json(py, "123"), None, None, None, false.into())
             .unwrap();
         let result_int: i64 = result.extract(py).unwrap();
         assert_eq!(result_int, 123);
@@ -37,7 +37,7 @@ fn ints_json(bench: &mut Bencher) {
         bench.iter(|| {
             black_box(
                 validator
-                    .validate_json(py, &json(py, "123"), None, None, None, false)
+                    .validate_json(py, &json(py, "123"), None, None, None, false.into())
                     .unwrap(),
             )
         })
@@ -51,7 +51,7 @@ fn ints_python(bench: &mut Bencher) {
 
         let input = 123_i64.into_py(py).into_bound(py);
         let result = validator
-            .validate_python(py, &input, None, None, None, None, false)
+            .validate_python(py, &input, None, None, None, None, false.into())
             .unwrap();
         let result_int: i64 = result.extract(py).unwrap();
         assert_eq!(result_int, 123);
@@ -60,7 +60,7 @@ fn ints_python(bench: &mut Bencher) {
         bench.iter(|| {
             black_box(
                 validator
-                    .validate_python(py, &input, None, None, None, None, false)
+                    .validate_python(py, &input, None, None, None, None, false.into())
                     .unwrap(),
             )
         })
@@ -79,7 +79,7 @@ fn list_int_json(bench: &mut Bencher) {
         bench.iter(|| {
             black_box(
                 validator
-                    .validate_json(py, &json(py, &code), None, None, None, false)
+                    .validate_json(py, &json(py, &code), None, None, None, false.into())
                     .unwrap(),
             )
         })
@@ -104,7 +104,7 @@ fn list_int_python(bench: &mut Bencher) {
         let input = black_box(input.bind(py));
         bench.iter(|| {
             let v = validator
-                .validate_python(py, &input, None, None, None, None, false)
+                .validate_python(py, &input, None, None, None, None, false.into())
                 .unwrap();
             black_box(v)
         })
@@ -138,7 +138,7 @@ fn list_error_json(bench: &mut Bencher) {
                 .join(", ")
         );
 
-        match validator.validate_json(py, &json(py, &code), None, None, None, false) {
+        match validator.validate_json(py, &json(py, &code), None, None, None, false.into()) {
             Ok(_) => panic!("unexpectedly valid"),
             Err(e) => {
                 let v = e.value_bound(py);
@@ -150,7 +150,7 @@ fn list_error_json(bench: &mut Bencher) {
         };
 
         bench.iter(
-            || match validator.validate_json(py, &json(py, &code), None, None, None, false) {
+            || match validator.validate_json(py, &json(py, &code), None, None, None, false.into()) {
                 Ok(_) => panic!("unexpectedly valid"),
                 Err(e) => black_box(e),
             },
@@ -170,7 +170,7 @@ fn list_error_python_input(py: Python<'_>) -> (SchemaValidator, PyObject) {
 
     let input = py.eval_bound(&code, None, None).unwrap().extract().unwrap();
 
-    match validator.validate_python(py, &input, None, None, None, None, false) {
+    match validator.validate_python(py, &input, None, None, None, None, false.into()) {
         Ok(_) => panic!("unexpectedly valid"),
         Err(e) => {
             let v = e.value_bound(py);
@@ -190,7 +190,7 @@ fn list_error_python(bench: &mut Bencher) {
 
         let input = black_box(input.bind(py));
         bench.iter(|| {
-            let result = validator.validate_python(py, &input, None, None, None, None, false);
+            let result = validator.validate_python(py, &input, None, None, None, None, false.into());
 
             match result {
                 Ok(_) => panic!("unexpectedly valid"),
@@ -226,7 +226,7 @@ fn list_any_json(bench: &mut Bencher) {
         bench.iter(|| {
             black_box(
                 validator
-                    .validate_json(py, &json(py, &code), None, None, None, false)
+                    .validate_json(py, &json(py, &code), None, None, None, false.into())
                     .unwrap(),
             )
         })
@@ -245,7 +245,7 @@ fn list_any_python(bench: &mut Bencher) {
         let input = black_box(input.bind(py));
         bench.iter(|| {
             let v = validator
-                .validate_python(py, &input, None, None, None, None, false)
+                .validate_python(py, &input, None, None, None, None, false.into())
                 .unwrap();
             black_box(v)
         })
@@ -279,7 +279,7 @@ fn dict_json(bench: &mut Bencher) {
         bench.iter(|| {
             black_box(
                 validator
-                    .validate_json(py, &json(py, &code), None, None, None, false)
+                    .validate_json(py, &json(py, &code), None, None, None, false.into())
                     .unwrap(),
             )
         })
@@ -305,7 +305,7 @@ fn dict_python(bench: &mut Bencher) {
         let input = black_box(input.bind(py));
         bench.iter(|| {
             let v = validator
-                .validate_python(py, &input, None, None, None, None, false)
+                .validate_python(py, &input, None, None, None, None, false.into())
                 .unwrap();
             black_box(v)
         })
@@ -334,7 +334,7 @@ fn dict_value_error(bench: &mut Bencher) {
 
         let input = py.eval_bound(&code, None, None).unwrap().to_object(py).into_bound(py);
 
-        match validator.validate_python(py, &input, None, None, None, None, false) {
+        match validator.validate_python(py, &input, None, None, None, None, false.into()) {
             Ok(_) => panic!("unexpectedly valid"),
             Err(e) => {
                 let v = e.value_bound(py);
@@ -347,7 +347,7 @@ fn dict_value_error(bench: &mut Bencher) {
 
         let input = black_box(input);
         bench.iter(|| {
-            let result = validator.validate_python(py, &input, None, None, None, None, false);
+            let result = validator.validate_python(py, &input, None, None, None, None, false.into());
 
             match result {
                 Ok(_) => panic!("unexpectedly valid"),
@@ -385,7 +385,7 @@ fn typed_dict_json(bench: &mut Bencher) {
         bench.iter(|| {
             black_box(
                 validator
-                    .validate_json(py, &json(py, &code), None, None, None, false)
+                    .validate_json(py, &json(py, &code), None, None, None, false.into())
                     .unwrap(),
             )
         })
@@ -420,7 +420,7 @@ fn typed_dict_python(bench: &mut Bencher) {
         let input = black_box(input.bind(py));
         bench.iter(|| {
             let v = validator
-                .validate_python(py, &input, None, None, None, None, false)
+                .validate_python(py, &input, None, None, None, None, false.into())
                 .unwrap();
             black_box(v)
         })
@@ -461,7 +461,7 @@ fn typed_dict_deep_error(bench: &mut Bencher) {
         let input = py.eval_bound(code, None, None).unwrap().to_object(py);
         let input = black_box(input.bind(py));
 
-        match validator.validate_python(py, &input, None, None, None, None, false) {
+        match validator.validate_python(py, &input, None, None, None, None, false.into()) {
             Ok(_) => panic!("unexpectedly valid"),
             Err(e) => {
                 let v = e.value_bound(py);
@@ -473,7 +473,7 @@ fn typed_dict_deep_error(bench: &mut Bencher) {
         };
 
         bench.iter(|| {
-            let result = validator.validate_python(py, &input, None, None, None, None, false);
+            let result = validator.validate_python(py, &input, None, None, None, None, false.into());
 
             match result {
                 Ok(_) => panic!("unexpectedly valid"),
@@ -500,7 +500,7 @@ fn complete_model(bench: &mut Bencher) {
         bench.iter(|| {
             black_box(
                 validator
-                    .validate_python(py, &input, None, None, None, None, false)
+                    .validate_python(py, &input, None, None, None, None, false.into())
                     .unwrap(),
             );
         })
@@ -522,13 +522,13 @@ fn nested_model_using_definitions(bench: &mut Bencher) {
         let input = black_box(input);
 
         validator
-            .validate_python(py, &input, None, None, None, None, false)
+            .validate_python(py, &input, None, None, None, None, false.into())
             .unwrap();
 
         bench.iter(|| {
             black_box(
                 validator
-                    .validate_python(py, &input, None, None, None, None, false)
+                    .validate_python(py, &input, None, None, None, None, false.into())
                     .unwrap(),
             );
         })
@@ -550,13 +550,13 @@ fn nested_model_inlined(bench: &mut Bencher) {
         let input = black_box(input);
 
         validator
-            .validate_python(py, &input, None, None, None, None, false)
+            .validate_python(py, &input, None, None, None, None, false.into())
             .unwrap();
 
         bench.iter(|| {
             black_box(
                 validator
-                    .validate_python(py, &input, None, None, None, None, false)
+                    .validate_python(py, &input, None, None, None, None, false.into())
                     .unwrap(),
             );
         })
@@ -571,7 +571,7 @@ fn literal_ints_few_python(bench: &mut Bencher) {
         let input = 4_i64.into_py(py);
         let input = input.bind(py);
         let result = validator
-            .validate_python(py, &input, None, None, None, None, false)
+            .validate_python(py, &input, None, None, None, None, false.into())
             .unwrap();
         let result_int: i64 = result.extract(py).unwrap();
         assert_eq!(result_int, 4);
@@ -580,7 +580,7 @@ fn literal_ints_few_python(bench: &mut Bencher) {
         bench.iter(|| {
             black_box(
                 validator
-                    .validate_python(py, &input, None, None, None, None, false)
+                    .validate_python(py, &input, None, None, None, None, false.into())
                     .unwrap(),
             )
         })
@@ -596,7 +596,7 @@ fn literal_strings_few_small_python(bench: &mut Bencher) {
         let input = input.to_object(py).into_bound(py);
         let input_str: String = input.extract().unwrap();
         let result = validator
-            .validate_python(py, &input, None, None, None, None, false)
+            .validate_python(py, &input, None, None, None, None, false.into())
             .unwrap();
         let result_str: String = result.extract(py).unwrap();
         assert_eq!(result_str, input_str);
@@ -605,7 +605,7 @@ fn literal_strings_few_small_python(bench: &mut Bencher) {
         bench.iter(|| {
             black_box(
                 validator
-                    .validate_python(py, &input, None, None, None, None, false)
+                    .validate_python(py, &input, None, None, None, None, false.into())
                     .unwrap(),
             )
         })
@@ -624,7 +624,7 @@ fn literal_strings_few_large_python(bench: &mut Bencher) {
         let input = input.to_object(py).into_bound(py);
         let input_str: String = input.extract().unwrap();
         let result = validator
-            .validate_python(py, &input, None, None, None, None, false)
+            .validate_python(py, &input, None, None, None, None, false.into())
             .unwrap();
         let result_str: String = result.extract(py).unwrap();
         assert_eq!(result_str, input_str);
@@ -633,7 +633,7 @@ fn literal_strings_few_large_python(bench: &mut Bencher) {
         bench.iter(|| {
             black_box(
                 validator
-                    .validate_python(py, &input, None, None, None, None, false)
+                    .validate_python(py, &input, None, None, None, None, false.into())
                     .unwrap(),
             )
         })
@@ -668,7 +668,7 @@ class Foo(Enum):
         let input = py.eval_bound("Foo.v4", Some(&globals), None).unwrap();
         let input = input.to_object(py).into_bound(py);
         let result = validator
-            .validate_python(py, &input, None, None, None, None, false)
+            .validate_python(py, &input, None, None, None, None, false.into())
             .unwrap();
         assert!(input.eq(result).unwrap());
 
@@ -676,7 +676,7 @@ class Foo(Enum):
         bench.iter(|| {
             black_box(
                 validator
-                    .validate_python(py, &input, None, None, None, None, false)
+                    .validate_python(py, &input, None, None, None, None, false.into())
                     .unwrap(),
             )
         })
@@ -690,7 +690,7 @@ fn literal_ints_many_python(bench: &mut Bencher) {
 
         let input = 99_i64.into_py(py).into_bound(py);
         let result = validator
-            .validate_python(py, &input, None, None, None, None, false)
+            .validate_python(py, &input, None, None, None, None, false.into())
             .unwrap();
         let result_int: i64 = result.extract(py).unwrap();
         assert_eq!(result_int, 99);
@@ -699,7 +699,7 @@ fn literal_ints_many_python(bench: &mut Bencher) {
         bench.iter(|| {
             black_box(
                 validator
-                    .validate_python(py, &input, None, None, None, None, false)
+                    .validate_python(py, &input, None, None, None, None, false.into())
                     .unwrap(),
             )
         })
@@ -715,7 +715,7 @@ fn literal_strings_many_small_python(bench: &mut Bencher) {
         let input = input.to_object(py).into_bound(py);
         let input_str: String = input.extract().unwrap();
         let result = validator
-            .validate_python(py, &input, None, None, None, None, false)
+            .validate_python(py, &input, None, None, None, None, false.into())
             .unwrap();
         let result_str: String = result.extract(py).unwrap();
         assert_eq!(result_str, input_str);
@@ -724,7 +724,7 @@ fn literal_strings_many_small_python(bench: &mut Bencher) {
         bench.iter(|| {
             black_box(
                 validator
-                    .validate_python(py, &input, None, None, None, None, false)
+                    .validate_python(py, &input, None, None, None, None, false.into())
                     .unwrap(),
             )
         })
@@ -743,7 +743,7 @@ fn literal_strings_many_large_python(bench: &mut Bencher) {
         let input = input.to_object(py).into_bound(py);
         let input_str: String = input.extract().unwrap();
         let result = validator
-            .validate_python(py, &input, None, None, None, None, false)
+            .validate_python(py, &input, None, None, None, None, false.into())
             .unwrap();
         let result_str: String = result.extract(py).unwrap();
         assert_eq!(result_str, input_str);
@@ -752,7 +752,7 @@ fn literal_strings_many_large_python(bench: &mut Bencher) {
         bench.iter(|| {
             black_box(
                 validator
-                    .validate_python(py, &input, None, None, None, None, false)
+                    .validate_python(py, &input, None, None, None, None, false.into())
                     .unwrap(),
             )
         })
@@ -767,7 +767,7 @@ fn literal_ints_many_json(bench: &mut Bencher) {
         let input_json = py.eval_bound("'99'", None, None).unwrap();
         let input_json = input_json.to_object(py).into_bound(py);
         let result = validator
-            .validate_json(py, &input_json, None, None, None, false)
+            .validate_json(py, &input_json, None, None, None, false.into())
             .unwrap();
         let result_int: i64 = result.extract(py).unwrap();
         assert_eq!(result_int, 99);
@@ -776,7 +776,7 @@ fn literal_ints_many_json(bench: &mut Bencher) {
         bench.iter(|| {
             black_box(
                 validator
-                    .validate_json(py, &input_json, None, None, None, false)
+                    .validate_json(py, &input_json, None, None, None, false.into())
                     .unwrap(),
             )
         })
@@ -797,7 +797,7 @@ fn literal_strings_many_large_json(bench: &mut Bencher) {
         let input_json = input_json.to_object(py).into_bound(py);
         let input_str: String = input.extract().unwrap();
         let result = validator
-            .validate_json(py, &input_json, None, None, None, false)
+            .validate_json(py, &input_json, None, None, None, false.into())
             .unwrap();
         let result_str: String = result.extract(py).unwrap();
         assert_eq!(result_str, input_str);
@@ -806,7 +806,7 @@ fn literal_strings_many_large_json(bench: &mut Bencher) {
         bench.iter(|| {
             black_box(
                 validator
-                    .validate_json(py, &input_json, None, None, None, false)
+                    .validate_json(py, &input_json, None, None, None, false.into())
                     .unwrap(),
             )
         })
@@ -843,7 +843,7 @@ class Foo(Enum):
             let input = input.to_object(py).into_bound(py);
             let input_str: String = input.extract().unwrap();
             let result = validator
-                .validate_python(py, &input, None, None, None, None, false)
+                .validate_python(py, &input, None, None, None, None, false.into())
                 .unwrap();
             let result_str: String = result.extract(py).unwrap();
             assert_eq!(result_str, input_str);
@@ -852,7 +852,7 @@ class Foo(Enum):
             bench.iter(|| {
                 black_box(
                     validator
-                        .validate_python(py, &input, None, None, None, None, false)
+                        .validate_python(py, &input, None, None, None, None, false.into())
                         .unwrap(),
                 )
             })
@@ -864,7 +864,7 @@ class Foo(Enum):
             let input = input.to_object(py).into_bound(py);
             let input_int: i64 = input.extract().unwrap();
             let result = validator
-                .validate_python(py, &input, None, None, None, None, false)
+                .validate_python(py, &input, None, None, None, None, false.into())
                 .unwrap();
             let result_int: i64 = result.extract(py).unwrap();
             assert_eq!(result_int, input_int);
@@ -873,7 +873,7 @@ class Foo(Enum):
             bench.iter(|| {
                 black_box(
                     validator
-                        .validate_python(py, &input, None, None, None, None, false)
+                        .validate_python(py, &input, None, None, None, None, false.into())
                         .unwrap(),
                 )
             })
@@ -884,7 +884,7 @@ class Foo(Enum):
             let input = py.eval_bound("None", None, None).unwrap();
             let input = input.to_object(py).into_bound(py);
             let result = validator
-                .validate_python(py, &input, None, None, None, None, false)
+                .validate_python(py, &input, None, None, None, None, false.into())
                 .unwrap();
             assert!(input.eq(result).unwrap());
 
@@ -892,7 +892,7 @@ class Foo(Enum):
             bench.iter(|| {
                 black_box(
                     validator
-                        .validate_python(py, &input, None, None, None, None, false)
+                        .validate_python(py, &input, None, None, None, None, false.into())
                         .unwrap(),
                 )
             })
@@ -903,7 +903,7 @@ class Foo(Enum):
             let input = py.eval_bound("Foo.v4", Some(&globals), None).unwrap();
             let input = input.to_object(py).into_bound(py);
             let result = validator
-                .validate_python(py, &input, None, None, None, None, false)
+                .validate_python(py, &input, None, None, None, None, false.into())
                 .unwrap();
             assert!(input.eq(result).unwrap());
 
@@ -911,7 +911,7 @@ class Foo(Enum):
             bench.iter(|| {
                 black_box(
                     validator
-                        .validate_python(py, &input, None, None, None, None, false)
+                        .validate_python(py, &input, None, None, None, None, false.into())
                         .unwrap(),
                 )
             })
diff --git a/pyproject.toml b/pyproject.toml
index 9d8e5f046..99f0fce73 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -109,3 +109,6 @@ require_change_file = false
 [tool.pyright]
 include = ['pydantic_core', 'tests/test_typing.py']
 reportUnnecessaryTypeIgnoreComment = true
+
+[tool.inline-snapshot.shortcuts]
+fix = ["create", "fix"]
diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index 718db625d..f3103f28f 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -96,7 +96,7 @@ class SchemaValidator:
         from_attributes: bool | None = None,
         context: Any | None = None,
         self_instance: Any | None = None,
-        allow_partial: bool = False,
+        allow_partial: bool | Literal['off', 'on', 'trailing-strings'] = False,
     ) -> Any:
         """
         Validate a Python object against the schema and return the validated object.
@@ -113,6 +113,7 @@ class SchemaValidator:
                 validation from the `__init__` method of a model.
             allow_partial: Whether to allow partial validation; if `True` errors in the last element of sequences
                 and mappings are ignored.
+                `'trailing-strings'` means any final unfinished JSON string is included in the result.
 
         Raises:
             ValidationError: If validation fails.
@@ -146,7 +147,7 @@ class SchemaValidator:
         strict: bool | None = None,
         context: Any | None = None,
         self_instance: Any | None = None,
-        allow_partial: bool = False,
+        allow_partial: bool | Literal['off', 'on', 'trailing-strings'] = False,
     ) -> Any:
         """
         Validate JSON data directly against the schema and return the validated Python object.
@@ -166,6 +167,7 @@ class SchemaValidator:
             self_instance: An instance of a model set attributes on from validation.
             allow_partial: Whether to allow partial validation; if `True` incomplete JSON will be parsed successfully
                 and errors in the last element of sequences and mappings are ignored.
+                `'trailing-strings'` means any final unfinished JSON string is included in the result.
 
         Raises:
             ValidationError: If validation fails or if the JSON data is invalid.
@@ -180,7 +182,7 @@ class SchemaValidator:
         *,
         strict: bool | None = None,
         context: Any | None = None,
-        allow_partial: bool = False,
+        allow_partial: bool | Literal['off', 'on', 'trailing-strings'] = False,
     ) -> Any:
         """
         Validate a string against the schema and return the validated Python object.
@@ -196,6 +198,7 @@ class SchemaValidator:
                 [`info.context`][pydantic_core.core_schema.ValidationInfo.context].
             allow_partial: Whether to allow partial validation; if `True` errors in the last element of sequences
                 and mappings are ignored.
+                `'trailing-strings'` means any final unfinished JSON string is included in the result.
 
         Raises:
             ValidationError: If validation fails or if the JSON data is invalid.
@@ -433,6 +436,7 @@ def from_json(
             `all/True` means cache all strings, `keys` means cache only dict keys, `none/False` means no caching.
         allow_partial: Whether to allow partial deserialization, if `True` JSON data is returned if the end of the
             input is reached before the full object is deserialized, e.g. `["aa", "bb", "c` would return `['aa', 'bb']`.
+            `'trailing-strings'` means any final unfinished JSON string is included in the result.
 
     Raises:
         ValueError: If deserialization fails.
diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index d5e31b97b..c91a6e2fd 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -3,7 +3,7 @@ use std::cmp::Ordering;
 use std::ops::Rem;
 use std::str::FromStr;
 
-use jiter::{JsonArray, JsonValue, StringCacheMode};
+use jiter::{JsonArray, JsonValue, PartialMode, StringCacheMode};
 use num_bigint::BigInt;
 
 use pyo3::exceptions::PyTypeError;
@@ -128,9 +128,13 @@ pub(crate) fn validate_iter_to_vec<'py>(
 ) -> ValResult<Vec<PyObject>> {
     let mut output: Vec<PyObject> = Vec::with_capacity(capacity);
     let mut errors: Vec<ValLineError> = Vec::new();
+    let allow_partial = state.allow_partial;
 
     for (index, is_last_partial, item_result) in state.enumerate_last_partial(iter) {
-        state.allow_partial = is_last_partial;
+        state.allow_partial = match is_last_partial {
+            true => allow_partial,
+            false => PartialMode::Off,
+        };
         let item = item_result.map_err(|e| any_next_error!(py, e, max_length_check.input, index))?;
         match validator.validate(py, item.borrow_input(), state) {
             Ok(item) => {
@@ -202,8 +206,13 @@ pub(crate) fn validate_iter_to_set<'py>(
 ) -> ValResult<()> {
     let mut errors: Vec<ValLineError> = Vec::new();
 
+    let allow_partial = state.allow_partial;
+
     for (index, is_last_partial, item_result) in state.enumerate_last_partial(iter) {
-        state.allow_partial = is_last_partial;
+        state.allow_partial = match is_last_partial {
+            true => allow_partial,
+            false => PartialMode::Off,
+        };
         let item = item_result.map_err(|e| any_next_error!(py, e, input, index))?;
         match validator.validate(py, item.borrow_input(), state) {
             Ok(item) => {
diff --git a/src/url.rs b/src/url.rs
index 3ba2c8451..dda583af5 100644
--- a/src/url.rs
+++ b/src/url.rs
@@ -45,7 +45,7 @@ impl PyUrl {
     pub fn py_new(py: Python, url: &Bound<'_, PyAny>) -> PyResult<Self> {
         let schema_obj = SCHEMA_DEFINITION_URL
             .get_or_init(py, || build_schema_validator(py, "url"))
-            .validate_python(py, url, None, None, None, None, false)?;
+            .validate_python(py, url, None, None, None, None, false.into())?;
         schema_obj.extract(py)
     }
 
@@ -225,7 +225,7 @@ impl PyMultiHostUrl {
     pub fn py_new(py: Python, url: &Bound<'_, PyAny>) -> PyResult<Self> {
         let schema_obj = SCHEMA_DEFINITION_MULTI_HOST_URL
             .get_or_init(py, || build_schema_validator(py, "multi-host-url"))
-            .validate_python(py, url, None, None, None, None, false)?;
+            .validate_python(py, url, None, None, None, None, false.into())?;
         schema_obj.extract(py)
     }
 
diff --git a/src/validators/arguments.rs b/src/validators/arguments.rs
index 0d90af5d3..2ffd49102 100644
--- a/src/validators/arguments.rs
+++ b/src/validators/arguments.rs
@@ -11,7 +11,6 @@ use crate::build_tools::{schema_or_config_same, ExtraBehavior};
 use crate::errors::{ErrorTypeDefaults, ValError, ValLineError, ValResult};
 use crate::input::{Arguments, BorrowInput, Input, KeywordArgs, PositionalArgs, ValidationMatch};
 use crate::lookup_key::LookupKey;
-
 use crate::tools::SchemaDict;
 
 use super::validation_state::ValidationState;
@@ -189,7 +188,7 @@ impl Validator for ArgumentsValidator {
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         // this validator does not yet support partial validation, disable it to avoid incorrect results
-        state.allow_partial = false;
+        state.allow_partial = false.into();
 
         let args = input.validate_args()?;
 
diff --git a/src/validators/dataclass.rs b/src/validators/dataclass.rs
index 86211b7b2..b41de429f 100644
--- a/src/validators/dataclass.rs
+++ b/src/validators/dataclass.rs
@@ -146,7 +146,7 @@ impl Validator for DataclassArgsValidator {
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         // this validator does not yet support partial validation, disable it to avoid incorrect results
-        state.allow_partial = false;
+        state.allow_partial = false.into();
 
         let args = input.validate_dataclass_args(&self.dataclass_name)?;
 
diff --git a/src/validators/definitions.rs b/src/validators/definitions.rs
index 34d0edef4..e0511f7fe 100644
--- a/src/validators/definitions.rs
+++ b/src/validators/definitions.rs
@@ -76,7 +76,7 @@ impl Validator for DefinitionRefValidator {
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         // this validator does not yet support partial validation, disable it to avoid incorrect results
-        state.allow_partial = false;
+        state.allow_partial = false.into();
 
         self.definition.read(|validator| {
             let validator = validator.unwrap();
diff --git a/src/validators/dict.rs b/src/validators/dict.rs
index adfadc6fa..985fe95b6 100644
--- a/src/validators/dict.rs
+++ b/src/validators/dict.rs
@@ -109,9 +109,10 @@ where
     fn consume_iterator(self, iterator: impl Iterator<Item = ValResult<(Key, Value)>>) -> ValResult<PyObject> {
         let output = PyDict::new_bound(self.py);
         let mut errors: Vec<ValLineError> = Vec::new();
+        let allow_partial = self.state.allow_partial;
 
         for (_, is_last_partial, item_result) in self.state.enumerate_last_partial(iterator) {
-            self.state.allow_partial = false;
+            self.state.allow_partial = false.into();
             let (key, value) = item_result?;
             let output_key = match self.key_validator.validate(self.py, key.borrow_input(), self.state) {
                 Ok(value) => Some(value),
@@ -125,7 +126,10 @@ where
                 Err(ValError::Omit) => continue,
                 Err(err) => return Err(err),
             };
-            self.state.allow_partial = is_last_partial;
+            self.state.allow_partial = match is_last_partial {
+                true => allow_partial,
+                false => false.into(),
+            };
             let output_value = match self.value_validator.validate(self.py, value.borrow_input(), self.state) {
                 Ok(value) => value,
                 Err(ValError::LineErrors(line_errors)) => {
diff --git a/src/validators/generator.rs b/src/validators/generator.rs
index 12241f205..1e8d41c85 100644
--- a/src/validators/generator.rs
+++ b/src/validators/generator.rs
@@ -67,7 +67,7 @@ impl Validator for GeneratorValidator {
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         // this validator does not yet support partial validation, disable it to avoid incorrect results
-        state.allow_partial = false;
+        state.allow_partial = false.into();
 
         let iterator = input.validate_iter()?.into_static();
         let validator = self.item_validator.as_ref().map(|v| {
@@ -282,7 +282,7 @@ impl InternalValidator {
             self_instance: self.self_instance.as_ref().map(|data| data.bind(py)),
             cache_str: self.cache_str,
         };
-        let mut state = ValidationState::new(extra, &mut self.recursion_guard, false);
+        let mut state = ValidationState::new(extra, &mut self.recursion_guard, false.into());
         state.exactness = self.exactness;
         let result = self
             .validator
@@ -317,7 +317,7 @@ impl InternalValidator {
             self_instance: self.self_instance.as_ref().map(|data| data.bind(py)),
             cache_str: self.cache_str,
         };
-        let mut state = ValidationState::new(extra, &mut self.recursion_guard, false);
+        let mut state = ValidationState::new(extra, &mut self.recursion_guard, false.into());
         state.exactness = self.exactness;
         let result = self.validator.validate(py, input, &mut state).map_err(|e| {
             ValidationError::from_val_error(
diff --git a/src/validators/json.rs b/src/validators/json.rs
index 9ba13dca1..daad6fbff 100644
--- a/src/validators/json.rs
+++ b/src/validators/json.rs
@@ -2,7 +2,7 @@ use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
 
-use jiter::{FloatMode, JsonValue, PartialMode, PythonParse};
+use jiter::{FloatMode, JsonValue, PythonParse};
 
 use crate::errors::{ErrorType, ErrorTypeDefaults, ValError, ValLineError, ValResult};
 use crate::input::{EitherBytes, Input, InputType, ValidationMatch};
@@ -70,11 +70,7 @@ impl Validator for JsonValidator {
                 let parse_builder = PythonParse {
                     allow_inf_nan: true,
                     cache_mode: state.cache_str(),
-                    partial_mode: if state.allow_partial {
-                        PartialMode::TrailingStrings
-                    } else {
-                        PartialMode::Off
-                    },
+                    partial_mode: state.allow_partial,
                     catch_duplicate_keys: false,
                     float_mode: FloatMode::Float,
                 };
diff --git a/src/validators/mod.rs b/src/validators/mod.rs
index c0c58adcf..10a4d6e34 100644
--- a/src/validators/mod.rs
+++ b/src/validators/mod.rs
@@ -1,7 +1,7 @@
 use std::fmt::Debug;
 
 use enum_dispatch::enum_dispatch;
-use jiter::StringCacheMode;
+use jiter::{PartialMode, StringCacheMode};
 
 use pyo3::exceptions::PyTypeError;
 use pyo3::prelude::*;
@@ -165,7 +165,7 @@ impl SchemaValidator {
     }
 
     #[allow(clippy::too_many_arguments)]
-    #[pyo3(signature = (input, *, strict=None, from_attributes=None, context=None, self_instance=None, allow_partial=false))]
+    #[pyo3(signature = (input, *, strict=None, from_attributes=None, context=None, self_instance=None, allow_partial=PartialMode::Off))]
     pub fn validate_python(
         &self,
         py: Python,
@@ -174,7 +174,7 @@ impl SchemaValidator {
         from_attributes: Option<bool>,
         context: Option<&Bound<'_, PyAny>>,
         self_instance: Option<&Bound<'_, PyAny>>,
-        allow_partial: bool,
+        allow_partial: PartialMode,
     ) -> PyResult<PyObject> {
         self._validate(
             py,
@@ -207,7 +207,7 @@ impl SchemaValidator {
             from_attributes,
             context,
             self_instance,
-            false,
+            false.into(),
         ) {
             Ok(_) => Ok(true),
             Err(ValError::InternalErr(err)) => Err(err),
@@ -217,7 +217,7 @@ impl SchemaValidator {
         }
     }
 
-    #[pyo3(signature = (input, *, strict=None, context=None, self_instance=None, allow_partial=false))]
+    #[pyo3(signature = (input, *, strict=None, context=None, self_instance=None, allow_partial=PartialMode::Off))]
     pub fn validate_json(
         &self,
         py: Python,
@@ -225,7 +225,7 @@ impl SchemaValidator {
         strict: Option<bool>,
         context: Option<&Bound<'_, PyAny>>,
         self_instance: Option<&Bound<'_, PyAny>>,
-        allow_partial: bool,
+        allow_partial: PartialMode,
     ) -> PyResult<PyObject> {
         let r = match json::validate_json_bytes(input) {
             Ok(v_match) => self._validate_json(
@@ -242,14 +242,14 @@ impl SchemaValidator {
         r.map_err(|e| self.prepare_validation_err(py, e, InputType::Json))
     }
 
-    #[pyo3(signature = (input, *, strict=None, context=None, allow_partial=false))]
+    #[pyo3(signature = (input, *, strict=None, context=None, allow_partial=PartialMode::Off))]
     pub fn validate_strings(
         &self,
         py: Python,
         input: Bound<'_, PyAny>,
         strict: Option<bool>,
         context: Option<&Bound<'_, PyAny>>,
-        allow_partial: bool,
+        allow_partial: PartialMode,
     ) -> PyResult<PyObject> {
         let t = InputType::String;
         let string_mapping = StringMapping::new_value(input).map_err(|e| self.prepare_validation_err(py, e, t))?;
@@ -283,7 +283,7 @@ impl SchemaValidator {
         };
 
         let guard = &mut RecursionState::default();
-        let mut state = ValidationState::new(extra, guard, false);
+        let mut state = ValidationState::new(extra, guard, false.into());
         self.validator
             .validate_assignment(py, &obj, field_name, &field_value, &mut state)
             .map_err(|e| self.prepare_validation_err(py, e, InputType::Python))
@@ -306,7 +306,7 @@ impl SchemaValidator {
             cache_str: self.cache_str,
         };
         let recursion_guard = &mut RecursionState::default();
-        let mut state = ValidationState::new(extra, recursion_guard, false);
+        let mut state = ValidationState::new(extra, recursion_guard, false.into());
         let r = self.validator.default_value(py, None::<i64>, &mut state);
         match r {
             Ok(maybe_default) => match maybe_default {
@@ -352,7 +352,7 @@ impl SchemaValidator {
         from_attributes: Option<bool>,
         context: Option<&Bound<'py, PyAny>>,
         self_instance: Option<&Bound<'py, PyAny>>,
-        allow_partial: bool,
+        allow_partial: PartialMode,
     ) -> ValResult<PyObject> {
         let mut recursion_guard = RecursionState::default();
         let mut state = ValidationState::new(
@@ -379,7 +379,7 @@ impl SchemaValidator {
         strict: Option<bool>,
         context: Option<&Bound<'_, PyAny>>,
         self_instance: Option<&Bound<'_, PyAny>>,
-        allow_partial: bool,
+        allow_partial: PartialMode,
     ) -> ValResult<PyObject> {
         let json_value = jiter::JsonValue::parse_with_config(json_data, true, allow_partial)
             .map_err(|e| json::map_json_err(input, e, json_data))?;
@@ -430,7 +430,7 @@ impl<'py> SelfValidator<'py> {
         let mut state = ValidationState::new(
             Extra::new(strict, None, None, None, InputType::Python, true.into()),
             &mut recursion_guard,
-            false,
+            false.into(),
         );
         match self.validator.validator.validate(py, schema, &mut state) {
             Ok(schema_obj) => Ok(schema_obj.into_bound(py)),
diff --git a/src/validators/model_fields.rs b/src/validators/model_fields.rs
index 39f905d84..7aba7c8e3 100644
--- a/src/validators/model_fields.rs
+++ b/src/validators/model_fields.rs
@@ -121,7 +121,7 @@ impl Validator for ModelFieldsValidator {
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         // this validator does not yet support partial validation, disable it to avoid incorrect results
-        state.allow_partial = false;
+        state.allow_partial = false.into();
 
         let strict = state.strict_or(self.strict);
         let from_attributes = state.extra().from_attributes.unwrap_or(self.from_attributes);
diff --git a/src/validators/tuple.rs b/src/validators/tuple.rs
index 2b544d417..60e777e01 100644
--- a/src/validators/tuple.rs
+++ b/src/validators/tuple.rs
@@ -1,7 +1,8 @@
+use std::collections::VecDeque;
+
 use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList, PyTuple};
-use std::collections::VecDeque;
 
 use crate::build_tools::is_strict;
 use crate::errors::{py_err_string, ErrorType, ErrorTypeDefaults, ValError, ValLineError, ValResult};
@@ -273,7 +274,7 @@ impl Validator for TupleValidator {
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         // this validator does not yet support partial validation, disable it to avoid incorrect results
-        state.allow_partial = false;
+        state.allow_partial = false.into();
 
         let collection = input.validate_tuple(state.strict_or(self.strict))?.unpack(state);
         let actual_length = collection.len();
diff --git a/src/validators/typed_dict.rs b/src/validators/typed_dict.rs
index 949cff9a5..0c127b93b 100644
--- a/src/validators/typed_dict.rs
+++ b/src/validators/typed_dict.rs
@@ -2,8 +2,6 @@ use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyString};
 
-use ahash::AHashSet;
-
 use crate::build_tools::py_schema_err;
 use crate::build_tools::{is_strict, schema_or_config, schema_or_config_same, ExtraBehavior};
 use crate::errors::LocItem;
@@ -14,6 +12,8 @@ use crate::input::ValidationMatch;
 use crate::input::{Input, ValidatedDict};
 use crate::lookup_key::LookupKey;
 use crate::tools::SchemaDict;
+use ahash::AHashSet;
+use jiter::PartialMode;
 
 use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
 
@@ -153,11 +153,12 @@ impl Validator for TypedDictValidator {
         let output_dict = PyDict::new_bound(py);
         let mut errors: Vec<ValLineError> = Vec::with_capacity(self.fields.len());
 
-        let partial_last_key = if state.allow_partial {
+        let partial_last_key = if state.allow_partial.is_active() {
             dict.last_key().map(Into::into)
         } else {
             None
         };
+        let allow_partial = state.allow_partial;
 
         // we only care about which keys have been used if we're iterating over the object for extra after
         // the first pass
@@ -198,7 +199,10 @@ impl Validator for TypedDictValidator {
                     } else {
                         false
                     };
-                    state.allow_partial = is_last_partial;
+                    state.allow_partial = match is_last_partial {
+                        true => allow_partial,
+                        false => false.into(),
+                    };
                     match field.validator.validate(py, value.borrow_input(), state) {
                         Ok(value) => {
                             output_dict.set_item(&field.name_py, value)?;
@@ -260,6 +264,7 @@ impl Validator for TypedDictValidator {
                 state: &'a mut ValidationState<'s, 'py>,
                 extra_behavior: ExtraBehavior,
                 partial_last_key: Option<LocItem>,
+                allow_partial: PartialMode,
             }
 
             impl<'py, Key, Value> ConsumeIterator<ValResult<(Key, Value)>> for ValidateExtras<'_, '_, 'py>
@@ -311,7 +316,10 @@ impl Validator for TypedDictValidator {
                                         let key_loc: LocItem = raw_key.clone().into();
                                         &key_loc == last_key
                                     });
-                                    self.state.allow_partial = last_partial;
+                                    self.state.allow_partial = match last_partial {
+                                        true => self.allow_partial,
+                                        false => false.into(),
+                                    };
                                     match validator.validate(self.py, value, self.state) {
                                         Ok(value) => {
                                             self.output_dict.set_item(py_key, value)?;
@@ -345,6 +353,7 @@ impl Validator for TypedDictValidator {
                 state,
                 extra_behavior: self.extra_behavior,
                 partial_last_key,
+                allow_partial,
             })??;
         }
 
diff --git a/src/validators/validation_state.rs b/src/validators/validation_state.rs
index b21284a99..8ee41f5de 100644
--- a/src/validators/validation_state.rs
+++ b/src/validators/validation_state.rs
@@ -1,7 +1,7 @@
 use pyo3::prelude::*;
 use pyo3::types::PyString;
 
-use jiter::StringCacheMode;
+use jiter::{PartialMode, StringCacheMode};
 
 use crate::recursion_guard::{ContainsRecursionState, RecursionState};
 use crate::tools::new_py_string;
@@ -24,13 +24,13 @@ pub struct ValidationState<'a, 'py> {
     // when extra='allow', whereas this tally does not.
     pub fields_set_count: Option<usize>,
     // True if `allow_partial=true` and we're validating the last element of a sequence or mapping.
-    pub allow_partial: bool,
+    pub allow_partial: PartialMode,
     // deliberately make Extra readonly
     extra: Extra<'a, 'py>,
 }
 
 impl<'a, 'py> ValidationState<'a, 'py> {
-    pub fn new(extra: Extra<'a, 'py>, recursion_guard: &'a mut RecursionState, allow_partial: bool) -> Self {
+    pub fn new(extra: Extra<'a, 'py>, recursion_guard: &'a mut RecursionState, allow_partial: PartialMode) -> Self {
         Self {
             recursion_guard, // Don't care about exactness unless doing union validation
             exactness: None,
@@ -130,10 +130,10 @@ pub struct EnumerateLastPartial<I: Iterator> {
     iter: I,
     index: usize,
     next_item: Option<I::Item>,
-    allow_partial: bool,
+    allow_partial: PartialMode,
 }
 impl<I: Iterator> EnumerateLastPartial<I> {
-    pub fn new(mut iter: I, allow_partial: bool) -> Self {
+    pub fn new(mut iter: I, allow_partial: PartialMode) -> Self {
         let next_item = iter.next();
         Self {
             iter,
@@ -151,7 +151,7 @@ impl<I: Iterator> Iterator for EnumerateLastPartial<I> {
         let a = std::mem::replace(&mut self.next_item, self.iter.next())?;
         let i = self.index;
         self.index += 1;
-        Some((i, self.allow_partial && self.next_item.is_none(), a))
+        Some((i, self.allow_partial.is_active() && self.next_item.is_none(), a))
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
diff --git a/tests/test.rs b/tests/test.rs
index fb141d377..dbc7a21e7 100644
--- a/tests/test.rs
+++ b/tests/test.rs
@@ -129,7 +129,7 @@ json_input = '{"a": "something"}'
             let json_input = locals.get_item("json_input").unwrap().unwrap();
             let binding = SchemaValidator::py_new(py, &schema, None)
                 .unwrap()
-                .validate_json(py, &json_input, None, None, None, false)
+                .validate_json(py, &json_input, None, None, None, false.into())
                 .unwrap();
             let validation_result: Bound<'_, PyAny> = binding.extract(py).unwrap();
             let repr = format!("{}", validation_result.repr().unwrap());
diff --git a/tests/validators/test_allow_partial.py b/tests/validators/test_allow_partial.py
index e147ff62d..2cd5a2735 100644
--- a/tests/validators/test_allow_partial.py
+++ b/tests/validators/test_allow_partial.py
@@ -299,6 +299,11 @@ def test_nullable():
     assert v.validate_python(None, allow_partial=True) is None
     assert v.validate_python(['ab', 'cd'], allow_partial=True) == ['ab', 'cd']
     assert v.validate_python(['ab', 'c'], allow_partial=True) == ['ab']
+    assert v.validate_json('["ab", "cd"]', allow_partial=True) == ['ab', 'cd']
+    assert v.validate_json('["ab", "cd', allow_partial=True) == ['ab']
+    assert v.validate_json('["ab", "cd', allow_partial='trailing-strings') == ['ab', 'cd']
+    assert v.validate_json('["ab", "c', allow_partial=True) == ['ab']
+    assert v.validate_json('["ab", "c', allow_partial='trailing-strings') == ['ab']
 
 
 @pytest.mark.parametrize(
@@ -311,3 +316,23 @@ def test_json(json_nested_type):
     assert v.validate_python(['{"a": 1}', '{"b": 2}'], allow_partial=True) == snapshot([{'a': 1}, {'b': 2}])
     assert v.validate_python(['{"a": 1}', 'xxx'], allow_partial=True) == snapshot([{'a': 1}])
     assert v.validate_python(['{"a": 1}', '{"b": 2'], allow_partial=True) == snapshot([{'a': 1}, {'b': 2}])
+    assert v.validate_json('["{\\"a\\": 1}", "{\\"b\\": 2}', allow_partial='trailing-strings') == snapshot(
+        [{'a': 1}, {'b': 2}]
+    )
+    assert v.validate_json('["{\\"a\\": 1}", "{\\"b\\": 2', allow_partial='trailing-strings') == snapshot(
+        [{'a': 1}, {'b': 2}]
+    )
+
+
+def test_json_trailing_strings():
+    v = SchemaValidator(core_schema.list_schema(core_schema.json_schema()))
+    assert v.validate_python(['{"a": 1}', '{"b": "x'], allow_partial=True) == snapshot([{'a': 1}, {}])
+    assert v.validate_python(['{"a": 1}', '{"b": "x'], allow_partial='trailing-strings') == snapshot(
+        [{'a': 1}, {'b': 'x'}]
+    )
+
+    assert v.validate_json('["{\\"a\\": 1}", "{\\"b\\": 2}"]') == snapshot([{'a': 1}, {'b': 2}])
+    assert v.validate_json('["{\\"a\\": 1}", "{\\"b\\": 2, \\"c\\": \\"x', allow_partial=True) == snapshot([{'a': 1}])
+    assert v.validate_json(
+        '["{\\"a\\": 1}", "{\\"b\\": 2, \\"c\\": \\"x', allow_partial='trailing-strings'
+    ) == snapshot([{'a': 1}, {'b': 2, 'c': 'x'}])

From 061711f962b855890763b7bf1149cffceff89805 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Tue, 12 Nov 2024 12:53:13 -0500
Subject: [PATCH 426/550] Prep for v2.27.0 release (#1541)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index b34342509..05b27a3ed 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -425,7 +425,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.26.0"
+version = "2.27.0"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index d68bd2701..25dbe6932 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.26.0"
+version = "2.27.0"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From 6472887b3ad3e865e494b46efb66a71e87ceb1cf Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Wed, 13 Nov 2024 11:00:12 -0500
Subject: [PATCH 427/550] WIP: Simplify shared union serializer logic (#1538)

Co-authored-by: David Hewitt <mail@davidhewitt.dev>
---
 src/serializers/type_serializers/union.rs | 261 +++++++---------------
 1 file changed, 84 insertions(+), 177 deletions(-)

diff --git a/src/serializers/type_serializers/union.rs b/src/serializers/type_serializers/union.rs
index 35a5c8bc7..40a72e9dd 100644
--- a/src/serializers/type_serializers/union.rs
+++ b/src/serializers/type_serializers/union.rs
@@ -8,8 +8,8 @@ use std::borrow::Cow;
 use crate::build_tools::py_schema_err;
 use crate::common::union::{Discriminator, SMALL_UNION_THRESHOLD};
 use crate::definitions::DefinitionsBuilder;
+use crate::serializers::PydanticSerializationUnexpectedValue;
 use crate::tools::{truncate_safe_repr, SchemaDict};
-use crate::PydanticSerializationUnexpectedValue;
 
 use super::{
     infer_json_key, infer_serialize, infer_to_python, BuildSerializer, CombinedSerializer, Extra, SerCheck,
@@ -70,22 +70,23 @@ impl UnionSerializer {
 
 impl_py_gc_traverse!(UnionSerializer { choices });
 
-fn to_python(
-    value: &Bound<'_, PyAny>,
-    include: Option<&Bound<'_, PyAny>>,
-    exclude: Option<&Bound<'_, PyAny>>,
+fn union_serialize<S>(
+    // if this returns `Ok(Some(v))`, we picked a union variant to serialize,
+    // Or `Ok(None)` if we couldn't find a suitable variant to serialize
+    // Finally, `Err(err)` if we encountered errors while trying to serialize
+    mut selector: impl FnMut(&CombinedSerializer, &Extra) -> PyResult<S>,
     extra: &Extra,
     choices: &[CombinedSerializer],
     retry_with_lax_check: bool,
-) -> PyResult<PyObject> {
+) -> PyResult<Option<S>> {
     // try the serializers in left to right order with error_on fallback=true
     let mut new_extra = extra.clone();
     new_extra.check = SerCheck::Strict;
     let mut errors: SmallVec<[PyErr; SMALL_UNION_THRESHOLD]> = SmallVec::new();
 
     for comb_serializer in choices {
-        match comb_serializer.to_python(value, include, exclude, &new_extra) {
-            Ok(v) => return Ok(v),
+        match selector(comb_serializer, &new_extra) {
+            Ok(v) => return Ok(Some(v)),
             Err(err) => errors.push(err),
         }
     }
@@ -94,8 +95,8 @@ fn to_python(
     if extra.check != SerCheck::Strict && retry_with_lax_check {
         new_extra.check = SerCheck::Lax;
         for comb_serializer in choices {
-            if let Ok(v) = comb_serializer.to_python(value, include, exclude, &new_extra) {
-                return Ok(v);
+            if let Ok(v) = selector(comb_serializer, &new_extra) {
+                return Ok(Some(v));
             }
         }
     }
@@ -113,94 +114,45 @@ fn to_python(
         return Err(PydanticSerializationUnexpectedValue::new_err(Some(message)));
     }
 
-    infer_to_python(value, include, exclude, extra)
+    Ok(None)
 }
 
-fn json_key<'a>(
-    key: &'a Bound<'_, PyAny>,
+fn tagged_union_serialize<S>(
+    discriminator_value: Option<Py<PyAny>>,
+    lookup: &HashMap<String, usize>,
+    // if this returns `Ok(v)`, we picked a union variant to serialize, where
+    // `S` is intermediate state which can be passed on to the finalizer
+    mut selector: impl FnMut(&CombinedSerializer, &Extra) -> PyResult<S>,
     extra: &Extra,
     choices: &[CombinedSerializer],
     retry_with_lax_check: bool,
-) -> PyResult<Cow<'a, str>> {
+) -> PyResult<Option<S>> {
     let mut new_extra = extra.clone();
     new_extra.check = SerCheck::Strict;
-    let mut errors: SmallVec<[PyErr; SMALL_UNION_THRESHOLD]> = SmallVec::new();
-
-    for comb_serializer in choices {
-        match comb_serializer.json_key(key, &new_extra) {
-            Ok(v) => return Ok(v),
-            Err(err) => errors.push(err),
-        }
-    }
 
-    // If extra.check is SerCheck::Strict, we're in a nested union
-    if extra.check != SerCheck::Strict && retry_with_lax_check {
-        new_extra.check = SerCheck::Lax;
-        for comb_serializer in choices {
-            if let Ok(v) = comb_serializer.json_key(key, &new_extra) {
-                return Ok(v);
-            }
-        }
-    }
-
-    // If extra.check is SerCheck::None, we're in a top-level union. We should thus raise the warnings
-    if extra.check == SerCheck::None {
-        for err in &errors {
-            extra.warnings.custom_warning(err.to_string());
-        }
-    }
-    // Otherwise, if we've encountered errors, return them to the parent union, which should take
-    // care of the formatting for us
-    else if !errors.is_empty() {
-        let message = errors.iter().map(ToString::to_string).collect::<Vec<_>>().join("\n");
-        return Err(PydanticSerializationUnexpectedValue::new_err(Some(message)));
-    }
-    infer_json_key(key, extra)
-}
-
-#[allow(clippy::too_many_arguments)]
-fn serde_serialize<S: serde::ser::Serializer>(
-    value: &Bound<'_, PyAny>,
-    serializer: S,
-    include: Option<&Bound<'_, PyAny>>,
-    exclude: Option<&Bound<'_, PyAny>>,
-    extra: &Extra,
-    choices: &[CombinedSerializer],
-    retry_with_lax_check: bool,
-) -> Result<S::Ok, S::Error> {
-    let py = value.py();
-    let mut new_extra = extra.clone();
-    new_extra.check = SerCheck::Strict;
-    let mut errors: SmallVec<[PyErr; SMALL_UNION_THRESHOLD]> = SmallVec::new();
-
-    for comb_serializer in choices {
-        match comb_serializer.to_python(value, include, exclude, &new_extra) {
-            Ok(v) => return infer_serialize(v.bind(py), serializer, None, None, extra),
-            Err(err) => errors.push(err),
-        }
-    }
-
-    // If extra.check is SerCheck::Strict, we're in a nested union
-    if extra.check != SerCheck::Strict && retry_with_lax_check {
-        new_extra.check = SerCheck::Lax;
-        for comb_serializer in choices {
-            if let Ok(v) = comb_serializer.to_python(value, include, exclude, &new_extra) {
-                return infer_serialize(v.bind(py), serializer, None, None, extra);
+    if let Some(tag) = discriminator_value {
+        let tag_str = tag.to_string();
+        if let Some(&serializer_index) = lookup.get(&tag_str) {
+            let selected_serializer = &choices[serializer_index];
+
+            match selector(selected_serializer, &new_extra) {
+                Ok(v) => return Ok(Some(v)),
+                Err(_) => {
+                    if retry_with_lax_check {
+                        new_extra.check = SerCheck::Lax;
+                        if let Ok(v) = selector(selected_serializer, &new_extra) {
+                            return Ok(Some(v));
+                        }
+                    }
+                }
             }
         }
     }
 
-    // If extra.check is SerCheck::None, we're in a top-level union. We should thus raise the warnings
-    if extra.check == SerCheck::None {
-        for err in &errors {
-            extra.warnings.custom_warning(err.to_string());
-        }
-    } else {
-        // NOTE: if this function becomes recursive at some point, an `Err(_)` containing the errors
-        // will have to be returned here
-    }
-
-    infer_serialize(value, serializer, include, exclude, extra)
+    // if we haven't returned at this point, we should fallback to the union serializer
+    // which preserves the historical expectation that we do our best with serialization
+    // even if that means we resort to inference
+    union_serialize(selector, extra, choices, retry_with_lax_check)
 }
 
 impl TypeSerializer for UnionSerializer {
@@ -211,18 +163,23 @@ impl TypeSerializer for UnionSerializer {
         exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
-        to_python(
-            value,
-            include,
-            exclude,
+        union_serialize(
+            |comb_serializer, new_extra| comb_serializer.to_python(value, include, exclude, new_extra),
             extra,
             &self.choices,
             self.retry_with_lax_check(),
-        )
+        )?
+        .map_or_else(|| infer_to_python(value, include, exclude, extra), Ok)
     }
 
     fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
-        json_key(key, extra, &self.choices, self.retry_with_lax_check())
+        union_serialize(
+            |comb_serializer, new_extra| comb_serializer.json_key(key, new_extra),
+            extra,
+            &self.choices,
+            self.retry_with_lax_check(),
+        )?
+        .map_or_else(|| infer_json_key(key, extra), Ok)
     }
 
     fn serde_serialize<S: serde::ser::Serializer>(
@@ -233,15 +190,16 @@ impl TypeSerializer for UnionSerializer {
         exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
-        serde_serialize(
-            value,
-            serializer,
-            include,
-            exclude,
+        match union_serialize(
+            |comb_serializer, new_extra| comb_serializer.to_python(value, include, exclude, new_extra),
             extra,
             &self.choices,
             self.retry_with_lax_check(),
-        )
+        ) {
+            Ok(Some(v)) => return infer_serialize(v.bind(value.py()), serializer, None, None, extra),
+            Ok(None) => infer_serialize(value, serializer, include, exclude, extra),
+            Err(err) => Err(serde::ser::Error::custom(err.to_string())),
+        }
     }
 
     fn get_name(&self) -> &str {
@@ -309,62 +267,29 @@ impl TypeSerializer for TaggedUnionSerializer {
         exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
-        let mut new_extra = extra.clone();
-        new_extra.check = SerCheck::Strict;
-
-        if let Some(tag) = self.get_discriminator_value(value, extra) {
-            let tag_str = tag.to_string();
-            if let Some(&serializer_index) = self.lookup.get(&tag_str) {
-                let serializer = &self.choices[serializer_index];
-
-                match serializer.to_python(value, include, exclude, &new_extra) {
-                    Ok(v) => return Ok(v),
-                    Err(_) => {
-                        if self.retry_with_lax_check() {
-                            new_extra.check = SerCheck::Lax;
-                            if let Ok(v) = serializer.to_python(value, include, exclude, &new_extra) {
-                                return Ok(v);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        to_python(
-            value,
-            include,
-            exclude,
+        tagged_union_serialize(
+            self.get_discriminator_value(value, extra),
+            &self.lookup,
+            |comb_serializer: &CombinedSerializer, new_extra: &Extra| {
+                comb_serializer.to_python(value, include, exclude, new_extra)
+            },
             extra,
             &self.choices,
             self.retry_with_lax_check(),
-        )
+        )?
+        .map_or_else(|| infer_to_python(value, include, exclude, extra), Ok)
     }
 
     fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
-        let mut new_extra = extra.clone();
-        new_extra.check = SerCheck::Strict;
-
-        if let Some(tag) = self.get_discriminator_value(key, extra) {
-            let tag_str = tag.to_string();
-            if let Some(&serializer_index) = self.lookup.get(&tag_str) {
-                let serializer = &self.choices[serializer_index];
-
-                match serializer.json_key(key, &new_extra) {
-                    Ok(v) => return Ok(v),
-                    Err(_) => {
-                        if self.retry_with_lax_check() {
-                            new_extra.check = SerCheck::Lax;
-                            if let Ok(v) = serializer.json_key(key, &new_extra) {
-                                return Ok(v);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        json_key(key, extra, &self.choices, self.retry_with_lax_check())
+        tagged_union_serialize(
+            self.get_discriminator_value(key, extra),
+            &self.lookup,
+            |comb_serializer: &CombinedSerializer, new_extra: &Extra| comb_serializer.json_key(key, new_extra),
+            extra,
+            &self.choices,
+            self.retry_with_lax_check(),
+        )?
+        .map_or_else(|| infer_json_key(key, extra), Ok)
     }
 
     fn serde_serialize<S: serde::ser::Serializer>(
@@ -375,38 +300,20 @@ impl TypeSerializer for TaggedUnionSerializer {
         exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
-        let py = value.py();
-        let mut new_extra = extra.clone();
-        new_extra.check = SerCheck::Strict;
-
-        if let Some(tag) = self.get_discriminator_value(value, extra) {
-            let tag_str = tag.to_string();
-            if let Some(&serializer_index) = self.lookup.get(&tag_str) {
-                let selected_serializer = &self.choices[serializer_index];
-
-                match selected_serializer.to_python(value, include, exclude, &new_extra) {
-                    Ok(v) => return infer_serialize(v.bind(py), serializer, None, None, extra),
-                    Err(_) => {
-                        if self.retry_with_lax_check() {
-                            new_extra.check = SerCheck::Lax;
-                            if let Ok(v) = selected_serializer.to_python(value, include, exclude, &new_extra) {
-                                return infer_serialize(v.bind(py), serializer, None, None, extra);
-                            }
-                        }
-                    }
-                }
-            }
-        }
-
-        serde_serialize(
-            value,
-            serializer,
-            include,
-            exclude,
+        match tagged_union_serialize(
+            None,
+            &self.lookup,
+            |comb_serializer: &CombinedSerializer, new_extra: &Extra| {
+                comb_serializer.to_python(value, include, exclude, new_extra)
+            },
             extra,
             &self.choices,
             self.retry_with_lax_check(),
-        )
+        ) {
+            Ok(Some(v)) => return infer_serialize(v.bind(value.py()), serializer, None, None, extra),
+            Ok(None) => infer_serialize(value, serializer, include, exclude, extra),
+            Err(err) => Err(serde::ser::Error::custom(err.to_string())),
+        }
     }
 
     fn get_name(&self) -> &str {

From 30f6f55e4e55a741f93a431bdcd3ee7d90fd7dd7 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Tue, 19 Nov 2024 14:52:57 +0000
Subject: [PATCH 428/550] tidy up some uses of `Bound<'_, PyString>::to_str`
 (#1544)

---
 src/serializers/infer.rs                   | 11 +++--------
 src/serializers/type_serializers/format.rs |  5 ++---
 2 files changed, 5 insertions(+), 11 deletions(-)

diff --git a/src/serializers/infer.rs b/src/serializers/infer.rs
index d358682ff..bdfa74b52 100644
--- a/src/serializers/infer.rs
+++ b/src/serializers/infer.rs
@@ -131,7 +131,7 @@ pub(crate) fn infer_to_python_known(
                 v.into_py(py)
             }
             ObType::Decimal => value.to_string().into_py(py),
-            ObType::StrSubclass => value.downcast::<PyString>()?.to_str()?.into_py(py),
+            ObType::StrSubclass => PyString::new_bound(py, value.downcast::<PyString>()?.to_str()?).into(),
             ObType::Bytes => extra
                 .config
                 .bytes_mode
@@ -609,16 +609,11 @@ pub(crate) fn infer_json_key_known<'a>(
         }
         ObType::Decimal => Ok(Cow::Owned(key.to_string())),
         ObType::Bool => super::type_serializers::simple::bool_json_key(key),
-        ObType::Str | ObType::StrSubclass => {
-            let py_str = key.downcast::<PyString>()?;
-            Ok(Cow::Owned(py_str.to_str()?.to_string()))
-        }
+        ObType::Str | ObType::StrSubclass => key.downcast::<PyString>()?.to_cow(),
         ObType::Bytes => extra
             .config
             .bytes_mode
-            .bytes_to_string(key.py(), key.downcast::<PyBytes>()?.as_bytes())
-            // FIXME it would be nice to have a "PyCow" which carries ownership of the Python type too
-            .map(|s| Cow::Owned(s.into_owned())),
+            .bytes_to_string(key.py(), key.downcast::<PyBytes>()?.as_bytes()),
         ObType::Bytearray => {
             let py_byte_array = key.downcast::<PyByteArray>()?;
             // Safety: the GIL is held while serialize_bytes is running; it doesn't run
diff --git a/src/serializers/type_serializers/format.rs b/src/serializers/type_serializers/format.rs
index cf785c1cc..eefd3736a 100644
--- a/src/serializers/type_serializers/format.rs
+++ b/src/serializers/type_serializers/format.rs
@@ -70,8 +70,7 @@ impl BuildSerializer for FormatSerializer {
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
         let formatting_string: Bound<'_, PyString> = schema.get_as_req(intern!(py, "formatting_string"))?;
-        let formatting_string = formatting_string.to_str()?;
-        if formatting_string.is_empty() {
+        if formatting_string.is_empty()? {
             ToStringSerializer::build(schema, config, definitions)
         } else {
             Ok(Self {
@@ -79,7 +78,7 @@ impl BuildSerializer for FormatSerializer {
                     .import_bound(intern!(py, "builtins"))?
                     .getattr(intern!(py, "format"))?
                     .into_py(py),
-                formatting_string: PyString::new_bound(py, formatting_string).into(),
+                formatting_string: formatting_string.unbind(),
                 when_used: WhenUsed::new(schema, WhenUsed::JsonUnlessNone)?,
             }
             .into())

From c9d01c3ba541ac38f69a025de655e9e5f12f2577 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Tue, 19 Nov 2024 10:27:38 -0500
Subject: [PATCH 429/550] Use `uv` for `pydantic` install (#1545)

---
 .github/workflows/ci.yml | 22 ++++++++++------------
 .gitignore               |  1 -
 2 files changed, 10 insertions(+), 13 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 1338b812d..fb267e378 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -219,31 +219,29 @@ jobs:
         with:
           path: pydantic-core
 
-      - name: set up python
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.13'
-
       - name: install rust stable
         uses: dtolnay/rust-toolchain@stable
 
       - name: cache rust
         uses: Swatinem/rust-cache@v2
 
+      - name: install uv
+        uses: astral-sh/setup-uv@v3
+        with:
+          enable-cache: true
+
       - name: install deps
         run: |
-          pip install pdm maturin
-          pdm venv create --with-pip
-          pdm install -G testing -G email
-          pdm run pip install maturin
-          pdm run bash -c 'cd ../pydantic-core && make build-dev'
+          uv sync --python 3.13 --extra timezone
+          uv pip install maturin pip
+          uv run bash -c 'cd ../pydantic-core && make build-dev'
         working-directory: pydantic
 
-      - run: pdm info && pdm list
+      - run: uv --version && uv pip list
         working-directory: pydantic
         # Run pytest with lax xfail because we often add tests to pydantic
         # which xfail on a pending release of pydantic-core
-      - run: pdm run pytest --override-ini=xfail_strict=False
+      - run: uv run pytest --override-ini=xfail_strict=False
         working-directory: pydantic
         env:
           PYDANTIC_PRIVATE_ALLOW_UNHANDLED_SCHEMA_TYPES: 1
diff --git a/.gitignore b/.gitignore
index efffcbf69..103281879 100644
--- a/.gitignore
+++ b/.gitignore
@@ -29,7 +29,6 @@ node_modules/
 /worktree/
 
 /.editorconfig
-/.pdm-python
 /*.lcov
 /*.profdata
 /*.profraw

From 1e5e89905b6f2c71b7941fdceeeeff9938754a90 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Thu, 21 Nov 2024 09:19:42 -0500
Subject: [PATCH 430/550] Use `uv` in `Makefile` and CI (#1546)

Co-authored-by: David Hewitt <mail@davidhewitt.dev>
---
 .github/workflows/ci.yml                    | 190 +++--
 .github/workflows/codspeed.yml              |  36 +-
 Makefile                                    |  64 +-
 pyproject.toml                              |  48 +-
 python/pydantic_core/core_schema.py         |   6 +-
 tests/benchmarks/complete_schema.py         |   2 +-
 tests/benchmarks/test_complete_benchmark.py |   2 +-
 tests/requirements-linting.txt              |   4 -
 tests/requirements.txt                      |  21 -
 uv.lock                                     | 867 ++++++++++++++++++++
 10 files changed, 1071 insertions(+), 169 deletions(-)
 delete mode 100644 tests/requirements-linting.txt
 delete mode 100644 tests/requirements.txt
 create mode 100644 uv.lock

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index fb267e378..3f7e38a43 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -10,6 +10,7 @@ on:
 
 env:
   COLUMNS: 150
+  UV_PYTHON: 3.13
 
 jobs:
   coverage:
@@ -30,26 +31,27 @@ jobs:
 
       - run: rustup component add llvm-tools-preview
 
-      - name: set up python
-        uses: actions/setup-python@v5
+      - name: install uv
+        uses: astral-sh/setup-uv@v3
         with:
-          python-version: '3.13'
+          enable-cache: true
 
-      - run: pip install -r tests/requirements.txt
+      - name: install deps
+        run: uv sync --group testing
 
       - run: rustc --version --verbose
 
-      - run: pip install -e .
+      - run: make build-dev
         env:
           RUST_BACKTRACE: 1
           RUSTFLAGS: '-C instrument-coverage'
 
-      - run: pip freeze
+      - run: uv pip freeze
 
-      - run: coverage run -m pytest
+      - run: uv run coverage run -m pytest
 
       - run: ls -lha
-      - run: coverage xml
+      - run: uv run coverage xml
 
       - run: coverage-prepare lcov python/pydantic_core/*.so
 
@@ -85,24 +87,27 @@ jobs:
         with:
           key: test-v3
 
-      - name: set up python
-        uses: actions/setup-python@v5
+      - name: install uv
+        uses: astral-sh/setup-uv@v3
         with:
-          python-version: ${{ matrix.python-version }}
-          allow-prereleases: true
+          enable-cache: true
 
-      - run: pip install -r tests/requirements.txt
+      - name: install deps
+        run: uv sync --group testing
 
-      - run: pip install -e .
+      - run: uv pip install -e .
         env:
           RUST_BACKTRACE: 1
 
-      - run: pip freeze
+      - run: uv pip freeze
 
-      - run: pytest
+      - run: uv run pytest
         env:
           HYPOTHESIS_PROFILE: slow
 
+    env:
+      UV_PYTHON: ${{ matrix.python-version }}
+
   test-os:
     name: test on ${{ matrix.os }}
 
@@ -121,20 +126,21 @@ jobs:
       - name: cache rust
         uses: Swatinem/rust-cache@v2
 
-      - name: set up python
-        uses: actions/setup-python@v5
+      - name: install uv
+        uses: astral-sh/setup-uv@v3
         with:
-          python-version: '3.13'
+          enable-cache: true
 
-      - run: pip install -r tests/requirements.txt
+      - name: install deps
+        run: uv sync --group testing
 
-      - run: pip install -e .
+      - run: uv pip install -e .
         env:
           RUST_BACKTRACE: 1
 
-      - run: pip freeze
+      - run: uv pip freeze
 
-      - run: pytest
+      - run: uv run pytest
 
       - run: cargo test
 
@@ -145,14 +151,17 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - name: set up python
-        uses: actions/setup-python@v5
+      - name: install uv
+        uses: astral-sh/setup-uv@v3
         with:
-          python-version: '3.13'
+          enable-cache: true
+
+      - name: install deps
+        run: uv sync --group testing
 
       - name: resolve MSRV
         id: resolve-msrv
-        run: echo MSRV=`python -c 'import tomllib; print(tomllib.load(open("Cargo.toml", "rb"))["package"]["rust-version"])'` >> $GITHUB_OUTPUT
+        run: echo MSRV=`uv run python -c 'import tomllib; print(tomllib.load(open("Cargo.toml", "rb"))["package"]["rust-version"])'` >> $GITHUB_OUTPUT
 
       - name: install rust MSRV
         uses: dtolnay/rust-toolchain@master
@@ -162,15 +171,13 @@ jobs:
       - name: cache rust
         uses: Swatinem/rust-cache@v2
 
-      - run: pip install -r tests/requirements.txt
-
-      - run: pip install -e .
+      - run: uv pip install -e .
         env:
           RUST_BACKTRACE: 1
 
-      - run: pip freeze
+      - run: uv pip freeze
 
-      - run: pytest
+      - run: uv run pytest
 
       - run: cargo test
 
@@ -188,10 +195,11 @@ jobs:
 
     steps:
       - uses: actions/checkout@v4
-      - name: set up python
-        uses: actions/setup-python@v5
+
+      - name: install uv
+        uses: astral-sh/setup-uv@v3
         with:
-          python-version: ${{ matrix.python-version }}
+          enable-cache: true
 
       - name: install rust stable
         uses: dtolnay/rust-toolchain@stable
@@ -199,11 +207,16 @@ jobs:
       - name: cache rust
         uses: Swatinem/rust-cache@v2
 
-      - run: pip install -r tests/requirements.txt
+      - name: install deps
+        run: uv sync --group testing
+
       - run: make build-dev
 
-      - run: pip freeze
-      - run: pytest
+      - run: uv pip freeze
+      - run: uv run pytest
+
+    env:
+      UV_PYTHON: ${{ matrix.python-version }}
 
   test-pydantic-integration:
     runs-on: ubuntu-latest
@@ -232,20 +245,24 @@ jobs:
 
       - name: install deps
         run: |
-          uv sync --python 3.13 --extra timezone
+          uv sync --extra timezone
           uv pip install maturin pip
-          uv run bash -c 'cd ../pydantic-core && make build-dev'
+          uv run bash -c 'cd ../pydantic-core && maturin develop'
         working-directory: pydantic
 
       - run: uv --version && uv pip list
         working-directory: pydantic
-        # Run pytest with lax xfail because we often add tests to pydantic
-        # which xfail on a pending release of pydantic-core
+
+      # Run pytest with lax xfail because we often add tests to pydantic
+      # which xfail on a pending release of pydantic-core
       - run: uv run pytest --override-ini=xfail_strict=False
         working-directory: pydantic
         env:
           PYDANTIC_PRIVATE_ALLOW_UNHANDLED_SCHEMA_TYPES: 1
 
+    env:
+      UV_PROJECT_ENVIRONMENT: ${{ github.workspace }}/.venv
+
   lint:
     runs-on: ubuntu-latest
 
@@ -260,32 +277,21 @@ jobs:
       - name: cache rust
         uses: Swatinem/rust-cache@v2
 
-      - uses: actions/setup-python@v5
-        with:
-          python-version: '3.13'
-
       # used to lint js code
       - uses: actions/setup-node@v4
         with:
           node-version: '18'
 
-      - uses: actions/cache@v4
-        id: cache-py
-        name: cache python
+      - name: install uv
+        uses: astral-sh/setup-uv@v3
         with:
-          path: ${{ env.pythonLocation }}
-          key: >
-            py
-            ${{ env.pythonLocation }}
-            ${{ hashFiles('tests/requirements-linting.txt') }}
-            ${{ hashFiles('pyproject.toml') }}
-
-      - run: pip install -r tests/requirements-linting.txt
-        if: steps.cache-py.outputs.cache-hit != 'true'
-
-      - run: make build-dev
+          enable-cache: true
 
-      - run: pip freeze
+      - name: install deps
+        run: |
+          uv sync --group linting
+          make build-dev
+          uv pip freeze
 
       - run: make lint
       - run: make pyright
@@ -319,12 +325,6 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - name: set up python
-        id: setup-python
-        uses: actions/setup-python@v5
-        with:
-          python-version: '3.13'
-
       - name: install rust nightly
         uses: dtolnay/rust-toolchain@nightly
         with:
@@ -342,7 +342,13 @@ jobs:
           version: '3.1.58'
           actions-cache-folder: emsdk-cache
 
-      - run: pip install 'maturin>=1,<2' 'ruff==0.5.0' typing_extensions
+      - name: install uv
+        uses: astral-sh/setup-uv@v3
+        with:
+          enable-cache: true
+
+      - name: install deps
+        run: uv sync --group wasm
 
       - name: build wheels
         run: make build-wasm
@@ -364,6 +370,9 @@ jobs:
           name: wasm_wheels
           path: dist
 
+    env:
+      UV_PYTHON: 3.12
+
   # https://github.com/marketplace/actions/alls-green#why used for branch protection checks
   check:
     if: always()
@@ -533,11 +542,10 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - name: set up python
-        uses: actions/setup-python@v5
+      - name: install uv
+        uses: astral-sh/setup-uv@v3
         with:
-          python-version: ${{ matrix.interpreter }}
-          allow-prereleases: true
+          enable-cache: true
 
       - name: install rust stable
         id: rust-toolchain
@@ -572,10 +580,9 @@ jobs:
 
       - name: generate pgo data
         run: |
-          pip install -U pip
-          pip install -r tests/requirements.txt
-          pip install pydantic-core --no-index --no-deps --find-links pgo-wheel --force-reinstall
-          pytest tests/benchmarks
+          uv sync --group testing
+          uv pip install pydantic-core --no-index --no-deps --find-links pgo-wheel --force-reinstall
+          uv run pytest tests/benchmarks
           rustup run ${{ steps.rust-toolchain.outputs.name }} bash -c 'echo LLVM_PROFDATA=$RUSTUP_HOME/toolchains/$RUSTUP_TOOLCHAIN/lib/rustlib/${{ env.RUST_HOST }}/bin/llvm-profdata >> "$GITHUB_ENV"'
 
       - name: merge pgo data
@@ -601,6 +608,9 @@ jobs:
           name: pypi_files_${{ matrix.os }}_${{ matrix.interpreter }}
           path: dist
 
+    env:
+      UV_PYTHON: ${{ matrix.interpreter }}
+
   inspect-pypi-assets:
     needs: [build, build-sdist, build-pgo]
     runs-on: ubuntu-latest
@@ -667,20 +677,20 @@ jobs:
             if command -v apt-get &> /dev/null; then
               echo "installing python & pip with apt-get..."
               apt-get update
-              apt-get install -y --no-install-recommends python3 python3-pip python3-venv git
+              apt-get install -y --no-install-recommends python3 python3-pip python3-venv git curl
             else
               echo "installing python & pip with apk..."
               apk update
-              apk add python3 py3-pip git
+              apk add python3 py3-pip git curl
             fi
           run: |
             set -x
-            python3 -m venv venv
-            source venv/bin/activate
-            python3 -m pip install -r tests/requirements.txt
-            python3 -m pip install pydantic-core --no-index --no-deps --find-links dist --force-reinstall
-            python3 -m pytest --ignore=tests/test_docstrings.py
-            python3 -c 'import pydantic_core._pydantic_core; print(pydantic_core._pydantic_core.__version__)'
+            curl -LsSf https://astral.sh/uv/install.sh | sh
+            source $HOME/.local/bin/env
+            uv sync --frozen --group testing --no-install-project
+            uv pip install pydantic-core --no-index --no-deps --find-links dist --force-reinstall
+            uv run --no-sync pytest --ignore=tests/test_docstrings.py
+            uv run --no-sync python -c 'import pydantic_core._pydantic_core; print(pydantic_core._pydantic_core.__version__)'
 
   test-builds-os:
     name: test build on ${{ matrix.os }}
@@ -695,10 +705,10 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
-      - name: set up python
-        uses: actions/setup-python@v5
+      - name: install uv
+        uses: astral-sh/setup-uv@v3
         with:
-          python-version: '3.13'
+          enable-cache: true
 
       - name: get dist artifacts
         uses: actions/download-artifact@v4
@@ -707,9 +717,9 @@ jobs:
           merge-multiple: true
           path: dist
 
-      - run: pip install -r tests/requirements.txt
-      - run: pip install pydantic-core --no-index --no-deps --find-links dist --force-reinstall
-      - run: pytest --ignore=tests/test_docstrings.py
+      - run: uv sync --group testing
+      - run: uv pip install pydantic-core --no-index --no-deps --find-links dist --force-reinstall
+      - run: uv run pytest --ignore=tests/test_docstrings.py
 
   release:
     needs: [test-builds-arch, test-builds-os, build-sdist, check]
diff --git a/.github/workflows/codspeed.yml b/.github/workflows/codspeed.yml
index 9dd4bbc6e..9ee91d25f 100644
--- a/.github/workflows/codspeed.yml
+++ b/.github/workflows/codspeed.yml
@@ -9,6 +9,10 @@ on:
   # performance analysis in order to generate initial data.
   workflow_dispatch:
 
+env:
+  UV_FROZEN: true
+  UV_PYTHON: 3.13
+
 jobs:
   benchmarks:
     runs-on: ubuntu-22.04
@@ -16,29 +20,21 @@ jobs:
     steps:
       - uses: actions/checkout@v4
 
+      # Using this action is still necessary for CodSpeed to work:
       - uses: actions/setup-python@v5
         with:
-          python-version: '3.13'
+          python-version: ${{ env.UV_PYTHON}}
 
-      - uses: actions/cache@v4
-        id: cache-py
-        name: cache python
+      - name: install uv
+        uses: astral-sh/setup-uv@v3
         with:
-          path: ${{ env.pythonLocation }}
-          key: >
-            py-v2
-            ${{ env.pythonLocation }}
-            ${{ hashFiles('tests/requirements.txt') }}
-            ${{ hashFiles('pyproject.toml') }}
-
-      - run: pip install -r tests/requirements.txt
-        if: steps.cache-py.outputs.cache-hit != 'true'
-
-      - run: pip uninstall pytest-speed -y
-        if: steps.cache-py.outputs.cache-hit != 'true'
+          enable-cache: true
 
-      - run: pip install pytest-benchmark==4.0.0 pytest-codspeed
-        if: steps.cache-py.outputs.cache-hit != 'true'
+      - name: install deps
+        run: |
+          uv sync --group testing
+          uv pip uninstall pytest-speed
+          uv pip install pytest-benchmark==4.0.0 pytest-codspeed
 
       - name: install rust stable
         id: rust-toolchain
@@ -56,7 +52,7 @@ jobs:
           RUSTFLAGS: "-Cprofile-generate=${{ github.workspace }}/profdata"
 
       - name: Gather pgo data
-        run: pytest tests/benchmarks
+        run: uv run pytest tests/benchmarks
 
       - name: Prepare merged pgo data
         run: rustup run stable bash -c '$RUSTUP_HOME/toolchains/$RUSTUP_TOOLCHAIN/lib/rustlib/x86_64-unknown-linux-gnu/bin/llvm-profdata merge -o ${{ github.workspace }}/merged.profdata ${{ github.workspace }}/profdata'
@@ -70,4 +66,4 @@ jobs:
       - name: Run CodSpeed benchmarks
         uses: CodSpeedHQ/action@v3
         with:
-          run: pytest tests/benchmarks/ --codspeed
+          run: uv run pytest tests/benchmarks/ --codspeed
diff --git a/Makefile b/Makefile
index 4186369a7..0f47e2d22 100644
--- a/Makefile
+++ b/Makefile
@@ -1,8 +1,6 @@
 .DEFAULT_GOAL := all
 sources = python/pydantic_core tests generate_self_schema.py wasm-preview/run_tests.py
 
-mypy-stubtest = python -m mypy.stubtest pydantic_core._pydantic_core --allowlist .mypy-stubtest-allowlist
-
 # using pip install cargo (via maturin via pip) doesn't get the tty handle
 # so doesn't render color without some help
 export CARGO_TERM_COLOR=$(shell (test -t 0 && echo "always") || echo "auto")
@@ -10,14 +8,25 @@ export CARGO_TERM_COLOR=$(shell (test -t 0 && echo "always") || echo "auto")
 # more or less equivalent to pip install -e just a little nicer
 USE_MATURIN = $(shell [ "$$VIRTUAL_ENV" != "" ] && (which maturin))
 
+.PHONY: .uv  ## Check that uv is installed
+.uv:
+	@uv -V || echo 'Please install uv: https://docs.astral.sh/uv/getting-started/installation/'
+
+.PHONY: .pre-commit  ## Check that pre-commit is installed
+.pre-commit:
+	@pre-commit -V || echo 'Please install pre-commit: https://pre-commit.com/'
+
 .PHONY: install
-install:
-	pip install -U pip wheel pre-commit
-	pip install -r tests/requirements.txt
-	pip install -r tests/requirements-linting.txt
-	pip install -v -e .
+install: .uv .pre-commit
+	uv pip install -U wheel
+	uv sync --frozen --group all
+	uv pip install -v -e .
 	pre-commit install
 
+.PHONY: rebuild-lockfiles  ## Rebuild lockfiles from scratch, updating all dependencies
+rebuild-lockfiles: .uv
+	uv lock --upgrade
+
 .PHONY: install-rust-coverage
 install-rust-coverage:
 	cargo install rustfilt coverage-prepare
@@ -30,36 +39,36 @@ install-rust-coverage:
 build-dev:
 	@rm -f python/pydantic_core/*.so
 ifneq ($(USE_MATURIN),)
-	maturin develop
+	uv run maturin develop
 else
-	pip install -v -e . --config-settings=build-args='--profile dev'
+	uv pip install --force-reinstall -v -e . --config-settings=build-args='--profile dev'
 endif
 
 .PHONY: build-prod
 build-prod:
 	@rm -f python/pydantic_core/*.so
 ifneq ($(USE_MATURIN),)
-	maturin develop --release
+	uv run maturin develop --release
 else
-	pip install -v -e .
+	uv pip install -v -e .
 endif
 
 .PHONY: build-profiling
 build-profiling:
 	@rm -f python/pydantic_core/*.so
 ifneq ($(USE_MATURIN),)
-	maturin develop --profile profiling
+	uv run maturin develop --profile profiling
 else
-	pip install -v -e . --config-settings=build-args='--profile profiling'
+	uv pip install --force-reinstall -v -e . --config-settings=build-args='--profile profiling'
 endif
 
 .PHONY: build-coverage
 build-coverage:
 	@rm -f python/pydantic_core/*.so
 ifneq ($(USE_MATURIN),)
-	RUSTFLAGS='-C instrument-coverage' maturin develop --release
+	RUSTFLAGS='-C instrument-coverage' uv run maturin develop --release
 else
-	RUSTFLAGS='-C instrument-coverage' pip install -v -e .
+	RUSTFLAGS='-C instrument-coverage' uv pip install -v -e .
 endif
 
 .PHONY: build-pgo
@@ -67,17 +76,17 @@ build-pgo:
 	@rm -f python/pydantic_core/*.so
 	$(eval PROFDATA := $(shell mktemp -d))
 ifneq ($(USE_MATURIN),)
-	RUSTFLAGS='-Cprofile-generate=$(PROFDATA)' maturin develop --release
+	RUSTFLAGS='-Cprofile-generate=$(PROFDATA)' uv run maturin develop --release
 else
-	RUSTFLAGS='-Cprofile-generate=$(PROFDATA)' pip install -v -e .
+	RUSTFLAGS='-Cprofile-generate=$(PROFDATA)' uv pip install --force-reinstall -v -e .
 endif
 	pytest tests/benchmarks
 	$(eval LLVM_PROFDATA := $(shell rustup run stable bash -c 'echo $$RUSTUP_HOME/toolchains/$$RUSTUP_TOOLCHAIN/lib/rustlib/$$(rustc -Vv | grep host | cut -d " " -f 2)/bin/llvm-profdata'))
 	$(LLVM_PROFDATA) merge -o $(PROFDATA)/merged.profdata $(PROFDATA)
 ifneq ($(USE_MATURIN),)
-	RUSTFLAGS='-Cprofile-use=$(PROFDATA)/merged.profdata' maturin develop --release
+	RUSTFLAGS='-Cprofile-use=$(PROFDATA)/merged.profdata' uv run maturin develop --release
 else
-	RUSTFLAGS='-Cprofile-use=$(PROFDATA)/merged.profdata' pip install -v -e .
+	RUSTFLAGS='-Cprofile-use=$(PROFDATA)/merged.profdata' uv pip install --force-reinstall -v -e .
 endif
 	@rm -rf $(PROFDATA)
 
@@ -85,21 +94,20 @@ endif
 .PHONY: build-wasm
 build-wasm:
 	@echo 'This requires python 3.12, maturin and emsdk to be installed'
-	maturin build --release --target wasm32-unknown-emscripten --out dist -i 3.12
+	uv run maturin build --release --target wasm32-unknown-emscripten --out dist -i 3.12
 	ls -lh dist
 
 .PHONY: format
 format:
-	ruff check --fix $(sources)
-	ruff format $(sources)
+	uv run ruff check --fix $(sources)
+	uv run ruff format $(sources)
 	cargo fmt
 
 .PHONY: lint-python
 lint-python:
-	ruff check $(sources)
-	ruff format --check $(sources)
-	$(mypy-stubtest)
-	griffe dump -f -d google -LWARNING -o/dev/null python/pydantic_core
+	uv run ruff check $(sources)
+	uv run ruff format --check $(sources)
+	uv run griffe dump -f -d google -LWARNING -o/dev/null python/pydantic_core
 
 .PHONY: lint-rust
 lint-rust:
@@ -113,11 +121,11 @@ lint: lint-python lint-rust
 
 .PHONY: pyright
 pyright:
-	pyright
+	uv run pyright
 
 .PHONY: test
 test:
-	pytest
+	uv run pytest
 
 .PHONY: testcov
 testcov: build-coverage
diff --git a/pyproject.toml b/pyproject.toml
index 99f0fce73..de04a3991 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -48,6 +48,47 @@ Homepage = 'https://github.com/pydantic/pydantic-core'
 Funding = 'https://github.com/sponsors/samuelcolvin'
 Source = 'https://github.com/pydantic/pydantic-core'
 
+[dependency-groups]
+testing = [
+    'backports.zoneinfo; python_version < "3.9"',
+    'coverage',
+    'dirty-equals',
+    'inline-snapshot',
+    'hypothesis',
+    # pandas doesn't offer prebuilt wheels for all versions and platforms we test in CI e.g. aarch64 musllinux
+    'pandas; python_version >= "3.9" and python_version < "3.13" and implementation_name == "cpython" and platform_machine == "x86_64"',
+    'pytest',
+    # pytest-examples currently depends on aiohttp via black; we don't want to build it on platforms like aarch64 musllinux in CI
+    'pytest-examples; implementation_name == "cpython" and platform_machine == "x86_64"',
+    'pytest-speed',
+    'pytest-mock',
+    'pytest-pretty',
+    'pytest-timeout',
+    'python-dateutil',
+    # numpy doesn't offer prebuilt wheels for all versions and platforms we test in CI e.g. aarch64 musllinux
+    'numpy; python_version >= "3.9" and python_version < "3.13" and implementation_name == "cpython" and platform_machine == "x86_64"',
+    'exceptiongroup; python_version < "3.11"',
+    'tzdata',
+    'typing_extensions',
+]
+linting = [
+    'griffe',
+    'pyright',
+    'ruff',
+    'mypy',
+]
+wasm = [
+    'typing_extensions',
+    'maturin>=1,<2',
+    'ruff',
+]
+
+all = [
+  { include-group = 'testing' },
+  { include-group = 'linting' },
+  { include-group = 'wasm' },
+]
+
 [tool.maturin]
 python-source = "python"
 module-name = "pydantic_core._pydantic_core"
@@ -107,8 +148,13 @@ reviewers = ['sydney-runkle', 'davidhewitt']
 require_change_file = false
 
 [tool.pyright]
-include = ['pydantic_core', 'tests/test_typing.py']
+include = ['python/pydantic_core', 'tests/test_typing.py']
 reportUnnecessaryTypeIgnoreComment = true
 
 [tool.inline-snapshot.shortcuts]
 fix = ["create", "fix"]
+
+[tool.uv]
+# this ensures that `uv run` doesn't actually build the package; a `make`
+# command is needed to build
+package = false
diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index c023a5635..0fcfe9cab 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -719,7 +719,7 @@ class DecimalSchema(TypedDict, total=False):
 
 def decimal_schema(
     *,
-    allow_inf_nan: bool = None,
+    allow_inf_nan: bool | None = None,
     multiple_of: Decimal | None = None,
     le: Decimal | None = None,
     ge: Decimal | None = None,
@@ -2860,7 +2860,7 @@ def typed_dict_field(
 class TypedDictSchema(TypedDict, total=False):
     type: Required[Literal['typed-dict']]
     fields: Required[Dict[str, TypedDictField]]
-    cls: Type[TypedDict]
+    cls: Type[Any]
     computed_fields: List[ComputedField]
     strict: bool
     extras_schema: CoreSchema
@@ -2877,7 +2877,7 @@ class TypedDictSchema(TypedDict, total=False):
 def typed_dict_schema(
     fields: Dict[str, TypedDictField],
     *,
-    cls: Type[TypedDict] | None = None,
+    cls: Type[Any] | None = None,
     computed_fields: list[ComputedField] | None = None,
     strict: bool | None = None,
     extras_schema: CoreSchema | None = None,
diff --git a/tests/benchmarks/complete_schema.py b/tests/benchmarks/complete_schema.py
index 69b840224..7c661fb3e 100644
--- a/tests/benchmarks/complete_schema.py
+++ b/tests/benchmarks/complete_schema.py
@@ -256,7 +256,7 @@ def input_data_lax():
         'field_tuple_var_len_float': tuple(i + 0.5 for i in range(100)),
         'field_tuple_var_len_float_con': tuple(i + 0.5 for i in range(42)),
         'field_tuple_fix_len': ('a', 1, 1.0, True),
-        'field_dict_any': {'a': 'b', 1: True, 1.0: 1.0},
+        'field_dict_any': {'a': 'b', 1: True, 1.0: 1.0},  # noqa: F601
         'field_dict_str_float': {f'{i}': i + 0.5 for i in range(100)},
         'field_literal_1_int': 1,
         'field_literal_1_str': 'foobar',
diff --git a/tests/benchmarks/test_complete_benchmark.py b/tests/benchmarks/test_complete_benchmark.py
index 23fe58cdf..89c6d7efd 100644
--- a/tests/benchmarks/test_complete_benchmark.py
+++ b/tests/benchmarks/test_complete_benchmark.py
@@ -53,7 +53,7 @@ def test_complete_valid():
         'field_tuple_var_len_float': tuple(i + 0.5 for i in range(100)),
         'field_tuple_var_len_float_con': tuple(i + 0.5 for i in range(42)),
         'field_tuple_fix_len': ('a', 1, 1.0, True),
-        'field_dict_any': {'a': 'b', 1: True, 1.0: 1.0},
+        'field_dict_any': {'a': 'b', 1: True, 1.0: 1.0},  # noqa: F601
         'field_dict_str_float': {f'{i}': i + 0.5 for i in range(100)},
         'field_literal_1_int': 1,
         'field_literal_1_str': 'foobar',
diff --git a/tests/requirements-linting.txt b/tests/requirements-linting.txt
deleted file mode 100644
index b3962930d..000000000
--- a/tests/requirements-linting.txt
+++ /dev/null
@@ -1,4 +0,0 @@
-griffe==1.5.1
-pyright==1.1.387
-ruff==0.7.2
-mypy==1.13.0
diff --git a/tests/requirements.txt b/tests/requirements.txt
deleted file mode 100644
index 837128b5a..000000000
--- a/tests/requirements.txt
+++ /dev/null
@@ -1,21 +0,0 @@
-backports.zoneinfo==0.2.1;python_version<"3.9"
-coverage==7.6.1
-dirty-equals==0.8.0
-inline-snapshot==0.13.3
-hypothesis==6.111.2
-# pandas doesn't offer prebuilt wheels for all versions and platforms we test in CI e.g. aarch64 musllinux
-pandas==2.1.3; python_version >= "3.9" and python_version < "3.13" and implementation_name == "cpython" and platform_machine == 'x86_64'
-pytest==8.3.3
-# pytest-examples currently depends on aiohttp via black; we don't want to build
-# it on platforms like aarch64 musllinux in CI
-pytest-examples==0.0.13; implementation_name == "cpython" and platform_machine == 'x86_64'
-pytest-speed==0.3.5
-pytest-mock==3.14.0
-pytest-pretty==1.2.0
-pytest-timeout==2.3.1
-python-dateutil==2.9.0.post0
-# numpy doesn't offer prebuilt wheels for all versions and platforms we test in CI e.g. aarch64 musllinux
-numpy==1.26.2; python_version >= "3.9" and python_version < "3.13" and implementation_name == "cpython" and platform_machine == 'x86_64'
-exceptiongroup==1.1; python_version < "3.11"
-tzdata==2024.2
-typing_extensions==4.12.2
diff --git a/uv.lock b/uv.lock
new file mode 100644
index 000000000..edc77b455
--- /dev/null
+++ b/uv.lock
@@ -0,0 +1,867 @@
+version = 1
+requires-python = ">=3.8"
+resolution-markers = [
+    "python_full_version < '3.9' or python_full_version >= '3.13' or implementation_name != 'cpython' or platform_machine != 'x86_64'",
+    "python_full_version >= '3.9' and python_full_version < '3.11' and implementation_name == 'cpython' and platform_machine == 'x86_64'",
+    "python_full_version == '3.11.*' and implementation_name == 'cpython' and platform_machine == 'x86_64'",
+    "python_full_version == '3.12.*' and implementation_name == 'cpython' and platform_machine == 'x86_64'",
+]
+
+[[package]]
+name = "asttokens"
+version = "2.4.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "six" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/45/1d/f03bcb60c4a3212e15f99a56085d93093a497718adf828d050b9d675da81/asttokens-2.4.1.tar.gz", hash = "sha256:b03869718ba9a6eb027e134bfdf69f38a236d681c83c160d510768af11254ba0", size = 62284 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/45/86/4736ac618d82a20d87d2f92ae19441ebc7ac9e7a581d7e58bbe79233b24a/asttokens-2.4.1-py2.py3-none-any.whl", hash = "sha256:051ed49c3dcae8913ea7cd08e46a606dba30b79993209636c4875bc1d637bc24", size = 27764 },
+]
+
+[[package]]
+name = "astunparse"
+version = "1.6.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "six", marker = "python_full_version < '3.9' or python_full_version >= '3.13' or implementation_name != 'cpython' or platform_machine != 'x86_64'" },
+    { name = "wheel", marker = "python_full_version < '3.9' or python_full_version >= '3.13' or implementation_name != 'cpython' or platform_machine != 'x86_64'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/f3/af/4182184d3c338792894f34a62672919db7ca008c89abee9b564dd34d8029/astunparse-1.6.3.tar.gz", hash = "sha256:5ad93a8456f0d084c3456d059fd9a92cce667963232cbf763eac3bc5b7940872", size = 18290 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2b/03/13dde6512ad7b4557eb792fbcf0c653af6076b81e5941d36ec61f7ce6028/astunparse-1.6.3-py2.py3-none-any.whl", hash = "sha256:c2652417f2c8b5bb325c885ae329bdf3f86424075c4fd1a128674bc6fba4b8e8", size = 12732 },
+]
+
+[[package]]
+name = "attrs"
+version = "24.2.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/fc/0f/aafca9af9315aee06a89ffde799a10a582fe8de76c563ee80bbcdc08b3fb/attrs-24.2.0.tar.gz", hash = "sha256:5cfb1b9148b5b086569baec03f20d7b6bf3bcacc9a42bebf87ffaaca362f6346", size = 792678 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6a/21/5b6702a7f963e95456c0de2d495f67bf5fd62840ac655dc451586d23d39a/attrs-24.2.0-py3-none-any.whl", hash = "sha256:81921eb96de3191c8258c199618104dd27ac608d9366f5e35d011eae1867ede2", size = 63001 },
+]
+
+[[package]]
+name = "backports-zoneinfo"
+version = "0.2.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ad/85/475e514c3140937cf435954f78dedea1861aeab7662d11de232bdaa90655/backports.zoneinfo-0.2.1.tar.gz", hash = "sha256:fadbfe37f74051d024037f223b8e001611eac868b5c5b06144ef4d8b799862f2", size = 74098 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4a/6d/eca004eeadcbf8bd64cc96feb9e355536147f0577420b44d80c7cac70767/backports.zoneinfo-0.2.1-cp38-cp38-macosx_10_14_x86_64.whl", hash = "sha256:8961c0f32cd0336fb8e8ead11a1f8cd99ec07145ec2931122faaac1c8f7fd987", size = 35816 },
+    { url = "https://files.pythonhosted.org/packages/c1/8f/9b1b920a6a95652463143943fa3b8c000cb0b932ab463764a6f2a2416560/backports.zoneinfo-0.2.1-cp38-cp38-manylinux1_i686.whl", hash = "sha256:e81b76cace8eda1fca50e345242ba977f9be6ae3945af8d46326d776b4cf78d1", size = 72147 },
+    { url = "https://files.pythonhosted.org/packages/1a/ab/3e941e3fcf1b7d3ab3d0233194d99d6a0ed6b24f8f956fc81e47edc8c079/backports.zoneinfo-0.2.1-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:7b0a64cda4145548fed9efc10322770f929b944ce5cee6c0dfe0c87bf4c0c8c9", size = 74033 },
+    { url = "https://files.pythonhosted.org/packages/c0/34/5fdb0a3a28841d215c255be8fc60b8666257bb6632193c86fd04b63d4a31/backports.zoneinfo-0.2.1-cp38-cp38-win32.whl", hash = "sha256:1b13e654a55cd45672cb54ed12148cd33628f672548f373963b0bff67b217328", size = 36803 },
+    { url = "https://files.pythonhosted.org/packages/78/cc/e27fd6493bbce8dbea7e6c1bc861fe3d3bc22c4f7c81f4c3befb8ff5bfaf/backports.zoneinfo-0.2.1-cp38-cp38-win_amd64.whl", hash = "sha256:4a0f800587060bf8880f954dbef70de6c11bbe59c673c3d818921f042f9954a6", size = 38967 },
+]
+
+[[package]]
+name = "black"
+version = "24.8.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "mypy-extensions" },
+    { name = "packaging" },
+    { name = "pathspec" },
+    { name = "platformdirs" },
+    { name = "tomli", marker = "python_full_version < '3.11'" },
+    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/04/b0/46fb0d4e00372f4a86a6f8efa3cb193c9f64863615e39010b1477e010578/black-24.8.0.tar.gz", hash = "sha256:2500945420b6784c38b9ee885af039f5e7471ef284ab03fa35ecdde4688cd83f", size = 644810 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/47/6e/74e29edf1fba3887ed7066930a87f698ffdcd52c5dbc263eabb06061672d/black-24.8.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:09cdeb74d494ec023ded657f7092ba518e8cf78fa8386155e4a03fdcc44679e6", size = 1632092 },
+    { url = "https://files.pythonhosted.org/packages/ab/49/575cb6c3faee690b05c9d11ee2e8dba8fbd6d6c134496e644c1feb1b47da/black-24.8.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:81c6742da39f33b08e791da38410f32e27d632260e599df7245cccee2064afeb", size = 1457529 },
+    { url = "https://files.pythonhosted.org/packages/7a/b4/d34099e95c437b53d01c4aa37cf93944b233066eb034ccf7897fa4e5f286/black-24.8.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:707a1ca89221bc8a1a64fb5e15ef39cd755633daa672a9db7498d1c19de66a42", size = 1757443 },
+    { url = "https://files.pythonhosted.org/packages/87/a0/6d2e4175ef364b8c4b64f8441ba041ed65c63ea1db2720d61494ac711c15/black-24.8.0-cp310-cp310-win_amd64.whl", hash = "sha256:d6417535d99c37cee4091a2f24eb2b6d5ec42b144d50f1f2e436d9fe1916fe1a", size = 1418012 },
+    { url = "https://files.pythonhosted.org/packages/08/a6/0a3aa89de9c283556146dc6dbda20cd63a9c94160a6fbdebaf0918e4a3e1/black-24.8.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:fb6e2c0b86bbd43dee042e48059c9ad7830abd5c94b0bc518c0eeec57c3eddc1", size = 1615080 },
+    { url = "https://files.pythonhosted.org/packages/db/94/b803d810e14588bb297e565821a947c108390a079e21dbdcb9ab6956cd7a/black-24.8.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:837fd281f1908d0076844bc2b801ad2d369c78c45cf800cad7b61686051041af", size = 1438143 },
+    { url = "https://files.pythonhosted.org/packages/a5/b5/f485e1bbe31f768e2e5210f52ea3f432256201289fd1a3c0afda693776b0/black-24.8.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:62e8730977f0b77998029da7971fa896ceefa2c4c4933fcd593fa599ecbf97a4", size = 1738774 },
+    { url = "https://files.pythonhosted.org/packages/a8/69/a000fc3736f89d1bdc7f4a879f8aaf516fb03613bb51a0154070383d95d9/black-24.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:72901b4913cbac8972ad911dc4098d5753704d1f3c56e44ae8dce99eecb0e3af", size = 1427503 },
+    { url = "https://files.pythonhosted.org/packages/a2/a8/05fb14195cfef32b7c8d4585a44b7499c2a4b205e1662c427b941ed87054/black-24.8.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:7c046c1d1eeb7aea9335da62472481d3bbf3fd986e093cffd35f4385c94ae368", size = 1646132 },
+    { url = "https://files.pythonhosted.org/packages/41/77/8d9ce42673e5cb9988f6df73c1c5c1d4e9e788053cccd7f5fb14ef100982/black-24.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:649f6d84ccbae73ab767e206772cc2d7a393a001070a4c814a546afd0d423aed", size = 1448665 },
+    { url = "https://files.pythonhosted.org/packages/cc/94/eff1ddad2ce1d3cc26c162b3693043c6b6b575f538f602f26fe846dfdc75/black-24.8.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2b59b250fdba5f9a9cd9d0ece6e6d993d91ce877d121d161e4698af3eb9c1018", size = 1762458 },
+    { url = "https://files.pythonhosted.org/packages/28/ea/18b8d86a9ca19a6942e4e16759b2fa5fc02bbc0eb33c1b866fcd387640ab/black-24.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:6e55d30d44bed36593c3163b9bc63bf58b3b30e4611e4d88a0c3c239930ed5b2", size = 1436109 },
+    { url = "https://files.pythonhosted.org/packages/9f/d4/ae03761ddecc1a37d7e743b89cccbcf3317479ff4b88cfd8818079f890d0/black-24.8.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:505289f17ceda596658ae81b61ebbe2d9b25aa78067035184ed0a9d855d18afd", size = 1617322 },
+    { url = "https://files.pythonhosted.org/packages/14/4b/4dfe67eed7f9b1ddca2ec8e4418ea74f0d1dc84d36ea874d618ffa1af7d4/black-24.8.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:b19c9ad992c7883ad84c9b22aaa73562a16b819c1d8db7a1a1a49fb7ec13c7d2", size = 1442108 },
+    { url = "https://files.pythonhosted.org/packages/97/14/95b3f91f857034686cae0e73006b8391d76a8142d339b42970eaaf0416ea/black-24.8.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1f13f7f386f86f8121d76599114bb8c17b69d962137fc70efe56137727c7047e", size = 1745786 },
+    { url = "https://files.pythonhosted.org/packages/95/54/68b8883c8aa258a6dde958cd5bdfada8382bec47c5162f4a01e66d839af1/black-24.8.0-cp38-cp38-win_amd64.whl", hash = "sha256:f490dbd59680d809ca31efdae20e634f3fae27fba3ce0ba3208333b713bc3920", size = 1426754 },
+    { url = "https://files.pythonhosted.org/packages/13/b2/b3f24fdbb46f0e7ef6238e131f13572ee8279b70f237f221dd168a9dba1a/black-24.8.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:eab4dd44ce80dea27dc69db40dab62d4ca96112f87996bca68cd75639aeb2e4c", size = 1631706 },
+    { url = "https://files.pythonhosted.org/packages/d9/35/31010981e4a05202a84a3116423970fd1a59d2eda4ac0b3570fbb7029ddc/black-24.8.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:3c4285573d4897a7610054af5a890bde7c65cb466040c5f0c8b732812d7f0e5e", size = 1457429 },
+    { url = "https://files.pythonhosted.org/packages/27/25/3f706b4f044dd569a20a4835c3b733dedea38d83d2ee0beb8178a6d44945/black-24.8.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9e84e33b37be070ba135176c123ae52a51f82306def9f7d063ee302ecab2cf47", size = 1756488 },
+    { url = "https://files.pythonhosted.org/packages/63/72/79375cd8277cbf1c5670914e6bd4c1b15dea2c8f8e906dc21c448d0535f0/black-24.8.0-cp39-cp39-win_amd64.whl", hash = "sha256:73bbf84ed136e45d451a260c6b73ed674652f90a2b3211d6a35e78054563a9bb", size = 1417721 },
+    { url = "https://files.pythonhosted.org/packages/27/1e/83fa8a787180e1632c3d831f7e58994d7aaf23a0961320d21e84f922f919/black-24.8.0-py3-none-any.whl", hash = "sha256:972085c618ee94f402da1af548a4f218c754ea7e5dc70acb168bfaca4c2542ed", size = 206504 },
+]
+
+[[package]]
+name = "click"
+version = "8.1.7"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "platform_system == 'Windows'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/96/d3/f04c7bfcf5c1862a2a5b845c6b2b360488cf47af55dfa79c98f6a6bf98b5/click-8.1.7.tar.gz", hash = "sha256:ca9853ad459e787e2192211578cc907e7594e294c7ccc834310722b41b9ca6de", size = 336121 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/00/2e/d53fa4befbf2cfa713304affc7ca780ce4fc1fd8710527771b58311a3229/click-8.1.7-py3-none-any.whl", hash = "sha256:ae74fb96c20a0277a1d615f1e4d73c8414f5a98db8b799a7931d1582f3390c28", size = 97941 },
+]
+
+[[package]]
+name = "colorama"
+version = "0.4.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335 },
+]
+
+[[package]]
+name = "coverage"
+version = "7.6.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/f7/08/7e37f82e4d1aead42a7443ff06a1e406aabf7302c4f00a546e4b320b994c/coverage-7.6.1.tar.gz", hash = "sha256:953510dfb7b12ab69d20135a0662397f077c59b1e6379a768e97c59d852ee51d", size = 798791 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/7e/61/eb7ce5ed62bacf21beca4937a90fe32545c91a3c8a42a30c6616d48fc70d/coverage-7.6.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b06079abebbc0e89e6163b8e8f0e16270124c154dc6e4a47b413dd538859af16", size = 206690 },
+    { url = "https://files.pythonhosted.org/packages/7d/73/041928e434442bd3afde5584bdc3f932fb4562b1597629f537387cec6f3d/coverage-7.6.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:cf4b19715bccd7ee27b6b120e7e9dd56037b9c0681dcc1adc9ba9db3d417fa36", size = 207127 },
+    { url = "https://files.pythonhosted.org/packages/c7/c8/6ca52b5147828e45ad0242388477fdb90df2c6cbb9a441701a12b3c71bc8/coverage-7.6.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e61c0abb4c85b095a784ef23fdd4aede7a2628478e7baba7c5e3deba61070a02", size = 235654 },
+    { url = "https://files.pythonhosted.org/packages/d5/da/9ac2b62557f4340270942011d6efeab9833648380109e897d48ab7c1035d/coverage-7.6.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fd21f6ae3f08b41004dfb433fa895d858f3f5979e7762d052b12aef444e29afc", size = 233598 },
+    { url = "https://files.pythonhosted.org/packages/53/23/9e2c114d0178abc42b6d8d5281f651a8e6519abfa0ef460a00a91f80879d/coverage-7.6.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f59d57baca39b32db42b83b2a7ba6f47ad9c394ec2076b084c3f029b7afca23", size = 234732 },
+    { url = "https://files.pythonhosted.org/packages/0f/7e/a0230756fb133343a52716e8b855045f13342b70e48e8ad41d8a0d60ab98/coverage-7.6.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:a1ac0ae2b8bd743b88ed0502544847c3053d7171a3cff9228af618a068ed9c34", size = 233816 },
+    { url = "https://files.pythonhosted.org/packages/28/7c/3753c8b40d232b1e5eeaed798c875537cf3cb183fb5041017c1fdb7ec14e/coverage-7.6.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e6a08c0be454c3b3beb105c0596ebdc2371fab6bb90c0c0297f4e58fd7e1012c", size = 232325 },
+    { url = "https://files.pythonhosted.org/packages/57/e3/818a2b2af5b7573b4b82cf3e9f137ab158c90ea750a8f053716a32f20f06/coverage-7.6.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f5796e664fe802da4f57a168c85359a8fbf3eab5e55cd4e4569fbacecc903959", size = 233418 },
+    { url = "https://files.pythonhosted.org/packages/c8/fb/4532b0b0cefb3f06d201648715e03b0feb822907edab3935112b61b885e2/coverage-7.6.1-cp310-cp310-win32.whl", hash = "sha256:7bb65125fcbef8d989fa1dd0e8a060999497629ca5b0efbca209588a73356232", size = 209343 },
+    { url = "https://files.pythonhosted.org/packages/5a/25/af337cc7421eca1c187cc9c315f0a755d48e755d2853715bfe8c418a45fa/coverage-7.6.1-cp310-cp310-win_amd64.whl", hash = "sha256:3115a95daa9bdba70aea750db7b96b37259a81a709223c8448fa97727d546fe0", size = 210136 },
+    { url = "https://files.pythonhosted.org/packages/ad/5f/67af7d60d7e8ce61a4e2ddcd1bd5fb787180c8d0ae0fbd073f903b3dd95d/coverage-7.6.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:7dea0889685db8550f839fa202744652e87c60015029ce3f60e006f8c4462c93", size = 206796 },
+    { url = "https://files.pythonhosted.org/packages/e1/0e/e52332389e057daa2e03be1fbfef25bb4d626b37d12ed42ae6281d0a274c/coverage-7.6.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ed37bd3c3b063412f7620464a9ac1314d33100329f39799255fb8d3027da50d3", size = 207244 },
+    { url = "https://files.pythonhosted.org/packages/aa/cd/766b45fb6e090f20f8927d9c7cb34237d41c73a939358bc881883fd3a40d/coverage-7.6.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d85f5e9a5f8b73e2350097c3756ef7e785f55bd71205defa0bfdaf96c31616ff", size = 239279 },
+    { url = "https://files.pythonhosted.org/packages/70/6c/a9ccd6fe50ddaf13442a1e2dd519ca805cbe0f1fcd377fba6d8339b98ccb/coverage-7.6.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9bc572be474cafb617672c43fe989d6e48d3c83af02ce8de73fff1c6bb3c198d", size = 236859 },
+    { url = "https://files.pythonhosted.org/packages/14/6f/8351b465febb4dbc1ca9929505202db909c5a635c6fdf33e089bbc3d7d85/coverage-7.6.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0c0420b573964c760df9e9e86d1a9a622d0d27f417e1a949a8a66dd7bcee7bc6", size = 238549 },
+    { url = "https://files.pythonhosted.org/packages/68/3c/289b81fa18ad72138e6d78c4c11a82b5378a312c0e467e2f6b495c260907/coverage-7.6.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1f4aa8219db826ce6be7099d559f8ec311549bfc4046f7f9fe9b5cea5c581c56", size = 237477 },
+    { url = "https://files.pythonhosted.org/packages/ed/1c/aa1efa6459d822bd72c4abc0b9418cf268de3f60eeccd65dc4988553bd8d/coverage-7.6.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:fc5a77d0c516700ebad189b587de289a20a78324bc54baee03dd486f0855d234", size = 236134 },
+    { url = "https://files.pythonhosted.org/packages/fb/c8/521c698f2d2796565fe9c789c2ee1ccdae610b3aa20b9b2ef980cc253640/coverage-7.6.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b48f312cca9621272ae49008c7f613337c53fadca647d6384cc129d2996d1133", size = 236910 },
+    { url = "https://files.pythonhosted.org/packages/7d/30/033e663399ff17dca90d793ee8a2ea2890e7fdf085da58d82468b4220bf7/coverage-7.6.1-cp311-cp311-win32.whl", hash = "sha256:1125ca0e5fd475cbbba3bb67ae20bd2c23a98fac4e32412883f9bcbaa81c314c", size = 209348 },
+    { url = "https://files.pythonhosted.org/packages/20/05/0d1ccbb52727ccdadaa3ff37e4d2dc1cd4d47f0c3df9eb58d9ec8508ca88/coverage-7.6.1-cp311-cp311-win_amd64.whl", hash = "sha256:8ae539519c4c040c5ffd0632784e21b2f03fc1340752af711f33e5be83a9d6c6", size = 210230 },
+    { url = "https://files.pythonhosted.org/packages/7e/d4/300fc921dff243cd518c7db3a4c614b7e4b2431b0d1145c1e274fd99bd70/coverage-7.6.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:95cae0efeb032af8458fc27d191f85d1717b1d4e49f7cb226cf526ff28179778", size = 206983 },
+    { url = "https://files.pythonhosted.org/packages/e1/ab/6bf00de5327ecb8db205f9ae596885417a31535eeda6e7b99463108782e1/coverage-7.6.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5621a9175cf9d0b0c84c2ef2b12e9f5f5071357c4d2ea6ca1cf01814f45d2391", size = 207221 },
+    { url = "https://files.pythonhosted.org/packages/92/8f/2ead05e735022d1a7f3a0a683ac7f737de14850395a826192f0288703472/coverage-7.6.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:260933720fdcd75340e7dbe9060655aff3af1f0c5d20f46b57f262ab6c86a5e8", size = 240342 },
+    { url = "https://files.pythonhosted.org/packages/0f/ef/94043e478201ffa85b8ae2d2c79b4081e5a1b73438aafafccf3e9bafb6b5/coverage-7.6.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:07e2ca0ad381b91350c0ed49d52699b625aab2b44b65e1b4e02fa9df0e92ad2d", size = 237371 },
+    { url = "https://files.pythonhosted.org/packages/1f/0f/c890339dd605f3ebc269543247bdd43b703cce6825b5ed42ff5f2d6122c7/coverage-7.6.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c44fee9975f04b33331cb8eb272827111efc8930cfd582e0320613263ca849ca", size = 239455 },
+    { url = "https://files.pythonhosted.org/packages/d1/04/7fd7b39ec7372a04efb0f70c70e35857a99b6a9188b5205efb4c77d6a57a/coverage-7.6.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:877abb17e6339d96bf08e7a622d05095e72b71f8afd8a9fefc82cf30ed944163", size = 238924 },
+    { url = "https://files.pythonhosted.org/packages/ed/bf/73ce346a9d32a09cf369f14d2a06651329c984e106f5992c89579d25b27e/coverage-7.6.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:3e0cadcf6733c09154b461f1ca72d5416635e5e4ec4e536192180d34ec160f8a", size = 237252 },
+    { url = "https://files.pythonhosted.org/packages/86/74/1dc7a20969725e917b1e07fe71a955eb34bc606b938316bcc799f228374b/coverage-7.6.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c3c02d12f837d9683e5ab2f3d9844dc57655b92c74e286c262e0fc54213c216d", size = 238897 },
+    { url = "https://files.pythonhosted.org/packages/b6/e9/d9cc3deceb361c491b81005c668578b0dfa51eed02cd081620e9a62f24ec/coverage-7.6.1-cp312-cp312-win32.whl", hash = "sha256:e05882b70b87a18d937ca6768ff33cc3f72847cbc4de4491c8e73880766718e5", size = 209606 },
+    { url = "https://files.pythonhosted.org/packages/47/c8/5a2e41922ea6740f77d555c4d47544acd7dc3f251fe14199c09c0f5958d3/coverage-7.6.1-cp312-cp312-win_amd64.whl", hash = "sha256:b5d7b556859dd85f3a541db6a4e0167b86e7273e1cdc973e5b175166bb634fdb", size = 210373 },
+    { url = "https://files.pythonhosted.org/packages/8c/f9/9aa4dfb751cb01c949c990d136a0f92027fbcc5781c6e921df1cb1563f20/coverage-7.6.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a4acd025ecc06185ba2b801f2de85546e0b8ac787cf9d3b06e7e2a69f925b106", size = 207007 },
+    { url = "https://files.pythonhosted.org/packages/b9/67/e1413d5a8591622a46dd04ff80873b04c849268831ed5c304c16433e7e30/coverage-7.6.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a6d3adcf24b624a7b778533480e32434a39ad8fa30c315208f6d3e5542aeb6e9", size = 207269 },
+    { url = "https://files.pythonhosted.org/packages/14/5b/9dec847b305e44a5634d0fb8498d135ab1d88330482b74065fcec0622224/coverage-7.6.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d0c212c49b6c10e6951362f7c6df3329f04c2b1c28499563d4035d964ab8e08c", size = 239886 },
+    { url = "https://files.pythonhosted.org/packages/7b/b7/35760a67c168e29f454928f51f970342d23cf75a2bb0323e0f07334c85f3/coverage-7.6.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6e81d7a3e58882450ec4186ca59a3f20a5d4440f25b1cff6f0902ad890e6748a", size = 237037 },
+    { url = "https://files.pythonhosted.org/packages/f7/95/d2fd31f1d638df806cae59d7daea5abf2b15b5234016a5ebb502c2f3f7ee/coverage-7.6.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:78b260de9790fd81e69401c2dc8b17da47c8038176a79092a89cb2b7d945d060", size = 239038 },
+    { url = "https://files.pythonhosted.org/packages/6e/bd/110689ff5752b67924efd5e2aedf5190cbbe245fc81b8dec1abaffba619d/coverage-7.6.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a78d169acd38300060b28d600344a803628c3fd585c912cacc9ea8790fe96862", size = 238690 },
+    { url = "https://files.pythonhosted.org/packages/d3/a8/08d7b38e6ff8df52331c83130d0ab92d9c9a8b5462f9e99c9f051a4ae206/coverage-7.6.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:2c09f4ce52cb99dd7505cd0fc8e0e37c77b87f46bc9c1eb03fe3bc9991085388", size = 236765 },
+    { url = "https://files.pythonhosted.org/packages/d6/6a/9cf96839d3147d55ae713eb2d877f4d777e7dc5ba2bce227167d0118dfe8/coverage-7.6.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6878ef48d4227aace338d88c48738a4258213cd7b74fd9a3d4d7582bb1d8a155", size = 238611 },
+    { url = "https://files.pythonhosted.org/packages/74/e4/7ff20d6a0b59eeaab40b3140a71e38cf52547ba21dbcf1d79c5a32bba61b/coverage-7.6.1-cp313-cp313-win32.whl", hash = "sha256:44df346d5215a8c0e360307d46ffaabe0f5d3502c8a1cefd700b34baf31d411a", size = 209671 },
+    { url = "https://files.pythonhosted.org/packages/35/59/1812f08a85b57c9fdb6d0b383d779e47b6f643bc278ed682859512517e83/coverage-7.6.1-cp313-cp313-win_amd64.whl", hash = "sha256:8284cf8c0dd272a247bc154eb6c95548722dce90d098c17a883ed36e67cdb129", size = 210368 },
+    { url = "https://files.pythonhosted.org/packages/9c/15/08913be1c59d7562a3e39fce20661a98c0a3f59d5754312899acc6cb8a2d/coverage-7.6.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:d3296782ca4eab572a1a4eca686d8bfb00226300dcefdf43faa25b5242ab8a3e", size = 207758 },
+    { url = "https://files.pythonhosted.org/packages/c4/ae/b5d58dff26cade02ada6ca612a76447acd69dccdbb3a478e9e088eb3d4b9/coverage-7.6.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:502753043567491d3ff6d08629270127e0c31d4184c4c8d98f92c26f65019962", size = 208035 },
+    { url = "https://files.pythonhosted.org/packages/b8/d7/62095e355ec0613b08dfb19206ce3033a0eedb6f4a67af5ed267a8800642/coverage-7.6.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6a89ecca80709d4076b95f89f308544ec8f7b4727e8a547913a35f16717856cb", size = 250839 },
+    { url = "https://files.pythonhosted.org/packages/7c/1e/c2967cb7991b112ba3766df0d9c21de46b476d103e32bb401b1b2adf3380/coverage-7.6.1-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a318d68e92e80af8b00fa99609796fdbcdfef3629c77c6283566c6f02c6d6704", size = 246569 },
+    { url = "https://files.pythonhosted.org/packages/8b/61/a7a6a55dd266007ed3b1df7a3386a0d760d014542d72f7c2c6938483b7bd/coverage-7.6.1-cp313-cp313t-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:13b0a73a0896988f053e4fbb7de6d93388e6dd292b0d87ee51d106f2c11b465b", size = 248927 },
+    { url = "https://files.pythonhosted.org/packages/c8/fa/13a6f56d72b429f56ef612eb3bc5ce1b75b7ee12864b3bd12526ab794847/coverage-7.6.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4421712dbfc5562150f7554f13dde997a2e932a6b5f352edcce948a815efee6f", size = 248401 },
+    { url = "https://files.pythonhosted.org/packages/75/06/0429c652aa0fb761fc60e8c6b291338c9173c6aa0f4e40e1902345b42830/coverage-7.6.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:166811d20dfea725e2e4baa71fffd6c968a958577848d2131f39b60043400223", size = 246301 },
+    { url = "https://files.pythonhosted.org/packages/52/76/1766bb8b803a88f93c3a2d07e30ffa359467810e5cbc68e375ebe6906efb/coverage-7.6.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:225667980479a17db1048cb2bf8bfb39b8e5be8f164b8f6628b64f78a72cf9d3", size = 247598 },
+    { url = "https://files.pythonhosted.org/packages/66/8b/f54f8db2ae17188be9566e8166ac6df105c1c611e25da755738025708d54/coverage-7.6.1-cp313-cp313t-win32.whl", hash = "sha256:170d444ab405852903b7d04ea9ae9b98f98ab6d7e63e1115e82620807519797f", size = 210307 },
+    { url = "https://files.pythonhosted.org/packages/9f/b0/e0dca6da9170aefc07515cce067b97178cefafb512d00a87a1c717d2efd5/coverage-7.6.1-cp313-cp313t-win_amd64.whl", hash = "sha256:b9f222de8cded79c49bf184bdbc06630d4c58eec9459b939b4a690c82ed05657", size = 211453 },
+    { url = "https://files.pythonhosted.org/packages/81/d0/d9e3d554e38beea5a2e22178ddb16587dbcbe9a1ef3211f55733924bf7fa/coverage-7.6.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:6db04803b6c7291985a761004e9060b2bca08da6d04f26a7f2294b8623a0c1a0", size = 206674 },
+    { url = "https://files.pythonhosted.org/packages/38/ea/cab2dc248d9f45b2b7f9f1f596a4d75a435cb364437c61b51d2eb33ceb0e/coverage-7.6.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:f1adfc8ac319e1a348af294106bc6a8458a0f1633cc62a1446aebc30c5fa186a", size = 207101 },
+    { url = "https://files.pythonhosted.org/packages/ca/6f/f82f9a500c7c5722368978a5390c418d2a4d083ef955309a8748ecaa8920/coverage-7.6.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a95324a9de9650a729239daea117df21f4b9868ce32e63f8b650ebe6cef5595b", size = 236554 },
+    { url = "https://files.pythonhosted.org/packages/a6/94/d3055aa33d4e7e733d8fa309d9adf147b4b06a82c1346366fc15a2b1d5fa/coverage-7.6.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b43c03669dc4618ec25270b06ecd3ee4fa94c7f9b3c14bae6571ca00ef98b0d3", size = 234440 },
+    { url = "https://files.pythonhosted.org/packages/e4/6e/885bcd787d9dd674de4a7d8ec83faf729534c63d05d51d45d4fa168f7102/coverage-7.6.1-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8929543a7192c13d177b770008bc4e8119f2e1f881d563fc6b6305d2d0ebe9de", size = 235889 },
+    { url = "https://files.pythonhosted.org/packages/f4/63/df50120a7744492710854860783d6819ff23e482dee15462c9a833cc428a/coverage-7.6.1-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:a09ece4a69cf399510c8ab25e0950d9cf2b42f7b3cb0374f95d2e2ff594478a6", size = 235142 },
+    { url = "https://files.pythonhosted.org/packages/3a/5d/9d0acfcded2b3e9ce1c7923ca52ccc00c78a74e112fc2aee661125b7843b/coverage-7.6.1-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:9054a0754de38d9dbd01a46621636689124d666bad1936d76c0341f7d71bf569", size = 233805 },
+    { url = "https://files.pythonhosted.org/packages/c4/56/50abf070cb3cd9b1dd32f2c88f083aab561ecbffbcd783275cb51c17f11d/coverage-7.6.1-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:0dbde0f4aa9a16fa4d754356a8f2e36296ff4d83994b2c9d8398aa32f222f989", size = 234655 },
+    { url = "https://files.pythonhosted.org/packages/25/ee/b4c246048b8485f85a2426ef4abab88e48c6e80c74e964bea5cd4cd4b115/coverage-7.6.1-cp38-cp38-win32.whl", hash = "sha256:da511e6ad4f7323ee5702e6633085fb76c2f893aaf8ce4c51a0ba4fc07580ea7", size = 209296 },
+    { url = "https://files.pythonhosted.org/packages/5c/1c/96cf86b70b69ea2b12924cdf7cabb8ad10e6130eab8d767a1099fbd2a44f/coverage-7.6.1-cp38-cp38-win_amd64.whl", hash = "sha256:3f1156e3e8f2872197af3840d8ad307a9dd18e615dc64d9ee41696f287c57ad8", size = 210137 },
+    { url = "https://files.pythonhosted.org/packages/19/d3/d54c5aa83268779d54c86deb39c1c4566e5d45c155369ca152765f8db413/coverage-7.6.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:abd5fd0db5f4dc9289408aaf34908072f805ff7792632250dcb36dc591d24255", size = 206688 },
+    { url = "https://files.pythonhosted.org/packages/a5/fe/137d5dca72e4a258b1bc17bb04f2e0196898fe495843402ce826a7419fe3/coverage-7.6.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:547f45fa1a93154bd82050a7f3cddbc1a7a4dd2a9bf5cb7d06f4ae29fe94eaf8", size = 207120 },
+    { url = "https://files.pythonhosted.org/packages/78/5b/a0a796983f3201ff5485323b225d7c8b74ce30c11f456017e23d8e8d1945/coverage-7.6.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:645786266c8f18a931b65bfcefdbf6952dd0dea98feee39bd188607a9d307ed2", size = 235249 },
+    { url = "https://files.pythonhosted.org/packages/4e/e1/76089d6a5ef9d68f018f65411fcdaaeb0141b504587b901d74e8587606ad/coverage-7.6.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9e0b2df163b8ed01d515807af24f63de04bebcecbd6c3bfeff88385789fdf75a", size = 233237 },
+    { url = "https://files.pythonhosted.org/packages/9a/6f/eef79b779a540326fee9520e5542a8b428cc3bfa8b7c8f1022c1ee4fc66c/coverage-7.6.1-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:609b06f178fe8e9f89ef676532760ec0b4deea15e9969bf754b37f7c40326dbc", size = 234311 },
+    { url = "https://files.pythonhosted.org/packages/75/e1/656d65fb126c29a494ef964005702b012f3498db1a30dd562958e85a4049/coverage-7.6.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:702855feff378050ae4f741045e19a32d57d19f3e0676d589df0575008ea5004", size = 233453 },
+    { url = "https://files.pythonhosted.org/packages/68/6a/45f108f137941a4a1238c85f28fd9d048cc46b5466d6b8dda3aba1bb9d4f/coverage-7.6.1-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:2bdb062ea438f22d99cba0d7829c2ef0af1d768d1e4a4f528087224c90b132cb", size = 231958 },
+    { url = "https://files.pythonhosted.org/packages/9b/e7/47b809099168b8b8c72ae311efc3e88c8d8a1162b3ba4b8da3cfcdb85743/coverage-7.6.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:9c56863d44bd1c4fe2abb8a4d6f5371d197f1ac0ebdee542f07f35895fc07f36", size = 232938 },
+    { url = "https://files.pythonhosted.org/packages/52/80/052222ba7058071f905435bad0ba392cc12006380731c37afaf3fe749b88/coverage-7.6.1-cp39-cp39-win32.whl", hash = "sha256:6e2cd258d7d927d09493c8df1ce9174ad01b381d4729a9d8d4e38670ca24774c", size = 209352 },
+    { url = "https://files.pythonhosted.org/packages/b8/d8/1b92e0b3adcf384e98770a00ca095da1b5f7b483e6563ae4eb5e935d24a1/coverage-7.6.1-cp39-cp39-win_amd64.whl", hash = "sha256:06a737c882bd26d0d6ee7269b20b12f14a8704807a01056c80bb881a4b2ce6ca", size = 210153 },
+    { url = "https://files.pythonhosted.org/packages/a5/2b/0354ed096bca64dc8e32a7cbcae28b34cb5ad0b1fe2125d6d99583313ac0/coverage-7.6.1-pp38.pp39.pp310-none-any.whl", hash = "sha256:e9a6e0eb86070e8ccaedfbd9d38fec54864f3125ab95419970575b42af7541df", size = 198926 },
+]
+
+[[package]]
+name = "dirty-equals"
+version = "0.8.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytz", marker = "python_full_version < '3.9'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/17/4c/39c428b7c900b21c8116d89a56b73f6dc14a2455767961b54adfe7c224fe/dirty_equals-0.8.0.tar.gz", hash = "sha256:798db3b9481b9a5024c0e520946507676ed2f0c65317d3e95bdce1a01657cf60", size = 50294 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f3/cd/8c3ce82cc6b18e149bff3cf8dd50a75316ca093ae706f0c1c4df87f2b88f/dirty_equals-0.8.0-py3-none-any.whl", hash = "sha256:0ef998ba3c395e03cf5eb3cd1c13c26a9a992efa18c0d59c22ba27344519cee1", size = 28217 },
+]
+
+[[package]]
+name = "exceptiongroup"
+version = "1.2.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/09/35/2495c4ac46b980e4ca1f6ad6db102322ef3ad2410b79fdde159a4b0f3b92/exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc", size = 28883 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/02/cc/b7e31358aac6ed1ef2bb790a9746ac2c69bcb3c8588b41616914eb106eaf/exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b", size = 16453 },
+]
+
+[[package]]
+name = "executing"
+version = "2.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8c/e3/7d45f492c2c4a0e8e0fad57d081a7c8a0286cdd86372b070cca1ec0caa1e/executing-2.1.0.tar.gz", hash = "sha256:8ea27ddd260da8150fa5a708269c4a10e76161e2496ec3e587da9e3c0fe4b9ab", size = 977485 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b5/fd/afcd0496feca3276f509df3dbd5dae726fcc756f1a08d9e25abe1733f962/executing-2.1.0-py2.py3-none-any.whl", hash = "sha256:8d63781349375b5ebccc3142f4b30350c0cd9c79f921cde38be2be4637e98eaf", size = 25805 },
+]
+
+[[package]]
+name = "griffe"
+version = "1.4.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "astunparse", marker = "python_full_version < '3.9'" },
+    { name = "colorama" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/05/e9/b2c86ad9d69053e497a24ceb25d661094fb321ab4ed39a8b71793dcbae82/griffe-1.4.0.tar.gz", hash = "sha256:8fccc585896d13f1221035d32c50dec65830c87d23f9adb9b1e6f3d63574f7f5", size = 381028 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/22/7c/e9e66869c2e4c9b378474e49c993128ec0131ef4721038b6d06e50538caf/griffe-1.4.0-py3-none-any.whl", hash = "sha256:e589de8b8c137e99a46ec45f9598fc0ac5b6868ce824b24db09c02d117b89bc5", size = 127015 },
+]
+
+[[package]]
+name = "hypothesis"
+version = "6.113.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "attrs" },
+    { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
+    { name = "sortedcontainers" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/28/32/6513cd7256f38c19a6c8a1d5ce9792bcd35c7f11651989994731f0e97672/hypothesis-6.113.0.tar.gz", hash = "sha256:5556ac66fdf72a4ccd5d237810f7cf6bdcd00534a4485015ef881af26e20f7c7", size = 408897 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/14/fa/4acb477b86a94571958bd337eae5baf334d21b8c98a04b594d0dad381ba8/hypothesis-6.113.0-py3-none-any.whl", hash = "sha256:d539180eb2bb71ed28a23dfe94e67c851f9b09f3ccc4125afad43f17e32e2bad", size = 469790 },
+]
+
+[[package]]
+name = "iniconfig"
+version = "2.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d7/4b/cbd8e699e64a6f16ca3a8220661b5f83792b3017d0f79807cb8708d33913/iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3", size = 4646 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ef/a6/62565a6e1cf69e10f5727360368e451d4b7f58beeac6173dc9db836a5b46/iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374", size = 5892 },
+]
+
+[[package]]
+name = "inline-snapshot"
+version = "0.14.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "asttokens" },
+    { name = "black" },
+    { name = "click" },
+    { name = "executing" },
+    { name = "rich" },
+    { name = "tomli", marker = "python_full_version < '3.11'" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/45/a9/b6b9db4f2ef1e3261460701a429f8248e517cb8d18e27ff05f4690ac0a73/inline_snapshot-0.14.0.tar.gz", hash = "sha256:54fdf7831055d06a2423054875d640102865a164cc8291a8086e44dd9b4fd316", size = 209662 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5e/a3/8ca14974625632d56d7e9f899d76d15dc4acd94ec15c179ca528beadeb4a/inline_snapshot-0.14.0-py3-none-any.whl", hash = "sha256:dc246d28b720f6050404b72cc1d171b0671e1494249197753d23771ff228748c", size = 31807 },
+]
+
+[[package]]
+name = "markdown-it-py"
+version = "3.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mdurl" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/38/71/3b932df36c1a044d397a1f92d1cf91ee0a503d91e470cbd670aa66b07ed0/markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb", size = 74596 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", size = 87528 },
+]
+
+[[package]]
+name = "maturin"
+version = "1.7.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "tomli", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/51/28/31a650d9209d873b6aec759c944bd284155154d7a01f7f541786d7c435ca/maturin-1.7.4.tar.gz", hash = "sha256:2b349d742a07527d236f0b4b6cab26f53ebecad0ceabfc09ec4c6a396e3176f9", size = 191145 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/85/19/b5be36f3cb30ba72aa2232492d4462409955da134ea25083f0e625618082/maturin-1.7.4-py3-none-linux_armv6l.whl", hash = "sha256:eb7b7753b733ae302c08f80bca7b0c3fda1eea665c2b1922c58795f35a54c833", size = 8215481 },
+    { url = "https://files.pythonhosted.org/packages/4f/0a/1b2a2fda3f338dedd219de358d77b01f1138bc4bc6b4c73b6ea01d8ddd9e/maturin-1.7.4-py3-none-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:0182a9638399c8835afd39d2aeacf56908e37cba3f7abb15816b9df6774fab81", size = 15930801 },
+    { url = "https://files.pythonhosted.org/packages/21/df/f75dcd8472f3be5b528942b11444eb4a82aa1aced7d105a8ba39bb85ece8/maturin-1.7.4-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:41a29c5b23f3ebdfe7633637e3de256579a1b2700c04cd68c16ed46934440c5a", size = 8166643 },
+    { url = "https://files.pythonhosted.org/packages/87/43/52baa75e6dae9848ea22ae6bd405e7f7da091ba63409b07912048fde2083/maturin-1.7.4-py3-none-manylinux_2_12_i686.manylinux2010_i686.musllinux_1_1_i686.whl", hash = "sha256:23fae44e345a2da5cb391ae878726fb793394826e2f97febe41710bd4099460e", size = 8560688 },
+    { url = "https://files.pythonhosted.org/packages/84/97/5e2bfbcf42725ba5f64310423edcf00d90e684a61d55dd0a26b2313a44b6/maturin-1.7.4-py3-none-manylinux_2_12_x86_64.manylinux2010_x86_64.musllinux_1_1_x86_64.whl", hash = "sha256:8b441521c151f0dbe70ed06fb1feb29b855d787bda038ff4330ca962e5d56641", size = 8939107 },
+    { url = "https://files.pythonhosted.org/packages/34/59/e0d58ce67a8a6245dcb74ffb81cb12f0cda8b622c8d902f2371de742ae04/maturin-1.7.4-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64.whl", hash = "sha256:7ccb66d0c5297cf06652c5f72cb398f447d3a332eccf5d1e73b3fe14dbc9498c", size = 8425431 },
+    { url = "https://files.pythonhosted.org/packages/53/20/4b79324b14a1f39b2c66eb1ad681cf8b0fff1f905374b0cca59fc9c8ef7a/maturin-1.7.4-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.musllinux_1_1_armv7l.whl", hash = "sha256:71f668f19e719048605dbca6a1f4d0dc03b987c922ad9c4bf5be03b9b278e4c3", size = 8104459 },
+    { url = "https://files.pythonhosted.org/packages/7f/fa/8d9497c62451fc19f52cda1ad652c5dca4e9646ff93be35250070afbc2af/maturin-1.7.4-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.musllinux_1_1_ppc64le.whl", hash = "sha256:c179fcb2b494f19186781b667320e43d95b3e71fcb1c98fffad9ef6bd6e276b3", size = 8729663 },
+    { url = "https://files.pythonhosted.org/packages/a4/e9/15a24263de981928303ca64465d5d9d5062f248b9ceaab3de5857ee0ba83/maturin-1.7.4-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fd5b4b95286f2f376437340f8a4908f4761587212170263084455be8099099a7", size = 10142511 },
+    { url = "https://files.pythonhosted.org/packages/a5/5d/59765561ea1a5f993141a403eb4ae85b7a8bd118971de0ed14048e3faf7f/maturin-1.7.4-py3-none-win32.whl", hash = "sha256:35487a424467d1fda4567cbb02d21f09febb10eda22f5fd647b130bc0767dc61", size = 6578873 },
+    { url = "https://files.pythonhosted.org/packages/72/50/a9b402aa506bad6c066c7775b1cb3036b7b1c74b9de708ed537ee804ea4a/maturin-1.7.4-py3-none-win_amd64.whl", hash = "sha256:f70c1c8ec9bd4749a53c0f3ae8fdbb326ce45be4f1c5551985ee25a6d7150328", size = 7442039 },
+    { url = "https://files.pythonhosted.org/packages/30/38/8e27282ab6ff94291f04e3eb11ba960dfb487605d73cec75177d3a29879a/maturin-1.7.4-py3-none-win_arm64.whl", hash = "sha256:f3d38a6d0c7fd7b04bec30dd470b2173cf9bd184ab6220c1acaf49df6b48faf5", size = 6388008 },
+]
+
+[[package]]
+name = "mdurl"
+version = "0.1.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979 },
+]
+
+[[package]]
+name = "mypy"
+version = "1.13.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "mypy-extensions" },
+    { name = "tomli", marker = "python_full_version < '3.11'" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/e8/21/7e9e523537991d145ab8a0a2fd98548d67646dc2aaaf6091c31ad883e7c1/mypy-1.13.0.tar.gz", hash = "sha256:0291a61b6fbf3e6673e3405cfcc0e7650bebc7939659fdca2702958038bd835e", size = 3152532 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/5e/8c/206de95a27722b5b5a8c85ba3100467bd86299d92a4f71c6b9aa448bfa2f/mypy-1.13.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6607e0f1dd1fb7f0aca14d936d13fd19eba5e17e1cd2a14f808fa5f8f6d8f60a", size = 11020731 },
+    { url = "https://files.pythonhosted.org/packages/ab/bb/b31695a29eea76b1569fd28b4ab141a1adc9842edde080d1e8e1776862c7/mypy-1.13.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8a21be69bd26fa81b1f80a61ee7ab05b076c674d9b18fb56239d72e21d9f4c80", size = 10184276 },
+    { url = "https://files.pythonhosted.org/packages/a5/2d/4a23849729bb27934a0e079c9c1aad912167d875c7b070382a408d459651/mypy-1.13.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7b2353a44d2179846a096e25691d54d59904559f4232519d420d64da6828a3a7", size = 12587706 },
+    { url = "https://files.pythonhosted.org/packages/5c/c3/d318e38ada50255e22e23353a469c791379825240e71b0ad03e76ca07ae6/mypy-1.13.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:0730d1c6a2739d4511dc4253f8274cdd140c55c32dfb0a4cf8b7a43f40abfa6f", size = 13105586 },
+    { url = "https://files.pythonhosted.org/packages/4a/25/3918bc64952370c3dbdbd8c82c363804678127815febd2925b7273d9482c/mypy-1.13.0-cp310-cp310-win_amd64.whl", hash = "sha256:c5fc54dbb712ff5e5a0fca797e6e0aa25726c7e72c6a5850cfd2adbc1eb0a372", size = 9632318 },
+    { url = "https://files.pythonhosted.org/packages/d0/19/de0822609e5b93d02579075248c7aa6ceaddcea92f00bf4ea8e4c22e3598/mypy-1.13.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:581665e6f3a8a9078f28d5502f4c334c0c8d802ef55ea0e7276a6e409bc0d82d", size = 10939027 },
+    { url = "https://files.pythonhosted.org/packages/c8/71/6950fcc6ca84179137e4cbf7cf41e6b68b4a339a1f5d3e954f8c34e02d66/mypy-1.13.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3ddb5b9bf82e05cc9a627e84707b528e5c7caaa1c55c69e175abb15a761cec2d", size = 10108699 },
+    { url = "https://files.pythonhosted.org/packages/26/50/29d3e7dd166e74dc13d46050b23f7d6d7533acf48f5217663a3719db024e/mypy-1.13.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:20c7ee0bc0d5a9595c46f38beb04201f2620065a93755704e141fcac9f59db2b", size = 12506263 },
+    { url = "https://files.pythonhosted.org/packages/3f/1d/676e76f07f7d5ddcd4227af3938a9c9640f293b7d8a44dd4ff41d4db25c1/mypy-1.13.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:3790ded76f0b34bc9c8ba4def8f919dd6a46db0f5a6610fb994fe8efdd447f73", size = 12984688 },
+    { url = "https://files.pythonhosted.org/packages/9c/03/5a85a30ae5407b1d28fab51bd3e2103e52ad0918d1e68f02a7778669a307/mypy-1.13.0-cp311-cp311-win_amd64.whl", hash = "sha256:51f869f4b6b538229c1d1bcc1dd7d119817206e2bc54e8e374b3dfa202defcca", size = 9626811 },
+    { url = "https://files.pythonhosted.org/packages/fb/31/c526a7bd2e5c710ae47717c7a5f53f616db6d9097caf48ad650581e81748/mypy-1.13.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:5c7051a3461ae84dfb5dd15eff5094640c61c5f22257c8b766794e6dd85e72d5", size = 11077900 },
+    { url = "https://files.pythonhosted.org/packages/83/67/b7419c6b503679d10bd26fc67529bc6a1f7a5f220bbb9f292dc10d33352f/mypy-1.13.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:39bb21c69a5d6342f4ce526e4584bc5c197fd20a60d14a8624d8743fffb9472e", size = 10074818 },
+    { url = "https://files.pythonhosted.org/packages/ba/07/37d67048786ae84e6612575e173d713c9a05d0ae495dde1e68d972207d98/mypy-1.13.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:164f28cb9d6367439031f4c81e84d3ccaa1e19232d9d05d37cb0bd880d3f93c2", size = 12589275 },
+    { url = "https://files.pythonhosted.org/packages/1f/17/b1018c6bb3e9f1ce3956722b3bf91bff86c1cefccca71cec05eae49d6d41/mypy-1.13.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:a4c1bfcdbce96ff5d96fc9b08e3831acb30dc44ab02671eca5953eadad07d6d0", size = 13037783 },
+    { url = "https://files.pythonhosted.org/packages/cb/32/cd540755579e54a88099aee0287086d996f5a24281a673f78a0e14dba150/mypy-1.13.0-cp312-cp312-win_amd64.whl", hash = "sha256:a0affb3a79a256b4183ba09811e3577c5163ed06685e4d4b46429a271ba174d2", size = 9726197 },
+    { url = "https://files.pythonhosted.org/packages/11/bb/ab4cfdc562cad80418f077d8be9b4491ee4fb257440da951b85cbb0a639e/mypy-1.13.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a7b44178c9760ce1a43f544e595d35ed61ac2c3de306599fa59b38a6048e1aa7", size = 11069721 },
+    { url = "https://files.pythonhosted.org/packages/59/3b/a393b1607cb749ea2c621def5ba8c58308ff05e30d9dbdc7c15028bca111/mypy-1.13.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5d5092efb8516d08440e36626f0153b5006d4088c1d663d88bf79625af3d1d62", size = 10063996 },
+    { url = "https://files.pythonhosted.org/packages/d1/1f/6b76be289a5a521bb1caedc1f08e76ff17ab59061007f201a8a18cc514d1/mypy-1.13.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:de2904956dac40ced10931ac967ae63c5089bd498542194b436eb097a9f77bc8", size = 12584043 },
+    { url = "https://files.pythonhosted.org/packages/a6/83/5a85c9a5976c6f96e3a5a7591aa28b4a6ca3a07e9e5ba0cec090c8b596d6/mypy-1.13.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:7bfd8836970d33c2105562650656b6846149374dc8ed77d98424b40b09340ba7", size = 13036996 },
+    { url = "https://files.pythonhosted.org/packages/b4/59/c39a6f752f1f893fccbcf1bdd2aca67c79c842402b5283563d006a67cf76/mypy-1.13.0-cp313-cp313-win_amd64.whl", hash = "sha256:9f73dba9ec77acb86457a8fc04b5239822df0c14a082564737833d2963677dbc", size = 9737709 },
+    { url = "https://files.pythonhosted.org/packages/5e/2a/13e9ad339131c0fba5c70584f639005a47088f5eed77081a3d00479df0ca/mypy-1.13.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:100fac22ce82925f676a734af0db922ecfea991e1d7ec0ceb1e115ebe501301a", size = 10955147 },
+    { url = "https://files.pythonhosted.org/packages/94/39/02929067dc16b72d78109195cfed349ac4ec85f3d52517ac62b9a5263685/mypy-1.13.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:7bcb0bb7f42a978bb323a7c88f1081d1b5dee77ca86f4100735a6f541299d8fb", size = 10138373 },
+    { url = "https://files.pythonhosted.org/packages/4a/cc/066709bb01734e3dbbd1375749f8789bf9693f8b842344fc0cf52109694f/mypy-1.13.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bde31fc887c213e223bbfc34328070996061b0833b0a4cfec53745ed61f3519b", size = 12543621 },
+    { url = "https://files.pythonhosted.org/packages/f5/a2/124df839025348c7b9877d0ce134832a9249968e3ab36bb826bab0e9a1cf/mypy-1.13.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:07de989f89786f62b937851295ed62e51774722e5444a27cecca993fc3f9cd74", size = 13050348 },
+    { url = "https://files.pythonhosted.org/packages/45/86/cc94b1e7f7e756a63043cf425c24fb7470013ee1c032180282db75b1b335/mypy-1.13.0-cp38-cp38-win_amd64.whl", hash = "sha256:4bde84334fbe19bad704b3f5b78c4abd35ff1026f8ba72b29de70dda0916beb6", size = 9615311 },
+    { url = "https://files.pythonhosted.org/packages/5f/d4/b33ddd40dad230efb317898a2d1c267c04edba73bc5086bf77edeb410fb2/mypy-1.13.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:0246bcb1b5de7f08f2826451abd947bf656945209b140d16ed317f65a17dc7dc", size = 11013906 },
+    { url = "https://files.pythonhosted.org/packages/f4/e6/f414bca465b44d01cd5f4a82761e15044bedd1bf8025c5af3cc64518fac5/mypy-1.13.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:7f5b7deae912cf8b77e990b9280f170381fdfbddf61b4ef80927edd813163732", size = 10180657 },
+    { url = "https://files.pythonhosted.org/packages/38/e9/fc3865e417722f98d58409770be01afb961e2c1f99930659ff4ae7ca8b7e/mypy-1.13.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7029881ec6ffb8bc233a4fa364736789582c738217b133f1b55967115288a2bc", size = 12586394 },
+    { url = "https://files.pythonhosted.org/packages/2e/35/f4d8b6d2cb0b3dad63e96caf159419dda023f45a358c6c9ac582ccaee354/mypy-1.13.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:3e38b980e5681f28f033f3be86b099a247b13c491f14bb8b1e1e134d23bb599d", size = 13103591 },
+    { url = "https://files.pythonhosted.org/packages/22/1d/80594aef135f921dd52e142fa0acd19df197690bd0cde42cea7b88cf5aa2/mypy-1.13.0-cp39-cp39-win_amd64.whl", hash = "sha256:a6789be98a2017c912ae6ccb77ea553bbaf13d27605d2ca20a76dfbced631b24", size = 9634690 },
+    { url = "https://files.pythonhosted.org/packages/3b/86/72ce7f57431d87a7ff17d442f521146a6585019eb8f4f31b7c02801f78ad/mypy-1.13.0-py3-none-any.whl", hash = "sha256:9c250883f9fd81d212e0952c92dbfcc96fc237f4b7c92f56ac81fd48460b3e5a", size = 2647043 },
+]
+
+[[package]]
+name = "mypy-extensions"
+version = "1.0.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/98/a4/1ab47638b92648243faf97a5aeb6ea83059cc3624972ab6b8d2316078d3f/mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782", size = 4433 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2a/e2/5d3f6ada4297caebe1a2add3b126fe800c96f56dbe5d1988a2cbe0b267aa/mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d", size = 4695 },
+]
+
+[[package]]
+name = "nodeenv"
+version = "1.9.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/43/16/fc88b08840de0e0a72a2f9d8c6bae36be573e475a6326ae854bcc549fc45/nodeenv-1.9.1.tar.gz", hash = "sha256:6ec12890a2dab7946721edbfbcd91f3319c6ccc9aec47be7c7e6b7011ee6645f", size = 47437 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d2/1d/1b658dbd2b9fa9c4c9f32accbfc0205d532c8c6194dc0f2a4c0428e7128a/nodeenv-1.9.1-py2.py3-none-any.whl", hash = "sha256:ba11c9782d29c27c70ffbdda2d7415098754709be8a7056d79a737cd901155c9", size = 22314 },
+]
+
+[[package]]
+name = "numpy"
+version = "2.0.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/a9/75/10dd1f8116a8b796cb2c737b674e02d02e80454bda953fa7e65d8c12b016/numpy-2.0.2.tar.gz", hash = "sha256:883c987dee1880e2a864ab0dc9892292582510604156762362d9326444636e78", size = 18902015 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/21/91/3495b3237510f79f5d81f2508f9f13fea78ebfdf07538fc7444badda173d/numpy-2.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:51129a29dbe56f9ca83438b706e2e69a39892b5eda6cedcb6b0c9fdc9b0d3ece", size = 21165245 },
+    { url = "https://files.pythonhosted.org/packages/05/33/26178c7d437a87082d11019292dce6d3fe6f0e9026b7b2309cbf3e489b1d/numpy-2.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f15975dfec0cf2239224d80e32c3170b1d168335eaedee69da84fbe9f1f9cd04", size = 13738540 },
+    { url = "https://files.pythonhosted.org/packages/ec/31/cc46e13bf07644efc7a4bf68df2df5fb2a1a88d0cd0da9ddc84dc0033e51/numpy-2.0.2-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:8c5713284ce4e282544c68d1c3b2c7161d38c256d2eefc93c1d683cf47683e66", size = 5300623 },
+    { url = "https://files.pythonhosted.org/packages/6e/16/7bfcebf27bb4f9d7ec67332ffebee4d1bf085c84246552d52dbb548600e7/numpy-2.0.2-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:becfae3ddd30736fe1889a37f1f580e245ba79a5855bff5f2a29cb3ccc22dd7b", size = 6901774 },
+    { url = "https://files.pythonhosted.org/packages/f9/a3/561c531c0e8bf082c5bef509d00d56f82e0ea7e1e3e3a7fc8fa78742a6e5/numpy-2.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2da5960c3cf0df7eafefd806d4e612c5e19358de82cb3c343631188991566ccd", size = 13907081 },
+    { url = "https://files.pythonhosted.org/packages/fa/66/f7177ab331876200ac7563a580140643d1179c8b4b6a6b0fc9838de2a9b8/numpy-2.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:496f71341824ed9f3d2fd36cf3ac57ae2e0165c143b55c3a035ee219413f3318", size = 19523451 },
+    { url = "https://files.pythonhosted.org/packages/25/7f/0b209498009ad6453e4efc2c65bcdf0ae08a182b2b7877d7ab38a92dc542/numpy-2.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:a61ec659f68ae254e4d237816e33171497e978140353c0c2038d46e63282d0c8", size = 19927572 },
+    { url = "https://files.pythonhosted.org/packages/3e/df/2619393b1e1b565cd2d4c4403bdd979621e2c4dea1f8532754b2598ed63b/numpy-2.0.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d731a1c6116ba289c1e9ee714b08a8ff882944d4ad631fd411106a30f083c326", size = 14400722 },
+    { url = "https://files.pythonhosted.org/packages/22/ad/77e921b9f256d5da36424ffb711ae79ca3f451ff8489eeca544d0701d74a/numpy-2.0.2-cp310-cp310-win32.whl", hash = "sha256:984d96121c9f9616cd33fbd0618b7f08e0cfc9600a7ee1d6fd9b239186d19d97", size = 6472170 },
+    { url = "https://files.pythonhosted.org/packages/10/05/3442317535028bc29cf0c0dd4c191a4481e8376e9f0db6bcf29703cadae6/numpy-2.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:c7b0be4ef08607dd04da4092faee0b86607f111d5ae68036f16cc787e250a131", size = 15905558 },
+    { url = "https://files.pythonhosted.org/packages/8b/cf/034500fb83041aa0286e0fb16e7c76e5c8b67c0711bb6e9e9737a717d5fe/numpy-2.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:49ca4decb342d66018b01932139c0961a8f9ddc7589611158cb3c27cbcf76448", size = 21169137 },
+    { url = "https://files.pythonhosted.org/packages/4a/d9/32de45561811a4b87fbdee23b5797394e3d1504b4a7cf40c10199848893e/numpy-2.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:11a76c372d1d37437857280aa142086476136a8c0f373b2e648ab2c8f18fb195", size = 13703552 },
+    { url = "https://files.pythonhosted.org/packages/c1/ca/2f384720020c7b244d22508cb7ab23d95f179fcfff33c31a6eeba8d6c512/numpy-2.0.2-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:807ec44583fd708a21d4a11d94aedf2f4f3c3719035c76a2bbe1fe8e217bdc57", size = 5298957 },
+    { url = "https://files.pythonhosted.org/packages/0e/78/a3e4f9fb6aa4e6fdca0c5428e8ba039408514388cf62d89651aade838269/numpy-2.0.2-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:8cafab480740e22f8d833acefed5cc87ce276f4ece12fdaa2e8903db2f82897a", size = 6905573 },
+    { url = "https://files.pythonhosted.org/packages/a0/72/cfc3a1beb2caf4efc9d0b38a15fe34025230da27e1c08cc2eb9bfb1c7231/numpy-2.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a15f476a45e6e5a3a79d8a14e62161d27ad897381fecfa4a09ed5322f2085669", size = 13914330 },
+    { url = "https://files.pythonhosted.org/packages/ba/a8/c17acf65a931ce551fee11b72e8de63bf7e8a6f0e21add4c937c83563538/numpy-2.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:13e689d772146140a252c3a28501da66dfecd77490b498b168b501835041f951", size = 19534895 },
+    { url = "https://files.pythonhosted.org/packages/ba/86/8767f3d54f6ae0165749f84648da9dcc8cd78ab65d415494962c86fac80f/numpy-2.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:9ea91dfb7c3d1c56a0e55657c0afb38cf1eeae4544c208dc465c3c9f3a7c09f9", size = 19937253 },
+    { url = "https://files.pythonhosted.org/packages/df/87/f76450e6e1c14e5bb1eae6836478b1028e096fd02e85c1c37674606ab752/numpy-2.0.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c1c9307701fec8f3f7a1e6711f9089c06e6284b3afbbcd259f7791282d660a15", size = 14414074 },
+    { url = "https://files.pythonhosted.org/packages/5c/ca/0f0f328e1e59f73754f06e1adfb909de43726d4f24c6a3f8805f34f2b0fa/numpy-2.0.2-cp311-cp311-win32.whl", hash = "sha256:a392a68bd329eafac5817e5aefeb39038c48b671afd242710b451e76090e81f4", size = 6470640 },
+    { url = "https://files.pythonhosted.org/packages/eb/57/3a3f14d3a759dcf9bf6e9eda905794726b758819df4663f217d658a58695/numpy-2.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:286cd40ce2b7d652a6f22efdfc6d1edf879440e53e76a75955bc0c826c7e64dc", size = 15910230 },
+    { url = "https://files.pythonhosted.org/packages/45/40/2e117be60ec50d98fa08c2f8c48e09b3edea93cfcabd5a9ff6925d54b1c2/numpy-2.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:df55d490dea7934f330006d0f81e8551ba6010a5bf035a249ef61a94f21c500b", size = 20895803 },
+    { url = "https://files.pythonhosted.org/packages/46/92/1b8b8dee833f53cef3e0a3f69b2374467789e0bb7399689582314df02651/numpy-2.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8df823f570d9adf0978347d1f926b2a867d5608f434a7cff7f7908c6570dcf5e", size = 13471835 },
+    { url = "https://files.pythonhosted.org/packages/7f/19/e2793bde475f1edaea6945be141aef6c8b4c669b90c90a300a8954d08f0a/numpy-2.0.2-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:9a92ae5c14811e390f3767053ff54eaee3bf84576d99a2456391401323f4ec2c", size = 5038499 },
+    { url = "https://files.pythonhosted.org/packages/e3/ff/ddf6dac2ff0dd50a7327bcdba45cb0264d0e96bb44d33324853f781a8f3c/numpy-2.0.2-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:a842d573724391493a97a62ebbb8e731f8a5dcc5d285dfc99141ca15a3302d0c", size = 6633497 },
+    { url = "https://files.pythonhosted.org/packages/72/21/67f36eac8e2d2cd652a2e69595a54128297cdcb1ff3931cfc87838874bd4/numpy-2.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c05e238064fc0610c840d1cf6a13bf63d7e391717d247f1bf0318172e759e692", size = 13621158 },
+    { url = "https://files.pythonhosted.org/packages/39/68/e9f1126d757653496dbc096cb429014347a36b228f5a991dae2c6b6cfd40/numpy-2.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0123ffdaa88fa4ab64835dcbde75dcdf89c453c922f18dced6e27c90d1d0ec5a", size = 19236173 },
+    { url = "https://files.pythonhosted.org/packages/d1/e9/1f5333281e4ebf483ba1c888b1d61ba7e78d7e910fdd8e6499667041cc35/numpy-2.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:96a55f64139912d61de9137f11bf39a55ec8faec288c75a54f93dfd39f7eb40c", size = 19634174 },
+    { url = "https://files.pythonhosted.org/packages/71/af/a469674070c8d8408384e3012e064299f7a2de540738a8e414dcfd639996/numpy-2.0.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ec9852fb39354b5a45a80bdab5ac02dd02b15f44b3804e9f00c556bf24b4bded", size = 14099701 },
+    { url = "https://files.pythonhosted.org/packages/d0/3d/08ea9f239d0e0e939b6ca52ad403c84a2bce1bde301a8eb4888c1c1543f1/numpy-2.0.2-cp312-cp312-win32.whl", hash = "sha256:671bec6496f83202ed2d3c8fdc486a8fc86942f2e69ff0e986140339a63bcbe5", size = 6174313 },
+    { url = "https://files.pythonhosted.org/packages/b2/b5/4ac39baebf1fdb2e72585c8352c56d063b6126be9fc95bd2bb5ef5770c20/numpy-2.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:cfd41e13fdc257aa5778496b8caa5e856dc4896d4ccf01841daee1d96465467a", size = 15606179 },
+    { url = "https://files.pythonhosted.org/packages/43/c1/41c8f6df3162b0c6ffd4437d729115704bd43363de0090c7f913cfbc2d89/numpy-2.0.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:9059e10581ce4093f735ed23f3b9d283b9d517ff46009ddd485f1747eb22653c", size = 21169942 },
+    { url = "https://files.pythonhosted.org/packages/39/bc/fd298f308dcd232b56a4031fd6ddf11c43f9917fbc937e53762f7b5a3bb1/numpy-2.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:423e89b23490805d2a5a96fe40ec507407b8ee786d66f7328be214f9679df6dd", size = 13711512 },
+    { url = "https://files.pythonhosted.org/packages/96/ff/06d1aa3eeb1c614eda245c1ba4fb88c483bee6520d361641331872ac4b82/numpy-2.0.2-cp39-cp39-macosx_14_0_arm64.whl", hash = "sha256:2b2955fa6f11907cf7a70dab0d0755159bca87755e831e47932367fc8f2f2d0b", size = 5306976 },
+    { url = "https://files.pythonhosted.org/packages/2d/98/121996dcfb10a6087a05e54453e28e58694a7db62c5a5a29cee14c6e047b/numpy-2.0.2-cp39-cp39-macosx_14_0_x86_64.whl", hash = "sha256:97032a27bd9d8988b9a97a8c4d2c9f2c15a81f61e2f21404d7e8ef00cb5be729", size = 6906494 },
+    { url = "https://files.pythonhosted.org/packages/15/31/9dffc70da6b9bbf7968f6551967fc21156207366272c2a40b4ed6008dc9b/numpy-2.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1e795a8be3ddbac43274f18588329c72939870a16cae810c2b73461c40718ab1", size = 13912596 },
+    { url = "https://files.pythonhosted.org/packages/b9/14/78635daab4b07c0930c919d451b8bf8c164774e6a3413aed04a6d95758ce/numpy-2.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f26b258c385842546006213344c50655ff1555a9338e2e5e02a0756dc3e803dd", size = 19526099 },
+    { url = "https://files.pythonhosted.org/packages/26/4c/0eeca4614003077f68bfe7aac8b7496f04221865b3a5e7cb230c9d055afd/numpy-2.0.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5fec9451a7789926bcf7c2b8d187292c9f93ea30284802a0ab3f5be8ab36865d", size = 19932823 },
+    { url = "https://files.pythonhosted.org/packages/f1/46/ea25b98b13dccaebddf1a803f8c748680d972e00507cd9bc6dcdb5aa2ac1/numpy-2.0.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:9189427407d88ff25ecf8f12469d4d39d35bee1db5d39fc5c168c6f088a6956d", size = 14404424 },
+    { url = "https://files.pythonhosted.org/packages/c8/a6/177dd88d95ecf07e722d21008b1b40e681a929eb9e329684d449c36586b2/numpy-2.0.2-cp39-cp39-win32.whl", hash = "sha256:905d16e0c60200656500c95b6b8dca5d109e23cb24abc701d41c02d74c6b3afa", size = 6476809 },
+    { url = "https://files.pythonhosted.org/packages/ea/2b/7fc9f4e7ae5b507c1a3a21f0f15ed03e794c1242ea8a242ac158beb56034/numpy-2.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:a3f4ab0caa7f053f6797fcd4e1e25caee367db3112ef2b6ef82d749530768c73", size = 15911314 },
+    { url = "https://files.pythonhosted.org/packages/8f/3b/df5a870ac6a3be3a86856ce195ef42eec7ae50d2a202be1f5a4b3b340e14/numpy-2.0.2-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:7f0a0c6f12e07fa94133c8a67404322845220c06a9e80e85999afe727f7438b8", size = 21025288 },
+    { url = "https://files.pythonhosted.org/packages/2c/97/51af92f18d6f6f2d9ad8b482a99fb74e142d71372da5d834b3a2747a446e/numpy-2.0.2-pp39-pypy39_pp73-macosx_14_0_x86_64.whl", hash = "sha256:312950fdd060354350ed123c0e25a71327d3711584beaef30cdaa93320c392d4", size = 6762793 },
+    { url = "https://files.pythonhosted.org/packages/12/46/de1fbd0c1b5ccaa7f9a005b66761533e2f6a3e560096682683a223631fe9/numpy-2.0.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:26df23238872200f63518dd2aa984cfca675d82469535dc7162dc2ee52d9dd5c", size = 19334885 },
+    { url = "https://files.pythonhosted.org/packages/cc/dc/d330a6faefd92b446ec0f0dfea4c3207bb1fef3c4771d19cf4543efd2c78/numpy-2.0.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:a46288ec55ebbd58947d31d72be2c63cbf839f0a63b49cb755022310792a3385", size = 15828784 },
+]
+
+[[package]]
+name = "packaging"
+version = "24.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f", size = 163950 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759", size = 65451 },
+]
+
+[[package]]
+name = "pandas"
+version = "2.2.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "numpy", marker = "python_full_version >= '3.9' and python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
+    { name = "python-dateutil", marker = "python_full_version >= '3.9' and python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
+    { name = "pytz", marker = "python_full_version >= '3.9' and python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
+    { name = "tzdata", marker = "python_full_version >= '3.9' and python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/9c/d6/9f8431bacc2e19dca897724cd097b1bb224a6ad5433784a44b587c7c13af/pandas-2.2.3.tar.gz", hash = "sha256:4f18ba62b61d7e192368b84517265a99b4d7ee8912f8708660fb4a366cc82667", size = 4399213 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/aa/70/c853aec59839bceed032d52010ff5f1b8d87dc3114b762e4ba2727661a3b/pandas-2.2.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:1948ddde24197a0f7add2bdc4ca83bf2b1ef84a1bc8ccffd95eda17fd836ecb5", size = 12580827 },
+    { url = "https://files.pythonhosted.org/packages/99/f2/c4527768739ffa4469b2b4fff05aa3768a478aed89a2f271a79a40eee984/pandas-2.2.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:381175499d3802cde0eabbaf6324cce0c4f5d52ca6f8c377c29ad442f50f6348", size = 11303897 },
+    { url = "https://files.pythonhosted.org/packages/ed/12/86c1747ea27989d7a4064f806ce2bae2c6d575b950be087837bdfcabacc9/pandas-2.2.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d9c45366def9a3dd85a6454c0e7908f2b3b8e9c138f5dc38fed7ce720d8453ed", size = 66480908 },
+    { url = "https://files.pythonhosted.org/packages/44/50/7db2cd5e6373ae796f0ddad3675268c8d59fb6076e66f0c339d61cea886b/pandas-2.2.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:86976a1c5b25ae3f8ccae3a5306e443569ee3c3faf444dfd0f41cda24667ad57", size = 13064210 },
+    { url = "https://files.pythonhosted.org/packages/61/61/a89015a6d5536cb0d6c3ba02cebed51a95538cf83472975275e28ebf7d0c/pandas-2.2.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:b8661b0238a69d7aafe156b7fa86c44b881387509653fdf857bebc5e4008ad42", size = 16754292 },
+    { url = "https://files.pythonhosted.org/packages/ce/0d/4cc7b69ce37fac07645a94e1d4b0880b15999494372c1523508511b09e40/pandas-2.2.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:37e0aced3e8f539eccf2e099f65cdb9c8aa85109b0be6e93e2baff94264bdc6f", size = 14416379 },
+    { url = "https://files.pythonhosted.org/packages/31/9e/6ebb433de864a6cd45716af52a4d7a8c3c9aaf3a98368e61db9e69e69a9c/pandas-2.2.3-cp310-cp310-win_amd64.whl", hash = "sha256:56534ce0746a58afaf7942ba4863e0ef81c9c50d3f0ae93e9497d6a41a057645", size = 11598471 },
+    { url = "https://files.pythonhosted.org/packages/a8/44/d9502bf0ed197ba9bf1103c9867d5904ddcaf869e52329787fc54ed70cc8/pandas-2.2.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:66108071e1b935240e74525006034333f98bcdb87ea116de573a6a0dccb6c039", size = 12602222 },
+    { url = "https://files.pythonhosted.org/packages/52/11/9eac327a38834f162b8250aab32a6781339c69afe7574368fffe46387edf/pandas-2.2.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7c2875855b0ff77b2a64a0365e24455d9990730d6431b9e0ee18ad8acee13dbd", size = 11321274 },
+    { url = "https://files.pythonhosted.org/packages/45/fb/c4beeb084718598ba19aa9f5abbc8aed8b42f90930da861fcb1acdb54c3a/pandas-2.2.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cd8d0c3be0515c12fed0bdbae072551c8b54b7192c7b1fda0ba56059a0179698", size = 15579836 },
+    { url = "https://files.pythonhosted.org/packages/cd/5f/4dba1d39bb9c38d574a9a22548c540177f78ea47b32f99c0ff2ec499fac5/pandas-2.2.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c124333816c3a9b03fbeef3a9f230ba9a737e9e5bb4060aa2107a86cc0a497fc", size = 13058505 },
+    { url = "https://files.pythonhosted.org/packages/b9/57/708135b90391995361636634df1f1130d03ba456e95bcf576fada459115a/pandas-2.2.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:63cc132e40a2e084cf01adf0775b15ac515ba905d7dcca47e9a251819c575ef3", size = 16744420 },
+    { url = "https://files.pythonhosted.org/packages/86/4a/03ed6b7ee323cf30404265c284cee9c65c56a212e0a08d9ee06984ba2240/pandas-2.2.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:29401dbfa9ad77319367d36940cd8a0b3a11aba16063e39632d98b0e931ddf32", size = 14440457 },
+    { url = "https://files.pythonhosted.org/packages/ed/8c/87ddf1fcb55d11f9f847e3c69bb1c6f8e46e2f40ab1a2d2abadb2401b007/pandas-2.2.3-cp311-cp311-win_amd64.whl", hash = "sha256:3fc6873a41186404dad67245896a6e440baacc92f5b716ccd1bc9ed2995ab2c5", size = 11617166 },
+    { url = "https://files.pythonhosted.org/packages/17/a3/fb2734118db0af37ea7433f57f722c0a56687e14b14690edff0cdb4b7e58/pandas-2.2.3-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:b1d432e8d08679a40e2a6d8b2f9770a5c21793a6f9f47fdd52c5ce1948a5a8a9", size = 12529893 },
+    { url = "https://files.pythonhosted.org/packages/e1/0c/ad295fd74bfac85358fd579e271cded3ac969de81f62dd0142c426b9da91/pandas-2.2.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a5a1595fe639f5988ba6a8e5bc9649af3baf26df3998a0abe56c02609392e0a4", size = 11363475 },
+    { url = "https://files.pythonhosted.org/packages/c6/2a/4bba3f03f7d07207481fed47f5b35f556c7441acddc368ec43d6643c5777/pandas-2.2.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5de54125a92bb4d1c051c0659e6fcb75256bf799a732a87184e5ea503965bce3", size = 15188645 },
+    { url = "https://files.pythonhosted.org/packages/38/f8/d8fddee9ed0d0c0f4a2132c1dfcf0e3e53265055da8df952a53e7eaf178c/pandas-2.2.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fffb8ae78d8af97f849404f21411c95062db1496aeb3e56f146f0355c9989319", size = 12739445 },
+    { url = "https://files.pythonhosted.org/packages/20/e8/45a05d9c39d2cea61ab175dbe6a2de1d05b679e8de2011da4ee190d7e748/pandas-2.2.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6dfcb5ee8d4d50c06a51c2fffa6cff6272098ad6540aed1a76d15fb9318194d8", size = 16359235 },
+    { url = "https://files.pythonhosted.org/packages/1d/99/617d07a6a5e429ff90c90da64d428516605a1ec7d7bea494235e1c3882de/pandas-2.2.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:062309c1b9ea12a50e8ce661145c6aab431b1e99530d3cd60640e255778bd43a", size = 14056756 },
+    { url = "https://files.pythonhosted.org/packages/29/d4/1244ab8edf173a10fd601f7e13b9566c1b525c4f365d6bee918e68381889/pandas-2.2.3-cp312-cp312-win_amd64.whl", hash = "sha256:59ef3764d0fe818125a5097d2ae867ca3fa64df032331b7e0917cf5d7bf66b13", size = 11504248 },
+    { url = "https://files.pythonhosted.org/packages/64/22/3b8f4e0ed70644e85cfdcd57454686b9057c6c38d2f74fe4b8bc2527214a/pandas-2.2.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f00d1345d84d8c86a63e476bb4955e46458b304b9575dcf71102b5c705320015", size = 12477643 },
+    { url = "https://files.pythonhosted.org/packages/e4/93/b3f5d1838500e22c8d793625da672f3eec046b1a99257666c94446969282/pandas-2.2.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3508d914817e153ad359d7e069d752cdd736a247c322d932eb89e6bc84217f28", size = 11281573 },
+    { url = "https://files.pythonhosted.org/packages/f5/94/6c79b07f0e5aab1dcfa35a75f4817f5c4f677931d4234afcd75f0e6a66ca/pandas-2.2.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:22a9d949bfc9a502d320aa04e5d02feab689d61da4e7764b62c30b991c42c5f0", size = 15196085 },
+    { url = "https://files.pythonhosted.org/packages/e8/31/aa8da88ca0eadbabd0a639788a6da13bb2ff6edbbb9f29aa786450a30a91/pandas-2.2.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f3a255b2c19987fbbe62a9dfd6cff7ff2aa9ccab3fc75218fd4b7530f01efa24", size = 12711809 },
+    { url = "https://files.pythonhosted.org/packages/ee/7c/c6dbdb0cb2a4344cacfb8de1c5808ca885b2e4dcfde8008266608f9372af/pandas-2.2.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:800250ecdadb6d9c78eae4990da62743b857b470883fa27f652db8bdde7f6659", size = 16356316 },
+    { url = "https://files.pythonhosted.org/packages/57/b7/8b757e7d92023b832869fa8881a992696a0bfe2e26f72c9ae9f255988d42/pandas-2.2.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6374c452ff3ec675a8f46fd9ab25c4ad0ba590b71cf0656f8b6daa5202bca3fb", size = 14022055 },
+    { url = "https://files.pythonhosted.org/packages/3b/bc/4b18e2b8c002572c5a441a64826252ce5da2aa738855747247a971988043/pandas-2.2.3-cp313-cp313-win_amd64.whl", hash = "sha256:61c5ad4043f791b61dd4752191d9f07f0ae412515d59ba8f005832a532f8736d", size = 11481175 },
+    { url = "https://files.pythonhosted.org/packages/76/a3/a5d88146815e972d40d19247b2c162e88213ef51c7c25993942c39dbf41d/pandas-2.2.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:3b71f27954685ee685317063bf13c7709a7ba74fc996b84fc6821c59b0f06468", size = 12615650 },
+    { url = "https://files.pythonhosted.org/packages/9c/8c/f0fd18f6140ddafc0c24122c8a964e48294acc579d47def376fef12bcb4a/pandas-2.2.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:38cf8125c40dae9d5acc10fa66af8ea6fdf760b2714ee482ca691fc66e6fcb18", size = 11290177 },
+    { url = "https://files.pythonhosted.org/packages/ed/f9/e995754eab9c0f14c6777401f7eece0943840b7a9fc932221c19d1abee9f/pandas-2.2.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ba96630bc17c875161df3818780af30e43be9b166ce51c9a18c1feae342906c2", size = 14651526 },
+    { url = "https://files.pythonhosted.org/packages/25/b0/98d6ae2e1abac4f35230aa756005e8654649d305df9a28b16b9ae4353bff/pandas-2.2.3-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1db71525a1538b30142094edb9adc10be3f3e176748cd7acc2240c2f2e5aa3a4", size = 11871013 },
+    { url = "https://files.pythonhosted.org/packages/cc/57/0f72a10f9db6a4628744c8e8f0df4e6e21de01212c7c981d31e50ffc8328/pandas-2.2.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:15c0e1e02e93116177d29ff83e8b1619c93ddc9c49083f237d4312337a61165d", size = 15711620 },
+    { url = "https://files.pythonhosted.org/packages/ab/5f/b38085618b950b79d2d9164a711c52b10aefc0ae6833b96f626b7021b2ed/pandas-2.2.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:ad5b65698ab28ed8d7f18790a0dc58005c7629f227be9ecc1072aa74c0c1d43a", size = 13098436 },
+    { url = "https://files.pythonhosted.org/packages/ca/8c/8848a4c9b8fdf5a534fe2077af948bf53cd713d77ffbcd7bd15710348fd7/pandas-2.2.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:bc6b93f9b966093cb0fd62ff1a7e4c09e6d546ad7c1de191767baffc57628f39", size = 12595535 },
+    { url = "https://files.pythonhosted.org/packages/9c/b9/5cead4f63b6d31bdefeb21a679bc5a7f4aaf262ca7e07e2bc1c341b68470/pandas-2.2.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:5dbca4c1acd72e8eeef4753eeca07de9b1db4f398669d5994086f788a5d7cc30", size = 11319822 },
+    { url = "https://files.pythonhosted.org/packages/31/af/89e35619fb573366fa68dc26dad6ad2c08c17b8004aad6d98f1a31ce4bb3/pandas-2.2.3-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8cd6d7cc958a3910f934ea8dbdf17b2364827bb4dafc38ce6eef6bb3d65ff09c", size = 15625439 },
+    { url = "https://files.pythonhosted.org/packages/3d/dd/bed19c2974296661493d7acc4407b1d2db4e2a482197df100f8f965b6225/pandas-2.2.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:99df71520d25fade9db7c1076ac94eb994f4d2673ef2aa2e86ee039b6746d20c", size = 13068928 },
+    { url = "https://files.pythonhosted.org/packages/31/a3/18508e10a31ea108d746c848b5a05c0711e0278fa0d6f1c52a8ec52b80a5/pandas-2.2.3-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:31d0ced62d4ea3e231a9f228366919a5ea0b07440d9d4dac345376fd8e1477ea", size = 16783266 },
+    { url = "https://files.pythonhosted.org/packages/c4/a5/3429bd13d82bebc78f4d78c3945efedef63a7cd0c15c17b2eeb838d1121f/pandas-2.2.3-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:7eee9e7cea6adf3e3d24e304ac6b8300646e2a5d1cd3a3c2abed9101b0846761", size = 14450871 },
+    { url = "https://files.pythonhosted.org/packages/2f/49/5c30646e96c684570925b772eac4eb0a8cb0ca590fa978f56c5d3ae73ea1/pandas-2.2.3-cp39-cp39-win_amd64.whl", hash = "sha256:4850ba03528b6dd51d6c5d273c46f183f39a9baf3f0143e566b89450965b105e", size = 11618011 },
+]
+
+[[package]]
+name = "pathspec"
+version = "0.12.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/ca/bc/f35b8446f4531a7cb215605d100cd88b7ac6f44ab3fc94870c120ab3adbf/pathspec-0.12.1.tar.gz", hash = "sha256:a482d51503a1ab33b1c67a6c3813a26953dbdc71c31dacaef9a838c4e29f5712", size = 51043 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/cc/20/ff623b09d963f88bfde16306a54e12ee5ea43e9b597108672ff3a408aad6/pathspec-0.12.1-py3-none-any.whl", hash = "sha256:a0d503e138a4c123b27490a4f7beda6a01c6f288df0e4a8b79c7eb0dc7b4cc08", size = 31191 },
+]
+
+[[package]]
+name = "platformdirs"
+version = "4.3.6"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/13/fc/128cc9cb8f03208bdbf93d3aa862e16d376844a14f9a0ce5cf4507372de4/platformdirs-4.3.6.tar.gz", hash = "sha256:357fb2acbc885b0419afd3ce3ed34564c13c9b95c89360cd9563f73aa5e2b907", size = 21302 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/3c/a6/bc1012356d8ece4d66dd75c4b9fc6c1f6650ddd5991e421177d9f8f671be/platformdirs-4.3.6-py3-none-any.whl", hash = "sha256:73e575e1408ab8103900836b97580d5307456908a03e92031bab39e4554cc3fb", size = 18439 },
+]
+
+[[package]]
+name = "pluggy"
+version = "1.5.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/96/2d/02d4312c973c6050a18b314a5ad0b3210edb65a906f868e31c111dede4a6/pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1", size = 67955 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/88/5f/e351af9a41f866ac3f1fac4ca0613908d9a41741cfcf2228f4ad853b697d/pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669", size = 20556 },
+]
+
+[[package]]
+name = "pydantic-core"
+version = "2.27.0"
+source = { virtual = "." }
+dependencies = [
+    { name = "typing-extensions" },
+]
+
+[package.dev-dependencies]
+all = [
+    { name = "backports-zoneinfo", marker = "python_full_version < '3.9'" },
+    { name = "coverage" },
+    { name = "dirty-equals" },
+    { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
+    { name = "griffe" },
+    { name = "hypothesis" },
+    { name = "inline-snapshot" },
+    { name = "maturin" },
+    { name = "mypy" },
+    { name = "numpy", marker = "python_full_version >= '3.9' and python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
+    { name = "pandas", marker = "python_full_version >= '3.9' and python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
+    { name = "pyright" },
+    { name = "pytest" },
+    { name = "pytest-examples", marker = "implementation_name == 'cpython' and platform_machine == 'x86_64'" },
+    { name = "pytest-mock" },
+    { name = "pytest-pretty" },
+    { name = "pytest-speed" },
+    { name = "pytest-timeout" },
+    { name = "python-dateutil" },
+    { name = "ruff" },
+    { name = "typing-extensions" },
+    { name = "tzdata" },
+]
+linting = [
+    { name = "griffe" },
+    { name = "mypy" },
+    { name = "pyright" },
+    { name = "ruff" },
+]
+testing = [
+    { name = "backports-zoneinfo", marker = "python_full_version < '3.9'" },
+    { name = "coverage" },
+    { name = "dirty-equals" },
+    { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
+    { name = "hypothesis" },
+    { name = "inline-snapshot" },
+    { name = "numpy", marker = "python_full_version >= '3.9' and python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
+    { name = "pandas", marker = "python_full_version >= '3.9' and python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
+    { name = "pytest" },
+    { name = "pytest-examples", marker = "implementation_name == 'cpython' and platform_machine == 'x86_64'" },
+    { name = "pytest-mock" },
+    { name = "pytest-pretty" },
+    { name = "pytest-speed" },
+    { name = "pytest-timeout" },
+    { name = "python-dateutil" },
+    { name = "typing-extensions" },
+    { name = "tzdata" },
+]
+wasm = [
+    { name = "maturin" },
+    { name = "ruff" },
+    { name = "typing-extensions" },
+]
+
+[package.metadata]
+requires-dist = [{ name = "typing-extensions", specifier = ">=4.6.0,!=4.7.0" }]
+
+[package.metadata.requires-dev]
+all = [
+    { name = "backports-zoneinfo", marker = "python_full_version < '3.9'" },
+    { name = "coverage" },
+    { name = "dirty-equals" },
+    { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
+    { name = "griffe" },
+    { name = "hypothesis" },
+    { name = "inline-snapshot" },
+    { name = "maturin", specifier = ">=1,<2" },
+    { name = "mypy" },
+    { name = "numpy", marker = "python_full_version >= '3.9' and python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
+    { name = "pandas", marker = "python_full_version >= '3.9' and python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
+    { name = "pyright" },
+    { name = "pytest" },
+    { name = "pytest-examples", marker = "implementation_name == 'cpython' and platform_machine == 'x86_64'" },
+    { name = "pytest-mock" },
+    { name = "pytest-pretty" },
+    { name = "pytest-speed" },
+    { name = "pytest-timeout" },
+    { name = "python-dateutil" },
+    { name = "ruff" },
+    { name = "typing-extensions" },
+    { name = "tzdata" },
+]
+linting = [
+    { name = "griffe" },
+    { name = "mypy" },
+    { name = "pyright" },
+    { name = "ruff" },
+]
+testing = [
+    { name = "backports-zoneinfo", marker = "python_full_version < '3.9'" },
+    { name = "coverage" },
+    { name = "dirty-equals" },
+    { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
+    { name = "hypothesis" },
+    { name = "inline-snapshot" },
+    { name = "numpy", marker = "python_full_version >= '3.9' and python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
+    { name = "pandas", marker = "python_full_version >= '3.9' and python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
+    { name = "pytest" },
+    { name = "pytest-examples", marker = "implementation_name == 'cpython' and platform_machine == 'x86_64'" },
+    { name = "pytest-mock" },
+    { name = "pytest-pretty" },
+    { name = "pytest-speed" },
+    { name = "pytest-timeout" },
+    { name = "python-dateutil" },
+    { name = "typing-extensions" },
+    { name = "tzdata" },
+]
+wasm = [
+    { name = "maturin", specifier = ">=1,<2" },
+    { name = "ruff" },
+    { name = "typing-extensions" },
+]
+
+[[package]]
+name = "pygments"
+version = "2.18.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/8e/62/8336eff65bcbc8e4cb5d05b55faf041285951b6e80f33e2bff2024788f31/pygments-2.18.0.tar.gz", hash = "sha256:786ff802f32e91311bff3889f6e9a86e81505fe99f2735bb6d60ae0c5004f199", size = 4891905 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f7/3f/01c8b82017c199075f8f788d0d906b9ffbbc5a47dc9918a945e13d5a2bda/pygments-2.18.0-py3-none-any.whl", hash = "sha256:b8e6aca0523f3ab76fee51799c488e38782ac06eafcf95e7ba832985c8e7b13a", size = 1205513 },
+]
+
+[[package]]
+name = "pyright"
+version = "1.1.389"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "nodeenv" },
+    { name = "typing-extensions" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/72/4e/9a5ab8745e7606b88c2c7ca223449ac9d82a71fd5e31df47b453f2cb39a1/pyright-1.1.389.tar.gz", hash = "sha256:716bf8cc174ab8b4dcf6828c3298cac05c5ed775dda9910106a5dcfe4c7fe220", size = 21940 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/1b/26/c288cabf8cfc5a27e1aa9e5029b7682c0f920b8074f45d22bf844314d66a/pyright-1.1.389-py3-none-any.whl", hash = "sha256:41e9620bba9254406dc1f621a88ceab5a88af4c826feb4f614d95691ed243a60", size = 18581 },
+]
+
+[[package]]
+name = "pytest"
+version = "8.3.3"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "colorama", marker = "sys_platform == 'win32'" },
+    { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
+    { name = "iniconfig" },
+    { name = "packaging" },
+    { name = "pluggy" },
+    { name = "tomli", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/8b/6c/62bbd536103af674e227c41a8f3dcd022d591f6eed5facb5a0f31ee33bbc/pytest-8.3.3.tar.gz", hash = "sha256:70b98107bd648308a7952b06e6ca9a50bc660be218d53c257cc1fc94fda10181", size = 1442487 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/6b/77/7440a06a8ead44c7757a64362dd22df5760f9b12dc5f11b6188cd2fc27a0/pytest-8.3.3-py3-none-any.whl", hash = "sha256:a6853c7375b2663155079443d2e45de913a911a11d669df02a50814944db57b2", size = 342341 },
+]
+
+[[package]]
+name = "pytest-examples"
+version = "0.0.14"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "black" },
+    { name = "pytest" },
+    { name = "ruff" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/d2/a7/b81d5cf26e9713a2d4c8e6863ee009360c5c07a0cfb880456ec8b09adab7/pytest_examples-0.0.14.tar.gz", hash = "sha256:776d1910709c0c5ce01b29bfe3651c5312d5cfe5c063e23ca6f65aed9af23f09", size = 20767 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/2b/99/f418071551ff2b5e8c06bd8b82b1f4fd472b5e4162f018773ba4ef52b6e8/pytest_examples-0.0.14-py3-none-any.whl", hash = "sha256:867a7ea105635d395df712a4b8d0df3bda4c3d78ae97a57b4f115721952b5e25", size = 17919 },
+]
+
+[[package]]
+name = "pytest-mock"
+version = "3.14.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/c6/90/a955c3ab35ccd41ad4de556596fa86685bf4fc5ffcc62d22d856cfd4e29a/pytest-mock-3.14.0.tar.gz", hash = "sha256:2719255a1efeceadbc056d6bf3df3d1c5015530fb40cf347c0f9afac88410bd0", size = 32814 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/f2/3b/b26f90f74e2986a82df6e7ac7e319b8ea7ccece1caec9f8ab6104dc70603/pytest_mock-3.14.0-py3-none-any.whl", hash = "sha256:0b72c38033392a5f4621342fe11e9219ac11ec9d375f8e2a0c164539e0d70f6f", size = 9863 },
+]
+
+[[package]]
+name = "pytest-pretty"
+version = "1.2.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest" },
+    { name = "rich" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/a5/18/30ad0408295f3157f7a4913f0eaa51a0a377ebad0ffa51ff239e833c6c72/pytest_pretty-1.2.0.tar.gz", hash = "sha256:105a355f128e392860ad2c478ae173ff96d2f03044692f9818ff3d49205d3a60", size = 6542 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/bf/fe/d44d391312c1b8abee2af58ee70fabb1c00b6577ac4e0bdf25b70c1caffb/pytest_pretty-1.2.0-py3-none-any.whl", hash = "sha256:6f79122bf53864ae2951b6c9e94d7a06a87ef753476acd4588aeac018f062036", size = 6180 },
+]
+
+[[package]]
+name = "pytest-speed"
+version = "0.3.5"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "click" },
+    { name = "pytest" },
+    { name = "rich" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/61/21/6acc1504e62f5b72ede4a1d10b70dd3e6a2acc14e21f214673fe701c272b/pytest_speed-0.3.5.tar.gz", hash = "sha256:e76208eb37362d0de9ce228488d18b5d96b95ea0dec6b0ad0e0f4ddfa359f3b0", size = 8702 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/59/c5/654fe3dae7d791d3a177f8aea58bec6aa72b9d8fdde1e2f30cd2e0c5fe1a/pytest_speed-0.3.5-py3-none-any.whl", hash = "sha256:ef9f17d6800b158e0a78df81bdbfe662a27ef5ddbf86376ff092fd6673135466", size = 9717 },
+]
+
+[[package]]
+name = "pytest-timeout"
+version = "2.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/93/0d/04719abc7a4bdb3a7a1f968f24b0f5253d698c9cc94975330e9d3145befb/pytest-timeout-2.3.1.tar.gz", hash = "sha256:12397729125c6ecbdaca01035b9e5239d4db97352320af155b3f5de1ba5165d9", size = 17697 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/03/27/14af9ef8321f5edc7527e47def2a21d8118c6f329a9342cc61387a0c0599/pytest_timeout-2.3.1-py3-none-any.whl", hash = "sha256:68188cb703edfc6a18fad98dc25a3c61e9f24d644b0b70f33af545219fc7813e", size = 14148 },
+]
+
+[[package]]
+name = "python-dateutil"
+version = "2.9.0.post0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "six" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892 },
+]
+
+[[package]]
+name = "pytz"
+version = "2024.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/3a/31/3c70bf7603cc2dca0f19bdc53b4537a797747a58875b552c8c413d963a3f/pytz-2024.2.tar.gz", hash = "sha256:2aa355083c50a0f93fa581709deac0c9ad65cca8a9e9beac660adcbd493c798a", size = 319692 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/11/c3/005fcca25ce078d2cc29fd559379817424e94885510568bc1bc53d7d5846/pytz-2024.2-py2.py3-none-any.whl", hash = "sha256:31c7c1817eb7fae7ca4b8c7ee50c72f93aa2dd863de768e1ef4245d426aa0725", size = 508002 },
+]
+
+[[package]]
+name = "rich"
+version = "13.9.4"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "markdown-it-py" },
+    { name = "pygments" },
+    { name = "typing-extensions", marker = "python_full_version < '3.11'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ab/3a/0316b28d0761c6734d6bc14e770d85506c986c85ffb239e688eeaab2c2bc/rich-13.9.4.tar.gz", hash = "sha256:439594978a49a09530cff7ebc4b5c7103ef57baf48d5ea3184f21d9a2befa098", size = 223149 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/19/71/39c7c0d87f8d4e6c020a393182060eaefeeae6c01dab6a84ec346f2567df/rich-13.9.4-py3-none-any.whl", hash = "sha256:6049d5e6ec054bf2779ab3358186963bac2ea89175919d699e378b99738c2a90", size = 242424 },
+]
+
+[[package]]
+name = "ruff"
+version = "0.7.4"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/0b/8b/bc4e0dfa1245b07cf14300e10319b98e958a53ff074c1dd86b35253a8c2a/ruff-0.7.4.tar.gz", hash = "sha256:cd12e35031f5af6b9b93715d8c4f40360070b2041f81273d0527683d5708fce2", size = 3275547 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/e6/4b/f5094719e254829766b807dadb766841124daba75a37da83e292ae5ad12f/ruff-0.7.4-py3-none-linux_armv6l.whl", hash = "sha256:a4919925e7684a3f18e18243cd6bea7cfb8e968a6eaa8437971f681b7ec51478", size = 10447512 },
+    { url = "https://files.pythonhosted.org/packages/9e/1d/3d2d2c9f601cf6044799c5349ff5267467224cefed9b35edf5f1f36486e9/ruff-0.7.4-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:cfb365c135b830778dda8c04fb7d4280ed0b984e1aec27f574445231e20d6c63", size = 10235436 },
+    { url = "https://files.pythonhosted.org/packages/62/83/42a6ec6216ded30b354b13e0e9327ef75a3c147751aaf10443756cb690e9/ruff-0.7.4-py3-none-macosx_11_0_arm64.whl", hash = "sha256:63a569b36bc66fbadec5beaa539dd81e0527cb258b94e29e0531ce41bacc1f20", size = 9888936 },
+    { url = "https://files.pythonhosted.org/packages/4d/26/e1e54893b13046a6ad05ee9b89ee6f71542ba250f72b4c7a7d17c3dbf73d/ruff-0.7.4-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0d06218747d361d06fd2fdac734e7fa92df36df93035db3dc2ad7aa9852cb109", size = 10697353 },
+    { url = "https://files.pythonhosted.org/packages/21/24/98d2e109c4efc02bfef144ec6ea2c3e1217e7ce0cfddda8361d268dfd499/ruff-0.7.4-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e0cea28d0944f74ebc33e9f934238f15c758841f9f5edd180b5315c203293452", size = 10228078 },
+    { url = "https://files.pythonhosted.org/packages/ad/b7/964c75be9bc2945fc3172241b371197bb6d948cc69e28bc4518448c368f3/ruff-0.7.4-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:80094ecd4793c68b2571b128f91754d60f692d64bc0d7272ec9197fdd09bf9ea", size = 11264823 },
+    { url = "https://files.pythonhosted.org/packages/12/8d/20abdbf705969914ce40988fe71a554a918deaab62c38ec07483e77866f6/ruff-0.7.4-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:997512325c6620d1c4c2b15db49ef59543ef9cd0f4aa8065ec2ae5103cedc7e7", size = 11951855 },
+    { url = "https://files.pythonhosted.org/packages/b8/fc/6519ce58c57b4edafcdf40920b7273dfbba64fc6ebcaae7b88e4dc1bf0a8/ruff-0.7.4-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:00b4cf3a6b5fad6d1a66e7574d78956bbd09abfd6c8a997798f01f5da3d46a05", size = 11516580 },
+    { url = "https://files.pythonhosted.org/packages/37/1a/5ec1844e993e376a86eb2456496831ed91b4398c434d8244f89094758940/ruff-0.7.4-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7dbdc7d8274e1422722933d1edddfdc65b4336abf0b16dfcb9dedd6e6a517d06", size = 12692057 },
+    { url = "https://files.pythonhosted.org/packages/50/90/76867152b0d3c05df29a74bb028413e90f704f0f6701c4801174ba47f959/ruff-0.7.4-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0e92dfb5f00eaedb1501b2f906ccabfd67b2355bdf117fea9719fc99ac2145bc", size = 11085137 },
+    { url = "https://files.pythonhosted.org/packages/c8/eb/0a7cb6059ac3555243bd026bb21785bbc812f7bbfa95a36c101bd72b47ae/ruff-0.7.4-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:3bd726099f277d735dc38900b6a8d6cf070f80828877941983a57bca1cd92172", size = 10681243 },
+    { url = "https://files.pythonhosted.org/packages/5e/76/2270719dbee0fd35780b05c08a07b7a726c3da9f67d9ae89ef21fc18e2e5/ruff-0.7.4-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:2e32829c429dd081ee5ba39aef436603e5b22335c3d3fff013cd585806a6486a", size = 10319187 },
+    { url = "https://files.pythonhosted.org/packages/9f/e5/39100f72f8ba70bec1bd329efc880dea8b6c1765ea1cb9d0c1c5f18b8d7f/ruff-0.7.4-py3-none-musllinux_1_2_i686.whl", hash = "sha256:662a63b4971807623f6f90c1fb664613f67cc182dc4d991471c23c541fee62dd", size = 10803715 },
+    { url = "https://files.pythonhosted.org/packages/a5/89/40e904784f305fb56850063f70a998a64ebba68796d823dde67e89a24691/ruff-0.7.4-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:876f5e09eaae3eb76814c1d3b68879891d6fde4824c015d48e7a7da4cf066a3a", size = 11162912 },
+    { url = "https://files.pythonhosted.org/packages/8d/1b/dd77503b3875c51e3dbc053fd8367b845ab8b01c9ca6d0c237082732856c/ruff-0.7.4-py3-none-win32.whl", hash = "sha256:75c53f54904be42dd52a548728a5b572344b50d9b2873d13a3f8c5e3b91f5cac", size = 8702767 },
+    { url = "https://files.pythonhosted.org/packages/63/76/253ddc3e89e70165bba952ecca424b980b8d3c2598ceb4fc47904f424953/ruff-0.7.4-py3-none-win_amd64.whl", hash = "sha256:745775c7b39f914238ed1f1b0bebed0b9155a17cd8bc0b08d3c87e4703b990d6", size = 9497534 },
+    { url = "https://files.pythonhosted.org/packages/aa/70/f8724f31abc0b329ca98b33d73c14020168babcf71b0cba3cded5d9d0e66/ruff-0.7.4-py3-none-win_arm64.whl", hash = "sha256:11bff065102c3ae9d3ea4dc9ecdfe5a5171349cdd0787c1fc64761212fc9cf1f", size = 8851590 },
+]
+
+[[package]]
+name = "six"
+version = "1.16.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/71/39/171f1c67cd00715f190ba0b100d606d440a28c93c7714febeca8b79af85e/six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926", size = 34041 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/d9/5a/e7c31adbe875f2abbb91bd84cf2dc52d792b5a01506781dbcf25c91daf11/six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254", size = 11053 },
+]
+
+[[package]]
+name = "sortedcontainers"
+version = "2.4.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e8/c4/ba2f8066cceb6f23394729afe52f3bf7adec04bf9ed2c820b39e19299111/sortedcontainers-2.4.0.tar.gz", hash = "sha256:25caa5a06cc30b6b83d11423433f65d1f9d76c4c6a0c90e3379eaa43b9bfdb88", size = 30594 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/32/46/9cb0e58b2deb7f82b84065f37f3bffeb12413f947f9388e4cac22c4621ce/sortedcontainers-2.4.0-py2.py3-none-any.whl", hash = "sha256:a163dcaede0f1c021485e957a39245190e74249897e2ae4b2aa38595db237ee0", size = 29575 },
+]
+
+[[package]]
+name = "tomli"
+version = "2.1.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1e/e4/1b6cbcc82d8832dd0ce34767d5c560df8a3547ad8cbc427f34601415930a/tomli-2.1.0.tar.gz", hash = "sha256:3f646cae2aec94e17d04973e4249548320197cfabdf130015d023de4b74d8ab8", size = 16622 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/de/f7/4da0ffe1892122c9ea096c57f64c2753ae5dd3ce85488802d11b0992cc6d/tomli-2.1.0-py3-none-any.whl", hash = "sha256:a5c57c3d1c56f5ccdf89f6523458f60ef716e210fc47c4cfb188c5ba473e0391", size = 13750 },
+]
+
+[[package]]
+name = "typing-extensions"
+version = "4.12.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/df/db/f35a00659bc03fec321ba8bce9420de607a1d37f8342eee1863174c69557/typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8", size = 85321 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/26/9f/ad63fc0248c5379346306f8668cda6e2e2e9c95e01216d2b8ffd9ff037d0/typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d", size = 37438 },
+]
+
+[[package]]
+name = "tzdata"
+version = "2024.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e1/34/943888654477a574a86a98e9896bae89c7aa15078ec29f490fef2f1e5384/tzdata-2024.2.tar.gz", hash = "sha256:7d85cc416e9382e69095b7bdf4afd9e3880418a2413feec7069d533d6b4e31cc", size = 193282 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a6/ab/7e5f53c3b9d14972843a647d8d7a853969a58aecc7559cb3267302c94774/tzdata-2024.2-py2.py3-none-any.whl", hash = "sha256:a48093786cdcde33cad18c2555e8532f34422074448fbc874186f0abd79565cd", size = 346586 },
+]
+
+[[package]]
+name = "wheel"
+version = "0.45.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/e7/52/fd4516fb8f7d11a08e3f9cd69eb1558f098ab67e79f32d920c4974ee550f/wheel-0.45.0.tar.gz", hash = "sha256:a57353941a3183b3d5365346b567a260a0602a0f8a635926a7dede41b94c674a", size = 107426 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/92/81/65ae90d584a73ca976d8f1eb83e2f58447a4055a9fb3ae69b28721070bdf/wheel-0.45.0-py3-none-any.whl", hash = "sha256:52f0baa5e6522155090a09c6bd95718cc46956d1b51d537ea5454249edb671c7", size = 72497 },
+]

From afd23eea7c2cb7755ba0530a4bf15c3c85733b8e Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Thu, 21 Nov 2024 13:36:52 -0500
Subject: [PATCH 431/550] Fix serialization inference for `complex` types in
 `python` (#1549)

---
 src/serializers/infer.rs          | 3 +--
 tests/serializers/test_complex.py | 6 ++++++
 2 files changed, 7 insertions(+), 2 deletions(-)

diff --git a/src/serializers/infer.rs b/src/serializers/infer.rs
index bdfa74b52..a188f6f60 100644
--- a/src/serializers/infer.rs
+++ b/src/serializers/infer.rs
@@ -285,8 +285,7 @@ pub(crate) fn infer_to_python_known(
             }
             ObType::Complex => {
                 let v = value.downcast::<PyComplex>()?;
-                let complex_str = type_serializers::complex::complex_to_str(v);
-                complex_str.into_py(py)
+                v.into_py(py)
             }
             ObType::Unknown => {
                 if let Some(fallback) = extra.fallback {
diff --git a/tests/serializers/test_complex.py b/tests/serializers/test_complex.py
index e7c98246a..2805ab3bd 100644
--- a/tests/serializers/test_complex.py
+++ b/tests/serializers/test_complex.py
@@ -37,3 +37,9 @@ def test_complex_json(value, expected):
         assert math.isnan(c.real)
     else:
         assert c.imag == value.imag
+
+
+def test_complex_inference() -> None:
+    s = SchemaSerializer(core_schema.any_schema())
+    assert s.to_python(1 + 2j) == 1 + 2j
+    assert s.to_json(1 + 2j) == b'"1+2j"'

From 4477692c0ac616c40b25a7102c942c531f7e6bf8 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Thu, 21 Nov 2024 18:56:28 +0000
Subject: [PATCH 432/550] bump to PyO3 0.22.6 (#1550)

---
 Cargo.lock | 20 ++++++++++----------
 Cargo.toml |  6 +++---
 2 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 05b27a3ed..f5b107750 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -451,9 +451,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.22.5"
+version = "0.22.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3d922163ba1f79c04bc49073ba7b32fd5a8d3b76a87c955921234b8e77333c51"
+checksum = "f402062616ab18202ae8319da13fa4279883a2b8a9d9f83f20dbade813ce1884"
 dependencies = [
  "cfg-if",
  "indoc",
@@ -470,9 +470,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.22.5"
+version = "0.22.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bc38c5feeb496c8321091edf3d63e9a6829eab4b863b4a6a65f26f3e9cc6b179"
+checksum = "b14b5775b5ff446dd1056212d778012cbe8a0fbffd368029fd9e25b514479c38"
 dependencies = [
  "once_cell",
  "python3-dll-a",
@@ -481,9 +481,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.22.5"
+version = "0.22.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94845622d88ae274d2729fcefc850e63d7a3ddff5e3ce11bd88486db9f1d357d"
+checksum = "9ab5bcf04a2cdcbb50c7d6105de943f543f9ed92af55818fd17b660390fc8636"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -491,9 +491,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.22.5"
+version = "0.22.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e655aad15e09b94ffdb3ce3d217acf652e26bbc37697ef012f5e5e348c716e5e"
+checksum = "0fd24d897903a9e6d80b968368a34e1525aeb719d568dba8b3d4bfa5dc67d453"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -503,9 +503,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.22.5"
+version = "0.22.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ae1e3f09eecd94618f60a455a23def79f79eba4dc561a97324bf9ac8c6df30ce"
+checksum = "36c011a03ba1e50152b4b394b479826cad97e7a21eb52df179cd91ac411cbfbe"
 dependencies = [
  "heck",
  "proc-macro2",
diff --git a/Cargo.toml b/Cargo.toml
index 25dbe6932..d2f470449 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -29,7 +29,7 @@ rust-version = "1.75"
 [dependencies]
 # TODO it would be very nice to remove the "py-clone" feature as it can panic,
 # but needs a bit of work to make sure it's not used in the codebase
-pyo3 = { version = "0.22.5", features = ["generate-import-lib", "num-bigint", "py-clone"] }
+pyo3 = { version = "0.22.6", features = ["generate-import-lib", "num-bigint", "py-clone"] }
 regex = "1.11.1"
 strum = { version = "0.26.3", features = ["derive"] }
 strum_macros = "0.26.4"
@@ -74,12 +74,12 @@ debug = true
 strip = false
 
 [dev-dependencies]
-pyo3 = { version = "0.22.5", features = ["auto-initialize"] }
+pyo3 = { version = "0.22.6", features = ["auto-initialize"] }
 
 [build-dependencies]
 version_check = "0.9.5"
 # used where logic has to be version/distribution specific, e.g. pypy
-pyo3-build-config = { version = "0.22.0" }
+pyo3-build-config = { version = "0.22.6" }
 
 [lints.clippy]
 dbg_macro = "warn"

From e4de8a68e2d9a30974fff258e3de9a20a00955c3 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Thu, 21 Nov 2024 23:42:43 +0000
Subject: [PATCH 433/550] Fix performance regression for JSON tagged union
 (#1552)

---
 src/serializers/type_serializers/union.rs | 133 ++++++++++------------
 1 file changed, 58 insertions(+), 75 deletions(-)

diff --git a/src/serializers/type_serializers/union.rs b/src/serializers/type_serializers/union.rs
index 40a72e9dd..2bf19cff9 100644
--- a/src/serializers/type_serializers/union.rs
+++ b/src/serializers/type_serializers/union.rs
@@ -117,44 +117,6 @@ fn union_serialize<S>(
     Ok(None)
 }
 
-fn tagged_union_serialize<S>(
-    discriminator_value: Option<Py<PyAny>>,
-    lookup: &HashMap<String, usize>,
-    // if this returns `Ok(v)`, we picked a union variant to serialize, where
-    // `S` is intermediate state which can be passed on to the finalizer
-    mut selector: impl FnMut(&CombinedSerializer, &Extra) -> PyResult<S>,
-    extra: &Extra,
-    choices: &[CombinedSerializer],
-    retry_with_lax_check: bool,
-) -> PyResult<Option<S>> {
-    let mut new_extra = extra.clone();
-    new_extra.check = SerCheck::Strict;
-
-    if let Some(tag) = discriminator_value {
-        let tag_str = tag.to_string();
-        if let Some(&serializer_index) = lookup.get(&tag_str) {
-            let selected_serializer = &choices[serializer_index];
-
-            match selector(selected_serializer, &new_extra) {
-                Ok(v) => return Ok(Some(v)),
-                Err(_) => {
-                    if retry_with_lax_check {
-                        new_extra.check = SerCheck::Lax;
-                        if let Ok(v) = selector(selected_serializer, &new_extra) {
-                            return Ok(Some(v));
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    // if we haven't returned at this point, we should fallback to the union serializer
-    // which preserves the historical expectation that we do our best with serialization
-    // even if that means we resort to inference
-    union_serialize(selector, extra, choices, retry_with_lax_check)
-}
-
 impl TypeSerializer for UnionSerializer {
     fn to_python(
         &self,
@@ -267,27 +229,21 @@ impl TypeSerializer for TaggedUnionSerializer {
         exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<PyObject> {
-        tagged_union_serialize(
-            self.get_discriminator_value(value, extra),
-            &self.lookup,
+        self.tagged_union_serialize(
+            value,
             |comb_serializer: &CombinedSerializer, new_extra: &Extra| {
                 comb_serializer.to_python(value, include, exclude, new_extra)
             },
             extra,
-            &self.choices,
-            self.retry_with_lax_check(),
         )?
         .map_or_else(|| infer_to_python(value, include, exclude, extra), Ok)
     }
 
     fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
-        tagged_union_serialize(
-            self.get_discriminator_value(key, extra),
-            &self.lookup,
+        self.tagged_union_serialize(
+            key,
             |comb_serializer: &CombinedSerializer, new_extra: &Extra| comb_serializer.json_key(key, new_extra),
             extra,
-            &self.choices,
-            self.retry_with_lax_check(),
         )?
         .map_or_else(|| infer_json_key(key, extra), Ok)
     }
@@ -300,15 +256,12 @@ impl TypeSerializer for TaggedUnionSerializer {
         exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
-        match tagged_union_serialize(
-            None,
-            &self.lookup,
+        match self.tagged_union_serialize(
+            value,
             |comb_serializer: &CombinedSerializer, new_extra: &Extra| {
                 comb_serializer.to_python(value, include, exclude, new_extra)
             },
             extra,
-            &self.choices,
-            self.retry_with_lax_check(),
         ) {
             Ok(Some(v)) => return infer_serialize(v.bind(value.py()), serializer, None, None, extra),
             Ok(None) => infer_serialize(value, serializer, include, exclude, extra),
@@ -326,36 +279,66 @@ impl TypeSerializer for TaggedUnionSerializer {
 }
 
 impl TaggedUnionSerializer {
-    fn get_discriminator_value(&self, value: &Bound<'_, PyAny>, extra: &Extra) -> Option<Py<PyAny>> {
+    fn get_discriminator_value<'py>(&self, value: &Bound<'py, PyAny>) -> Option<Bound<'py, PyAny>> {
         let py = value.py();
-        let discriminator_value = match &self.discriminator {
+        match &self.discriminator {
             Discriminator::LookupKey(lookup_key) => {
                 // we're pretty lax here, we allow either dict[key] or object.key, as we very well could
                 // be doing a discriminator lookup on a typed dict, and there's no good way to check that
                 // at this point. we could be more strict and only do this in lax mode...
-                let getattr_result = match value.is_instance_of::<PyDict>() {
-                    true => {
-                        let value_dict = value.downcast::<PyDict>().unwrap();
-                        lookup_key.py_get_dict_item(value_dict).ok()
-                    }
-                    false => lookup_key.simple_py_get_attr(value).ok(),
-                };
-                getattr_result.and_then(|opt| opt.map(|(_, bound)| bound.to_object(py)))
+                if let Ok(value_dict) = value.downcast::<PyDict>() {
+                    lookup_key.py_get_dict_item(value_dict).ok().flatten()
+                } else {
+                    lookup_key.simple_py_get_attr(value).ok().flatten()
+                }
+                .map(|(_, tag)| tag)
             }
-            Discriminator::Function(func) => func.call1(py, (value,)).ok(),
-        };
-        if discriminator_value.is_none() {
-            let value_str = truncate_safe_repr(value, None);
+            Discriminator::Function(func) => func.bind(py).call1((value,)).ok(),
+        }
+    }
 
-            // If extra.check is SerCheck::None, we're in a top-level union. We should thus raise this warning
-            if extra.check == SerCheck::None {
-                extra.warnings.custom_warning(
-                    format!(
-                        "Failed to get discriminator value for tagged union serialization with value `{value_str}` - defaulting to left to right union serialization."
-                    )
-                );
+    fn tagged_union_serialize<S>(
+        &self,
+        value: &Bound<'_, PyAny>,
+        // if this returns `Ok(v)`, we picked a union variant to serialize, where
+        // `S` is intermediate state which can be passed on to the finalizer
+        mut selector: impl FnMut(&CombinedSerializer, &Extra) -> PyResult<S>,
+        extra: &Extra,
+    ) -> PyResult<Option<S>> {
+        if let Some(tag) = self.get_discriminator_value(value) {
+            let mut new_extra = extra.clone();
+            new_extra.check = SerCheck::Strict;
+
+            let tag_str = tag.to_string();
+            if let Some(&serializer_index) = self.lookup.get(&tag_str) {
+                let selected_serializer = &self.choices[serializer_index];
+
+                match selector(selected_serializer, &new_extra) {
+                    Ok(v) => return Ok(Some(v)),
+                    Err(_) => {
+                        if self.retry_with_lax_check() {
+                            new_extra.check = SerCheck::Lax;
+                            if let Ok(v) = selector(selected_serializer, &new_extra) {
+                                return Ok(Some(v));
+                            }
+                        }
+                    }
+                }
             }
+        } else if extra.check == SerCheck::None {
+            // If extra.check is SerCheck::None, we're in a top-level union. We should thus raise
+            // this warning
+            let value_str = truncate_safe_repr(value, None);
+            extra.warnings.custom_warning(
+                format!(
+                    "Failed to get discriminator value for tagged union serialization with value `{value_str}` - defaulting to left to right union serialization."
+                )
+            );
         }
-        discriminator_value
+
+        // if we haven't returned at this point, we should fallback to the union serializer
+        // which preserves the historical expectation that we do our best with serialization
+        // even if that means we resort to inference
+        union_serialize(selector, extra, &self.choices, self.retry_with_lax_check())
     }
 }

From 83ff1cfd0c3f32d5bd54ff10979a39fb1335982b Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Thu, 21 Nov 2024 18:49:50 -0500
Subject: [PATCH 434/550] Version bump -> v2.27.1 (#1553)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 uv.lock    | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index f5b107750..08a290071 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -425,7 +425,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.27.0"
+version = "2.27.1"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index d2f470449..3b3b8a9bc 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.27.0"
+version = "2.27.1"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"
diff --git a/uv.lock b/uv.lock
index edc77b455..91cafe0be 100644
--- a/uv.lock
+++ b/uv.lock
@@ -527,7 +527,7 @@ wheels = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.27.0"
+version = "2.27.1"
 source = { virtual = "." }
 dependencies = [
     { name = "typing-extensions" },

From 49bcd5104f1ca984fd7163f4b01a500ece4b07de Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Tue, 26 Nov 2024 12:47:25 +0000
Subject: [PATCH 435/550] fix linux PGO wheel build (#1557)

---
 .github/actions/build-pgo-wheel/action.yml |  74 ++++++++++++
 .github/workflows/ci.yml                   |  46 +------
 .github/workflows/codspeed.yml             |  34 +++---
 pyproject.toml                             |   4 +
 uv.lock                                    | 132 ++++++++++++++++++++-
 5 files changed, 226 insertions(+), 64 deletions(-)
 create mode 100644 .github/actions/build-pgo-wheel/action.yml

diff --git a/.github/actions/build-pgo-wheel/action.yml b/.github/actions/build-pgo-wheel/action.yml
new file mode 100644
index 000000000..3631af635
--- /dev/null
+++ b/.github/actions/build-pgo-wheel/action.yml
@@ -0,0 +1,74 @@
+name: Build PGO wheel
+description: Builds a PGO-optimized wheel
+inputs:
+  interpreter:
+    description: 'Interpreter to build the wheel for'
+    required: true
+  rust-toolchain:
+    description: 'Rust toolchain to use'
+    required: true
+outputs:
+  wheel:
+    description: 'Path to the built wheel'
+    value: ${{ steps.find_wheel.outputs.path }}
+runs:
+  using: "composite"
+  steps:
+    - name: prepare self schema
+      shell: bash
+      # generate up front so that we don't have to do this inside the docker container
+      run: uv run python generate_self_schema.py
+
+    - name: prepare profiling directory
+      shell: bash
+      # making this ahead of the compile ensures that the local user can write to this
+      # directory; the maturin action (on linux) runs in docker so would create as root
+      run: mkdir -p ${{ github.workspace }}/profdata
+
+    - name: build initial wheel
+      uses: PyO3/maturin-action@v1
+      with:
+        manylinux: auto
+        args: >
+          --release
+          --out pgo-wheel
+          --interpreter ${{ inputs.interpreter }}
+        rust-toolchain: ${{ inputs.rust-toolchain }}
+        docker-options: -e CI
+      env:
+        RUSTFLAGS: '-Cprofile-generate=${{ github.workspace }}/profdata'
+
+    - name: detect rust host
+      run: echo RUST_HOST=$(rustc -Vv | grep host | cut -d ' ' -f 2) >> "$GITHUB_ENV"
+      shell: bash
+
+    - name: generate pgo data
+      run: |
+        uv sync --group testing
+        uv pip install pydantic-core --no-index --no-deps --find-links pgo-wheel --force-reinstall
+        uv run pytest tests/benchmarks
+        RUST_HOST=$(rustc -Vv | grep host | cut -d ' ' -f 2)
+        rustup run ${{ inputs.rust-toolchain }} bash -c 'echo LLVM_PROFDATA=$RUSTUP_HOME/toolchains/$RUSTUP_TOOLCHAIN/lib/rustlib/$RUST_HOST/bin/llvm-profdata >> "$GITHUB_ENV"'
+      shell: bash
+
+    - name: merge pgo data
+      run: ${{ env.LLVM_PROFDATA }} merge -o ${{ github.workspace }}/merged.profdata ${{ github.workspace }}/profdata
+      shell: bash
+
+    - name: build pgo-optimized wheel
+      uses: PyO3/maturin-action@v1
+      with:
+        manylinux: auto
+        args: >
+          --release
+          --out dist
+          --interpreter ${{ inputs.interpreter }}
+        rust-toolchain: ${{inputs.rust-toolchain}}
+        docker-options: -e CI
+      env:
+        RUSTFLAGS: '-Cprofile-use=${{ github.workspace }}/merged.profdata'
+
+    - name: find built wheel
+      id: find_wheel
+      run: echo "path=$(ls dist/*.whl)" | tee -a "$GITHUB_OUTPUT"
+      shell: bash
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 3f7e38a43..a08a25ea2 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -556,50 +556,12 @@ jobs:
           # FIXME: Unpin when Python 3.8 support is dropped. (3.9 requires Windows 10)
           toolchain: ${{ (matrix.os == 'windows' && '1.77') || 'stable' }}
 
-      - run: pip install -U 'ruff==0.5.0' typing_extensions
-
-      # generate self-schema now, so we don't have to do so inside docker in maturin build
-      - run: python generate_self_schema.py
-
-      - name: build initial wheel
-        uses: PyO3/maturin-action@v1
+      - name: Build PGO wheel
+        id: pgo-wheel
+        uses: ./.github/actions/build-pgo-wheel
         with:
-          manylinux: auto
-          args: >
-            --release
-            --out pgo-wheel
-            --interpreter ${{ matrix.interpreter }}
+          interpreter: ${{ env.UV_PYTHON }}
           rust-toolchain: ${{ steps.rust-toolchain.outputs.name }}
-          docker-options: -e CI
-        env:
-          RUSTFLAGS: '-Cprofile-generate=${{ github.workspace }}/profdata'
-
-      - name: detect rust host
-        run: echo RUST_HOST=$(rustc -Vv | grep host | cut -d ' ' -f 2) >> "$GITHUB_ENV"
-        shell: bash
-
-      - name: generate pgo data
-        run: |
-          uv sync --group testing
-          uv pip install pydantic-core --no-index --no-deps --find-links pgo-wheel --force-reinstall
-          uv run pytest tests/benchmarks
-          rustup run ${{ steps.rust-toolchain.outputs.name }} bash -c 'echo LLVM_PROFDATA=$RUSTUP_HOME/toolchains/$RUSTUP_TOOLCHAIN/lib/rustlib/${{ env.RUST_HOST }}/bin/llvm-profdata >> "$GITHUB_ENV"'
-
-      - name: merge pgo data
-        run: ${{ env.LLVM_PROFDATA }} merge -o ${{ github.workspace }}/merged.profdata ${{ github.workspace }}/profdata
-
-      - name: build pgo-optimized wheel
-        uses: PyO3/maturin-action@v1
-        with:
-          manylinux: auto
-          args: >
-            --release
-            --out dist
-            --interpreter ${{ matrix.interpreter }}
-          rust-toolchain: ${{steps.rust-toolchain.outputs.name}}
-          docker-options: -e CI
-        env:
-          RUSTFLAGS: '-Cprofile-use=${{ github.workspace }}/merged.profdata'
 
       - run: ${{ matrix.ls || 'ls -lh' }} dist/
 
diff --git a/.github/workflows/codspeed.yml b/.github/workflows/codspeed.yml
index 9ee91d25f..b8ddb3076 100644
--- a/.github/workflows/codspeed.yml
+++ b/.github/workflows/codspeed.yml
@@ -30,40 +30,36 @@ jobs:
         with:
           enable-cache: true
 
-      - name: install deps
+      - name: Install deps
         run: |
           uv sync --group testing
           uv pip uninstall pytest-speed
           uv pip install pytest-benchmark==4.0.0 pytest-codspeed
 
-      - name: install rust stable
+      - name: Install rust stable
         id: rust-toolchain
         uses: dtolnay/rust-toolchain@stable
         with:
           components: llvm-tools
 
-      - name: cache rust
+      - name: Cache rust
         uses: Swatinem/rust-cache@v2
 
-      - name: Compile pydantic-core for profiling
-        run: make build-profiling
+      - name: Build PGO wheel
+        id: pgo-wheel
+        uses: ./.github/actions/build-pgo-wheel
+        with:
+          interpreter: ${{ env.UV_PYTHON }}
+          rust-toolchain: ${{ steps.rust-toolchain.outputs.name }}
         env:
-          CONST_RANDOM_SEED: 0 # Fix the compile time RNG seed
-          RUSTFLAGS: "-Cprofile-generate=${{ github.workspace }}/profdata"
-
-      - name: Gather pgo data
-        run: uv run pytest tests/benchmarks
+          # make sure profiling information is present
+          CARGO_PROFILE_RELEASE_DEBUG: "line-tables-only"
+          CARGO_PROFILE_RELEASE_STRIP: false
 
-      - name: Prepare merged pgo data
-        run: rustup run stable bash -c '$RUSTUP_HOME/toolchains/$RUSTUP_TOOLCHAIN/lib/rustlib/x86_64-unknown-linux-gnu/bin/llvm-profdata merge -o ${{ github.workspace }}/merged.profdata ${{ github.workspace }}/profdata'
-
-      - name: Compile pydantic-core for benchmarking
-        run: make build-profiling
-        env:
-          CONST_RANDOM_SEED: 0 # Fix the compile time RNG seed
-          RUSTFLAGS: "-Cprofile-use=${{ github.workspace }}/merged.profdata"
+      - name: Install PGO wheel
+        run: uv pip install ${{ steps.pgo-wheel.outputs.wheel }} --force-reinstall
 
       - name: Run CodSpeed benchmarks
         uses: CodSpeedHQ/action@v3
         with:
-          run: uv run pytest tests/benchmarks/ --codspeed
+          run: uv run --group=codspeed pytest tests/benchmarks/ --codspeed
diff --git a/pyproject.toml b/pyproject.toml
index de04a3991..9edafc5cd 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -82,6 +82,10 @@ wasm = [
     'maturin>=1,<2',
     'ruff',
 ]
+codspeed = [
+    # codspeed is only run on CI, with latest version of CPython
+    'pytest-codspeed; python_version == "3.13" and implementation_name == "cpython"',
+]
 
 all = [
   { include-group = 'testing' },
diff --git a/uv.lock b/uv.lock
index 91cafe0be..34afc1275 100644
--- a/uv.lock
+++ b/uv.lock
@@ -1,7 +1,9 @@
 version = 1
 requires-python = ">=3.8"
 resolution-markers = [
-    "python_full_version < '3.9' or python_full_version >= '3.13' or implementation_name != 'cpython' or platform_machine != 'x86_64'",
+    "python_full_version < '3.9' or (python_full_version < '3.12' and implementation_name != 'cpython') or (python_full_version < '3.12' and platform_machine != 'x86_64')",
+    "(python_full_version == '3.12.*' and implementation_name != 'cpython') or (python_full_version == '3.12.*' and platform_machine != 'x86_64') or (python_full_version == '3.13.*' and implementation_name != 'cpython') or python_full_version >= '3.14'",
+    "python_full_version == '3.13.*' and implementation_name == 'cpython'",
     "python_full_version >= '3.9' and python_full_version < '3.11' and implementation_name == 'cpython' and platform_machine == 'x86_64'",
     "python_full_version == '3.11.*' and implementation_name == 'cpython' and platform_machine == 'x86_64'",
     "python_full_version == '3.12.*' and implementation_name == 'cpython' and platform_machine == 'x86_64'",
@@ -24,8 +26,8 @@ name = "astunparse"
 version = "1.6.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "six", marker = "python_full_version < '3.9' or python_full_version >= '3.13' or implementation_name != 'cpython' or platform_machine != 'x86_64'" },
-    { name = "wheel", marker = "python_full_version < '3.9' or python_full_version >= '3.13' or implementation_name != 'cpython' or platform_machine != 'x86_64'" },
+    { name = "six", marker = "python_full_version < '3.9' or (python_full_version < '3.12' and implementation_name != 'cpython') or (python_full_version < '3.12' and platform_machine != 'x86_64')" },
+    { name = "wheel", marker = "python_full_version < '3.9' or (python_full_version < '3.12' and implementation_name != 'cpython') or (python_full_version < '3.12' and platform_machine != 'x86_64')" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/f3/af/4182184d3c338792894f34a62672919db7ca008c89abee9b564dd34d8029/astunparse-1.6.3.tar.gz", hash = "sha256:5ad93a8456f0d084c3456d059fd9a92cce667963232cbf763eac3bc5b7940872", size = 18290 }
 wheels = [
@@ -92,6 +94,83 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/27/1e/83fa8a787180e1632c3d831f7e58994d7aaf23a0961320d21e84f922f919/black-24.8.0-py3-none-any.whl", hash = "sha256:972085c618ee94f402da1af548a4f218c754ea7e5dc70acb168bfaca4c2542ed", size = 206504 },
 ]
 
+[[package]]
+name = "cffi"
+version = "1.17.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pycparser", marker = "python_full_version == '3.13.*' and implementation_name == 'cpython'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/fc/97/c783634659c2920c3fc70419e3af40972dbaf758daa229a7d6ea6135c90d/cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824", size = 516621 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/90/07/f44ca684db4e4f08a3fdc6eeb9a0d15dc6883efc7b8c90357fdbf74e186c/cffi-1.17.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:df8b1c11f177bc2313ec4b2d46baec87a5f3e71fc8b45dab2ee7cae86d9aba14", size = 182191 },
+    { url = "https://files.pythonhosted.org/packages/08/fd/cc2fedbd887223f9f5d170c96e57cbf655df9831a6546c1727ae13fa977a/cffi-1.17.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8f2cdc858323644ab277e9bb925ad72ae0e67f69e804f4898c070998d50b1a67", size = 178592 },
+    { url = "https://files.pythonhosted.org/packages/de/cc/4635c320081c78d6ffc2cab0a76025b691a91204f4aa317d568ff9280a2d/cffi-1.17.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:edae79245293e15384b51f88b00613ba9f7198016a5948b5dddf4917d4d26382", size = 426024 },
+    { url = "https://files.pythonhosted.org/packages/b6/7b/3b2b250f3aab91abe5f8a51ada1b717935fdaec53f790ad4100fe2ec64d1/cffi-1.17.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:45398b671ac6d70e67da8e4224a065cec6a93541bb7aebe1b198a61b58c7b702", size = 448188 },
+    { url = "https://files.pythonhosted.org/packages/d3/48/1b9283ebbf0ec065148d8de05d647a986c5f22586b18120020452fff8f5d/cffi-1.17.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ad9413ccdeda48c5afdae7e4fa2192157e991ff761e7ab8fdd8926f40b160cc3", size = 455571 },
+    { url = "https://files.pythonhosted.org/packages/40/87/3b8452525437b40f39ca7ff70276679772ee7e8b394934ff60e63b7b090c/cffi-1.17.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5da5719280082ac6bd9aa7becb3938dc9f9cbd57fac7d2871717b1feb0902ab6", size = 436687 },
+    { url = "https://files.pythonhosted.org/packages/8d/fb/4da72871d177d63649ac449aec2e8a29efe0274035880c7af59101ca2232/cffi-1.17.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2bb1a08b8008b281856e5971307cc386a8e9c5b625ac297e853d36da6efe9c17", size = 446211 },
+    { url = "https://files.pythonhosted.org/packages/ab/a0/62f00bcb411332106c02b663b26f3545a9ef136f80d5df746c05878f8c4b/cffi-1.17.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:045d61c734659cc045141be4bae381a41d89b741f795af1dd018bfb532fd0df8", size = 461325 },
+    { url = "https://files.pythonhosted.org/packages/36/83/76127035ed2e7e27b0787604d99da630ac3123bfb02d8e80c633f218a11d/cffi-1.17.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:6883e737d7d9e4899a8a695e00ec36bd4e5e4f18fabe0aca0efe0a4b44cdb13e", size = 438784 },
+    { url = "https://files.pythonhosted.org/packages/21/81/a6cd025db2f08ac88b901b745c163d884641909641f9b826e8cb87645942/cffi-1.17.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:6b8b4a92e1c65048ff98cfe1f735ef8f1ceb72e3d5f0c25fdb12087a23da22be", size = 461564 },
+    { url = "https://files.pythonhosted.org/packages/f8/fe/4d41c2f200c4a457933dbd98d3cf4e911870877bd94d9656cc0fcb390681/cffi-1.17.1-cp310-cp310-win32.whl", hash = "sha256:c9c3d058ebabb74db66e431095118094d06abf53284d9c81f27300d0e0d8bc7c", size = 171804 },
+    { url = "https://files.pythonhosted.org/packages/d1/b6/0b0f5ab93b0df4acc49cae758c81fe4e5ef26c3ae2e10cc69249dfd8b3ab/cffi-1.17.1-cp310-cp310-win_amd64.whl", hash = "sha256:0f048dcf80db46f0098ccac01132761580d28e28bc0f78ae0d58048063317e15", size = 181299 },
+    { url = "https://files.pythonhosted.org/packages/6b/f4/927e3a8899e52a27fa57a48607ff7dc91a9ebe97399b357b85a0c7892e00/cffi-1.17.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a45e3c6913c5b87b3ff120dcdc03f6131fa0065027d0ed7ee6190736a74cd401", size = 182264 },
+    { url = "https://files.pythonhosted.org/packages/6c/f5/6c3a8efe5f503175aaddcbea6ad0d2c96dad6f5abb205750d1b3df44ef29/cffi-1.17.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:30c5e0cb5ae493c04c8b42916e52ca38079f1b235c2f8ae5f4527b963c401caf", size = 178651 },
+    { url = "https://files.pythonhosted.org/packages/94/dd/a3f0118e688d1b1a57553da23b16bdade96d2f9bcda4d32e7d2838047ff7/cffi-1.17.1-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f75c7ab1f9e4aca5414ed4d8e5c0e303a34f4421f8a0d47a4d019ceff0ab6af4", size = 445259 },
+    { url = "https://files.pythonhosted.org/packages/2e/ea/70ce63780f096e16ce8588efe039d3c4f91deb1dc01e9c73a287939c79a6/cffi-1.17.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a1ed2dd2972641495a3ec98445e09766f077aee98a1c896dcb4ad0d303628e41", size = 469200 },
+    { url = "https://files.pythonhosted.org/packages/1c/a0/a4fa9f4f781bda074c3ddd57a572b060fa0df7655d2a4247bbe277200146/cffi-1.17.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:46bf43160c1a35f7ec506d254e5c890f3c03648a4dbac12d624e4490a7046cd1", size = 477235 },
+    { url = "https://files.pythonhosted.org/packages/62/12/ce8710b5b8affbcdd5c6e367217c242524ad17a02fe5beec3ee339f69f85/cffi-1.17.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a24ed04c8ffd54b0729c07cee15a81d964e6fee0e3d4d342a27b020d22959dc6", size = 459721 },
+    { url = "https://files.pythonhosted.org/packages/ff/6b/d45873c5e0242196f042d555526f92aa9e0c32355a1be1ff8c27f077fd37/cffi-1.17.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:610faea79c43e44c71e1ec53a554553fa22321b65fae24889706c0a84d4ad86d", size = 467242 },
+    { url = "https://files.pythonhosted.org/packages/1a/52/d9a0e523a572fbccf2955f5abe883cfa8bcc570d7faeee06336fbd50c9fc/cffi-1.17.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:a9b15d491f3ad5d692e11f6b71f7857e7835eb677955c00cc0aefcd0669adaf6", size = 477999 },
+    { url = "https://files.pythonhosted.org/packages/44/74/f2a2460684a1a2d00ca799ad880d54652841a780c4c97b87754f660c7603/cffi-1.17.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:de2ea4b5833625383e464549fec1bc395c1bdeeb5f25c4a3a82b5a8c756ec22f", size = 454242 },
+    { url = "https://files.pythonhosted.org/packages/f8/4a/34599cac7dfcd888ff54e801afe06a19c17787dfd94495ab0c8d35fe99fb/cffi-1.17.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:fc48c783f9c87e60831201f2cce7f3b2e4846bf4d8728eabe54d60700b318a0b", size = 478604 },
+    { url = "https://files.pythonhosted.org/packages/34/33/e1b8a1ba29025adbdcda5fb3a36f94c03d771c1b7b12f726ff7fef2ebe36/cffi-1.17.1-cp311-cp311-win32.whl", hash = "sha256:85a950a4ac9c359340d5963966e3e0a94a676bd6245a4b55bc43949eee26a655", size = 171727 },
+    { url = "https://files.pythonhosted.org/packages/3d/97/50228be003bb2802627d28ec0627837ac0bf35c90cf769812056f235b2d1/cffi-1.17.1-cp311-cp311-win_amd64.whl", hash = "sha256:caaf0640ef5f5517f49bc275eca1406b0ffa6aa184892812030f04c2abf589a0", size = 181400 },
+    { url = "https://files.pythonhosted.org/packages/5a/84/e94227139ee5fb4d600a7a4927f322e1d4aea6fdc50bd3fca8493caba23f/cffi-1.17.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:805b4371bf7197c329fcb3ead37e710d1bca9da5d583f5073b799d5c5bd1eee4", size = 183178 },
+    { url = "https://files.pythonhosted.org/packages/da/ee/fb72c2b48656111c4ef27f0f91da355e130a923473bf5ee75c5643d00cca/cffi-1.17.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:733e99bc2df47476e3848417c5a4540522f234dfd4ef3ab7fafdf555b082ec0c", size = 178840 },
+    { url = "https://files.pythonhosted.org/packages/cc/b6/db007700f67d151abadf508cbfd6a1884f57eab90b1bb985c4c8c02b0f28/cffi-1.17.1-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1257bdabf294dceb59f5e70c64a3e2f462c30c7ad68092d01bbbfb1c16b1ba36", size = 454803 },
+    { url = "https://files.pythonhosted.org/packages/1a/df/f8d151540d8c200eb1c6fba8cd0dfd40904f1b0682ea705c36e6c2e97ab3/cffi-1.17.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da95af8214998d77a98cc14e3a3bd00aa191526343078b530ceb0bd710fb48a5", size = 478850 },
+    { url = "https://files.pythonhosted.org/packages/28/c0/b31116332a547fd2677ae5b78a2ef662dfc8023d67f41b2a83f7c2aa78b1/cffi-1.17.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d63afe322132c194cf832bfec0dc69a99fb9bb6bbd550f161a49e9e855cc78ff", size = 485729 },
+    { url = "https://files.pythonhosted.org/packages/91/2b/9a1ddfa5c7f13cab007a2c9cc295b70fbbda7cb10a286aa6810338e60ea1/cffi-1.17.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f79fc4fc25f1c8698ff97788206bb3c2598949bfe0fef03d299eb1b5356ada99", size = 471256 },
+    { url = "https://files.pythonhosted.org/packages/b2/d5/da47df7004cb17e4955df6a43d14b3b4ae77737dff8bf7f8f333196717bf/cffi-1.17.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b62ce867176a75d03a665bad002af8e6d54644fad99a3c70905c543130e39d93", size = 479424 },
+    { url = "https://files.pythonhosted.org/packages/0b/ac/2a28bcf513e93a219c8a4e8e125534f4f6db03e3179ba1c45e949b76212c/cffi-1.17.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:386c8bf53c502fff58903061338ce4f4950cbdcb23e2902d86c0f722b786bbe3", size = 484568 },
+    { url = "https://files.pythonhosted.org/packages/d4/38/ca8a4f639065f14ae0f1d9751e70447a261f1a30fa7547a828ae08142465/cffi-1.17.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4ceb10419a9adf4460ea14cfd6bc43d08701f0835e979bf821052f1805850fe8", size = 488736 },
+    { url = "https://files.pythonhosted.org/packages/86/c5/28b2d6f799ec0bdecf44dced2ec5ed43e0eb63097b0f58c293583b406582/cffi-1.17.1-cp312-cp312-win32.whl", hash = "sha256:a08d7e755f8ed21095a310a693525137cfe756ce62d066e53f502a83dc550f65", size = 172448 },
+    { url = "https://files.pythonhosted.org/packages/50/b9/db34c4755a7bd1cb2d1603ac3863f22bcecbd1ba29e5ee841a4bc510b294/cffi-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:51392eae71afec0d0c8fb1a53b204dbb3bcabcb3c9b807eedf3e1e6ccf2de903", size = 181976 },
+    { url = "https://files.pythonhosted.org/packages/8d/f8/dd6c246b148639254dad4d6803eb6a54e8c85c6e11ec9df2cffa87571dbe/cffi-1.17.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f3a2b4222ce6b60e2e8b337bb9596923045681d71e5a082783484d845390938e", size = 182989 },
+    { url = "https://files.pythonhosted.org/packages/8b/f1/672d303ddf17c24fc83afd712316fda78dc6fce1cd53011b839483e1ecc8/cffi-1.17.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0984a4925a435b1da406122d4d7968dd861c1385afe3b45ba82b750f229811e2", size = 178802 },
+    { url = "https://files.pythonhosted.org/packages/0e/2d/eab2e858a91fdff70533cab61dcff4a1f55ec60425832ddfdc9cd36bc8af/cffi-1.17.1-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d01b12eeeb4427d3110de311e1774046ad344f5b1a7403101878976ecd7a10f3", size = 454792 },
+    { url = "https://files.pythonhosted.org/packages/75/b2/fbaec7c4455c604e29388d55599b99ebcc250a60050610fadde58932b7ee/cffi-1.17.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:706510fe141c86a69c8ddc029c7910003a17353970cff3b904ff0686a5927683", size = 478893 },
+    { url = "https://files.pythonhosted.org/packages/4f/b7/6e4a2162178bf1935c336d4da8a9352cccab4d3a5d7914065490f08c0690/cffi-1.17.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de55b766c7aa2e2a3092c51e0483d700341182f08e67c63630d5b6f200bb28e5", size = 485810 },
+    { url = "https://files.pythonhosted.org/packages/c7/8a/1d0e4a9c26e54746dc08c2c6c037889124d4f59dffd853a659fa545f1b40/cffi-1.17.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c59d6e989d07460165cc5ad3c61f9fd8f1b4796eacbd81cee78957842b834af4", size = 471200 },
+    { url = "https://files.pythonhosted.org/packages/26/9f/1aab65a6c0db35f43c4d1b4f580e8df53914310afc10ae0397d29d697af4/cffi-1.17.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd398dbc6773384a17fe0d3e7eeb8d1a21c2200473ee6806bb5e6a8e62bb73dd", size = 479447 },
+    { url = "https://files.pythonhosted.org/packages/5f/e4/fb8b3dd8dc0e98edf1135ff067ae070bb32ef9d509d6cb0f538cd6f7483f/cffi-1.17.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:3edc8d958eb099c634dace3c7e16560ae474aa3803a5df240542b305d14e14ed", size = 484358 },
+    { url = "https://files.pythonhosted.org/packages/f1/47/d7145bf2dc04684935d57d67dff9d6d795b2ba2796806bb109864be3a151/cffi-1.17.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:72e72408cad3d5419375fc87d289076ee319835bdfa2caad331e377589aebba9", size = 488469 },
+    { url = "https://files.pythonhosted.org/packages/bf/ee/f94057fa6426481d663b88637a9a10e859e492c73d0384514a17d78ee205/cffi-1.17.1-cp313-cp313-win32.whl", hash = "sha256:e03eab0a8677fa80d646b5ddece1cbeaf556c313dcfac435ba11f107ba117b5d", size = 172475 },
+    { url = "https://files.pythonhosted.org/packages/7c/fc/6a8cb64e5f0324877d503c854da15d76c1e50eb722e320b15345c4d0c6de/cffi-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:f6a16c31041f09ead72d69f583767292f750d24913dadacf5756b966aacb3f1a", size = 182009 },
+    { url = "https://files.pythonhosted.org/packages/48/08/15bf6b43ae9bd06f6b00ad8a91f5a8fe1069d4c9fab550a866755402724e/cffi-1.17.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:636062ea65bd0195bc012fea9321aca499c0504409f413dc88af450b57ffd03b", size = 182457 },
+    { url = "https://files.pythonhosted.org/packages/c2/5b/f1523dd545f92f7df468e5f653ffa4df30ac222f3c884e51e139878f1cb5/cffi-1.17.1-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c7eac2ef9b63c79431bc4b25f1cd649d7f061a28808cbc6c47b534bd789ef964", size = 425932 },
+    { url = "https://files.pythonhosted.org/packages/53/93/7e547ab4105969cc8c93b38a667b82a835dd2cc78f3a7dad6130cfd41e1d/cffi-1.17.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e221cf152cff04059d011ee126477f0d9588303eb57e88923578ace7baad17f9", size = 448585 },
+    { url = "https://files.pythonhosted.org/packages/56/c4/a308f2c332006206bb511de219efeff090e9d63529ba0a77aae72e82248b/cffi-1.17.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:31000ec67d4221a71bd3f67df918b1f88f676f1c3b535a7eb473255fdc0b83fc", size = 456268 },
+    { url = "https://files.pythonhosted.org/packages/ca/5b/b63681518265f2f4060d2b60755c1c77ec89e5e045fc3773b72735ddaad5/cffi-1.17.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6f17be4345073b0a7b8ea599688f692ac3ef23ce28e5df79c04de519dbc4912c", size = 436592 },
+    { url = "https://files.pythonhosted.org/packages/bb/19/b51af9f4a4faa4a8ac5a0e5d5c2522dcd9703d07fac69da34a36c4d960d3/cffi-1.17.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0e2b1fac190ae3ebfe37b979cc1ce69c81f4e4fe5746bb401dca63a9062cdaf1", size = 446512 },
+    { url = "https://files.pythonhosted.org/packages/e2/63/2bed8323890cb613bbecda807688a31ed11a7fe7afe31f8faaae0206a9a3/cffi-1.17.1-cp38-cp38-win32.whl", hash = "sha256:7596d6620d3fa590f677e9ee430df2958d2d6d6de2feeae5b20e82c00b76fbf8", size = 171576 },
+    { url = "https://files.pythonhosted.org/packages/2f/70/80c33b044ebc79527447fd4fbc5455d514c3bb840dede4455de97da39b4d/cffi-1.17.1-cp38-cp38-win_amd64.whl", hash = "sha256:78122be759c3f8a014ce010908ae03364d00a1f81ab5c7f4a7a5120607ea56e1", size = 181229 },
+    { url = "https://files.pythonhosted.org/packages/b9/ea/8bb50596b8ffbc49ddd7a1ad305035daa770202a6b782fc164647c2673ad/cffi-1.17.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:b2ab587605f4ba0bf81dc0cb08a41bd1c0a5906bd59243d56bad7668a6fc6c16", size = 182220 },
+    { url = "https://files.pythonhosted.org/packages/ae/11/e77c8cd24f58285a82c23af484cf5b124a376b32644e445960d1a4654c3a/cffi-1.17.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:28b16024becceed8c6dfbc75629e27788d8a3f9030691a1dbf9821a128b22c36", size = 178605 },
+    { url = "https://files.pythonhosted.org/packages/ed/65/25a8dc32c53bf5b7b6c2686b42ae2ad58743f7ff644844af7cdb29b49361/cffi-1.17.1-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1d599671f396c4723d016dbddb72fe8e0397082b0a77a4fab8028923bec050e8", size = 424910 },
+    { url = "https://files.pythonhosted.org/packages/42/7a/9d086fab7c66bd7c4d0f27c57a1b6b068ced810afc498cc8c49e0088661c/cffi-1.17.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca74b8dbe6e8e8263c0ffd60277de77dcee6c837a3d0881d8c1ead7268c9e576", size = 447200 },
+    { url = "https://files.pythonhosted.org/packages/da/63/1785ced118ce92a993b0ec9e0d0ac8dc3e5dbfbcaa81135be56c69cabbb6/cffi-1.17.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f7f5baafcc48261359e14bcd6d9bff6d4b28d9103847c9e136694cb0501aef87", size = 454565 },
+    { url = "https://files.pythonhosted.org/packages/74/06/90b8a44abf3556599cdec107f7290277ae8901a58f75e6fe8f970cd72418/cffi-1.17.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:98e3969bcff97cae1b2def8ba499ea3d6f31ddfdb7635374834cf89a1a08ecf0", size = 435635 },
+    { url = "https://files.pythonhosted.org/packages/bd/62/a1f468e5708a70b1d86ead5bab5520861d9c7eacce4a885ded9faa7729c3/cffi-1.17.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cdf5ce3acdfd1661132f2a9c19cac174758dc2352bfe37d98aa7512c6b7178b3", size = 445218 },
+    { url = "https://files.pythonhosted.org/packages/5b/95/b34462f3ccb09c2594aa782d90a90b045de4ff1f70148ee79c69d37a0a5a/cffi-1.17.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:9755e4345d1ec879e3849e62222a18c7174d65a6a92d5b346b1863912168b595", size = 460486 },
+    { url = "https://files.pythonhosted.org/packages/fc/fc/a1e4bebd8d680febd29cf6c8a40067182b64f00c7d105f8f26b5bc54317b/cffi-1.17.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:f1e22e8c4419538cb197e4dd60acc919d7696e5ef98ee4da4e01d3f8cfa4cc5a", size = 437911 },
+    { url = "https://files.pythonhosted.org/packages/e6/c3/21cab7a6154b6a5ea330ae80de386e7665254835b9e98ecc1340b3a7de9a/cffi-1.17.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:c03e868a0b3bc35839ba98e74211ed2b05d2119be4e8a0f224fba9384f1fe02e", size = 460632 },
+    { url = "https://files.pythonhosted.org/packages/cb/b5/fd9f8b5a84010ca169ee49f4e4ad6f8c05f4e3545b72ee041dbbcb159882/cffi-1.17.1-cp39-cp39-win32.whl", hash = "sha256:e31ae45bc2e29f6b2abd0de1cc3b9d5205aa847cafaecb8af1476a609a2f6eb7", size = 171820 },
+    { url = "https://files.pythonhosted.org/packages/8c/52/b08750ce0bce45c143e1b5d7357ee8c55341b52bdef4b0f081af1eb248c2/cffi-1.17.1-cp39-cp39-win_amd64.whl", hash = "sha256:d016c76bdd850f3c626af19b0542c9677ba156e4ee4fccfdd7848803533ef662", size = 181290 },
+]
+
 [[package]]
 name = "click"
 version = "8.1.7"
@@ -222,6 +301,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/b5/fd/afcd0496feca3276f509df3dbd5dae726fcc756f1a08d9e25abe1733f962/executing-2.1.0-py2.py3-none-any.whl", hash = "sha256:8d63781349375b5ebccc3142f4b30350c0cd9c79f921cde38be2be4637e98eaf", size = 25805 },
 ]
 
+[[package]]
+name = "filelock"
+version = "3.16.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/9d/db/3ef5bb276dae18d6ec2124224403d1d67bccdbefc17af4cc8f553e341ab1/filelock-3.16.1.tar.gz", hash = "sha256:c249fbfcd5db47e5e2d6d62198e565475ee65e4831e2561c8e313fa7eb961435", size = 18037 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/b9/f8/feced7779d755758a52d1f6635d990b8d98dc0a29fa568bbe0625f18fdf3/filelock-3.16.1-py3-none-any.whl", hash = "sha256:2082e5703d51fbf98ea75855d9d5527e33d8ff23099bec374a134febee6946b0", size = 16163 },
+]
+
 [[package]]
 name = "griffe"
 version = "1.4.0"
@@ -525,6 +613,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/88/5f/e351af9a41f866ac3f1fac4ca0613908d9a41741cfcf2228f4ad853b697d/pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669", size = 20556 },
 ]
 
+[[package]]
+name = "pycparser"
+version = "2.22"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/1d/b2/31537cf4b1ca988837256c910a668b553fceb8f069bedc4b1c826024b52c/pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6", size = 172736 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/13/a3/a812df4e2dd5696d1f351d58b8fe16a405b234ad2886a0dab9183fb78109/pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc", size = 117552 },
+]
+
 [[package]]
 name = "pydantic-core"
 version = "2.27.1"
@@ -558,6 +655,9 @@ all = [
     { name = "typing-extensions" },
     { name = "tzdata" },
 ]
+codspeed = [
+    { name = "pytest-codspeed", marker = "python_full_version == '3.13.*' and implementation_name == 'cpython'" },
+]
 linting = [
     { name = "griffe" },
     { name = "mypy" },
@@ -617,6 +717,7 @@ all = [
     { name = "typing-extensions" },
     { name = "tzdata" },
 ]
+codspeed = [{ name = "pytest-codspeed", marker = "python_full_version == '3.13.*' and implementation_name == 'cpython'" }]
 linting = [
     { name = "griffe" },
     { name = "mypy" },
@@ -687,6 +788,22 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/6b/77/7440a06a8ead44c7757a64362dd22df5760f9b12dc5f11b6188cd2fc27a0/pytest-8.3.3-py3-none-any.whl", hash = "sha256:a6853c7375b2663155079443d2e45de913a911a11d669df02a50814944db57b2", size = 342341 },
 ]
 
+[[package]]
+name = "pytest-codspeed"
+version = "3.0.0"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "cffi", marker = "python_full_version == '3.13.*' and implementation_name == 'cpython'" },
+    { name = "filelock", marker = "python_full_version == '3.13.*' and implementation_name == 'cpython'" },
+    { name = "pytest", marker = "python_full_version == '3.13.*' and implementation_name == 'cpython'" },
+    { name = "rich", marker = "python_full_version == '3.13.*' and implementation_name == 'cpython'" },
+    { name = "setuptools", marker = "python_full_version == '3.13.*' and implementation_name == 'cpython'" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ba/78/40e613268cce75b11cd35ea9fdc280fb648e2233fc4187c76112377b1869/pytest_codspeed-3.0.0.tar.gz", hash = "sha256:c5b80100ea32dd44079bb2db298288763eb8fe859eafa1650a8711bd2c32fd06", size = 12540 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a6/79/fa067436033410ac16e5d14b61b1a5f355688930ca8c6a8c61a52b2cbe0a/pytest_codspeed-3.0.0-py3-none-any.whl", hash = "sha256:ab1b8cb9da72e0d394718333d1abc7bea38524e09fd4854bc70a91abbcdcb20e", size = 15640 },
+]
+
 [[package]]
 name = "pytest-examples"
 version = "0.0.14"
@@ -812,6 +929,15 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/aa/70/f8724f31abc0b329ca98b33d73c14020168babcf71b0cba3cded5d9d0e66/ruff-0.7.4-py3-none-win_arm64.whl", hash = "sha256:11bff065102c3ae9d3ea4dc9ecdfe5a5171349cdd0787c1fc64761212fc9cf1f", size = 8851590 },
 ]
 
+[[package]]
+name = "setuptools"
+version = "75.6.0"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/43/54/292f26c208734e9a7f067aea4a7e282c080750c4546559b58e2e45413ca0/setuptools-75.6.0.tar.gz", hash = "sha256:8199222558df7c86216af4f84c30e9b34a61d8ba19366cc914424cdbd28252f6", size = 1337429 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/55/21/47d163f615df1d30c094f6c8bbb353619274edccf0327b185cc2493c2c33/setuptools-75.6.0-py3-none-any.whl", hash = "sha256:ce74b49e8f7110f9bf04883b730f4765b774ef3ef28f722cce7c273d253aaf7d", size = 1224032 },
+]
+
 [[package]]
 name = "six"
 version = "1.16.0"

From 334e3df6a45d3af08b2294c174715132a196e114 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Tue, 26 Nov 2024 14:23:02 +0000
Subject: [PATCH 436/550] ci: fix PGO build on windows (#1558)

---
 .github/actions/build-pgo-wheel/action.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/actions/build-pgo-wheel/action.yml b/.github/actions/build-pgo-wheel/action.yml
index 3631af635..0e0ee4e99 100644
--- a/.github/actions/build-pgo-wheel/action.yml
+++ b/.github/actions/build-pgo-wheel/action.yml
@@ -53,7 +53,7 @@ runs:
 
     - name: merge pgo data
       run: ${{ env.LLVM_PROFDATA }} merge -o ${{ github.workspace }}/merged.profdata ${{ github.workspace }}/profdata
-      shell: bash
+      shell: pwsh  # because it handles paths on windows better, and works well enough on unix for this step
 
     - name: build pgo-optimized wheel
       uses: PyO3/maturin-action@v1

From 5c96bec06141d896cae33e255ef56a08a11d4110 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Tue, 26 Nov 2024 22:43:23 +0000
Subject: [PATCH 437/550] minimal upgrade to PyO3 0.23 (ignoring deprecations)
 (#1556)

---
 Cargo.lock                         | 24 ++++++------
 Cargo.toml                         |  8 ++--
 benches/main.rs                    |  1 +
 src/errors/validation_exception.rs |  2 +-
 src/input/datetime.rs              |  2 +-
 src/input/input_abstract.rs        | 21 ++++++----
 src/input/return_enums.rs          |  8 ++--
 src/lib.rs                         |  1 +
 src/lookup_key.rs                  | 17 +++++---
 src/serializers/extra.rs           | 62 ++++++++++++++++++------------
 src/serializers/filter.rs          | 12 +++---
 src/tools.rs                       | 12 +++---
 src/validators/arguments.rs        |  3 +-
 src/validators/dataclass.rs        |  6 ++-
 src/validators/decimal.rs          |  4 +-
 tests/test.rs                      |  2 +
 16 files changed, 107 insertions(+), 78 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 08a290071..5ff11690c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -297,9 +297,9 @@ checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
 
 [[package]]
 name = "jiter"
-version = "0.7.1"
+version = "0.8.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "07f69a121b68af57bc10f151f3f67444a64d1d3a0eb48b042801ea917a38dd25"
+checksum = "1c88e0910b421b182953e774fd31930f690fc456a0ea56cd5e6ffcccee278731"
 dependencies = [
  "ahash",
  "bitvec",
@@ -451,9 +451,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.22.6"
+version = "0.23.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f402062616ab18202ae8319da13fa4279883a2b8a9d9f83f20dbade813ce1884"
+checksum = "f54b3d09cbdd1f8c20650b28e7b09e338881482f4aa908a5f61a00c98fba2690"
 dependencies = [
  "cfg-if",
  "indoc",
@@ -470,9 +470,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.22.6"
+version = "0.23.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b14b5775b5ff446dd1056212d778012cbe8a0fbffd368029fd9e25b514479c38"
+checksum = "3015cf985888fe66cfb63ce0e321c603706cd541b7aec7ddd35c281390af45d8"
 dependencies = [
  "once_cell",
  "python3-dll-a",
@@ -481,9 +481,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.22.6"
+version = "0.23.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9ab5bcf04a2cdcbb50c7d6105de943f543f9ed92af55818fd17b660390fc8636"
+checksum = "6fca7cd8fd809b5ac4eefb89c1f98f7a7651d3739dfb341ca6980090f554c270"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -491,9 +491,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.22.6"
+version = "0.23.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0fd24d897903a9e6d80b968368a34e1525aeb719d568dba8b3d4bfa5dc67d453"
+checksum = "34e657fa5379a79151b6ff5328d9216a84f55dc93b17b08e7c3609a969b73aa0"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -503,9 +503,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.22.6"
+version = "0.23.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "36c011a03ba1e50152b4b394b479826cad97e7a21eb52df179cd91ac411cbfbe"
+checksum = "295548d5ffd95fd1981d2d3cf4458831b21d60af046b729b6fd143b0ba7aee2f"
 dependencies = [
  "heck",
  "proc-macro2",
diff --git a/Cargo.toml b/Cargo.toml
index 3b3b8a9bc..59fead109 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -29,7 +29,7 @@ rust-version = "1.75"
 [dependencies]
 # TODO it would be very nice to remove the "py-clone" feature as it can panic,
 # but needs a bit of work to make sure it's not used in the codebase
-pyo3 = { version = "0.22.6", features = ["generate-import-lib", "num-bigint", "py-clone"] }
+pyo3 = { version = "0.23.2", features = ["generate-import-lib", "num-bigint", "py-clone"] }
 regex = "1.11.1"
 strum = { version = "0.26.3", features = ["derive"] }
 strum_macros = "0.26.4"
@@ -46,7 +46,7 @@ base64 = "0.22.1"
 num-bigint = "0.4.6"
 python3-dll-a = "0.2.10"
 uuid = "1.11.0"
-jiter = { version = "0.7.1", features = ["python"] }
+jiter = { version = "0.8.0", features = ["python"] }
 hex = "0.4.3"
 
 [lib]
@@ -74,12 +74,12 @@ debug = true
 strip = false
 
 [dev-dependencies]
-pyo3 = { version = "0.22.6", features = ["auto-initialize"] }
+pyo3 = { version = "0.23.2", features = ["auto-initialize"] }
 
 [build-dependencies]
 version_check = "0.9.5"
 # used where logic has to be version/distribution specific, e.g. pypy
-pyo3-build-config = { version = "0.22.6" }
+pyo3-build-config = { version = "0.23.2" }
 
 [lints.clippy]
 dbg_macro = "warn"
diff --git a/benches/main.rs b/benches/main.rs
index 69157e2d3..46b9db5f3 100644
--- a/benches/main.rs
+++ b/benches/main.rs
@@ -1,4 +1,5 @@
 #![feature(test)]
+#![allow(deprecated)] // FIXME: just used during upgrading PyO3 to 0.23
 
 extern crate test;
 
diff --git a/src/errors/validation_exception.rs b/src/errors/validation_exception.rs
index 6fc0e96bd..ea851b495 100644
--- a/src/errors/validation_exception.rs
+++ b/src/errors/validation_exception.rs
@@ -386,7 +386,7 @@ impl ValidationError {
         let args = (
             borrow.title.bind(py),
             borrow.errors(py, include_url_env(py), true, true)?,
-            borrow.input_type.into_py(py),
+            borrow.input_type.into_pyobject(py)?,
             borrow.hide_input,
         )
             .into_py(slf.py());
diff --git a/src/input/datetime.rs b/src/input/datetime.rs
index 577a91014..da68462d7 100644
--- a/src/input/datetime.rs
+++ b/src/input/datetime.rs
@@ -527,7 +527,7 @@ impl TzInfo {
     }
 
     #[allow(unused_variables)]
-    fn dst(&self, dt: &Bound<'_, PyAny>) -> Option<&PyDelta> {
+    fn dst(&self, dt: &Bound<'_, PyAny>) -> Option<Bound<'_, PyDelta>> {
         None
     }
 
diff --git a/src/input/input_abstract.rs b/src/input/input_abstract.rs
index 05473c702..b006b7e1f 100644
--- a/src/input/input_abstract.rs
+++ b/src/input/input_abstract.rs
@@ -1,7 +1,8 @@
+use std::convert::Infallible;
 use std::fmt;
 
 use pyo3::exceptions::PyValueError;
-use pyo3::types::{PyDict, PyList};
+use pyo3::types::{PyDict, PyList, PyString};
 use pyo3::{intern, prelude::*};
 
 use crate::errors::{ErrorTypeDefaults, InputValue, LocItem, ValError, ValResult};
@@ -20,13 +21,17 @@ pub enum InputType {
     String,
 }
 
-impl IntoPy<PyObject> for InputType {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        match self {
-            Self::Json => intern!(py, "json").into_py(py),
-            Self::Python => intern!(py, "python").into_py(py),
-            Self::String => intern!(py, "string").into_py(py),
-        }
+impl<'py> IntoPyObject<'py> for InputType {
+    type Target = PyString;
+    type Output = Bound<'py, PyString>;
+    type Error = Infallible;
+
+    fn into_pyobject(self, py: Python<'_>) -> Result<Bound<'_, PyString>, Infallible> {
+        Ok(match self {
+            Self::Json => intern!(py, "json").clone(),
+            Self::Python => intern!(py, "python").clone(),
+            Self::String => intern!(py, "string").clone(),
+        })
     }
 }
 
diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index c91a6e2fd..1b92d3eff 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -278,9 +278,8 @@ pub(crate) fn iterate_mapping_items<'a, 'py>(
         .items()
         .map_err(|e| mapping_err(e, py, input))?
         .iter()
-        .map_err(|e| mapping_err(e, py, input))?
-        .map(move |item| match item {
-            Ok(item) => item.extract().map_err(|_| {
+        .map(move |item| {
+            item.extract().map_err(|_| {
                 ValError::new(
                     ErrorType::MappingType {
                         error: MAPPING_TUPLE_ERROR.into(),
@@ -288,8 +287,7 @@ pub(crate) fn iterate_mapping_items<'a, 'py>(
                     },
                     input,
                 )
-            }),
-            Err(e) => Err(mapping_err(e, py, input)),
+            })
         });
     Ok(iterator)
 }
diff --git a/src/lib.rs b/src/lib.rs
index 0fdb038ea..9b1a470fc 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,4 +1,5 @@
 #![cfg_attr(has_coverage_attribute, feature(coverage_attribute))]
+#![allow(deprecated)] // FIXME: just used during upgrading PyO3 to 0.23
 
 extern crate core;
 
diff --git a/src/lookup_key.rs b/src/lookup_key.rs
index 7415d0942..3c52684d0 100644
--- a/src/lookup_key.rs
+++ b/src/lookup_key.rs
@@ -4,6 +4,7 @@ use std::fmt;
 use pyo3::exceptions::{PyAttributeError, PyTypeError};
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList, PyMapping, PyString};
+use pyo3::IntoPyObjectExt;
 
 use jiter::{JsonObject, JsonValue};
 
@@ -407,14 +408,18 @@ impl fmt::Display for PathItem {
     }
 }
 
-impl ToPyObject for PathItem {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
+impl<'py> IntoPyObject<'py> for &'_ PathItem {
+    type Target = PyAny;
+    type Output = Bound<'py, PyAny>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
         match self {
-            Self::S(_, val) => val.to_object(py),
-            Self::Pos(val) => val.to_object(py),
-            Self::Neg(val) => {
+            PathItem::S(_, val) => Ok(val.bind(py).clone().into_any()),
+            PathItem::Pos(val) => val.into_bound_py_any(py),
+            PathItem::Neg(val) => {
                 let neg_value = -(*val as i64);
-                neg_value.to_object(py)
+                neg_value.into_bound_py_any(py)
             }
         }
     }
diff --git a/src/serializers/extra.rs b/src/serializers/extra.rs
index 28aeea133..6fc18f014 100644
--- a/src/serializers/extra.rs
+++ b/src/serializers/extra.rs
@@ -1,5 +1,5 @@
-use std::cell::RefCell;
 use std::fmt;
+use std::sync::Mutex;
 
 use pyo3::exceptions::{PyTypeError, PyValueError};
 use pyo3::intern;
@@ -370,18 +370,27 @@ impl From<bool> for WarningsMode {
     }
 }
 
-#[derive(Clone)]
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub(crate) struct CollectWarnings {
     mode: WarningsMode,
-    warnings: RefCell<Option<Vec<String>>>,
+    // FIXME: mutex is to satisfy PyO3 0.23, we should be able to refactor this away
+    warnings: Mutex<Vec<String>>,
+}
+
+impl Clone for CollectWarnings {
+    fn clone(&self) -> Self {
+        Self {
+            mode: self.mode,
+            warnings: Mutex::new(self.warnings.lock().expect("lock poisoned").clone()),
+        }
+    }
 }
 
 impl CollectWarnings {
     pub(crate) fn new(mode: WarningsMode) -> Self {
         Self {
             mode,
-            warnings: RefCell::new(None),
+            warnings: Mutex::new(Vec::new()),
         }
     }
 
@@ -447,41 +456,46 @@ impl CollectWarnings {
     }
 
     fn add_warning(&self, message: String) {
-        let mut op_warnings = self.warnings.borrow_mut();
-        if let Some(ref mut warnings) = *op_warnings {
-            warnings.push(message);
-        } else {
-            *op_warnings = Some(vec![message]);
-        }
+        self.warnings.lock().expect("lock poisoned").push(message);
     }
 
     pub fn final_check(&self, py: Python) -> PyResult<()> {
         if self.mode == WarningsMode::None {
             return Ok(());
         }
-        match *self.warnings.borrow() {
-            Some(ref warnings) => {
-                let message = format!("Pydantic serializer warnings:\n  {}", warnings.join("\n  "));
-                if self.mode == WarningsMode::Warn {
-                    let user_warning_type = py.import_bound("builtins")?.getattr("UserWarning")?;
-                    PyErr::warn_bound(py, &user_warning_type, &message, 0)
-                } else {
-                    Err(PydanticSerializationError::new_err(message))
-                }
-            }
-            _ => Ok(()),
+        let warnings = self.warnings.lock().expect("lock poisoned");
+
+        if warnings.is_empty() {
+            return Ok(());
+        }
+
+        let message = format!("Pydantic serializer warnings:\n  {}", warnings.join("\n  "));
+        if self.mode == WarningsMode::Warn {
+            let user_warning_type = py.import_bound("builtins")?.getattr("UserWarning")?;
+            PyErr::warn_bound(py, &user_warning_type, &message, 0)
+        } else {
+            Err(PydanticSerializationError::new_err(message))
         }
     }
 }
 
-#[derive(Default, Clone)]
+#[derive(Default)]
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub struct SerRecursionState {
-    guard: RefCell<RecursionState>,
+    // FIXME: mutex is to satisfy PyO3 0.23, we should be able to refactor this away
+    guard: Mutex<RecursionState>,
+}
+
+impl Clone for SerRecursionState {
+    fn clone(&self) -> Self {
+        Self {
+            guard: Mutex::new(self.guard.lock().expect("lock poisoned").clone()),
+        }
+    }
 }
 
 impl ContainsRecursionState for &'_ Extra<'_> {
     fn access_recursion_state<R>(&mut self, f: impl FnOnce(&mut RecursionState) -> R) -> R {
-        f(&mut self.rec_guard.guard.borrow_mut())
+        f(&mut self.rec_guard.guard.lock().expect("lock poisoned"))
     }
 }
diff --git a/src/serializers/filter.rs b/src/serializers/filter.rs
index efeba7d25..bce94ecb4 100644
--- a/src/serializers/filter.rs
+++ b/src/serializers/filter.rs
@@ -132,7 +132,7 @@ impl SchemaFilter<isize> {
 
     pub fn key_filter<'py>(
         &self,
-        key: &Bound<'_, PyAny>,
+        key: &Bound<'py, PyAny>,
         include: Option<&Bound<'py, PyAny>>,
         exclude: Option<&Bound<'py, PyAny>>,
     ) -> PyResult<NextFilters<'py>> {
@@ -152,7 +152,7 @@ trait FilterLogic<T: Eq + Copy> {
     /// 2. or include it, in which case, what values of `include` and `exclude` should be passed to it
     fn filter<'py>(
         &self,
-        py_key: impl ToPyObject + Copy,
+        py_key: impl IntoPyObject<'py> + Copy,
         int_key: T,
         include: Option<&Bound<'py, PyAny>>,
         exclude: Option<&Bound<'py, PyAny>>,
@@ -266,7 +266,7 @@ impl AnyFilter {
 
     pub fn key_filter<'py>(
         &self,
-        key: &Bound<'_, PyAny>,
+        key: &Bound<'py, PyAny>,
         include: Option<&Bound<'py, PyAny>>,
         exclude: Option<&Bound<'py, PyAny>>,
     ) -> PyResult<NextFilters<'py>> {
@@ -289,11 +289,11 @@ impl AnyFilter {
 
 /// if a `__contains__` method exists, call it with the key and `__all__`, and return the result
 /// if it doesn't exist, or calling it fails (e.g. it's not a function), return `None`
-fn check_contains(obj: &Bound<'_, PyAny>, py_key: impl ToPyObject + Copy) -> PyResult<Option<bool>> {
+fn check_contains<'py>(obj: &Bound<'py, PyAny>, py_key: impl IntoPyObject<'py> + Copy) -> PyResult<Option<bool>> {
     let py = obj.py();
     match obj.getattr(intern!(py, "__contains__")) {
         Ok(contains_method) => {
-            if let Ok(result) = contains_method.call1((py_key.to_object(py),)) {
+            if let Ok(result) = contains_method.call1((py_key,)) {
                 Ok(Some(
                     result.is_truthy()? || contains_method.call1((intern!(py, "__all__"),))?.is_truthy()?,
                 ))
@@ -330,7 +330,7 @@ fn is_ellipsis_like(v: &Bound<'_, PyAny>) -> bool {
 /// lookup the dict, for the key and "__all__" key, and merge them following the same rules as pydantic V1
 fn merge_all_value<'py>(
     dict: &Bound<'py, PyDict>,
-    py_key: impl ToPyObject + Copy,
+    py_key: impl IntoPyObject<'py> + Copy,
 ) -> PyResult<Option<Bound<'py, PyAny>>> {
     let op_item_value = dict.get_item(py_key)?;
     let op_all_value = dict.get_item(intern!(dict.py(), "__all__"))?;
diff --git a/src/tools.rs b/src/tools.rs
index 231a94df6..21631b451 100644
--- a/src/tools.rs
+++ b/src/tools.rs
@@ -11,17 +11,17 @@ use crate::input::Int;
 use jiter::{cached_py_string, pystring_fast_new, StringCacheMode};
 
 pub trait SchemaDict<'py> {
-    fn get_as<T>(&self, key: &Bound<'_, PyString>) -> PyResult<Option<T>>
+    fn get_as<T>(&self, key: &Bound<'py, PyString>) -> PyResult<Option<T>>
     where
         T: FromPyObject<'py>;
 
-    fn get_as_req<T>(&self, key: &Bound<'_, PyString>) -> PyResult<T>
+    fn get_as_req<T>(&self, key: &Bound<'py, PyString>) -> PyResult<T>
     where
         T: FromPyObject<'py>;
 }
 
 impl<'py> SchemaDict<'py> for Bound<'py, PyDict> {
-    fn get_as<T>(&self, key: &Bound<'_, PyString>) -> PyResult<Option<T>>
+    fn get_as<T>(&self, key: &Bound<'py, PyString>) -> PyResult<Option<T>>
     where
         T: FromPyObject<'py>,
     {
@@ -31,7 +31,7 @@ impl<'py> SchemaDict<'py> for Bound<'py, PyDict> {
         }
     }
 
-    fn get_as_req<T>(&self, key: &Bound<'_, PyString>) -> PyResult<T>
+    fn get_as_req<T>(&self, key: &Bound<'py, PyString>) -> PyResult<T>
     where
         T: FromPyObject<'py>,
     {
@@ -43,7 +43,7 @@ impl<'py> SchemaDict<'py> for Bound<'py, PyDict> {
 }
 
 impl<'py> SchemaDict<'py> for Option<&Bound<'py, PyDict>> {
-    fn get_as<T>(&self, key: &Bound<'_, PyString>) -> PyResult<Option<T>>
+    fn get_as<T>(&self, key: &Bound<'py, PyString>) -> PyResult<Option<T>>
     where
         T: FromPyObject<'py>,
     {
@@ -54,7 +54,7 @@ impl<'py> SchemaDict<'py> for Option<&Bound<'py, PyDict>> {
     }
 
     #[cfg_attr(has_coverage_attribute, coverage(off))]
-    fn get_as_req<T>(&self, key: &Bound<'_, PyString>) -> PyResult<T>
+    fn get_as_req<T>(&self, key: &Bound<'py, PyString>) -> PyResult<T>
     where
         T: FromPyObject<'py>,
     {
diff --git a/src/validators/arguments.rs b/src/validators/arguments.rs
index 2ffd49102..39fa9d274 100644
--- a/src/validators/arguments.rs
+++ b/src/validators/arguments.rs
@@ -347,7 +347,8 @@ impl Validator for ArgumentsValidator {
                             },
                             VarKwargsMode::UnpackedTypedDict => {
                                 // Save to the remaining kwargs, we will validate as a single dict:
-                                remaining_kwargs.set_item(either_str.as_py_string(py, state.cache_str()), value)?;
+                                remaining_kwargs
+                                    .set_item(either_str.as_py_string(py, state.cache_str()), value.to_object(py))?;
                             }
                         }
                     }
diff --git a/src/validators/dataclass.rs b/src/validators/dataclass.rs
index b41de429f..53be75e88 100644
--- a/src/validators/dataclass.rs
+++ b/src/validators/dataclass.rs
@@ -326,8 +326,10 @@ impl Validator for DataclassArgsValidator {
                                                 Err(err) => return Err(err),
                                             }
                                         } else {
-                                            output_dict
-                                                .set_item(either_str.as_py_string(py, state.cache_str()), value)?;
+                                            output_dict.set_item(
+                                                either_str.as_py_string(py, state.cache_str()),
+                                                value.to_object(py),
+                                            )?;
                                         }
                                     }
                                 }
diff --git a/src/validators/decimal.rs b/src/validators/decimal.rs
index 8008d4260..5cad9e0ce 100644
--- a/src/validators/decimal.rs
+++ b/src/validators/decimal.rs
@@ -279,9 +279,9 @@ pub(crate) fn create_decimal<'py>(arg: &Bound<'py, PyAny>, input: impl ToErrorVa
 
 fn handle_decimal_new_error(input: impl ToErrorValue, error: PyErr, decimal_exception: Bound<'_, PyAny>) -> ValError {
     let py = decimal_exception.py();
-    if error.matches(py, decimal_exception) {
+    if error.matches(py, decimal_exception).unwrap_or(false) {
         ValError::new(ErrorTypeDefaults::DecimalParsing, input)
-    } else if error.matches(py, PyTypeError::type_object_bound(py)) {
+    } else if error.matches(py, PyTypeError::type_object_bound(py)).unwrap_or(false) {
         ValError::new(ErrorTypeDefaults::DecimalType, input)
     } else {
         ValError::InternalErr(error)
diff --git a/tests/test.rs b/tests/test.rs
index dbc7a21e7..1b5beb0fe 100644
--- a/tests/test.rs
+++ b/tests/test.rs
@@ -1,3 +1,5 @@
+#![allow(deprecated)] // FIXME: just used during upgrading PyO3 to 0.23
+
 #[cfg(test)]
 mod tests {
     use _pydantic_core::{SchemaSerializer, SchemaValidator, WarningsArg};

From 298e4eadc7e3745ae94309e6dc6e3855e7e50b62 Mon Sep 17 00:00:00 2001
From: Huan-Cheng Chang <changhc84@gmail.com>
Date: Mon, 2 Dec 2024 11:09:41 +0000
Subject: [PATCH 438/550] Fix lint errors with toolchain 1.83 (#1561)

---
 src/errors/validation_exception.rs            |  4 +-
 src/input/datetime.rs                         | 12 ++---
 src/input/input_abstract.rs                   | 16 ++++--
 src/input/input_json.rs                       | 54 ++++++++++++++-----
 src/input/input_python.rs                     | 42 +++++++++++----
 src/input/input_string.rs                     | 39 ++++++++++----
 src/input/return_enums.rs                     | 16 +++---
 src/serializers/computed_fields.rs            |  2 +-
 src/serializers/fields.rs                     |  2 +-
 src/serializers/infer.rs                      |  2 +-
 src/serializers/ser.rs                        | 20 +++----
 src/serializers/shared.rs                     |  5 +-
 src/serializers/type_serializers/complex.rs   |  2 +-
 src/serializers/type_serializers/dict.rs      |  2 +-
 src/serializers/type_serializers/generator.rs |  2 +-
 src/serializers/type_serializers/list.rs      |  2 +-
 .../type_serializers/set_frozenset.rs         |  2 +-
 src/serializers/type_serializers/union.rs     |  4 +-
 .../type_serializers/with_default.rs          |  2 +-
 src/validators/function.rs                    |  6 +++
 src/validators/mod.rs                         |  5 ++
 src/validators/url.rs                         | 16 +++---
 src/validators/with_default.rs                | 10 ++--
 23 files changed, 178 insertions(+), 89 deletions(-)

diff --git a/src/errors/validation_exception.rs b/src/errors/validation_exception.rs
index ea851b495..c55d02427 100644
--- a/src/errors/validation_exception.rs
+++ b/src/errors/validation_exception.rs
@@ -582,7 +582,7 @@ struct ValidationErrorSerializer<'py> {
     input_type: &'py InputType,
 }
 
-impl<'py> Serialize for ValidationErrorSerializer<'py> {
+impl Serialize for ValidationErrorSerializer<'_> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
@@ -614,7 +614,7 @@ struct PyLineErrorSerializer<'py> {
     input_type: &'py InputType,
 }
 
-impl<'py> Serialize for PyLineErrorSerializer<'py> {
+impl Serialize for PyLineErrorSerializer<'_> {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
         S: Serializer,
diff --git a/src/input/datetime.rs b/src/input/datetime.rs
index da68462d7..ed1ba51b4 100644
--- a/src/input/datetime.rs
+++ b/src/input/datetime.rs
@@ -24,7 +24,7 @@ pub enum EitherDate<'a> {
     Py(Bound<'a, PyDate>),
 }
 
-impl<'a> From<Date> for EitherDate<'a> {
+impl From<Date> for EitherDate<'_> {
     fn from(date: Date) -> Self {
         Self::Raw(date)
     }
@@ -45,7 +45,7 @@ pub fn pydate_as_date(py_date: &Bound<'_, PyAny>) -> PyResult<Date> {
     })
 }
 
-impl<'a> EitherDate<'a> {
+impl EitherDate<'_> {
     pub fn as_raw(&self) -> PyResult<Date> {
         match self {
             Self::Raw(date) => Ok(date.clone()),
@@ -68,7 +68,7 @@ pub enum EitherTime<'a> {
     Py(Bound<'a, PyTime>),
 }
 
-impl<'a> From<Time> for EitherTime<'a> {
+impl From<Time> for EitherTime<'_> {
     fn from(time: Time) -> Self {
         Self::Raw(time)
     }
@@ -87,7 +87,7 @@ pub enum EitherTimedelta<'a> {
     PySubclass(Bound<'a, PyDelta>),
 }
 
-impl<'a> From<Duration> for EitherTimedelta<'a> {
+impl From<Duration> for EitherTimedelta<'_> {
     fn from(timedelta: Duration) -> Self {
         Self::Raw(timedelta)
     }
@@ -200,7 +200,7 @@ pub fn pytime_as_time(py_time: &Bound<'_, PyAny>, py_dt: Option<&Bound<'_, PyAny
     })
 }
 
-impl<'a> EitherTime<'a> {
+impl EitherTime<'_> {
     pub fn as_raw(&self) -> PyResult<Time> {
         match self {
             Self::Raw(time) => Ok(time.clone()),
@@ -240,7 +240,7 @@ pub enum EitherDateTime<'a> {
     Py(Bound<'a, PyDateTime>),
 }
 
-impl<'a> From<DateTime> for EitherDateTime<'a> {
+impl From<DateTime> for EitherDateTime<'_> {
     fn from(dt: DateTime) -> Self {
         Self::Raw(dt)
     }
diff --git a/src/input/input_abstract.rs b/src/input/input_abstract.rs
index b006b7e1f..6f5b9279e 100644
--- a/src/input/input_abstract.rs
+++ b/src/input/input_abstract.rs
@@ -268,7 +268,6 @@ pub trait ValidatedSet<'py> {
 
 /// This type is used for inputs which don't support certain types.
 /// It implements all the associated traits, but never actually gets called.
-
 pub enum Never {}
 
 impl<'py> ValidatedDict<'py> for Never {
@@ -330,7 +329,10 @@ impl Arguments<'_> for Never {
 }
 
 impl<'py> PositionalArgs<'py> for Never {
-    type Item<'a> = Bound<'py, PyAny> where Self: 'a;
+    type Item<'a>
+        = Bound<'py, PyAny>
+    where
+        Self: 'a;
     fn len(&self) -> usize {
         unreachable!()
     }
@@ -343,8 +345,14 @@ impl<'py> PositionalArgs<'py> for Never {
 }
 
 impl<'py> KeywordArgs<'py> for Never {
-    type Key<'a> = Bound<'py, PyAny> where Self: 'a;
-    type Item<'a> = Bound<'py, PyAny> where Self: 'a;
+    type Key<'a>
+        = Bound<'py, PyAny>
+    where
+        Self: 'a;
+    type Item<'a>
+        = Bound<'py, PyAny>
+    where
+        Self: 'a;
     fn len(&self) -> usize {
         unreachable!()
     }
diff --git a/src/input/input_json.rs b/src/input/input_json.rs
index d69874613..c9d737634 100644
--- a/src/input/input_json.rs
+++ b/src/input/input_json.rs
@@ -66,9 +66,10 @@ impl<'py, 'data> Input<'py> for JsonValue<'data> {
         }
     }
 
-    type Arguments<'a> = JsonArgs<'a, 'data>
+    type Arguments<'a>
+        = JsonArgs<'a, 'data>
     where
-        Self: 'a,;
+        Self: 'a;
 
     fn validate_args(&self) -> ValResult<JsonArgs<'_, 'data>> {
         match self {
@@ -179,7 +180,10 @@ impl<'py, 'data> Input<'py> for JsonValue<'data> {
         }
     }
 
-    type Dict<'a> = &'a JsonObject<'data> where Self: 'a;
+    type Dict<'a>
+        = &'a JsonObject<'data>
+    where
+        Self: 'a;
 
     fn validate_dict(&self, _strict: bool) -> ValResult<Self::Dict<'_>> {
         match self {
@@ -192,7 +196,10 @@ impl<'py, 'data> Input<'py> for JsonValue<'data> {
         self.validate_dict(false)
     }
 
-    type List<'a> = &'a JsonArray<'data> where Self: 'a;
+    type List<'a>
+        = &'a JsonArray<'data>
+    where
+        Self: 'a;
 
     fn validate_list(&self, _strict: bool) -> ValMatch<&JsonArray<'data>> {
         match self {
@@ -201,7 +208,10 @@ impl<'py, 'data> Input<'py> for JsonValue<'data> {
         }
     }
 
-    type Tuple<'a> = &'a JsonArray<'data> where Self: 'a;
+    type Tuple<'a>
+        = &'a JsonArray<'data>
+    where
+        Self: 'a;
 
     fn validate_tuple(&self, _strict: bool) -> ValMatch<&JsonArray<'data>> {
         // just as in set's case, List has to be allowed
@@ -211,7 +221,10 @@ impl<'py, 'data> Input<'py> for JsonValue<'data> {
         }
     }
 
-    type Set<'a> = &'a JsonArray<'data> where Self: 'a;
+    type Set<'a>
+        = &'a JsonArray<'data>
+    where
+        Self: 'a;
 
     fn validate_set(&self, _strict: bool) -> ValMatch<&JsonArray<'data>> {
         // we allow a list here since otherwise it would be impossible to create a set from JSON
@@ -501,10 +514,16 @@ fn string_to_vec(s: &str) -> JsonArray<'static> {
     JsonArray::new(s.chars().map(|c| JsonValue::Str(c.to_string().into())).collect())
 }
 
-impl<'py, 'data> ValidatedDict<'py> for &'_ JsonObject<'data> {
-    type Key<'a> = &'a str where Self: 'a;
+impl<'data> ValidatedDict<'_> for &'_ JsonObject<'data> {
+    type Key<'a>
+        = &'a str
+    where
+        Self: 'a;
 
-    type Item<'a> = &'a JsonValue<'data> where Self: 'a;
+    type Item<'a>
+        = &'a JsonValue<'data>
+    where
+        Self: 'a;
 
     fn get_item<'k>(&self, key: &'k LookupKey) -> ValResult<Option<(&'k LookupPath, Self::Item<'_>)>> {
         key.json_get(self)
@@ -567,7 +586,7 @@ impl<'a, 'data> JsonArgs<'a, 'data> {
     }
 }
 
-impl<'a, 'data> Arguments<'_> for JsonArgs<'a, 'data> {
+impl<'data> Arguments<'_> for JsonArgs<'_, 'data> {
     type Args = [JsonValue<'data>];
     type Kwargs = JsonObject<'data>;
 
@@ -581,7 +600,10 @@ impl<'a, 'data> Arguments<'_> for JsonArgs<'a, 'data> {
 }
 
 impl<'data> PositionalArgs<'_> for [JsonValue<'data>] {
-    type Item<'a> = &'a JsonValue<'data> where Self: 'a;
+    type Item<'a>
+        = &'a JsonValue<'data>
+    where
+        Self: 'a;
 
     fn len(&self) -> usize {
         <[JsonValue]>::len(self)
@@ -595,8 +617,14 @@ impl<'data> PositionalArgs<'_> for [JsonValue<'data>] {
 }
 
 impl<'data> KeywordArgs<'_> for JsonObject<'data> {
-    type Key<'a> = &'a str where Self: 'a;
-    type Item<'a> = &'a JsonValue<'data> where Self: 'a;
+    type Key<'a>
+        = &'a str
+    where
+        Self: 'a;
+    type Item<'a>
+        = &'a JsonValue<'data>
+    where
+        Self: 'a;
 
     fn len(&self) -> usize {
         LazyIndexMap::len(self)
diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index 4fb88e99c..1eaa69415 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -93,7 +93,10 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
             .map(|dict| dict.to_owned().unbind().into_bound(py))
     }
 
-    type Arguments<'a> = PyArgs<'py> where Self: 'a;
+    type Arguments<'a>
+        = PyArgs<'py>
+    where
+        Self: 'a;
 
     fn validate_args(&self) -> ValResult<PyArgs<'py>> {
         if let Ok(dict) = self.downcast::<PyDict>() {
@@ -350,7 +353,10 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
         Err(ValError::new(error_type, self))
     }
 
-    type Dict<'a> = GenericPyMapping<'a, 'py> where Self: 'a;
+    type Dict<'a>
+        = GenericPyMapping<'a, 'py>
+    where
+        Self: 'a;
 
     fn strict_dict<'a>(&'a self) -> ValResult<GenericPyMapping<'a, 'py>> {
         if let Ok(dict) = self.downcast::<PyDict>() {
@@ -404,7 +410,10 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
         }
     }
 
-    type List<'a> = PySequenceIterable<'a, 'py> where Self: 'a;
+    type List<'a>
+        = PySequenceIterable<'a, 'py>
+    where
+        Self: 'a;
 
     fn validate_list<'a>(&'a self, strict: bool) -> ValMatch<PySequenceIterable<'a, 'py>> {
         if let Ok(list) = self.downcast::<PyList>() {
@@ -418,7 +427,10 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
         Err(ValError::new(ErrorTypeDefaults::ListType, self))
     }
 
-    type Tuple<'a> = PySequenceIterable<'a, 'py> where Self: 'a;
+    type Tuple<'a>
+        = PySequenceIterable<'a, 'py>
+    where
+        Self: 'a;
 
     fn validate_tuple<'a>(&'a self, strict: bool) -> ValMatch<PySequenceIterable<'a, 'py>> {
         if let Ok(tup) = self.downcast::<PyTuple>() {
@@ -432,7 +444,10 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
         Err(ValError::new(ErrorTypeDefaults::TupleType, self))
     }
 
-    type Set<'a> = PySequenceIterable<'a, 'py> where Self: 'a;
+    type Set<'a>
+        = PySequenceIterable<'a, 'py>
+    where
+        Self: 'a;
 
     fn validate_set<'a>(&'a self, strict: bool) -> ValMatch<PySequenceIterable<'a, 'py>> {
         if let Ok(set) = self.downcast::<PySet>() {
@@ -742,7 +757,10 @@ impl<'py> Arguments<'py> for PyArgs<'py> {
 }
 
 impl<'py> PositionalArgs<'py> for PyPosArgs<'py> {
-    type Item<'a> = Borrowed<'a, 'py, PyAny> where Self: 'a;
+    type Item<'a>
+        = Borrowed<'a, 'py, PyAny>
+    where
+        Self: 'a;
 
     fn len(&self) -> usize {
         self.0.len()
@@ -758,11 +776,13 @@ impl<'py> PositionalArgs<'py> for PyPosArgs<'py> {
 }
 
 impl<'py> KeywordArgs<'py> for PyKwargs<'py> {
-    type Key<'a> = Bound<'py, PyAny>
+    type Key<'a>
+        = Bound<'py, PyAny>
     where
         Self: 'a;
 
-    type Item<'a> = Bound<'py, PyAny>
+    type Item<'a>
+        = Bound<'py, PyAny>
     where
         Self: 'a;
 
@@ -790,11 +810,13 @@ pub enum GenericPyMapping<'a, 'py> {
 }
 
 impl<'py> ValidatedDict<'py> for GenericPyMapping<'_, 'py> {
-    type Key<'a> = Bound<'py, PyAny>
+    type Key<'a>
+        = Bound<'py, PyAny>
     where
         Self: 'a;
 
-    type Item<'a> = Bound<'py, PyAny>
+    type Item<'a>
+        = Bound<'py, PyAny>
     where
         Self: 'a;
 
diff --git a/src/input/input_string.rs b/src/input/input_string.rs
index 2ac218658..d2e3137e4 100644
--- a/src/input/input_string.rs
+++ b/src/input/input_string.rs
@@ -28,7 +28,7 @@ pub enum StringMapping<'py> {
     Mapping(Bound<'py, PyDict>),
 }
 
-impl<'py> ToPyObject for StringMapping<'py> {
+impl ToPyObject for StringMapping<'_> {
     fn to_object(&self, py: Python<'_>) -> PyObject {
         match self {
             Self::String(s) => s.to_object(py),
@@ -83,7 +83,10 @@ impl<'py> Input<'py> for StringMapping<'py> {
         None
     }
 
-    type Arguments<'a> = StringMappingDict<'py> where Self: 'a;
+    type Arguments<'a>
+        = StringMappingDict<'py>
+    where
+        Self: 'a;
 
     fn validate_args(&self) -> ValResult<StringMappingDict<'py>> {
         // do we want to support this?
@@ -150,7 +153,10 @@ impl<'py> Input<'py> for StringMapping<'py> {
         }
     }
 
-    type Dict<'a> = StringMappingDict<'py> where Self: 'a;
+    type Dict<'a>
+        = StringMappingDict<'py>
+    where
+        Self: 'a;
 
     fn strict_dict(&self) -> ValResult<StringMappingDict<'py>> {
         match self {
@@ -159,19 +165,28 @@ impl<'py> Input<'py> for StringMapping<'py> {
         }
     }
 
-    type List<'a> = Never where Self: 'a;
+    type List<'a>
+        = Never
+    where
+        Self: 'a;
 
     fn validate_list(&self, _strict: bool) -> ValMatch<Never> {
         Err(ValError::new(ErrorTypeDefaults::ListType, self))
     }
 
-    type Tuple<'a> = Never where Self: 'a;
+    type Tuple<'a>
+        = Never
+    where
+        Self: 'a;
 
     fn validate_tuple(&self, _strict: bool) -> ValMatch<Never> {
         Err(ValError::new(ErrorTypeDefaults::TupleType, self))
     }
 
-    type Set<'a> = Never where Self: 'a;
+    type Set<'a>
+        = Never
+    where
+        Self: 'a;
 
     fn validate_set(&self, _strict: bool) -> ValMatch<Never> {
         Err(ValError::new(ErrorTypeDefaults::SetType, self))
@@ -259,11 +274,13 @@ impl<'py> Arguments<'py> for StringMappingDict<'py> {
 }
 
 impl<'py> KeywordArgs<'py> for StringMappingDict<'py> {
-    type Key<'a> = StringMapping<'py>
+    type Key<'a>
+        = StringMapping<'py>
     where
         Self: 'a;
 
-    type Item<'a> = StringMapping<'py>
+    type Item<'a>
+        = StringMapping<'py>
     where
         Self: 'a;
 
@@ -283,11 +300,13 @@ impl<'py> KeywordArgs<'py> for StringMappingDict<'py> {
 }
 
 impl<'py> ValidatedDict<'py> for StringMappingDict<'py> {
-    type Key<'a> = StringMapping<'py>
+    type Key<'a>
+        = StringMapping<'py>
     where
         Self: 'a;
 
-    type Item<'a> = StringMapping<'py>
+    type Item<'a>
+        = StringMapping<'py>
     where
         Self: 'a;
     fn get_item<'k>(&self, key: &'k LookupKey) -> ValResult<Option<(&'k LookupPath, Self::Item<'_>)>> {
diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index 1b92d3eff..8897344dd 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -484,7 +484,7 @@ impl<'a> From<&'a str> for EitherString<'a> {
     }
 }
 
-impl<'a> From<String> for EitherString<'a> {
+impl From<String> for EitherString<'_> {
     fn from(data: String) -> Self {
         Self::Cow(Cow::Owned(data))
     }
@@ -511,7 +511,7 @@ pub enum EitherBytes<'a, 'py> {
     Py(Bound<'py, PyBytes>),
 }
 
-impl<'a> From<Vec<u8>> for EitherBytes<'a, '_> {
+impl From<Vec<u8>> for EitherBytes<'_, '_> {
     fn from(bytes: Vec<u8>) -> Self {
         Self::Cow(Cow::Owned(bytes))
     }
@@ -633,7 +633,7 @@ impl<'a> EitherInt<'a> {
     }
 }
 
-impl<'a> IntoPy<PyObject> for EitherInt<'a> {
+impl IntoPy<PyObject> for EitherInt<'_> {
     fn into_py(self, py: Python<'_>) -> PyObject {
         match self {
             Self::I64(int) => int.into_py(py),
@@ -651,7 +651,7 @@ pub enum EitherFloat<'a> {
     Py(Bound<'a, PyFloat>),
 }
 
-impl<'a> EitherFloat<'a> {
+impl EitherFloat<'_> {
     pub fn as_f64(&self) -> f64 {
         match self {
             EitherFloat::F64(f) => *f,
@@ -660,7 +660,7 @@ impl<'a> EitherFloat<'a> {
     }
 }
 
-impl<'a> IntoPy<PyObject> for EitherFloat<'a> {
+impl IntoPy<PyObject> for EitherFloat<'_> {
     fn into_py(self, py: Python<'_>) -> PyObject {
         match self {
             Self::F64(float) => float.into_py(py),
@@ -715,7 +715,7 @@ impl PartialEq for Int {
     }
 }
 
-impl<'a> Rem for &'a Int {
+impl Rem for &Int {
     type Output = Int;
 
     fn rem(self, rhs: Self) -> Self::Output {
@@ -752,7 +752,7 @@ pub enum EitherComplex<'a> {
     Py(Bound<'a, PyComplex>),
 }
 
-impl<'a> IntoPy<PyObject> for EitherComplex<'a> {
+impl IntoPy<PyObject> for EitherComplex<'_> {
     fn into_py(self, py: Python<'_>) -> PyObject {
         match self {
             Self::Complex(c) => PyComplex::from_doubles_bound(py, c[0], c[1]).into_py(py),
@@ -761,7 +761,7 @@ impl<'a> IntoPy<PyObject> for EitherComplex<'a> {
     }
 }
 
-impl<'a> EitherComplex<'a> {
+impl EitherComplex<'_> {
     pub fn as_f64(&self, py: Python<'_>) -> [f64; 2] {
         match self {
             EitherComplex::Complex(f) => *f,
diff --git a/src/serializers/computed_fields.rs b/src/serializers/computed_fields.rs
index 0cfa2d4d1..42f95f2f2 100644
--- a/src/serializers/computed_fields.rs
+++ b/src/serializers/computed_fields.rs
@@ -191,7 +191,7 @@ impl PyGcTraverse for ComputedFields {
 
 impl_py_gc_traverse!(ComputedFieldSerializer<'_> { computed_field });
 
-impl<'py> Serialize for ComputedFieldSerializer<'py> {
+impl Serialize for ComputedFieldSerializer<'_> {
     fn serialize<S: serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
         let py = self.model.py();
         let property_name_py = self.computed_field.property_name_py.bind(py);
diff --git a/src/serializers/fields.rs b/src/serializers/fields.rs
index 4498d8fa7..d8971d8cb 100644
--- a/src/serializers/fields.rs
+++ b/src/serializers/fields.rs
@@ -389,7 +389,7 @@ impl TypeSerializer for GeneralFieldsSerializer {
     }
 
     fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
-        self._invalid_as_json_key(key, extra, "fields")
+        self.invalid_as_json_key(key, extra, "fields")
     }
 
     fn serde_serialize<S: serde::ser::Serializer>(
diff --git a/src/serializers/infer.rs b/src/serializers/infer.rs
index a188f6f60..5cb530256 100644
--- a/src/serializers/infer.rs
+++ b/src/serializers/infer.rs
@@ -324,7 +324,7 @@ impl<'py> SerializeInfer<'py> {
     }
 }
 
-impl<'py> Serialize for SerializeInfer<'py> {
+impl Serialize for SerializeInfer<'_> {
     fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
         let ob_type = self.extra.ob_type_lookup.get_type(self.value);
         infer_serialize_known(ob_type, self.value, serializer, self.include, self.exclude, self.extra)
diff --git a/src/serializers/ser.rs b/src/serializers/ser.rs
index 50f006e7b..f28918e58 100644
--- a/src/serializers/ser.rs
+++ b/src/serializers/ser.rs
@@ -32,7 +32,7 @@ where
     }
 }
 
-impl<'a, W> PythonSerializer<W, PrettyFormatter<'a>>
+impl<W> PythonSerializer<W, PrettyFormatter<'_>>
 where
     W: io::Write,
 {
@@ -388,7 +388,7 @@ where
     }
 }
 
-impl<'a, W, F> serde::ser::SerializeSeq for Compound<'a, W, F>
+impl<W, F> serde::ser::SerializeSeq for Compound<'_, W, F>
 where
     W: io::Write,
     F: Formatter,
@@ -436,7 +436,7 @@ where
     }
 }
 
-impl<'a, W, F> serde::ser::SerializeTuple for Compound<'a, W, F>
+impl<W, F> serde::ser::SerializeTuple for Compound<'_, W, F>
 where
     W: io::Write,
     F: Formatter,
@@ -458,7 +458,7 @@ where
     }
 }
 
-impl<'a, W, F> serde::ser::SerializeTupleStruct for Compound<'a, W, F>
+impl<W, F> serde::ser::SerializeTupleStruct for Compound<'_, W, F>
 where
     W: io::Write,
     F: Formatter,
@@ -480,7 +480,7 @@ where
     }
 }
 
-impl<'a, W, F> serde::ser::SerializeTupleVariant for Compound<'a, W, F>
+impl<W, F> serde::ser::SerializeTupleVariant for Compound<'_, W, F>
 where
     W: io::Write,
     F: Formatter,
@@ -522,7 +522,7 @@ where
     }
 }
 
-impl<'a, W, F> serde::ser::SerializeMap for Compound<'a, W, F>
+impl<W, F> serde::ser::SerializeMap for Compound<'_, W, F>
 where
     W: io::Write,
     F: Formatter,
@@ -595,7 +595,7 @@ where
     }
 }
 
-impl<'a, W, F> serde::ser::SerializeStruct for Compound<'a, W, F>
+impl<W, F> serde::ser::SerializeStruct for Compound<'_, W, F>
 where
     W: io::Write,
     F: Formatter,
@@ -630,7 +630,7 @@ where
     }
 }
 
-impl<'a, W, F> serde::ser::SerializeStructVariant for Compound<'a, W, F>
+impl<W, F> serde::ser::SerializeStructVariant for Compound<'_, W, F>
 where
     W: io::Write,
     F: Formatter,
@@ -794,7 +794,7 @@ fn invalid_number() -> PythonSerializerError {
     }
 }
 
-impl<'a, W, F> serde::ser::Serializer for MapKeySerializer<'a, W, F>
+impl<W, F> serde::ser::Serializer for MapKeySerializer<'_, W, F>
 where
     W: io::Write,
     F: Formatter,
@@ -1124,7 +1124,7 @@ where
 
 struct NumberStrEmitter<'a, W: 'a + io::Write, F: 'a + Formatter>(&'a mut PythonSerializer<W, F>);
 
-impl<'a, W: io::Write, F: Formatter> serde::ser::Serializer for NumberStrEmitter<'a, W, F> {
+impl<W: io::Write, F: Formatter> serde::ser::Serializer for NumberStrEmitter<'_, W, F> {
     type Ok = ();
     type Error = PythonSerializerError;
 
diff --git a/src/serializers/shared.rs b/src/serializers/shared.rs
index 8eb54c837..d3a87735f 100644
--- a/src/serializers/shared.rs
+++ b/src/serializers/shared.rs
@@ -270,7 +270,7 @@ pub(crate) trait TypeSerializer: Send + Sync + Debug {
 
     fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>>;
 
-    fn _invalid_as_json_key<'a>(
+    fn invalid_as_json_key<'a>(
         &self,
         key: &'a Bound<'_, PyAny>,
         extra: &Extra,
@@ -332,7 +332,7 @@ impl<'py> PydanticSerializer<'py> {
     }
 }
 
-impl<'py> Serialize for PydanticSerializer<'py> {
+impl Serialize for PydanticSerializer<'_> {
     fn serialize<S: serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
         self.serializer
             .serde_serialize(self.value, serializer, self.include, self.exclude, self.extra)
@@ -369,6 +369,7 @@ pub(crate) fn to_json_bytes(
     Ok(bytes)
 }
 
+#[allow(clippy::type_complexity)]
 pub(super) fn any_dataclass_iter<'a, 'py>(
     dataclass: &'a Bound<'py, PyAny>,
 ) -> PyResult<(
diff --git a/src/serializers/type_serializers/complex.rs b/src/serializers/type_serializers/complex.rs
index 57c5ba069..9847a25f5 100644
--- a/src/serializers/type_serializers/complex.rs
+++ b/src/serializers/type_serializers/complex.rs
@@ -45,7 +45,7 @@ impl TypeSerializer for ComplexSerializer {
     }
 
     fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
-        self._invalid_as_json_key(key, extra, "complex")
+        self.invalid_as_json_key(key, extra, "complex")
     }
 
     fn serde_serialize<S: serde::ser::Serializer>(
diff --git a/src/serializers/type_serializers/dict.rs b/src/serializers/type_serializers/dict.rs
index ec750faed..79a3d1669 100644
--- a/src/serializers/type_serializers/dict.rs
+++ b/src/serializers/type_serializers/dict.rs
@@ -106,7 +106,7 @@ impl TypeSerializer for DictSerializer {
     }
 
     fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
-        self._invalid_as_json_key(key, extra, Self::EXPECTED_TYPE)
+        self.invalid_as_json_key(key, extra, Self::EXPECTED_TYPE)
     }
 
     fn serde_serialize<S: serde::ser::Serializer>(
diff --git a/src/serializers/type_serializers/generator.rs b/src/serializers/type_serializers/generator.rs
index c85cd0f72..94065aae8 100644
--- a/src/serializers/type_serializers/generator.rs
+++ b/src/serializers/type_serializers/generator.rs
@@ -101,7 +101,7 @@ impl TypeSerializer for GeneratorSerializer {
     }
 
     fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
-        self._invalid_as_json_key(key, extra, Self::EXPECTED_TYPE)
+        self.invalid_as_json_key(key, extra, Self::EXPECTED_TYPE)
     }
 
     fn serde_serialize<S: serde::ser::Serializer>(
diff --git a/src/serializers/type_serializers/list.rs b/src/serializers/type_serializers/list.rs
index adec6c13c..713ce4f86 100644
--- a/src/serializers/type_serializers/list.rs
+++ b/src/serializers/type_serializers/list.rs
@@ -82,7 +82,7 @@ impl TypeSerializer for ListSerializer {
     }
 
     fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
-        self._invalid_as_json_key(key, extra, Self::EXPECTED_TYPE)
+        self.invalid_as_json_key(key, extra, Self::EXPECTED_TYPE)
     }
 
     fn serde_serialize<S: serde::ser::Serializer>(
diff --git a/src/serializers/type_serializers/set_frozenset.rs b/src/serializers/type_serializers/set_frozenset.rs
index 7373c286d..03a05accd 100644
--- a/src/serializers/type_serializers/set_frozenset.rs
+++ b/src/serializers/type_serializers/set_frozenset.rs
@@ -77,7 +77,7 @@ macro_rules! build_serializer {
             }
 
             fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
-                self._invalid_as_json_key(key, extra, Self::EXPECTED_TYPE)
+                self.invalid_as_json_key(key, extra, Self::EXPECTED_TYPE)
             }
 
             fn serde_serialize<S: serde::ser::Serializer>(
diff --git a/src/serializers/type_serializers/union.rs b/src/serializers/type_serializers/union.rs
index 2bf19cff9..2c10c1f7b 100644
--- a/src/serializers/type_serializers/union.rs
+++ b/src/serializers/type_serializers/union.rs
@@ -158,7 +158,7 @@ impl TypeSerializer for UnionSerializer {
             &self.choices,
             self.retry_with_lax_check(),
         ) {
-            Ok(Some(v)) => return infer_serialize(v.bind(value.py()), serializer, None, None, extra),
+            Ok(Some(v)) => infer_serialize(v.bind(value.py()), serializer, None, None, extra),
             Ok(None) => infer_serialize(value, serializer, include, exclude, extra),
             Err(err) => Err(serde::ser::Error::custom(err.to_string())),
         }
@@ -263,7 +263,7 @@ impl TypeSerializer for TaggedUnionSerializer {
             },
             extra,
         ) {
-            Ok(Some(v)) => return infer_serialize(v.bind(value.py()), serializer, None, None, extra),
+            Ok(Some(v)) => infer_serialize(v.bind(value.py()), serializer, None, None, extra),
             Ok(None) => infer_serialize(value, serializer, include, exclude, extra),
             Err(err) => Err(serde::ser::Error::custom(err.to_string())),
         }
diff --git a/src/serializers/type_serializers/with_default.rs b/src/serializers/type_serializers/with_default.rs
index 7a4225d26..97b07156c 100644
--- a/src/serializers/type_serializers/with_default.rs
+++ b/src/serializers/type_serializers/with_default.rs
@@ -78,7 +78,7 @@ impl TypeSerializer for WithDefaultSerializer {
             Ok(None)
         } else {
             self.default.default_value(
-                py, &None, // Won't be used.
+                py, None, // Won't be used.
             )
         }
     }
diff --git a/src/validators/function.rs b/src/validators/function.rs
index 286107c92..96e15e87b 100644
--- a/src/validators/function.rs
+++ b/src/validators/function.rs
@@ -124,6 +124,7 @@ impl Validator for FunctionBeforeValidator {
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let validate = |v, s: &mut ValidationState<'_, 'py>| self.validator.validate(py, &v, s);
+        #[allow(clippy::used_underscore_items)]
         self._validate(validate, py, input, state)
     }
     fn validate_assignment<'py>(
@@ -137,6 +138,7 @@ impl Validator for FunctionBeforeValidator {
         let validate = move |v, s: &mut ValidationState<'_, 'py>| {
             self.validator.validate_assignment(py, &v, field_name, field_value, s)
         };
+        #[allow(clippy::used_underscore_items)]
         self._validate(validate, py, obj, state)
     }
 
@@ -190,6 +192,7 @@ impl Validator for FunctionAfterValidator {
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let validate = |v: &_, s: &mut ValidationState<'_, 'py>| self.validator.validate(py, v, s);
+        #[allow(clippy::used_underscore_items)]
         self._validate(validate, py, input, state)
     }
     fn validate_assignment<'py>(
@@ -203,6 +206,7 @@ impl Validator for FunctionAfterValidator {
         let validate = move |v: &Bound<'py, PyAny>, s: &mut ValidationState<'_, 'py>| {
             self.validator.validate_assignment(py, v, field_name, field_value, s)
         };
+        #[allow(clippy::used_underscore_items)]
         self._validate(validate, py, obj, state)
     }
 
@@ -351,6 +355,7 @@ impl Validator for FunctionWrapValidator {
             ),
         };
         let handler = Bound::new(py, handler)?;
+        #[allow(clippy::used_underscore_items)]
         let result = self._validate(handler.as_any(), py, input, state);
         state.exactness = handler.borrow_mut().validator.exactness;
         result
@@ -376,6 +381,7 @@ impl Validator for FunctionWrapValidator {
             updated_field_name: field_name.to_string(),
             updated_field_value: field_value.to_object(py),
         };
+        #[allow(clippy::used_underscore_items)]
         self._validate(Bound::new(py, handler)?.as_any(), py, obj, state)
     }
 
diff --git a/src/validators/mod.rs b/src/validators/mod.rs
index 10a4d6e34..cafdfcd12 100644
--- a/src/validators/mod.rs
+++ b/src/validators/mod.rs
@@ -176,6 +176,7 @@ impl SchemaValidator {
         self_instance: Option<&Bound<'_, PyAny>>,
         allow_partial: PartialMode,
     ) -> PyResult<PyObject> {
+        #[allow(clippy::used_underscore_items)]
         self._validate(
             py,
             input,
@@ -199,6 +200,7 @@ impl SchemaValidator {
         context: Option<&Bound<'_, PyAny>>,
         self_instance: Option<&Bound<'_, PyAny>>,
     ) -> PyResult<bool> {
+        #[allow(clippy::used_underscore_items)]
         match self._validate(
             py,
             input,
@@ -228,6 +230,7 @@ impl SchemaValidator {
         allow_partial: PartialMode,
     ) -> PyResult<PyObject> {
         let r = match json::validate_json_bytes(input) {
+            #[allow(clippy::used_underscore_items)]
             Ok(v_match) => self._validate_json(
                 py,
                 input,
@@ -254,6 +257,7 @@ impl SchemaValidator {
         let t = InputType::String;
         let string_mapping = StringMapping::new_value(input).map_err(|e| self.prepare_validation_err(py, e, t))?;
 
+        #[allow(clippy::used_underscore_items)]
         match self._validate(py, &string_mapping, t, strict, None, context, None, allow_partial) {
             Ok(r) => Ok(r),
             Err(e) => Err(self.prepare_validation_err(py, e, t)),
@@ -383,6 +387,7 @@ impl SchemaValidator {
     ) -> ValResult<PyObject> {
         let json_value = jiter::JsonValue::parse_with_config(json_data, true, allow_partial)
             .map_err(|e| json::map_json_err(input, e, json_data))?;
+        #[allow(clippy::used_underscore_items)]
         self._validate(
             py,
             &json_value,
diff --git a/src/validators/url.rs b/src/validators/url.rs
index 46bab20c1..69e1e668d 100644
--- a/src/validators/url.rs
+++ b/src/validators/url.rs
@@ -86,9 +86,9 @@ impl Validator for UrlValidator {
         match check_sub_defaults(
             &mut either_url,
             self.host_required,
-            &self.default_host,
+            self.default_host.as_ref(),
             self.default_port,
-            &self.default_path,
+            self.default_path.as_ref(),
         ) {
             Ok(()) => {
                 // Lax rather than strict to preserve V2.4 semantic that str wins over url in union
@@ -251,9 +251,9 @@ impl Validator for MultiHostUrlValidator {
         match check_sub_defaults(
             &mut multi_url,
             self.host_required,
-            &self.default_host,
+            self.default_host.as_ref(),
             self.default_port,
-            &self.default_path,
+            self.default_path.as_ref(),
         ) {
             Ok(()) => {
                 // Lax rather than strict to preserve V2.4 semantic that str wins over url in union
@@ -536,9 +536,9 @@ fn parse_url(url_str: &str, input: impl ToErrorValue, strict: bool) -> ValResult
 fn check_sub_defaults(
     url: &mut impl CopyFromPyUrl,
     host_required: bool,
-    default_host: &Option<String>,
+    default_host: Option<&String>,
     default_port: Option<u16>,
-    default_path: &Option<String>,
+    default_path: Option<&String>,
 ) -> Result<(), ErrorType> {
     let map_parse_err = |e: ParseError| ErrorType::UrlParsing {
         error: e.to_string(),
@@ -546,7 +546,7 @@ fn check_sub_defaults(
     };
 
     if !url.url().has_host() {
-        if let Some(ref default_host) = default_host {
+        if let Some(default_host) = default_host {
             url.url_mut().set_host(Some(default_host)).map_err(map_parse_err)?;
         } else if host_required {
             return Err(ErrorType::UrlParsing {
@@ -562,7 +562,7 @@ fn check_sub_defaults(
                 .map_err(|()| map_parse_err(ParseError::EmptyHost))?;
         }
     }
-    if let Some(ref default_path) = default_path {
+    if let Some(default_path) = default_path {
         let path = url.url().path();
         if path.is_empty() || path == "/" {
             url.url_mut().set_path(default_path);
diff --git a/src/validators/with_default.rs b/src/validators/with_default.rs
index 565c31060..caa30cdac 100644
--- a/src/validators/with_default.rs
+++ b/src/validators/with_default.rs
@@ -47,15 +47,15 @@ impl DefaultType {
         }
     }
 
-    pub fn default_value(&self, py: Python, validated_data: &Option<Bound<PyDict>>) -> PyResult<Option<PyObject>> {
+    pub fn default_value(&self, py: Python, validated_data: Option<&Bound<PyDict>>) -> PyResult<Option<PyObject>> {
         match self {
             Self::Default(ref default) => Ok(Some(default.clone_ref(py))),
             Self::DefaultFactory(ref default_factory, ref takes_data) => {
                 let result = if *takes_data {
-                    if validated_data.is_none() {
-                        default_factory.call1(py, ({},))
+                    if let Some(data) = validated_data {
+                        default_factory.call1(py, (data,))
                     } else {
-                        default_factory.call1(py, (validated_data.as_deref().unwrap(),))
+                        default_factory.call1(py, ({},))
                     }
                 } else {
                     default_factory.call0(py)
@@ -180,7 +180,7 @@ impl Validator for WithDefaultValidator {
         outer_loc: Option<impl Into<LocItem>>,
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<Option<PyObject>> {
-        match self.default.default_value(py, &state.extra().data)? {
+        match self.default.default_value(py, state.extra().data.as_ref())? {
             Some(stored_dft) => {
                 let dft: Py<PyAny> = if self.copy_default {
                     let deepcopy_func = COPY_DEEPCOPY.get_or_init(py, || get_deepcopy(py).unwrap());

From c278ba6d7118b0fd0ce51276669e1d62473b530f Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 2 Dec 2024 11:16:43 +0000
Subject: [PATCH 439/550] Bump codecov/codecov-action from 4 to 5 (#1562)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index a08a25ea2..3a85b7778 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -55,7 +55,7 @@ jobs:
 
       - run: coverage-prepare lcov python/pydantic_core/*.so
 
-      - uses: codecov/codecov-action@v4
+      - uses: codecov/codecov-action@v5
 
   # See https://github.com/PyO3/pyo3/discussions/2781
   # tests intermittently segfault with pypy and cpython 3.7 when using `coverage run ...`, hence separate job

From 8e867bc242597c0a99948622d9f2e3dbe3cc4084 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 2 Dec 2024 11:19:24 +0000
Subject: [PATCH 440/550] Bump astral-sh/setup-uv from 3 to 4 (#1563)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/ci.yml       | 20 ++++++++++----------
 .github/workflows/codspeed.yml |  2 +-
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 3a85b7778..18228feb1 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -32,7 +32,7 @@ jobs:
       - run: rustup component add llvm-tools-preview
 
       - name: install uv
-        uses: astral-sh/setup-uv@v3
+        uses: astral-sh/setup-uv@v4
         with:
           enable-cache: true
 
@@ -88,7 +88,7 @@ jobs:
           key: test-v3
 
       - name: install uv
-        uses: astral-sh/setup-uv@v3
+        uses: astral-sh/setup-uv@v4
         with:
           enable-cache: true
 
@@ -127,7 +127,7 @@ jobs:
         uses: Swatinem/rust-cache@v2
 
       - name: install uv
-        uses: astral-sh/setup-uv@v3
+        uses: astral-sh/setup-uv@v4
         with:
           enable-cache: true
 
@@ -152,7 +152,7 @@ jobs:
       - uses: actions/checkout@v4
 
       - name: install uv
-        uses: astral-sh/setup-uv@v3
+        uses: astral-sh/setup-uv@v4
         with:
           enable-cache: true
 
@@ -197,7 +197,7 @@ jobs:
       - uses: actions/checkout@v4
 
       - name: install uv
-        uses: astral-sh/setup-uv@v3
+        uses: astral-sh/setup-uv@v4
         with:
           enable-cache: true
 
@@ -239,7 +239,7 @@ jobs:
         uses: Swatinem/rust-cache@v2
 
       - name: install uv
-        uses: astral-sh/setup-uv@v3
+        uses: astral-sh/setup-uv@v4
         with:
           enable-cache: true
 
@@ -283,7 +283,7 @@ jobs:
           node-version: '18'
 
       - name: install uv
-        uses: astral-sh/setup-uv@v3
+        uses: astral-sh/setup-uv@v4
         with:
           enable-cache: true
 
@@ -343,7 +343,7 @@ jobs:
           actions-cache-folder: emsdk-cache
 
       - name: install uv
-        uses: astral-sh/setup-uv@v3
+        uses: astral-sh/setup-uv@v4
         with:
           enable-cache: true
 
@@ -543,7 +543,7 @@ jobs:
       - uses: actions/checkout@v4
 
       - name: install uv
-        uses: astral-sh/setup-uv@v3
+        uses: astral-sh/setup-uv@v4
         with:
           enable-cache: true
 
@@ -668,7 +668,7 @@ jobs:
       - uses: actions/checkout@v4
 
       - name: install uv
-        uses: astral-sh/setup-uv@v3
+        uses: astral-sh/setup-uv@v4
         with:
           enable-cache: true
 
diff --git a/.github/workflows/codspeed.yml b/.github/workflows/codspeed.yml
index b8ddb3076..d3d2a59ac 100644
--- a/.github/workflows/codspeed.yml
+++ b/.github/workflows/codspeed.yml
@@ -26,7 +26,7 @@ jobs:
           python-version: ${{ env.UV_PYTHON}}
 
       - name: install uv
-        uses: astral-sh/setup-uv@v3
+        uses: astral-sh/setup-uv@v4
         with:
           enable-cache: true
 

From 6b49c1ec4ca4cfc6f20bbabf50bd9ab97adbad44 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 2 Dec 2024 11:19:31 +0000
Subject: [PATCH 441/550] Bump serde_json from 1.0.132 to 1.0.133 (#1564)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 5ff11690c..b0e5517e9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -601,9 +601,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.132"
+version = "1.0.133"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d726bfaff4b320266d395898905d0eba0345aae23b54aee3a737e260fd46db03"
+checksum = "c7fceb2473b9166b2294ef05efcb65a3db80803f0b03ef86a5fc88a2b85ee377"
 dependencies = [
  "indexmap",
  "itoa",
diff --git a/Cargo.toml b/Cargo.toml
index 59fead109..e857cbe1d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -33,7 +33,7 @@ pyo3 = { version = "0.23.2", features = ["generate-import-lib", "num-bigint", "p
 regex = "1.11.1"
 strum = { version = "0.26.3", features = ["derive"] }
 strum_macros = "0.26.4"
-serde_json = {version = "1.0.132", features = ["arbitrary_precision", "preserve_order"]}
+serde_json = {version = "1.0.133", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.13"
 serde = { version = "1.0.214", features = ["derive"] }
 speedate = "0.15.0"

From 3bb1eb1c24d88853a36ed0827f18c9bb5a9bdfbe Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 2 Dec 2024 11:19:44 +0000
Subject: [PATCH 442/550] Bump idna from 1.0.2 to 1.0.3 (#1567)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 19 ++++++++++++++-----
 Cargo.toml |  2 +-
 2 files changed, 15 insertions(+), 6 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index b0e5517e9..421cfaedf 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -263,16 +263,25 @@ dependencies = [
 
 [[package]]
 name = "idna"
-version = "1.0.2"
+version = "1.0.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd69211b9b519e98303c015e21a007e293db403b6c85b9b124e133d25e242cdd"
+checksum = "686f825264d630750a544639377bae737628043f20d38bbc029e8f29ea968a7e"
 dependencies = [
- "icu_normalizer",
- "icu_properties",
+ "idna_adapter",
  "smallvec",
  "utf8_iter",
 ]
 
+[[package]]
+name = "idna_adapter"
+version = "1.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "daca1df1c957320b2cf139ac61e7bd64fed304c5040df000a745aa1de3b4ef71"
+dependencies = [
+ "icu_normalizer",
+ "icu_properties",
+]
+
 [[package]]
 name = "indexmap"
 version = "2.2.6"
@@ -431,7 +440,7 @@ dependencies = [
  "base64",
  "enum_dispatch",
  "hex",
- "idna 1.0.2",
+ "idna 1.0.3",
  "jiter",
  "num-bigint",
  "pyo3",
diff --git a/Cargo.toml b/Cargo.toml
index e857cbe1d..0a33390d5 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -41,7 +41,7 @@ smallvec = "1.13.2"
 ahash = "0.8.10"
 url = "2.5.0"
 # idna is already required by url, added here to be explicit
-idna = "1.0.2"
+idna = "1.0.3"
 base64 = "0.22.1"
 num-bigint = "0.4.6"
 python3-dll-a = "0.2.10"

From ce03db571dbba2c2192713d6843d7fea397c3051 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 2 Dec 2024 11:19:50 +0000
Subject: [PATCH 443/550] Bump serde from 1.0.214 to 1.0.215 (#1565)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 8 ++++----
 Cargo.toml | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 421cfaedf..fb39941a0 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -590,18 +590,18 @@ checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
 
 [[package]]
 name = "serde"
-version = "1.0.214"
+version = "1.0.215"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f55c3193aca71c12ad7890f1785d2b73e1b9f63a0bbc353c08ef26fe03fc56b5"
+checksum = "6513c1ad0b11a9376da888e3e0baa0077f1aed55c17f50e7b2397136129fb88f"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.214"
+version = "1.0.215"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "de523f781f095e28fa605cdce0f8307e451cc0fd14e2eb4cd2e98a355b147766"
+checksum = "ad1e866f866923f252f05c889987993144fb74e722403468a4ebd70c3cd756c0"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/Cargo.toml b/Cargo.toml
index 0a33390d5..8132aae31 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -35,7 +35,7 @@ strum = { version = "0.26.3", features = ["derive"] }
 strum_macros = "0.26.4"
 serde_json = {version = "1.0.133", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.13"
-serde = { version = "1.0.214", features = ["derive"] }
+serde = { version = "1.0.215", features = ["derive"] }
 speedate = "0.15.0"
 smallvec = "1.13.2"
 ahash = "0.8.10"

From 167ffcf8616d02553695de368aebad1df1955387 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Mon, 2 Dec 2024 11:32:41 +0000
Subject: [PATCH 444/550] remove `python3-dll-a` dependency (#1568)

---
 Cargo.lock | 1 -
 Cargo.toml | 1 -
 2 files changed, 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index fb39941a0..55644ccd6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -445,7 +445,6 @@ dependencies = [
  "num-bigint",
  "pyo3",
  "pyo3-build-config",
- "python3-dll-a",
  "regex",
  "serde",
  "serde_json",
diff --git a/Cargo.toml b/Cargo.toml
index 8132aae31..94545239c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -44,7 +44,6 @@ url = "2.5.0"
 idna = "1.0.3"
 base64 = "0.22.1"
 num-bigint = "0.4.6"
-python3-dll-a = "0.2.10"
 uuid = "1.11.0"
 jiter = { version = "0.8.0", features = ["python"] }
 hex = "0.4.3"

From ab0e4bd32ec6edaf66732872c853a04f930e9589 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 2 Dec 2024 12:02:22 +0000
Subject: [PATCH 445/550] Bump python3-dll-a from 0.2.10 to 0.2.11 (#1566)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 55644ccd6..95d9c7a1f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -524,9 +524,9 @@ dependencies = [
 
 [[package]]
 name = "python3-dll-a"
-version = "0.2.10"
+version = "0.2.11"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "bd0b78171a90d808b319acfad166c4790d9e9759bbc14ac8273fe133673dd41b"
+checksum = "9b9e268ee1be609e93a13eb06839f68f67e5fe0fb4049834d261c2d5091c1b6d"
 dependencies = [
  "cc",
 ]

From be87e05d70afafb7aacc0bb9371ecb4c6ab7e5be Mon Sep 17 00:00:00 2001
From: Huan-Cheng Chang <changhc84@gmail.com>
Date: Tue, 3 Dec 2024 10:02:10 +0000
Subject: [PATCH 446/550] Use UserWarning from pyo3 (#1559)

---
 src/serializers/extra.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/serializers/extra.rs b/src/serializers/extra.rs
index 6fc18f014..94ccf19a9 100644
--- a/src/serializers/extra.rs
+++ b/src/serializers/extra.rs
@@ -1,10 +1,10 @@
 use std::fmt;
 use std::sync::Mutex;
 
-use pyo3::exceptions::{PyTypeError, PyValueError};
-use pyo3::intern;
+use pyo3::exceptions::{PyTypeError, PyUserWarning, PyValueError};
 use pyo3::prelude::*;
 use pyo3::types::{PyBool, PyString};
+use pyo3::{intern, PyTypeInfo};
 
 use serde::ser::Error;
 
@@ -471,7 +471,7 @@ impl CollectWarnings {
 
         let message = format!("Pydantic serializer warnings:\n  {}", warnings.join("\n  "));
         if self.mode == WarningsMode::Warn {
-            let user_warning_type = py.import_bound("builtins")?.getattr("UserWarning")?;
+            let user_warning_type = PyUserWarning::type_object(py);
             PyErr::warn_bound(py, &user_warning_type, &message, 0)
         } else {
             Err(PydanticSerializationError::new_err(message))

From 707b440c51f56ffc40365d89601ab62b8b74ff01 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Wed, 4 Dec 2024 14:02:47 +0000
Subject: [PATCH 447/550] bump jiter to 0.8.2, PyO3 to 0.23.3 (#1570)

---
 Cargo.lock | 24 ++++++++++++------------
 Cargo.toml |  8 ++++----
 2 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 95d9c7a1f..ba9644655 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -306,9 +306,9 @@ checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
 
 [[package]]
 name = "jiter"
-version = "0.8.0"
+version = "0.8.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1c88e0910b421b182953e774fd31930f690fc456a0ea56cd5e6ffcccee278731"
+checksum = "8243cf2d026264056bfacf305e54f5bee8866fd46b4c1873adcaebf614a0d306"
 dependencies = [
  "ahash",
  "bitvec",
@@ -459,9 +459,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.23.2"
+version = "0.23.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f54b3d09cbdd1f8c20650b28e7b09e338881482f4aa908a5f61a00c98fba2690"
+checksum = "e484fd2c8b4cb67ab05a318f1fd6fa8f199fcc30819f08f07d200809dba26c15"
 dependencies = [
  "cfg-if",
  "indoc",
@@ -478,9 +478,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.23.2"
+version = "0.23.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3015cf985888fe66cfb63ce0e321c603706cd541b7aec7ddd35c281390af45d8"
+checksum = "dc0e0469a84f208e20044b98965e1561028180219e35352a2afaf2b942beff3b"
 dependencies = [
  "once_cell",
  "python3-dll-a",
@@ -489,9 +489,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.23.2"
+version = "0.23.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6fca7cd8fd809b5ac4eefb89c1f98f7a7651d3739dfb341ca6980090f554c270"
+checksum = "eb1547a7f9966f6f1a0f0227564a9945fe36b90da5a93b3933fc3dc03fae372d"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -499,9 +499,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.23.2"
+version = "0.23.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "34e657fa5379a79151b6ff5328d9216a84f55dc93b17b08e7c3609a969b73aa0"
+checksum = "fdb6da8ec6fa5cedd1626c886fc8749bdcbb09424a86461eb8cdf096b7c33257"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -511,9 +511,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.23.2"
+version = "0.23.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "295548d5ffd95fd1981d2d3cf4458831b21d60af046b729b6fd143b0ba7aee2f"
+checksum = "38a385202ff5a92791168b1136afae5059d3ac118457bb7bc304c197c2d33e7d"
 dependencies = [
  "heck",
  "proc-macro2",
diff --git a/Cargo.toml b/Cargo.toml
index 94545239c..9b32263da 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -29,7 +29,7 @@ rust-version = "1.75"
 [dependencies]
 # TODO it would be very nice to remove the "py-clone" feature as it can panic,
 # but needs a bit of work to make sure it's not used in the codebase
-pyo3 = { version = "0.23.2", features = ["generate-import-lib", "num-bigint", "py-clone"] }
+pyo3 = { version = "0.23.3", features = ["generate-import-lib", "num-bigint", "py-clone"] }
 regex = "1.11.1"
 strum = { version = "0.26.3", features = ["derive"] }
 strum_macros = "0.26.4"
@@ -45,7 +45,7 @@ idna = "1.0.3"
 base64 = "0.22.1"
 num-bigint = "0.4.6"
 uuid = "1.11.0"
-jiter = { version = "0.8.0", features = ["python"] }
+jiter = { version = "0.8.2", features = ["python"] }
 hex = "0.4.3"
 
 [lib]
@@ -73,12 +73,12 @@ debug = true
 strip = false
 
 [dev-dependencies]
-pyo3 = { version = "0.23.2", features = ["auto-initialize"] }
+pyo3 = { version = "0.23.3", features = ["auto-initialize"] }
 
 [build-dependencies]
 version_check = "0.9.5"
 # used where logic has to be version/distribution specific, e.g. pypy
-pyo3-build-config = { version = "0.23.2" }
+pyo3-build-config = { version = "0.23.3" }
 
 [lints.clippy]
 dbg_macro = "warn"

From 4c02cbd0af5aaa80ae53039d6ec023f751ea65e5 Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Fri, 6 Dec 2024 22:00:43 +0100
Subject: [PATCH 448/550] Fix typo in `PydanticUseDefault` docstring (#1571)

---
 python/pydantic_core/_pydantic_core.pyi | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index f3103f28f..7245c37f7 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -836,7 +836,7 @@ class PydanticUseDefault(Exception):
         # > Event(name='meeting', time=datetime.datetime(2024, 1, 1, 12, 0))
         ```
 
-    For an additional example, seethe [validating partial json data](../concepts/json.md#partial-json-parsing) section of the Pydantic documentation.
+    For an additional example, see the [validating partial json data](../concepts/json.md#partial-json-parsing) section of the Pydantic documentation.
     """
 
     def __new__(cls) -> Self: ...

From 7f13140efde3b7e75686ce112943a5c6ecae772e Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Mon, 9 Dec 2024 11:25:23 +0100
Subject: [PATCH 449/550] Forward `default_value` calls to the underlying
 schema for `DefinitionRefValidator` (#1573)

---
 src/validators/definitions.rs        | 12 ++++++++++++
 tests/validators/test_definitions.py | 14 ++++++++++++++
 2 files changed, 26 insertions(+)

diff --git a/src/validators/definitions.rs b/src/validators/definitions.rs
index e0511f7fe..aeeb627ac 100644
--- a/src/validators/definitions.rs
+++ b/src/validators/definitions.rs
@@ -92,6 +92,18 @@ impl Validator for DefinitionRefValidator {
         })
     }
 
+    fn default_value<'py>(
+        &self,
+        _py: Python<'py>,
+        _outer_loc: Option<impl Into<crate::errors::LocItem>>,
+        _state: &mut ValidationState<'_, 'py>,
+    ) -> ValResult<Option<PyObject>> {
+        self.definition.read(|validator| {
+            let validator = validator.unwrap();
+            validator.default_value(_py, _outer_loc, _state)
+        })
+    }
+
     fn validate_assignment<'py>(
         &self,
         py: Python<'py>,
diff --git a/tests/validators/test_definitions.py b/tests/validators/test_definitions.py
index 18101fa93..d4102e95a 100644
--- a/tests/validators/test_definitions.py
+++ b/tests/validators/test_definitions.py
@@ -150,3 +150,17 @@ def test_definition_chain():
         ),
     )
     assert v.validate_python('1') == 1
+
+
+def test_forwards_get_default_value():
+    v = SchemaValidator(
+        core_schema.definitions_schema(
+            core_schema.definition_reference_schema('foo'),
+            [core_schema.with_default_schema(core_schema.int_schema(), default=1, ref='foo')],
+        )
+    )
+
+    default = v.get_default_value()
+
+    assert default is not None
+    assert default.value == 1

From 6a455fbfc1ab8cf7e304cfae9b75577b71e3798a Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Mon, 9 Dec 2024 12:42:29 +0000
Subject: [PATCH 450/550] fix type hint for `SerializationInfo.round_trip`
 (#1576)

---
 python/pydantic_core/core_schema.py | 1 +
 1 file changed, 1 insertion(+)

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index 0fcfe9cab..eff30a15a 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -149,6 +149,7 @@ def exclude_none(self) -> bool: ...
     @property
     def serialize_as_any(self) -> bool: ...
 
+    @property
     def round_trip(self) -> bool: ...
 
     def mode_is_json(self) -> bool: ...

From 98bc1e2a380344a5157824f9e5659e7a040b1ea4 Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Thu, 12 Dec 2024 15:11:18 +0100
Subject: [PATCH 451/550] Include JSON Schema input core schema in function
 schemas (#1572)

---
 python/pydantic_core/core_schema.py | 24 ++++++++++++++++++++++++
 1 file changed, 24 insertions(+)

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index eff30a15a..a45d82f9c 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -1971,6 +1971,7 @@ class _ValidatorFunctionSchema(TypedDict, total=False):
 
 class BeforeValidatorFunctionSchema(_ValidatorFunctionSchema, total=False):
     type: Required[Literal['function-before']]
+    json_schema_input_schema: CoreSchema
 
 
 def no_info_before_validator_function(
@@ -1978,6 +1979,7 @@ def no_info_before_validator_function(
     schema: CoreSchema,
     *,
     ref: str | None = None,
+    json_schema_input_schema: CoreSchema | None = None,
     metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> BeforeValidatorFunctionSchema:
@@ -2003,6 +2005,7 @@ def fn(v: bytes) -> str:
         function: The validator function to call
         schema: The schema to validate the output of the validator function
         ref: optional unique identifier of the schema, used to reference the schema in other places
+        json_schema_input_schema: The core schema to be used to generate the corresponding JSON Schema input type
         metadata: Any other information you want to include with the schema, not used by pydantic-core
         serialization: Custom serialization schema
     """
@@ -2011,6 +2014,7 @@ def fn(v: bytes) -> str:
         function={'type': 'no-info', 'function': function},
         schema=schema,
         ref=ref,
+        json_schema_input_schema=json_schema_input_schema,
         metadata=metadata,
         serialization=serialization,
     )
@@ -2022,6 +2026,7 @@ def with_info_before_validator_function(
     *,
     field_name: str | None = None,
     ref: str | None = None,
+    json_schema_input_schema: CoreSchema | None = None,
     metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> BeforeValidatorFunctionSchema:
@@ -2051,6 +2056,7 @@ def fn(v: bytes, info: core_schema.ValidationInfo) -> str:
         field_name: The name of the field
         schema: The schema to validate the output of the validator function
         ref: optional unique identifier of the schema, used to reference the schema in other places
+        json_schema_input_schema: The core schema to be used to generate the corresponding JSON Schema input type
         metadata: Any other information you want to include with the schema, not used by pydantic-core
         serialization: Custom serialization schema
     """
@@ -2059,6 +2065,7 @@ def fn(v: bytes, info: core_schema.ValidationInfo) -> str:
         function=_dict_not_none(type='with-info', function=function, field_name=field_name),
         schema=schema,
         ref=ref,
+        json_schema_input_schema=json_schema_input_schema,
         metadata=metadata,
         serialization=serialization,
     )
@@ -2073,6 +2080,7 @@ def no_info_after_validator_function(
     schema: CoreSchema,
     *,
     ref: str | None = None,
+    json_schema_input_schema: CoreSchema | None = None,
     metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> AfterValidatorFunctionSchema:
@@ -2096,6 +2104,7 @@ def fn(v: str) -> str:
         function: The validator function to call after the schema is validated
         schema: The schema to validate before the validator function
         ref: optional unique identifier of the schema, used to reference the schema in other places
+        json_schema_input_schema: The core schema to be used to generate the corresponding JSON Schema input type
         metadata: Any other information you want to include with the schema, not used by pydantic-core
         serialization: Custom serialization schema
     """
@@ -2104,6 +2113,7 @@ def fn(v: str) -> str:
         function={'type': 'no-info', 'function': function},
         schema=schema,
         ref=ref,
+        json_schema_input_schema=json_schema_input_schema,
         metadata=metadata,
         serialization=serialization,
     )
@@ -2189,6 +2199,7 @@ class WrapValidatorFunctionSchema(TypedDict, total=False):
     function: Required[WrapValidatorFunction]
     schema: Required[CoreSchema]
     ref: str
+    json_schema_input_schema: CoreSchema
     metadata: Dict[str, Any]
     serialization: SerSchema
 
@@ -2198,6 +2209,7 @@ def no_info_wrap_validator_function(
     schema: CoreSchema,
     *,
     ref: str | None = None,
+    json_schema_input_schema: CoreSchema | None = None,
     metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> WrapValidatorFunctionSchema:
@@ -2226,6 +2238,7 @@ def fn(
         function: The validator function to call
         schema: The schema to validate the output of the validator function
         ref: optional unique identifier of the schema, used to reference the schema in other places
+        json_schema_input_schema: The core schema to be used to generate the corresponding JSON Schema input type
         metadata: Any other information you want to include with the schema, not used by pydantic-core
         serialization: Custom serialization schema
     """
@@ -2233,6 +2246,7 @@ def fn(
         type='function-wrap',
         function={'type': 'no-info', 'function': function},
         schema=schema,
+        json_schema_input_schema=json_schema_input_schema,
         ref=ref,
         metadata=metadata,
         serialization=serialization,
@@ -2244,6 +2258,7 @@ def with_info_wrap_validator_function(
     schema: CoreSchema,
     *,
     field_name: str | None = None,
+    json_schema_input_schema: CoreSchema | None = None,
     ref: str | None = None,
     metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
@@ -2274,6 +2289,7 @@ def fn(
         function: The validator function to call
         schema: The schema to validate the output of the validator function
         field_name: The name of the field this validators is applied to, if any
+        json_schema_input_schema: The core schema to be used to generate the corresponding JSON Schema input type
         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
         serialization: Custom serialization schema
@@ -2282,6 +2298,7 @@ def fn(
         type='function-wrap',
         function=_dict_not_none(type='with-info', function=function, field_name=field_name),
         schema=schema,
+        json_schema_input_schema=json_schema_input_schema,
         ref=ref,
         metadata=metadata,
         serialization=serialization,
@@ -2292,6 +2309,7 @@ class PlainValidatorFunctionSchema(TypedDict, total=False):
     type: Required[Literal['function-plain']]
     function: Required[ValidationFunction]
     ref: str
+    json_schema_input_schema: CoreSchema
     metadata: Dict[str, Any]
     serialization: SerSchema
 
@@ -2300,6 +2318,7 @@ def no_info_plain_validator_function(
     function: NoInfoValidatorFunction,
     *,
     ref: str | None = None,
+    json_schema_input_schema: CoreSchema | None = None,
     metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> PlainValidatorFunctionSchema:
@@ -2321,6 +2340,7 @@ def fn(v: str) -> str:
     Args:
         function: The validator function to call
         ref: optional unique identifier of the schema, used to reference the schema in other places
+        json_schema_input_schema: The core schema to be used to generate the corresponding JSON Schema input type
         metadata: Any other information you want to include with the schema, not used by pydantic-core
         serialization: Custom serialization schema
     """
@@ -2328,6 +2348,7 @@ def fn(v: str) -> str:
         type='function-plain',
         function={'type': 'no-info', 'function': function},
         ref=ref,
+        json_schema_input_schema=json_schema_input_schema,
         metadata=metadata,
         serialization=serialization,
     )
@@ -2338,6 +2359,7 @@ def with_info_plain_validator_function(
     *,
     field_name: str | None = None,
     ref: str | None = None,
+    json_schema_input_schema: CoreSchema | None = None,
     metadata: Dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> PlainValidatorFunctionSchema:
@@ -2360,6 +2382,7 @@ def fn(v: str, info: core_schema.ValidationInfo) -> str:
         function: The validator function to call
         field_name: The name of the field this validators is applied to, if any
         ref: optional unique identifier of the schema, used to reference the schema in other places
+        json_schema_input_schema: The core schema to be used to generate the corresponding JSON Schema input type
         metadata: Any other information you want to include with the schema, not used by pydantic-core
         serialization: Custom serialization schema
     """
@@ -2367,6 +2390,7 @@ def fn(v: str, info: core_schema.ValidationInfo) -> str:
         type='function-plain',
         function=_dict_not_none(type='with-info', function=function, field_name=field_name),
         ref=ref,
+        json_schema_input_schema=json_schema_input_schema,
         metadata=metadata,
         serialization=serialization,
     )

From d7650d115a404c79ea9f73b6c189afa838232380 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Thu, 12 Dec 2024 19:42:08 +0000
Subject: [PATCH 452/550] Move from `_bound` suffixed APIs as part of PyO3 0.23
 update (#1577)

---
 src/build_tools.rs                            |  4 +--
 src/errors/location.rs                        |  6 ++---
 src/errors/mod.rs                             |  2 +-
 src/errors/types.rs                           |  6 ++---
 src/errors/validation_exception.rs            | 22 ++++++++--------
 src/input/datetime.rs                         | 12 ++++-----
 src/input/input_json.rs                       |  6 ++---
 src/input/input_python.rs                     |  8 +++---
 src/input/return_enums.rs                     |  4 +--
 src/input/shared.rs                           |  2 +-
 src/lib.rs                                    |  2 +-
 src/lookup_key.rs                             |  8 +++---
 src/serializers/config.rs                     |  4 +--
 src/serializers/extra.rs                      |  7 ++---
 src/serializers/fields.rs                     |  6 ++---
 src/serializers/filter.rs                     |  6 ++---
 src/serializers/infer.rs                      | 26 +++++++++----------
 src/serializers/mod.rs                        |  4 +--
 src/serializers/ob_type.rs                    | 22 +++++-----------
 src/serializers/shared.rs                     |  2 +-
 src/serializers/type_serializers/dataclass.rs |  4 +--
 src/serializers/type_serializers/dict.rs      |  2 +-
 src/serializers/type_serializers/format.rs    |  2 +-
 src/serializers/type_serializers/function.rs  |  6 ++---
 src/serializers/type_serializers/literal.rs   |  4 +--
 .../type_serializers/set_frozenset.rs         |  4 +--
 src/serializers/type_serializers/tuple.rs     |  4 +--
 src/url.rs                                    |  4 +--
 src/validators/arguments.rs                   |  8 +++---
 src/validators/call.rs                        |  4 +--
 src/validators/dataclass.rs                   | 10 +++----
 src/validators/datetime.rs                    |  2 +-
 src/validators/decimal.rs                     | 16 ++++++------
 src/validators/dict.rs                        |  2 +-
 src/validators/frozenset.rs                   |  2 +-
 src/validators/function.rs                    |  6 ++---
 src/validators/literal.rs                     |  4 +--
 src/validators/mod.rs                         | 11 ++++----
 src/validators/model.rs                       | 12 ++++-----
 src/validators/model_fields.rs                | 14 +++++-----
 src/validators/set.rs                         |  2 +-
 src/validators/string.rs                      |  2 +-
 src/validators/tuple.rs                       |  2 +-
 src/validators/typed_dict.rs                  |  2 +-
 src/validators/union.rs                       |  2 +-
 src/validators/uuid.rs                        |  4 +--
 src/validators/with_default.rs                |  2 +-
 47 files changed, 142 insertions(+), 154 deletions(-)

diff --git a/src/build_tools.rs b/src/build_tools.rs
index 3d7e8ccc8..000ffff34 100644
--- a/src/build_tools.rs
+++ b/src/build_tools.rs
@@ -90,7 +90,7 @@ impl SchemaError {
                     ValidationError::new(line_errors, "Schema".to_object(py), InputType::Python, false);
                 let schema_error = SchemaError(SchemaErrorEnum::ValidationError(validation_error));
                 match Py::new(py, schema_error) {
-                    Ok(err) => PyErr::from_value_bound(err.into_bound(py).into_any()),
+                    Ok(err) => PyErr::from_value(err.into_bound(py).into_any()),
                     Err(err) => err,
                 }
             }
@@ -124,7 +124,7 @@ impl SchemaError {
 
     fn errors(&self, py: Python) -> PyResult<Py<PyList>> {
         match &self.0 {
-            SchemaErrorEnum::Message(_) => Ok(PyList::empty_bound(py).unbind()),
+            SchemaErrorEnum::Message(_) => Ok(PyList::empty(py).unbind()),
             SchemaErrorEnum::ValidationError(error) => error.errors(py, false, false, true),
         }
     }
diff --git a/src/errors/location.rs b/src/errors/location.rs
index e9e20ab5d..9449e26a2 100644
--- a/src/errors/location.rs
+++ b/src/errors/location.rs
@@ -12,7 +12,7 @@ use crate::lookup_key::{LookupPath, PathItem};
 
 /// Used to store individual items of the error location, e.g. a string for key/field names
 /// or a number for array indices.
-#[derive(Clone, Eq, PartialEq)]
+#[derive(Clone, Eq, PartialEq, IntoPyObjectRef)]
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub enum LocItem {
     /// string type key, used to identify items from a dict or anything that implements `__getitem__`
@@ -133,9 +133,9 @@ static EMPTY_TUPLE: GILOnceCell<PyObject> = GILOnceCell::new();
 impl ToPyObject for Location {
     fn to_object(&self, py: Python<'_>) -> PyObject {
         match self {
-            Self::List(loc) => PyTuple::new_bound(py, loc.iter().rev()).to_object(py),
+            Self::List(loc) => PyTuple::new(py, loc.iter().rev()).unwrap().to_object(py),
             Self::Empty => EMPTY_TUPLE
-                .get_or_init(py, || PyTuple::empty_bound(py).to_object(py))
+                .get_or_init(py, || PyTuple::empty(py).to_object(py))
                 .clone_ref(py),
         }
     }
diff --git a/src/errors/mod.rs b/src/errors/mod.rs
index ffdda90e3..6cf38b186 100644
--- a/src/errors/mod.rs
+++ b/src/errors/mod.rs
@@ -13,7 +13,7 @@ pub use self::validation_exception::ValidationError;
 pub use self::value_exception::{PydanticCustomError, PydanticKnownError, PydanticOmit, PydanticUseDefault};
 
 pub fn py_err_string(py: Python, err: PyErr) -> String {
-    let value = err.value_bound(py);
+    let value = err.value(py);
     match value.get_type().qualname() {
         Ok(type_name) => match value.str() {
             Ok(py_str) => {
diff --git a/src/errors/types.rs b/src/errors/types.rs
index 07186003d..8e36ec9f5 100644
--- a/src/errors/types.rs
+++ b/src/errors/types.rs
@@ -22,7 +22,7 @@ pub fn list_all_errors(py: Python) -> PyResult<Bound<'_, PyList>> {
     let mut errors: Vec<Bound<'_, PyDict>> = Vec::with_capacity(100);
     for error_type in ErrorType::iter() {
         if !matches!(error_type, ErrorType::CustomError { .. }) {
-            let d = PyDict::new_bound(py);
+            let d = PyDict::new(py);
             d.set_item("type", error_type.to_string())?;
             let message_template_python = error_type.message_template_python();
             d.set_item("message_template_python", message_template_python)?;
@@ -39,7 +39,7 @@ pub fn list_all_errors(py: Python) -> PyResult<Bound<'_, PyList>> {
             errors.push(d);
         }
     }
-    Ok(PyList::new_bound(py, errors))
+    PyList::new(py, errors)
 }
 
 fn field_from_context<'py, T: FromPyObject<'py>>(
@@ -745,7 +745,7 @@ impl ErrorType {
     }
 
     pub fn py_dict(&self, py: Python) -> PyResult<Option<Py<PyDict>>> {
-        let dict = PyDict::new_bound(py);
+        let dict = PyDict::new(py);
         let custom_ctx_used = self.py_dict_update_ctx(py, &dict)?;
 
         if let Self::CustomError { .. } = self {
diff --git a/src/errors/validation_exception.rs b/src/errors/validation_exception.rs
index c55d02427..acbce0d7f 100644
--- a/src/errors/validation_exception.rs
+++ b/src/errors/validation_exception.rs
@@ -3,7 +3,7 @@ use std::fmt::{Display, Write};
 use std::str::from_utf8;
 
 use pyo3::exceptions::{PyKeyError, PyTypeError, PyValueError};
-use pyo3::ffi;
+use pyo3::ffi::{self, c_str};
 use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::sync::GILOnceCell;
@@ -73,7 +73,7 @@ impl ValidationError {
                                 return cause_problem;
                             }
                         }
-                        PyErr::from_value_bound(err.into_bound(py).into_any())
+                        PyErr::from_value(err.into_bound(py).into_any())
                     }
                     Err(err) => err,
                 }
@@ -145,7 +145,7 @@ impl ValidationError {
                     use pyo3::exceptions::PyUserWarning;
 
                     let wrapped = PyUserWarning::new_err((note,));
-                    wrapped.set_cause(py, Some(PyErr::from_value_bound(err.clone_ref(py).into_bound(py))));
+                    wrapped.set_cause(py, Some(PyErr::from_value(err.clone_ref(py).into_bound(py))));
                     user_py_errs.push(wrapped);
                 }
             }
@@ -167,7 +167,7 @@ impl ValidationError {
             #[cfg(not(Py_3_11))]
             let cause = {
                 use pyo3::exceptions::PyImportError;
-                match py.import_bound("exceptiongroup") {
+                match py.import("exceptiongroup") {
                     Ok(py_mod) => match py_mod.getattr("ExceptionGroup") {
                         Ok(group_cls) => match group_cls.call1((title, user_py_errs)) {
                             Ok(group_instance) => Some(group_instance.into_py(py)),
@@ -202,10 +202,10 @@ fn include_url_env(py: Python) -> bool {
         match std::env::var_os("PYDANTIC_ERRORS_OMIT_URL") {
             Some(val) => {
                 // We don't care whether warning succeeded or not, hence the assignment
-                let _ = PyErr::warn_bound(
+                let _ = PyErr::warn(
                     py,
-                    &py.get_type_bound::<pyo3::exceptions::PyDeprecationWarning>(),
-                    "PYDANTIC_ERRORS_OMIT_URL is deprecated, use PYDANTIC_ERRORS_INCLUDE_URL instead",
+                    &py.get_type::<pyo3::exceptions::PyDeprecationWarning>(),
+                    c_str!("PYDANTIC_ERRORS_OMIT_URL is deprecated, use PYDANTIC_ERRORS_INCLUDE_URL instead"),
                     1,
                 );
                 // If OMIT_URL exists but is empty, we include the URL:
@@ -298,7 +298,7 @@ impl ValidationError {
     ) -> PyResult<Py<PyList>> {
         let url_prefix = get_url_prefix(py, include_url);
         let mut iteration_error = None;
-        let list = PyList::new_bound(
+        let list = PyList::new(
             py,
             // PyList::new takes ExactSizeIterator, so if an error occurs during iteration we
             // fill the list with None before returning the error; the list will then be thrown
@@ -313,7 +313,7 @@ impl ValidationError {
                         py.None()
                     })
             }),
-        );
+        )?;
         if let Some(err) = iteration_error {
             Err(err)
         } else {
@@ -368,7 +368,7 @@ impl ValidationError {
             }
         };
         let s = from_utf8(&bytes).map_err(json_py_err)?;
-        Ok(PyString::new_bound(py, s))
+        Ok(PyString::new(py, s))
     }
 
     fn __repr__(&self, py: Python) -> String {
@@ -489,7 +489,7 @@ impl PyLineError {
         input_type: InputType,
         include_input: bool,
     ) -> PyResult<PyObject> {
-        let dict = PyDict::new_bound(py);
+        let dict = PyDict::new(py);
         dict.set_item("type", self.error_type.type_string())?;
         dict.set_item("loc", self.location.to_object(py))?;
         dict.set_item("msg", self.error_type.render_message(py, input_type)?)?;
diff --git a/src/input/datetime.rs b/src/input/datetime.rs
index ed1ba51b4..33a09dcb7 100644
--- a/src/input/datetime.rs
+++ b/src/input/datetime.rs
@@ -56,7 +56,7 @@ impl EitherDate<'_> {
     pub fn try_into_py(self, py: Python<'_>) -> PyResult<PyObject> {
         let date = match self {
             Self::Py(date) => Ok(date),
-            Self::Raw(date) => PyDate::new_bound(py, date.year.into(), date.month, date.day),
+            Self::Raw(date) => PyDate::new(py, date.year.into(), date.month, date.day),
         }?;
         Ok(date.into_py(py))
     }
@@ -165,7 +165,7 @@ pub fn pytimedelta_subclass_as_duration(py_timedelta: &Bound<'_, PyDelta>) -> Py
 
 pub fn duration_as_pytimedelta<'py>(py: Python<'py>, duration: &Duration) -> PyResult<Bound<'py, PyDelta>> {
     let sign = if duration.positive { 1 } else { -1 };
-    PyDelta::new_bound(
+    PyDelta::new(
         py,
         sign * duration.day as i32,
         sign * duration.second as i32,
@@ -211,7 +211,7 @@ impl EitherTime<'_> {
     pub fn try_into_py(self, py: Python<'_>) -> PyResult<PyObject> {
         let time = match self {
             Self::Py(time) => Ok(time),
-            Self::Raw(time) => PyTime::new_bound(
+            Self::Raw(time) => PyTime::new(
                 py,
                 time.hour,
                 time.minute,
@@ -269,7 +269,7 @@ impl<'a> EitherDateTime<'a> {
 
     pub fn try_into_py(self, py: Python<'a>) -> PyResult<PyObject> {
         let dt = match self {
-            Self::Raw(datetime) => PyDateTime::new_bound(
+            Self::Raw(datetime) => PyDateTime::new(
                 py,
                 datetime.date.year.into(),
                 datetime.date.month,
@@ -393,7 +393,7 @@ pub fn float_as_datetime<'py>(input: &(impl Input<'py> + ?Sized), timestamp: f64
 
 pub fn date_as_datetime<'py>(date: &Bound<'py, PyDate>) -> PyResult<EitherDateTime<'py>> {
     let py = date.py();
-    let dt = PyDateTime::new_bound(
+    let dt = PyDateTime::new(
         py,
         date.getattr(intern!(py, "year"))?.extract()?,
         date.getattr(intern!(py, "month"))?.extract()?,
@@ -518,7 +518,7 @@ impl TzInfo {
 
     #[allow(unused_variables)]
     fn utcoffset<'py>(&self, py: Python<'py>, dt: &Bound<'_, PyAny>) -> PyResult<Bound<'py, PyDelta>> {
-        PyDelta::new_bound(py, 0, self.seconds, 0, true)
+        PyDelta::new(py, 0, self.seconds, 0, true)
     }
 
     #[allow(unused_variables)]
diff --git a/src/input/input_json.rs b/src/input/input_json.rs
index c9d737634..58839318e 100644
--- a/src/input/input_json.rs
+++ b/src/input/input_json.rs
@@ -56,7 +56,7 @@ impl<'py, 'data> Input<'py> for JsonValue<'data> {
     fn as_kwargs(&self, py: Python<'py>) -> Option<Bound<'py, PyDict>> {
         match self {
             JsonValue::Object(object) => {
-                let dict = PyDict::new_bound(py);
+                let dict = PyDict::new(py);
                 for (k, v) in LazyIndexMap::iter(object) {
                     dict.set_item(k, v.to_object(py)).unwrap();
                 }
@@ -171,7 +171,7 @@ impl<'py, 'data> Input<'py> for JsonValue<'data> {
     fn validate_decimal(&self, _strict: bool, py: Python<'py>) -> ValMatch<Bound<'py, PyAny>> {
         match self {
             JsonValue::Float(f) => {
-                create_decimal(&PyString::new_bound(py, &f.to_string()), self).map(ValidationMatch::strict)
+                create_decimal(&PyString::new(py, &f.to_string()), self).map(ValidationMatch::strict)
             }
             JsonValue::Str(..) | JsonValue::Int(..) | JsonValue::BigInt(..) => {
                 create_decimal(self.to_object(py).bind(py), self).map(ValidationMatch::strict)
@@ -324,7 +324,7 @@ impl<'py, 'data> Input<'py> for JsonValue<'data> {
     fn validate_complex(&self, strict: bool, py: Python<'py>) -> ValResult<ValidationMatch<EitherComplex<'py>>> {
         match self {
             JsonValue::Str(s) => Ok(ValidationMatch::strict(EitherComplex::Py(string_to_complex(
-                &PyString::new_bound(py, s),
+                &PyString::new(py, s),
                 self,
             )?))),
             JsonValue::Float(f) => {
diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index 1eaa69415..fa5cc3167 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -87,10 +87,8 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
         Some(self)
     }
 
-    fn as_kwargs(&self, py: Python<'py>) -> Option<Bound<'py, PyDict>> {
-        self.downcast::<PyDict>()
-            .ok()
-            .map(|dict| dict.to_owned().unbind().into_bound(py))
+    fn as_kwargs(&self, _py: Python<'py>) -> Option<Bound<'py, PyDict>> {
+        self.downcast::<PyDict>().ok().map(Bound::to_owned)
     }
 
     type Arguments<'a>
@@ -620,7 +618,7 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
         if strict {
             return Err(ValError::new(
                 ErrorType::IsInstanceOf {
-                    class: PyComplex::type_object_bound(py)
+                    class: PyComplex::type_object(py)
                         .qualname()
                         .and_then(|name| name.extract())
                         .unwrap_or_else(|_| "complex".to_owned()),
diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index 8897344dd..3fcf2a003 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -548,7 +548,7 @@ impl EitherBytes<'_, '_> {
 impl IntoPy<PyObject> for EitherBytes<'_, '_> {
     fn into_py(self, py: Python<'_>) -> PyObject {
         match self {
-            EitherBytes::Cow(bytes) => PyBytes::new_bound(py, &bytes).into_py(py),
+            EitherBytes::Cow(bytes) => PyBytes::new(py, &bytes).into_py(py),
             EitherBytes::Py(py_bytes) => py_bytes.into_py(py),
         }
     }
@@ -755,7 +755,7 @@ pub enum EitherComplex<'a> {
 impl IntoPy<PyObject> for EitherComplex<'_> {
     fn into_py(self, py: Python<'_>) -> PyObject {
         match self {
-            Self::Complex(c) => PyComplex::from_doubles_bound(py, c[0], c[1]).into_py(py),
+            Self::Complex(c) => PyComplex::from_doubles(py, c[0], c[1]).into_py(py),
             Self::Py(c) => c.into_py(py),
         }
     }
diff --git a/src/input/shared.rs b/src/input/shared.rs
index 0c81c1cfe..f3d8a3b9f 100644
--- a/src/input/shared.rs
+++ b/src/input/shared.rs
@@ -14,7 +14,7 @@ static ENUM_META_OBJECT: GILOnceCell<Py<PyAny>> = GILOnceCell::new();
 pub fn get_enum_meta_object(py: Python) -> &Bound<'_, PyAny> {
     ENUM_META_OBJECT
         .get_or_init(py, || {
-            py.import_bound(intern!(py, "enum"))
+            py.import(intern!(py, "enum"))
                 .and_then(|enum_module| enum_module.getattr(intern!(py, "EnumMeta")))
                 .unwrap()
                 .into()
diff --git a/src/lib.rs b/src/lib.rs
index 9b1a470fc..4a9effb48 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -89,7 +89,7 @@ fn get_pydantic_version(py: Python<'_>) -> Option<&'static str> {
 
     PYDANTIC_VERSION
         .get_or_init(py, || {
-            py.import_bound("pydantic")
+            py.import("pydantic")
                 .and_then(|pydantic| pydantic.getattr("__version__")?.extract())
                 .ok()
         })
diff --git a/src/lookup_key.rs b/src/lookup_key.rs
index 3c52684d0..b3352da70 100644
--- a/src/lookup_key.rs
+++ b/src/lookup_key.rs
@@ -63,7 +63,7 @@ impl LookupKey {
                     py_key1: alias_py.clone().into(),
                     path1,
                     key2: alt_alias.to_string(),
-                    py_key2: PyString::new_bound(py, alt_alias).into(),
+                    py_key2: PyString::new(py, alt_alias).into(),
                     path2: LookupPath::from_str(py, alt_alias, None),
                 }),
                 None => Ok(Self::simple(py, &alias, Some(alias_py.clone()))),
@@ -97,7 +97,7 @@ impl LookupKey {
     fn simple(py: Python, key: &str, opt_py_key: Option<Bound<'_, PyString>>) -> Self {
         let py_key = match &opt_py_key {
             Some(py_key) => py_key.clone(),
-            None => PyString::new_bound(py, key),
+            None => PyString::new(py, key),
         };
         Self::Simple {
             key: key.to_string(),
@@ -346,7 +346,7 @@ impl LookupPath {
     fn from_str(py: Python, key: &str, py_key: Option<Bound<'_, PyString>>) -> Self {
         let py_key = match py_key {
             Some(py_key) => py_key,
-            None => PyString::new_bound(py, key),
+            None => PyString::new(py, key),
         };
         Self(vec![PathItem::S(key.to_string(), py_key.into())])
     }
@@ -511,7 +511,7 @@ fn py_get_attrs<'py>(obj: &Bound<'py, PyAny>, attr_name: &Py<PyString>) -> PyRes
     match obj.getattr(attr_name) {
         Ok(attr) => Ok(Some(attr)),
         Err(err) => {
-            if err.get_type_bound(obj.py()).is_subclass_of::<PyAttributeError>()? {
+            if err.get_type(obj.py()).is_subclass_of::<PyAttributeError>()? {
                 Ok(None)
             } else {
                 Err(err)
diff --git a/src/serializers/config.rs b/src/serializers/config.rs
index 13a833176..dca555c82 100644
--- a/src/serializers/config.rs
+++ b/src/serializers/config.rs
@@ -189,8 +189,8 @@ impl BytesMode {
 }
 
 pub fn utf8_py_error(py: Python, err: Utf8Error, data: &[u8]) -> PyErr {
-    match pyo3::exceptions::PyUnicodeDecodeError::new_utf8_bound(py, data, err) {
-        Ok(decode_err) => PyErr::from_value_bound(decode_err.into_any()),
+    match pyo3::exceptions::PyUnicodeDecodeError::new_utf8(py, data, err) {
+        Ok(decode_err) => PyErr::from_value(decode_err.into_any()),
         Err(err) => err,
     }
 }
diff --git a/src/serializers/extra.rs b/src/serializers/extra.rs
index 94ccf19a9..b0e26b826 100644
--- a/src/serializers/extra.rs
+++ b/src/serializers/extra.rs
@@ -1,3 +1,4 @@
+use std::ffi::CString;
 use std::fmt;
 use std::sync::Mutex;
 
@@ -408,7 +409,7 @@ impl CollectWarnings {
             let type_name = value
                 .get_type()
                 .qualname()
-                .unwrap_or_else(|_| PyString::new_bound(value.py(), "<unknown python object>"));
+                .unwrap_or_else(|_| PyString::new(value.py(), "<unknown python object>"));
 
             let value_str = truncate_safe_repr(value, None);
             Err(PydanticSerializationUnexpectedValue::new_err(Some(format!(
@@ -445,7 +446,7 @@ impl CollectWarnings {
             let type_name = value
                 .get_type()
                 .qualname()
-                .unwrap_or_else(|_| PyString::new_bound(value.py(), "<unknown python object>"));
+                .unwrap_or_else(|_| PyString::new(value.py(), "<unknown python object>"));
 
             let value_str = truncate_safe_repr(value, None);
 
@@ -472,7 +473,7 @@ impl CollectWarnings {
         let message = format!("Pydantic serializer warnings:\n  {}", warnings.join("\n  "));
         if self.mode == WarningsMode::Warn {
             let user_warning_type = PyUserWarning::type_object(py);
-            PyErr::warn_bound(py, &user_warning_type, &message, 0)
+            PyErr::warn(py, &user_warning_type, &CString::new(message)?, 0)
         } else {
             Err(PydanticSerializationError::new_err(message))
         }
diff --git a/src/serializers/fields.rs b/src/serializers/fields.rs
index d8971d8cb..74dd5b6c9 100644
--- a/src/serializers/fields.rs
+++ b/src/serializers/fields.rs
@@ -41,9 +41,7 @@ impl SerField {
         serializer: Option<CombinedSerializer>,
         required: bool,
     ) -> Self {
-        let alias_py = alias
-            .as_ref()
-            .map(|alias| PyString::new_bound(py, alias.as_str()).into());
+        let alias_py = alias.as_ref().map(|alias| PyString::new(py, alias.as_str()).into());
         Self {
             key_py,
             alias,
@@ -153,7 +151,7 @@ impl GeneralFieldsSerializer {
         exclude: Option<&Bound<'py, PyAny>>,
         extra: Extra,
     ) -> PyResult<Bound<'py, PyDict>> {
-        let output_dict = PyDict::new_bound(py);
+        let output_dict = PyDict::new(py);
         let mut used_req_fields: usize = 0;
 
         // NOTE! we maintain the order of the input dict assuming that's right
diff --git a/src/serializers/filter.rs b/src/serializers/filter.rs
index bce94ecb4..65ec4062d 100644
--- a/src/serializers/filter.rs
+++ b/src/serializers/filter.rs
@@ -40,7 +40,7 @@ fn map_negative_indices<'py>(
 ) -> PyResult<Bound<'py, PyAny>> {
     let py = include_or_exclude.py();
     if let Ok(exclude_dict) = include_or_exclude.downcast::<PyDict>() {
-        let out = PyDict::new_bound(py);
+        let out = PyDict::new(py);
         for (k, v) in exclude_dict.iter() {
             out.set_item(map_negative_index(&k, len)?, v)?;
         }
@@ -50,7 +50,7 @@ fn map_negative_indices<'py>(
         for v in exclude_set.iter() {
             values.push(map_negative_index(&v, len)?);
         }
-        Ok(PySet::new_bound(py, &values)?.into_any())
+        Ok(PySet::new(py, &values)?.into_any())
     } else {
         // return as is and deal with the error later
         Ok(include_or_exclude.clone())
@@ -356,7 +356,7 @@ fn as_dict<'py>(value: &Bound<'py, PyAny>) -> PyResult<Bound<'py, PyDict>> {
         dict.copy()
     } else if let Ok(set) = value.downcast::<PySet>() {
         let py = value.py();
-        let dict = PyDict::new_bound(py);
+        let dict = PyDict::new(py);
         for item in set.iter() {
             dict.set_item(item, py.Ellipsis())?;
         }
diff --git a/src/serializers/infer.rs b/src/serializers/infer.rs
index 5cb530256..6e4688d3d 100644
--- a/src/serializers/infer.rs
+++ b/src/serializers/infer.rs
@@ -131,7 +131,7 @@ pub(crate) fn infer_to_python_known(
                 v.into_py(py)
             }
             ObType::Decimal => value.to_string().into_py(py),
-            ObType::StrSubclass => PyString::new_bound(py, value.downcast::<PyString>()?.to_str()?).into(),
+            ObType::StrSubclass => PyString::new(py, value.downcast::<PyString>()?.to_str()?).into(),
             ObType::Bytes => extra
                 .config
                 .bytes_mode
@@ -150,24 +150,24 @@ pub(crate) fn infer_to_python_known(
             }
             ObType::Tuple => {
                 let elements = serialize_seq_filter!(PyTuple);
-                PyList::new_bound(py, elements).into_py(py)
+                PyList::new(py, elements)?.into_py(py)
             }
             ObType::List => {
                 let elements = serialize_seq_filter!(PyList);
-                PyList::new_bound(py, elements).into_py(py)
+                PyList::new(py, elements)?.into_py(py)
             }
             ObType::Set => {
                 let elements = serialize_seq!(PySet);
-                PyList::new_bound(py, elements).into_py(py)
+                PyList::new(py, elements)?.into_py(py)
             }
             ObType::Frozenset => {
                 let elements = serialize_seq!(PyFrozenSet);
-                PyList::new_bound(py, elements).into_py(py)
+                PyList::new(py, elements)?.into_py(py)
             }
             ObType::Dict => {
                 let dict = value.downcast::<PyDict>()?;
                 serialize_pairs_python(py, dict.iter().map(Ok), include, exclude, extra, |k| {
-                    Ok(PyString::new_bound(py, &infer_json_key(&k, extra)?).into_any())
+                    Ok(PyString::new(py, &infer_json_key(&k, extra)?).into_any())
                 })?
             }
             ObType::Datetime => {
@@ -204,7 +204,7 @@ pub(crate) fn infer_to_python_known(
             ObType::PydanticSerializable => serialize_with_serializer()?,
             ObType::Dataclass => {
                 serialize_pairs_python(py, any_dataclass_iter(value)?.0, include, exclude, extra, |k| {
-                    Ok(PyString::new_bound(py, &infer_json_key(&k, extra)?).into_any())
+                    Ok(PyString::new(py, &infer_json_key(&k, extra)?).into_any())
                 })?
             }
             ObType::Enum => {
@@ -228,7 +228,7 @@ pub(crate) fn infer_to_python_known(
                         )?);
                     }
                 }
-                PyList::new_bound(py, items).into_py(py)
+                PyList::new(py, items)?.into_py(py)
             }
             ObType::Complex => {
                 let v = value.downcast::<PyComplex>()?;
@@ -252,19 +252,19 @@ pub(crate) fn infer_to_python_known(
         _ => match ob_type {
             ObType::Tuple => {
                 let elements = serialize_seq_filter!(PyTuple);
-                PyTuple::new_bound(py, elements).into_py(py)
+                PyTuple::new(py, elements)?.into_py(py)
             }
             ObType::List => {
                 let elements = serialize_seq_filter!(PyList);
-                PyList::new_bound(py, elements).into_py(py)
+                PyList::new(py, elements)?.into_py(py)
             }
             ObType::Set => {
                 let elements = serialize_seq!(PySet);
-                PySet::new_bound(py, &elements)?.into_py(py)
+                PySet::new(py, &elements)?.into_py(py)
             }
             ObType::Frozenset => {
                 let elements = serialize_seq!(PyFrozenSet);
-                PyFrozenSet::new_bound(py, &elements)?.into_py(py)
+                PyFrozenSet::new(py, &elements)?.into_py(py)
             }
             ObType::Dict => {
                 let dict = value.downcast::<PyDict>()?;
@@ -708,7 +708,7 @@ fn serialize_pairs_python<'py>(
     extra: &Extra,
     key_transform: impl Fn(Bound<'py, PyAny>) -> PyResult<Bound<'py, PyAny>>,
 ) -> PyResult<PyObject> {
-    let new_dict = PyDict::new_bound(py);
+    let new_dict = PyDict::new(py);
     let filter = AnyFilter::new();
 
     for result in pairs_iter {
diff --git a/src/serializers/mod.rs b/src/serializers/mod.rs
index 1a0405e2c..5e5e7b382 100644
--- a/src/serializers/mod.rs
+++ b/src/serializers/mod.rs
@@ -209,7 +209,7 @@ impl SchemaSerializer {
         warnings.final_check(py)?;
 
         self.expected_json_size.store(bytes.len(), Ordering::Relaxed);
-        let py_bytes = PyBytes::new_bound(py, &bytes);
+        let py_bytes = PyBytes::new(py, &bytes);
         Ok(py_bytes.into())
     }
 
@@ -278,7 +278,7 @@ pub fn to_json(
     let serializer = type_serializers::any::AnySerializer.into();
     let bytes = to_json_bytes(value, &serializer, include, exclude, &extra, indent, 1024)?;
     state.final_check(py)?;
-    let py_bytes = PyBytes::new_bound(py, &bytes);
+    let py_bytes = PyBytes::new(py, &bytes);
     Ok(py_bytes.into())
 }
 
diff --git a/src/serializers/ob_type.rs b/src/serializers/ob_type.rs
index 4fddc8790..fc44b32a9 100644
--- a/src/serializers/ob_type.rs
+++ b/src/serializers/ob_type.rs
@@ -69,12 +69,7 @@ impl ObTypeLookup {
             float: PyFloat::type_object_raw(py) as usize,
             list: PyList::type_object_raw(py) as usize,
             dict: PyDict::type_object_raw(py) as usize,
-            decimal_object: py
-                .import_bound("decimal")
-                .unwrap()
-                .getattr("Decimal")
-                .unwrap()
-                .to_object(py),
+            decimal_object: py.import("decimal").unwrap().getattr("Decimal").unwrap().to_object(py),
             string: PyString::type_object_raw(py) as usize,
             bytes: PyBytes::type_object_raw(py) as usize,
             bytearray: PyByteArray::type_object_raw(py) as usize,
@@ -87,21 +82,16 @@ impl ObTypeLookup {
             timedelta: PyDelta::type_object_raw(py) as usize,
             url: PyUrl::type_object_raw(py) as usize,
             multi_host_url: PyMultiHostUrl::type_object_raw(py) as usize,
-            enum_object: py.import_bound("enum").unwrap().getattr("Enum").unwrap().to_object(py),
+            enum_object: py.import("enum").unwrap().getattr("Enum").unwrap().to_object(py),
             generator_object: py
-                .import_bound("types")
+                .import("types")
                 .unwrap()
                 .getattr("GeneratorType")
                 .unwrap()
                 .to_object(py),
-            path_object: py
-                .import_bound("pathlib")
-                .unwrap()
-                .getattr("Path")
-                .unwrap()
-                .to_object(py),
-            pattern_object: py.import_bound("re").unwrap().getattr("Pattern").unwrap().to_object(py),
-            uuid_object: py.import_bound("uuid").unwrap().getattr("UUID").unwrap().to_object(py),
+            path_object: py.import("pathlib").unwrap().getattr("Path").unwrap().to_object(py),
+            pattern_object: py.import("re").unwrap().getattr("Pattern").unwrap().to_object(py),
+            uuid_object: py.import("uuid").unwrap().getattr("UUID").unwrap().to_object(py),
             complex: PyComplex::type_object_raw(py) as usize,
         }
     }
diff --git a/src/serializers/shared.rs b/src/serializers/shared.rs
index d3a87735f..9ffdc1dab 100644
--- a/src/serializers/shared.rs
+++ b/src/serializers/shared.rs
@@ -403,7 +403,7 @@ static DC_FIELD_MARKER: GILOnceCell<PyObject> = GILOnceCell::new();
 /// needed to match the logic from dataclasses.fields `tuple(f for f in fields.values() if f._field_type is _FIELD)`
 fn get_field_marker(py: Python<'_>) -> PyResult<Bound<'_, PyAny>> {
     let field_type_marker_obj = DC_FIELD_MARKER.get_or_try_init(py, || {
-        py.import_bound("dataclasses")?.getattr("_FIELD").map(|f| f.into_py(py))
+        py.import("dataclasses")?.getattr("_FIELD").map(|f| f.into_py(py))
     })?;
     Ok(field_type_marker_obj.bind(py).clone())
 }
diff --git a/src/serializers/type_serializers/dataclass.rs b/src/serializers/type_serializers/dataclass.rs
index ffe71adb9..d85dd2f17 100644
--- a/src/serializers/type_serializers/dataclass.rs
+++ b/src/serializers/type_serializers/dataclass.rs
@@ -41,7 +41,7 @@ impl BuildSerializer for DataclassArgsBuilder {
             let field_info = item.downcast::<PyDict>()?;
             let name: String = field_info.get_as_req(intern!(py, "name"))?;
 
-            let key_py: Py<PyString> = PyString::new_bound(py, &name).into();
+            let key_py: Py<PyString> = PyString::new(py, &name).into();
 
             if field_info.get_as(intern!(py, "serialization_exclude"))? == Some(true) {
                 fields.insert(name, SerField::new(py, key_py, None, None, true));
@@ -113,7 +113,7 @@ impl DataclassSerializer {
 
     fn get_inner_value<'py>(&self, value: &Bound<'py, PyAny>) -> PyResult<Bound<'py, PyDict>> {
         let py = value.py();
-        let dict = PyDict::new_bound(py);
+        let dict = PyDict::new(py);
 
         for field_name in &self.fields {
             let field_name = field_name.bind(py);
diff --git a/src/serializers/type_serializers/dict.rs b/src/serializers/type_serializers/dict.rs
index 79a3d1669..37f156b37 100644
--- a/src/serializers/type_serializers/dict.rs
+++ b/src/serializers/type_serializers/dict.rs
@@ -83,7 +83,7 @@ impl TypeSerializer for DictSerializer {
             Ok(py_dict) => {
                 let value_serializer = self.value_serializer.as_ref();
 
-                let new_dict = PyDict::new_bound(py);
+                let new_dict = PyDict::new(py);
                 for (key, value) in py_dict.iter() {
                     let op_next = self.filter.key_filter(&key, include, exclude)?;
                     if let Some((next_include, next_exclude)) = op_next {
diff --git a/src/serializers/type_serializers/format.rs b/src/serializers/type_serializers/format.rs
index eefd3736a..959efb36c 100644
--- a/src/serializers/type_serializers/format.rs
+++ b/src/serializers/type_serializers/format.rs
@@ -75,7 +75,7 @@ impl BuildSerializer for FormatSerializer {
         } else {
             Ok(Self {
                 format_func: py
-                    .import_bound(intern!(py, "builtins"))?
+                    .import(intern!(py, "builtins"))?
                     .getattr(intern!(py, "format"))?
                     .into_py(py),
                 formatting_string: formatting_string.unbind(),
diff --git a/src/serializers/type_serializers/function.rs b/src/serializers/type_serializers/function.rs
index f01b0c556..ec459a373 100644
--- a/src/serializers/type_serializers/function.rs
+++ b/src/serializers/type_serializers/function.rs
@@ -189,7 +189,7 @@ impl FunctionPlainSerializer {
 }
 
 fn on_error(py: Python, err: PyErr, function_name: &str, extra: &Extra) -> PyResult<()> {
-    let exception = err.value_bound(py);
+    let exception = err.value(py);
     if let Ok(ser_err) = exception.extract::<PydanticSerializationUnexpectedValue>() {
         if extra.check.enabled() {
             Err(err)
@@ -638,7 +638,7 @@ impl SerializationInfo {
 
     #[getter]
     fn __dict__<'py>(&'py self, py: Python<'py>) -> PyResult<Bound<'py, PyDict>> {
-        let d = PyDict::new_bound(py);
+        let d = PyDict::new(py);
         if let Some(ref include) = self.include {
             d.set_item("include", include)?;
         }
@@ -689,7 +689,7 @@ impl SerializationInfo {
     #[getter]
     fn get_field_name<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyString>> {
         match self.field_name {
-            Some(ref field_name) => Ok(PyString::new_bound(py, field_name)),
+            Some(ref field_name) => Ok(PyString::new(py, field_name)),
             None => Err(PyAttributeError::new_err("No attribute named 'field_name'")),
         }
     }
diff --git a/src/serializers/type_serializers/literal.rs b/src/serializers/type_serializers/literal.rs
index ce353dc03..c9f7d6912 100644
--- a/src/serializers/type_serializers/literal.rs
+++ b/src/serializers/type_serializers/literal.rs
@@ -40,7 +40,7 @@ impl BuildSerializer for LiteralSerializer {
         let mut expected_int = AHashSet::new();
         let mut expected_str = AHashSet::new();
         let py = expected.py();
-        let expected_py = PyList::empty_bound(py);
+        let expected_py = PyList::empty(py);
         let mut repr_args: Vec<String> = Vec::new();
         for item in expected {
             repr_args.push(item.repr()?.extract()?);
@@ -89,7 +89,7 @@ impl LiteralSerializer {
                 if let Ok(py_str) = value.downcast::<PyString>() {
                     let s = py_str.to_str()?;
                     if self.expected_str.contains(s) {
-                        return Ok(OutputValue::OkStr(PyString::new_bound(value.py(), s)));
+                        return Ok(OutputValue::OkStr(PyString::new(value.py(), s)));
                     }
                 }
             }
diff --git a/src/serializers/type_serializers/set_frozenset.rs b/src/serializers/type_serializers/set_frozenset.rs
index 03a05accd..6356c8c1b 100644
--- a/src/serializers/type_serializers/set_frozenset.rs
+++ b/src/serializers/type_serializers/set_frozenset.rs
@@ -65,8 +65,8 @@ macro_rules! build_serializer {
                             items.push(item_serializer.to_python(&element, include, exclude, extra)?);
                         }
                         match extra.mode {
-                            SerMode::Json => Ok(PyList::new_bound(py, items).into_py(py)),
-                            _ => Ok(<$py_type>::new_bound(py, &items)?.into_py(py)),
+                            SerMode::Json => Ok(PyList::new(py, items)?.into_py(py)),
+                            _ => Ok(<$py_type>::new(py, &items)?.into_py(py)),
                         }
                     }
                     Err(_) => {
diff --git a/src/serializers/type_serializers/tuple.rs b/src/serializers/type_serializers/tuple.rs
index 07196bf43..87ff4002c 100644
--- a/src/serializers/type_serializers/tuple.rs
+++ b/src/serializers/type_serializers/tuple.rs
@@ -82,8 +82,8 @@ impl TypeSerializer for TupleSerializer {
                 })??;
 
                 match extra.mode {
-                    SerMode::Json => Ok(PyList::new_bound(py, items).into_py(py)),
-                    _ => Ok(PyTuple::new_bound(py, items).into_py(py)),
+                    SerMode::Json => Ok(PyList::new(py, items)?.into_py(py)),
+                    _ => Ok(PyTuple::new(py, items)?.into_py(py)),
                 }
             }
             Err(_) => {
diff --git a/src/url.rs b/src/url.rs
index dda583af5..a4f3a83e5 100644
--- a/src/url.rs
+++ b/src/url.rs
@@ -34,7 +34,7 @@ impl PyUrl {
 }
 
 fn build_schema_validator(py: Python, schema_type: &str) -> SchemaValidator {
-    let schema = PyDict::new_bound(py);
+    let schema = PyDict::new(py);
     schema.set_item("type", schema_type).unwrap();
     SchemaValidator::py_new(py, &schema, None).unwrap()
 }
@@ -468,7 +468,7 @@ impl fmt::Display for UrlHostParts {
 }
 
 fn host_to_dict<'a>(py: Python<'a>, lib_url: &Url) -> PyResult<Bound<'a, PyDict>> {
-    let dict = PyDict::new_bound(py);
+    let dict = PyDict::new(py);
     dict.set_item(
         "username",
         match lib_url.username() {
diff --git a/src/validators/arguments.rs b/src/validators/arguments.rs
index 39fa9d274..e6a9d0415 100644
--- a/src/validators/arguments.rs
+++ b/src/validators/arguments.rs
@@ -142,7 +142,7 @@ impl BuildValidator for ArgumentsValidator {
 
         let py_var_kwargs_mode: Bound<PyString> = schema
             .get_as(intern!(py, "var_kwargs_mode"))?
-            .unwrap_or_else(|| PyString::new_bound(py, "uniform"));
+            .unwrap_or_else(|| PyString::new(py, "uniform"));
 
         let var_kwargs_mode = VarKwargsMode::from_str(py_var_kwargs_mode.to_str()?)?;
         let var_kwargs_validator = match schema.get_item(intern!(py, "var_kwargs_schema"))? {
@@ -193,7 +193,7 @@ impl Validator for ArgumentsValidator {
         let args = input.validate_args()?;
 
         let mut output_args: Vec<PyObject> = Vec::with_capacity(self.positional_params_count);
-        let output_kwargs = PyDict::new_bound(py);
+        let output_kwargs = PyDict::new(py);
         let mut errors: Vec<ValLineError> = Vec::new();
         let mut used_kwargs: AHashSet<&str> = AHashSet::with_capacity(self.parameters.len());
 
@@ -296,7 +296,7 @@ impl Validator for ArgumentsValidator {
             }
         }
 
-        let remaining_kwargs = PyDict::new_bound(py);
+        let remaining_kwargs = PyDict::new(py);
 
         // if there are kwargs check any that haven't been processed yet
         if let Some(kwargs) = args.kwargs() {
@@ -377,7 +377,7 @@ impl Validator for ArgumentsValidator {
         if !errors.is_empty() {
             Err(ValError::LineErrors(errors))
         } else {
-            Ok((PyTuple::new_bound(py, output_args), output_kwargs).to_object(py))
+            Ok((PyTuple::new(py, output_args)?, output_kwargs).to_object(py))
         }
     }
 
diff --git a/src/validators/call.rs b/src/validators/call.rs
index 6783a5eda..5eff0c6d0 100644
--- a/src/validators/call.rs
+++ b/src/validators/call.rs
@@ -84,9 +84,9 @@ impl Validator for CallValidator {
         let args = self.arguments_validator.validate(py, input, state)?.into_bound(py);
 
         let return_value = if let Ok((args, kwargs)) = args.extract::<(Bound<PyTuple>, Bound<PyDict>)>() {
-            self.function.call_bound(py, args, Some(&kwargs))?
+            self.function.call(py, args, Some(&kwargs))?
         } else if let Ok(kwargs) = args.downcast::<PyDict>() {
-            self.function.call_bound(py, (), Some(kwargs))?
+            self.function.call(py, (), Some(kwargs))?
         } else {
             let msg = "Arguments validator should return a tuple of (args, kwargs) or a dict of kwargs";
             return Err(PyTypeError::new_err(msg).into());
diff --git a/src/validators/dataclass.rs b/src/validators/dataclass.rs
index 53be75e88..2bdd27b3c 100644
--- a/src/validators/dataclass.rs
+++ b/src/validators/dataclass.rs
@@ -150,7 +150,7 @@ impl Validator for DataclassArgsValidator {
 
         let args = input.validate_dataclass_args(&self.dataclass_name)?;
 
-        let output_dict = PyDict::new_bound(py);
+        let output_dict = PyDict::new(py);
         let mut init_only_args = self.init_only_count.map(Vec::with_capacity);
 
         let mut errors: Vec<ValLineError> = Vec::new();
@@ -353,7 +353,7 @@ impl Validator for DataclassArgsValidator {
 
         if errors.is_empty() {
             if let Some(init_only_args) = init_only_args {
-                Ok((output_dict, PyTuple::new_bound(py, init_only_args)).to_object(py))
+                Ok((output_dict, PyTuple::new(py, init_only_args)?).to_object(py))
             } else {
                 Ok((output_dict, py.None()).to_object(py))
             }
@@ -378,7 +378,7 @@ impl Validator for DataclassArgsValidator {
             // which doesn't make much sense in this context but we need to put something there
             // so that function validators that sit between DataclassValidator and DataclassArgsValidator
             // always get called the same shape of data.
-            Ok(PyTuple::new_bound(py, vec![dict.to_object(py), py.None()]).into_py(py))
+            Ok(PyTuple::new(py, vec![dict.to_object(py), py.None()])?.into_py(py))
         };
 
         if let Some(field) = self.fields.iter().find(|f| f.name == field_name) {
@@ -393,7 +393,7 @@ impl Validator for DataclassArgsValidator {
             let data_dict = dict.copy()?;
             if let Err(err) = data_dict.del_item(field_name) {
                 // KeyError is fine here as the field might not be in the dict
-                if !err.get_type_bound(py).is(&PyType::new_bound::<PyKeyError>(py)) {
+                if !err.get_type(py).is(&PyType::new::<PyKeyError>(py)) {
                     return Err(err.into());
                 }
             }
@@ -631,7 +631,7 @@ impl DataclassValidator {
 
     fn dataclass_to_dict<'py>(&self, dc: &Bound<'py, PyAny>) -> PyResult<Bound<'py, PyDict>> {
         let py = dc.py();
-        let dict = PyDict::new_bound(py);
+        let dict = PyDict::new(py);
 
         for field_name in &self.fields {
             dict.set_item(field_name, dc.getattr(field_name)?)?;
diff --git a/src/validators/datetime.rs b/src/validators/datetime.rs
index a6ccad328..48537000f 100644
--- a/src/validators/datetime.rs
+++ b/src/validators/datetime.rs
@@ -248,7 +248,7 @@ pub struct NowConstraint {
 static TIME_LOCALTIME: GILOnceCell<PyObject> = GILOnceCell::new();
 
 fn get_localtime(py: Python) -> PyResult<PyObject> {
-    Ok(py.import_bound("time")?.getattr("localtime")?.into_py(py))
+    Ok(py.import("time")?.getattr("localtime")?.into_py(py))
 }
 
 impl NowConstraint {
diff --git a/src/validators/decimal.rs b/src/validators/decimal.rs
index 5cad9e0ce..a1ec26a5b 100644
--- a/src/validators/decimal.rs
+++ b/src/validators/decimal.rs
@@ -19,7 +19,7 @@ static DECIMAL_TYPE: GILOnceCell<Py<PyType>> = GILOnceCell::new();
 pub fn get_decimal_type(py: Python) -> &Bound<'_, PyType> {
     DECIMAL_TYPE
         .get_or_init(py, || {
-            py.import_bound("decimal")
+            py.import("decimal")
                 .and_then(|decimal_module| decimal_module.getattr("Decimal"))
                 .unwrap()
                 .extract()
@@ -192,7 +192,7 @@ impl Validator for DecimalValidator {
                 return Err(ValError::new(
                     ErrorType::MultipleOf {
                         multiple_of: multiple_of.to_string().into(),
-                        context: Some([("multiple_of", multiple_of)].into_py_dict_bound(py).into()),
+                        context: Some([("multiple_of", multiple_of)].into_py_dict(py)?.into()),
                     },
                     input,
                 ));
@@ -215,7 +215,7 @@ impl Validator for DecimalValidator {
                 return Err(ValError::new(
                     ErrorType::LessThanEqual {
                         le: Number::String(le.to_string()),
-                        context: Some([("le", le)].into_py_dict_bound(py).into()),
+                        context: Some([("le", le)].into_py_dict(py)?.into()),
                     },
                     input,
                 ));
@@ -226,7 +226,7 @@ impl Validator for DecimalValidator {
                 return Err(ValError::new(
                     ErrorType::LessThan {
                         lt: Number::String(lt.to_string()),
-                        context: Some([("lt", lt)].into_py_dict_bound(py).into()),
+                        context: Some([("lt", lt)].into_py_dict(py)?.into()),
                     },
                     input,
                 ));
@@ -237,7 +237,7 @@ impl Validator for DecimalValidator {
                 return Err(ValError::new(
                     ErrorType::GreaterThanEqual {
                         ge: Number::String(ge.to_string()),
-                        context: Some([("ge", ge)].into_py_dict_bound(py).into()),
+                        context: Some([("ge", ge)].into_py_dict(py)?.into()),
                     },
                     input,
                 ));
@@ -248,7 +248,7 @@ impl Validator for DecimalValidator {
                 return Err(ValError::new(
                     ErrorType::GreaterThan {
                         gt: Number::String(gt.to_string()),
-                        context: Some([("gt", gt)].into_py_dict_bound(py).into()),
+                        context: Some([("gt", gt)].into_py_dict(py)?.into()),
                     },
                     input,
                 ));
@@ -267,7 +267,7 @@ pub(crate) fn create_decimal<'py>(arg: &Bound<'py, PyAny>, input: impl ToErrorVa
     let py = arg.py();
     get_decimal_type(py).call1((arg,)).map_err(|e| {
         let decimal_exception = match py
-            .import_bound("decimal")
+            .import("decimal")
             .and_then(|decimal_module| decimal_module.getattr("DecimalException"))
         {
             Ok(decimal_exception) => decimal_exception,
@@ -281,7 +281,7 @@ fn handle_decimal_new_error(input: impl ToErrorValue, error: PyErr, decimal_exce
     let py = decimal_exception.py();
     if error.matches(py, decimal_exception).unwrap_or(false) {
         ValError::new(ErrorTypeDefaults::DecimalParsing, input)
-    } else if error.matches(py, PyTypeError::type_object_bound(py)).unwrap_or(false) {
+    } else if error.matches(py, PyTypeError::type_object(py)).unwrap_or(false) {
         ValError::new(ErrorTypeDefaults::DecimalType, input)
     } else {
         ValError::InternalErr(error)
diff --git a/src/validators/dict.rs b/src/validators/dict.rs
index 985fe95b6..b65b38fb1 100644
--- a/src/validators/dict.rs
+++ b/src/validators/dict.rs
@@ -107,7 +107,7 @@ where
 {
     type Output = ValResult<PyObject>;
     fn consume_iterator(self, iterator: impl Iterator<Item = ValResult<(Key, Value)>>) -> ValResult<PyObject> {
-        let output = PyDict::new_bound(self.py);
+        let output = PyDict::new(self.py);
         let mut errors: Vec<ValLineError> = Vec::new();
         let allow_partial = self.state.allow_partial;
 
diff --git a/src/validators/frozenset.rs b/src/validators/frozenset.rs
index 60fe451a7..06859ff43 100644
--- a/src/validators/frozenset.rs
+++ b/src/validators/frozenset.rs
@@ -35,7 +35,7 @@ impl Validator for FrozenSetValidator {
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let collection = input.validate_frozenset(state.strict_or(self.strict))?.unpack(state);
-        let f_set = PyFrozenSet::empty_bound(py)?;
+        let f_set = PyFrozenSet::empty(py)?;
         collection.iterate(ValidateToFrozenSet {
             py,
             input,
diff --git a/src/validators/function.rs b/src/validators/function.rs
index 96e15e87b..8095d6298 100644
--- a/src/validators/function.rs
+++ b/src/validators/function.rs
@@ -480,18 +480,18 @@ macro_rules! py_err_string {
 /// as validation errors, `TypeError` is now considered as a runtime error to catch errors in function signatures
 pub fn convert_err(py: Python<'_>, err: PyErr, input: impl ToErrorValue) -> ValError {
     if err.is_instance_of::<PyValueError>(py) {
-        let error_value = err.value_bound(py);
+        let error_value = err.value(py);
         if let Ok(pydantic_value_error) = error_value.extract::<PydanticCustomError>() {
             pydantic_value_error.into_val_error(input)
         } else if let Ok(pydantic_error_type) = error_value.extract::<PydanticKnownError>() {
             pydantic_error_type.into_val_error(input)
-        } else if let Ok(validation_error) = err.value_bound(py).extract::<ValidationError>() {
+        } else if let Ok(validation_error) = err.value(py).extract::<ValidationError>() {
             validation_error.into_val_error()
         } else {
             py_err_string!(py, err, error_value, ValueError, input)
         }
     } else if err.is_instance_of::<PyAssertionError>(py) {
-        py_err_string!(py, err, err.value_bound(py), AssertionError, input)
+        py_err_string!(py, err, err.value(py), AssertionError, input)
     } else if err.is_instance_of::<PydanticOmit>(py) {
         ValError::Omit
     } else if err.is_instance_of::<PydanticUseDefault>(py) {
diff --git a/src/validators/literal.rs b/src/validators/literal.rs
index 9ef0d5f82..755e8fccb 100644
--- a/src/validators/literal.rs
+++ b/src/validators/literal.rs
@@ -48,9 +48,9 @@ impl<T: Debug> LiteralLookup<T> {
         let mut expected_bool = BoolLiteral::default();
         let mut expected_int = AHashMap::new();
         let mut expected_str: AHashMap<String, usize> = AHashMap::new();
-        let expected_py_dict = PyDict::new_bound(py);
+        let expected_py_dict = PyDict::new(py);
         let mut expected_py_values = Vec::new();
-        let expected_py_primitives = PyDict::new_bound(py);
+        let expected_py_primitives = PyDict::new(py);
         let mut values = Vec::new();
         for (k, v) in expected {
             let id = values.len();
diff --git a/src/validators/mod.rs b/src/validators/mod.rs
index cafdfcd12..b84ed811b 100644
--- a/src/validators/mod.rs
+++ b/src/validators/mod.rs
@@ -4,6 +4,7 @@ use enum_dispatch::enum_dispatch;
 use jiter::{PartialMode, StringCacheMode};
 
 use pyo3::exceptions::PyTypeError;
+use pyo3::ffi::c_str;
 use pyo3::prelude::*;
 use pyo3::sync::GILOnceCell;
 use pyo3::types::{PyAny, PyDict, PyString, PyTuple, PyType};
@@ -96,8 +97,8 @@ impl PySome {
     }
 
     #[classattr]
-    fn __match_args__(py: Python) -> Bound<'_, PyTuple> {
-        PyTuple::new_bound(py, vec![intern!(py, "value")])
+    fn __match_args__(py: Python<'_>) -> PyResult<Bound<'_, PyTuple>> {
+        (intern!(py, "value"),).into_pyobject(py)
     }
 }
 
@@ -444,9 +445,9 @@ impl<'py> SelfValidator<'py> {
     }
 
     fn build(py: Python) -> PyResult<SchemaValidator> {
-        let code = include_str!("../self_schema.py");
-        let locals = PyDict::new_bound(py);
-        py.run_bound(code, None, Some(&locals))?;
+        let code = c_str!(include_str!("../self_schema.py"));
+        let locals = PyDict::new(py);
+        py.run(code, None, Some(&locals))?;
         let self_schema = locals.get_as_req(intern!(py, "self_schema"))?;
 
         let mut definitions_builder = DefinitionsBuilder::new();
diff --git a/src/validators/model.rs b/src/validators/model.rs
index 1564e7e31..a514c5539 100644
--- a/src/validators/model.rs
+++ b/src/validators/model.rs
@@ -264,9 +264,9 @@ impl ModelValidator {
 
         if self.root_model {
             let fields_set = if input.to_object(py).is(&self.undefined) {
-                PySet::empty_bound(py)?
+                PySet::empty(py)?
             } else {
-                PySet::new_bound(py, [&String::from(ROOT_FIELD)])?
+                PySet::new(py, [&String::from(ROOT_FIELD)])?
             };
             force_setattr(py, self_instance, intern!(py, DUNDER_FIELDS_SET_KEY), &fields_set)?;
             force_setattr(py, self_instance, intern!(py, ROOT_FIELD), &output)?;
@@ -294,7 +294,7 @@ impl ModelValidator {
             if let Some(kwargs) = input.as_kwargs(py) {
                 return self
                     .class
-                    .call_bound(py, (), Some(&kwargs))
+                    .call(py, (), Some(&kwargs))
                     .map_err(|e| convert_err(py, e, input));
             }
         }
@@ -305,9 +305,9 @@ impl ModelValidator {
 
         if self.root_model {
             let fields_set = if input.to_object(py).is(&self.undefined) {
-                PySet::empty_bound(py)?
+                PySet::empty(py)?
             } else {
-                PySet::new_bound(py, [&String::from(ROOT_FIELD)])?
+                PySet::new(py, [&String::from(ROOT_FIELD)])?
             };
             force_setattr(py, &instance, intern!(py, DUNDER_FIELDS_SET_KEY), &fields_set)?;
             force_setattr(py, &instance, intern!(py, ROOT_FIELD), output)?;
@@ -340,7 +340,7 @@ impl ModelValidator {
 /// https://github.com/PyO3/pyo3/blob/d2caa056e9aacc46374139ef491d112cb8af1a25/src/pyclass_init.rs#L35-L77
 pub(super) fn create_class<'py>(class: &Bound<'py, PyType>) -> PyResult<Bound<'py, PyAny>> {
     let py = class.py();
-    let args = PyTuple::empty_bound(py);
+    let args = PyTuple::empty(py);
     let raw_type = class.as_type_ptr();
     unsafe {
         // Safety: raw_type is known to be a non-null type object pointer
diff --git a/src/validators/model_fields.rs b/src/validators/model_fields.rs
index 7aba7c8e3..d2e1afe70 100644
--- a/src/validators/model_fields.rs
+++ b/src/validators/model_fields.rs
@@ -149,7 +149,7 @@ impl Validator for ModelFieldsValidator {
             Err(err) => return Err(err),
         };
 
-        let model_dict = PyDict::new_bound(py);
+        let model_dict = PyDict::new(py);
         let mut model_extra_dict_op: Option<Bound<PyDict>> = None;
         let mut errors: Vec<ValLineError> = Vec::with_capacity(self.fields.len());
         let mut fields_set_vec: Vec<Py<PyString>> = Vec::with_capacity(self.fields.len());
@@ -251,7 +251,7 @@ impl Validator for ModelFieldsValidator {
                     self,
                     iterator: impl Iterator<Item = ValResult<(Key, Value)>>,
                 ) -> ValResult<Bound<'py, PyDict>> {
-                    let model_extra_dict = PyDict::new_bound(self.py);
+                    let model_extra_dict = PyDict::new(self.py);
                     for item_result in iterator {
                         let (raw_key, value) = item_result?;
                         let either_str = match raw_key
@@ -331,13 +331,13 @@ impl Validator for ModelFieldsValidator {
         if !errors.is_empty() {
             Err(ValError::LineErrors(errors))
         } else {
-            let fields_set = PySet::new_bound(py, &fields_set_vec)?;
+            let fields_set = PySet::new(py, &fields_set_vec)?;
             state.add_fields_set(fields_set_count);
 
             // if we have extra=allow, but we didn't create a dict because we were validating
             // from attributes, set it now so __pydantic_extra__ is always a dict if extra=allow
             if matches!(self.extra_behavior, ExtraBehavior::Allow) && model_extra_dict_op.is_none() {
-                model_extra_dict_op = Some(PyDict::new_bound(py));
+                model_extra_dict_op = Some(PyDict::new(py));
             };
 
             Ok((model_dict, model_extra_dict_op, fields_set).to_object(py))
@@ -375,7 +375,7 @@ impl Validator for ModelFieldsValidator {
         let data_dict = dict.copy()?;
         if let Err(err) = data_dict.del_item(field_name) {
             // KeyError is fine here as the field might not be in the dict
-            if !err.get_type_bound(py).is(&PyType::new_bound::<PyKeyError>(py)) {
+            if !err.get_type(py).is(&PyType::new::<PyKeyError>(py)) {
                 return Err(err.into());
             }
         }
@@ -420,7 +420,7 @@ impl Validator for ModelFieldsValidator {
 
         let new_extra = match &self.extra_behavior {
             ExtraBehavior::Allow => {
-                let non_extra_data = PyDict::new_bound(py);
+                let non_extra_data = PyDict::new(py);
                 self.fields.iter().try_for_each(|f| -> PyResult<()> {
                     let Some(popped_value) = new_data.get_item(&f.name)? else {
                         // field not present in __dict__ for some reason; let the rest of the
@@ -439,7 +439,7 @@ impl Validator for ModelFieldsValidator {
             _ => py.None(),
         };
 
-        let fields_set = PySet::new_bound(py, &[field_name.to_string()])?;
+        let fields_set = PySet::new(py, &[field_name.to_string()])?;
         Ok((new_data.to_object(py), new_extra, fields_set.to_object(py)).to_object(py))
     }
 
diff --git a/src/validators/set.rs b/src/validators/set.rs
index 281cfc37d..c8900f7dc 100644
--- a/src/validators/set.rs
+++ b/src/validators/set.rs
@@ -66,7 +66,7 @@ impl Validator for SetValidator {
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let collection = input.validate_set(state.strict_or(self.strict))?.unpack(state);
-        let set = PySet::empty_bound(py)?;
+        let set = PySet::empty(py)?;
         collection.iterate(ValidateToSet {
             py,
             input,
diff --git a/src/validators/string.rs b/src/validators/string.rs
index 985aa1068..341567355 100644
--- a/src/validators/string.rs
+++ b/src/validators/string.rs
@@ -245,7 +245,7 @@ impl Pattern {
 
         let py = pattern.py();
 
-        let re_module = py.import_bound(intern!(py, "re"))?;
+        let re_module = py.import(intern!(py, "re"))?;
         let re_compile = re_module.getattr(intern!(py, "compile"))?;
         let re_pattern = re_module.getattr(intern!(py, "Pattern"))?;
 
diff --git a/src/validators/tuple.rs b/src/validators/tuple.rs
index 60e777e01..364f26b59 100644
--- a/src/validators/tuple.rs
+++ b/src/validators/tuple.rs
@@ -306,7 +306,7 @@ impl Validator for TupleValidator {
         }
 
         if errors.is_empty() {
-            Ok(PyTuple::new_bound(py, output).into_py(py))
+            Ok(PyTuple::new(py, output)?.into_py(py))
         } else {
             Err(ValError::LineErrors(errors))
         }
diff --git a/src/validators/typed_dict.rs b/src/validators/typed_dict.rs
index 0c127b93b..9c6523189 100644
--- a/src/validators/typed_dict.rs
+++ b/src/validators/typed_dict.rs
@@ -150,7 +150,7 @@ impl Validator for TypedDictValidator {
         let strict = state.strict_or(self.strict);
         let dict = input.validate_dict(strict)?;
 
-        let output_dict = PyDict::new_bound(py);
+        let output_dict = PyDict::new(py);
         let mut errors: Vec<ValLineError> = Vec::with_capacity(self.fields.len());
 
         let partial_last_key = if state.allow_partial.is_active() {
diff --git a/src/validators/union.rs b/src/validators/union.rs
index 747f6a0cf..ad14d421f 100644
--- a/src/validators/union.rs
+++ b/src/validators/union.rs
@@ -319,7 +319,7 @@ impl BuildValidator for TaggedUnionValidator {
         let discriminator = Discriminator::new(py, &schema.get_as_req(intern!(py, "discriminator"))?)?;
         let discriminator_repr = discriminator.to_string_py(py)?;
 
-        let choices = PyDict::new_bound(py);
+        let choices = PyDict::new(py);
         let mut tags_repr = String::with_capacity(50);
         let mut descr = String::with_capacity(50);
         let mut first = true;
diff --git a/src/validators/uuid.rs b/src/validators/uuid.rs
index e19dfcfd0..d1cab32a4 100644
--- a/src/validators/uuid.rs
+++ b/src/validators/uuid.rs
@@ -27,7 +27,7 @@ const UUID_IS_SAFE: &str = "is_safe";
 static UUID_TYPE: GILOnceCell<Py<PyType>> = GILOnceCell::new();
 
 fn import_type(py: Python, module: &str, attr: &str) -> PyResult<Py<PyType>> {
-    py.import_bound(module)?.getattr(attr)?.extract()
+    py.import(module)?.getattr(attr)?.extract()
 }
 
 fn get_uuid_type(py: Python) -> PyResult<&Bound<'_, PyType>> {
@@ -225,7 +225,7 @@ impl UuidValidator {
         let dc = create_class(py_type)?;
         let int = uuid.as_u128();
         let safe = py
-            .import_bound(intern!(py, "uuid"))?
+            .import(intern!(py, "uuid"))?
             .getattr(intern!(py, "SafeUUID"))?
             .get_item("safe")?;
         force_setattr(py, &dc, intern!(py, UUID_INT), int)?;
diff --git a/src/validators/with_default.rs b/src/validators/with_default.rs
index caa30cdac..2014616b5 100644
--- a/src/validators/with_default.rs
+++ b/src/validators/with_default.rs
@@ -18,7 +18,7 @@ use crate::PydanticUndefinedType;
 static COPY_DEEPCOPY: GILOnceCell<PyObject> = GILOnceCell::new();
 
 fn get_deepcopy(py: Python) -> PyResult<PyObject> {
-    Ok(py.import_bound("copy")?.getattr("deepcopy")?.into_py(py))
+    Ok(py.import("copy")?.getattr("deepcopy")?.into_py(py))
 }
 
 #[derive(Debug, Clone)]

From 80756c197ed66c7ef9256366bbcf9dead41e37c9 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Thu, 12 Dec 2024 19:42:26 +0000
Subject: [PATCH 453/550] clean up deprecations in PyO3 0.23 for tests /
 benches (#1575)

---
 benches/main.rs | 197 ++++++++++++++++++++++++------------------------
 tests/test.rs   |  41 +++++-----
 2 files changed, 121 insertions(+), 117 deletions(-)

diff --git a/benches/main.rs b/benches/main.rs
index 46b9db5f3..0198c2943 100644
--- a/benches/main.rs
+++ b/benches/main.rs
@@ -1,8 +1,8 @@
 #![feature(test)]
-#![allow(deprecated)] // FIXME: just used during upgrading PyO3 to 0.23
 
 extern crate test;
 
+use std::ffi::{CStr, CString};
 use test::{black_box, Bencher};
 
 use pyo3::prelude::*;
@@ -10,24 +10,28 @@ use pyo3::types::{PyDict, PyString};
 
 use _pydantic_core::{validate_core_schema, SchemaValidator};
 
-fn build_schema_validator_with_globals(py: Python, code: &str, globals: Option<&Bound<'_, PyDict>>) -> SchemaValidator {
-    let mut schema = py.eval_bound(code, globals, None).unwrap().extract().unwrap();
+fn build_schema_validator_with_globals(
+    py: Python,
+    code: &CStr,
+    globals: Option<&Bound<'_, PyDict>>,
+) -> SchemaValidator {
+    let mut schema = py.eval(code, globals, None).unwrap().extract().unwrap();
     schema = validate_core_schema(&schema, None).unwrap().extract().unwrap();
     SchemaValidator::py_new(py, &schema, None).unwrap()
 }
 
-fn build_schema_validator(py: Python, code: &str) -> SchemaValidator {
+fn build_schema_validator(py: Python, code: &CStr) -> SchemaValidator {
     build_schema_validator_with_globals(py, code, None)
 }
 
 fn json<'a>(py: Python<'a>, code: &'a str) -> Bound<'a, PyAny> {
-    black_box(PyString::new_bound(py, code).into_any())
+    black_box(PyString::new(py, code).into_any())
 }
 
 #[bench]
 fn ints_json(bench: &mut Bencher) {
     Python::with_gil(|py| {
-        let validator = build_schema_validator(py, "{'type': 'int'}");
+        let validator = build_schema_validator(py, c"{'type': 'int'}");
 
         let result = validator
             .validate_json(py, &json(py, "123"), None, None, None, false.into())
@@ -48,9 +52,9 @@ fn ints_json(bench: &mut Bencher) {
 #[bench]
 fn ints_python(bench: &mut Bencher) {
     Python::with_gil(|py| {
-        let validator = build_schema_validator(py, "{'type': 'int'}");
+        let validator = build_schema_validator(py, c"{'type': 'int'}");
 
-        let input = 123_i64.into_py(py).into_bound(py);
+        let Ok(input) = 123_i64.into_pyobject(py);
         let result = validator
             .validate_python(py, &input, None, None, None, None, false.into())
             .unwrap();
@@ -71,7 +75,7 @@ fn ints_python(bench: &mut Bencher) {
 #[bench]
 fn list_int_json(bench: &mut Bencher) {
     Python::with_gil(|py| {
-        let validator = build_schema_validator(py, "{'type': 'list', 'items_schema': {'type': 'int'}}");
+        let validator = build_schema_validator(py, c"{'type': 'list', 'items_schema': {'type': 'int'}}");
         let code = format!(
             "[{}]",
             (0..100).map(|x| x.to_string()).collect::<Vec<String>>().join(",")
@@ -88,14 +92,15 @@ fn list_int_json(bench: &mut Bencher) {
 }
 
 fn list_int_input(py: Python<'_>) -> (SchemaValidator, PyObject) {
-    let validator = build_schema_validator(py, "{'type': 'list', 'items_schema': {'type': 'int'}}");
-    let code = format!(
+    let validator = build_schema_validator(py, c"{'type': 'list', 'items_schema': {'type': 'int'}}");
+    let code = CString::new(format!(
         "[{}]",
         (0..100).map(|x| x.to_string()).collect::<Vec<String>>().join(",")
-    );
+    ))
+    .unwrap();
 
-    let input = py.eval_bound(&code, None, None).unwrap();
-    (validator, input.to_object(py))
+    let input = py.eval(&code, None, None).unwrap();
+    (validator, input.unbind())
 }
 
 #[bench]
@@ -130,7 +135,7 @@ fn list_int_python_isinstance(bench: &mut Bencher) {
 #[bench]
 fn list_error_json(bench: &mut Bencher) {
     Python::with_gil(|py| {
-        let validator = build_schema_validator(py, "{'type': 'list', 'items_schema': {'type': 'int'}}");
+        let validator = build_schema_validator(py, c"{'type': 'list', 'items_schema': {'type': 'int'}}");
         let code = format!(
             "[{}]",
             (0..100)
@@ -142,7 +147,7 @@ fn list_error_json(bench: &mut Bencher) {
         match validator.validate_json(py, &json(py, &code), None, None, None, false.into()) {
             Ok(_) => panic!("unexpectedly valid"),
             Err(e) => {
-                let v = e.value_bound(py);
+                let v = e.value(py);
                 // println!("error: {}", v.to_string());
                 assert_eq!(v.getattr("title").unwrap().to_string(), "list[int]");
                 let error_count: i64 = v.call_method0("error_count").unwrap().extract().unwrap();
@@ -160,28 +165,29 @@ fn list_error_json(bench: &mut Bencher) {
 }
 
 fn list_error_python_input(py: Python<'_>) -> (SchemaValidator, PyObject) {
-    let validator = build_schema_validator(py, "{'type': 'list', 'items_schema': {'type': 'int'}}");
-    let code = format!(
+    let validator = build_schema_validator(py, c"{'type': 'list', 'items_schema': {'type': 'int'}}");
+    let code = CString::new(format!(
         "[{}]",
         (0..100)
             .map(|v| format!(r#""{}""#, as_str(v)))
             .collect::<Vec<String>>()
             .join(", ")
-    );
+    ))
+    .unwrap();
 
-    let input = py.eval_bound(&code, None, None).unwrap().extract().unwrap();
+    let input = py.eval(&code, None, None).unwrap().extract().unwrap();
 
     match validator.validate_python(py, &input, None, None, None, None, false.into()) {
         Ok(_) => panic!("unexpectedly valid"),
         Err(e) => {
-            let v = e.value_bound(py);
+            let v = e.value(py);
             // println!("error: {}", v.to_string());
             assert_eq!(v.getattr("title").unwrap().to_string(), "list[int]");
             let error_count: i64 = v.call_method0("error_count").unwrap().extract().unwrap();
             assert_eq!(error_count, 100);
         }
     };
-    (validator, input.to_object(py))
+    (validator, input.unbind())
 }
 
 #[bench]
@@ -218,7 +224,7 @@ fn list_error_python_isinstance(bench: &mut Bencher) {
 #[bench]
 fn list_any_json(bench: &mut Bencher) {
     Python::with_gil(|py| {
-        let validator = build_schema_validator(py, "{'type': 'list'}");
+        let validator = build_schema_validator(py, c"{'type': 'list'}");
         let code = format!(
             "[{}]",
             (0..100).map(|x| x.to_string()).collect::<Vec<String>>().join(",")
@@ -237,13 +243,14 @@ fn list_any_json(bench: &mut Bencher) {
 #[bench]
 fn list_any_python(bench: &mut Bencher) {
     Python::with_gil(|py| {
-        let validator = build_schema_validator(py, "{'type': 'list'}");
-        let code = format!(
+        let validator = build_schema_validator(py, c"{'type': 'list'}");
+        let code = CString::new(format!(
             "[{}]",
             (0..100).map(|x| x.to_string()).collect::<Vec<String>>().join(",")
-        );
-        let input = py.eval_bound(&code, None, None).unwrap().to_object(py);
-        let input = black_box(input.bind(py));
+        ))
+        .unwrap();
+        let input = py.eval(&code, None, None).unwrap();
+        let input = black_box(input);
         bench.iter(|| {
             let v = validator
                 .validate_python(py, &input, None, None, None, None, false.into())
@@ -266,7 +273,7 @@ fn dict_json(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let validator = build_schema_validator(
             py,
-            "{'type': 'dict', 'keys_schema': {'type': 'str'}, 'values_schema': {'type': 'int'}}",
+            c"{'type': 'dict', 'keys_schema': {'type': 'str'}, 'values_schema': {'type': 'int'}}",
         );
 
         let code = format!(
@@ -292,18 +299,19 @@ fn dict_python(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let validator = build_schema_validator(
             py,
-            "{'type': 'dict', 'keys_schema': {'type': 'str'}, 'values_schema': {'type': 'int'}}",
+            c"{'type': 'dict', 'keys_schema': {'type': 'str'}, 'values_schema': {'type': 'int'}}",
         );
 
-        let code = format!(
+        let code = CString::new(format!(
             "{{{}}}",
             (0..100_u8)
                 .map(|i| format!(r#""{}{}": {i}"#, as_char(i / 26), as_char(i)))
                 .collect::<Vec<String>>()
                 .join(", ")
-        );
-        let input = py.eval_bound(&code, None, None).unwrap().to_object(py);
-        let input = black_box(input.bind(py));
+        ))
+        .unwrap();
+        let input = py.eval(&code, None, None).unwrap();
+        let input = black_box(input);
         bench.iter(|| {
             let v = validator
                 .validate_python(py, &input, None, None, None, None, false.into())
@@ -318,27 +326,28 @@ fn dict_value_error(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let validator = build_schema_validator(
             py,
-            r"{
+            cr"{
                 'type': 'dict',
                 'keys_schema': {'type': 'str'},
                 'values_schema': {'type': 'int', 'lt': 0},
             }",
         );
 
-        let code = format!(
+        let code = CString::new(format!(
             "{{{}}}",
             (0..100_u8)
                 .map(|i| format!(r#""{}": {i}"#, as_str(i)))
                 .collect::<Vec<String>>()
                 .join(", ")
-        );
+        ))
+        .unwrap();
 
-        let input = py.eval_bound(&code, None, None).unwrap().to_object(py).into_bound(py);
+        let input = py.eval(&code, None, None).unwrap();
 
         match validator.validate_python(py, &input, None, None, None, None, false.into()) {
             Ok(_) => panic!("unexpectedly valid"),
             Err(e) => {
-                let v = e.value_bound(py);
+                let v = e.value(py);
                 // println!("error: {}", v.to_string());
                 assert_eq!(v.getattr("title").unwrap().to_string(), "dict[str,constrained-int]");
                 let error_count: i64 = v.call_method0("error_count").unwrap().extract().unwrap();
@@ -363,7 +372,7 @@ fn typed_dict_json(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let validator = build_schema_validator(
             py,
-            r"{
+            cr"{
           'type': 'typed-dict',
           'extra_behavior': 'ignore',
           'fields': {
@@ -381,12 +390,12 @@ fn typed_dict_json(bench: &mut Bencher) {
         }",
         );
 
-        let code = r#"{"a": 1, "b": 2, "c": 3, "d": 4, "e": 5, "f": 6, "g": 7, "h": 8, "i": 9, "j": 0}"#.to_string();
+        let code = r#"{"a": 1, "b": 2, "c": 3, "d": 4, "e": 5, "f": 6, "g": 7, "h": 8, "i": 9, "j": 0}"#;
 
         bench.iter(|| {
             black_box(
                 validator
-                    .validate_json(py, &json(py, &code), None, None, None, false.into())
+                    .validate_json(py, &json(py, code), None, None, None, false.into())
                     .unwrap(),
             )
         })
@@ -398,7 +407,7 @@ fn typed_dict_python(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let validator = build_schema_validator(
             py,
-            r"{
+            cr"{
           'type': 'typed-dict',
           'extra_behavior': 'ignore',
           'fields': {
@@ -416,9 +425,9 @@ fn typed_dict_python(bench: &mut Bencher) {
         }",
         );
 
-        let code = r#"{"a": 1, "b": 2, "c": 3, "d": 4, "e": 5, "f": 6, "g": 7, "h": 8, "i": 9, "j": 0}"#.to_string();
-        let input = py.eval_bound(&code, None, None).unwrap().to_object(py);
-        let input = black_box(input.bind(py));
+        let code = cr#"{"a": 1, "b": 2, "c": 3, "d": 4, "e": 5, "f": 6, "g": 7, "h": 8, "i": 9, "j": 0}"#;
+        let input = py.eval(&code, None, None).unwrap();
+        let input = black_box(input);
         bench.iter(|| {
             let v = validator
                 .validate_python(py, &input, None, None, None, None, false.into())
@@ -433,7 +442,7 @@ fn typed_dict_deep_error(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let validator = build_schema_validator(
             py,
-            r"{
+            cr"{
             'type': 'typed-dict',
             'fields': {
                 'field_a': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
@@ -457,15 +466,15 @@ fn typed_dict_deep_error(bench: &mut Bencher) {
         }",
         );
 
-        let code = "{'field_a': '1', 'field_b': {'field_c': '2', 'field_d': {'field_e': '4', 'field_f': 'xx'}}}";
+        let code = c"{'field_a': '1', 'field_b': {'field_c': '2', 'field_d': {'field_e': '4', 'field_f': 'xx'}}}";
 
-        let input = py.eval_bound(code, None, None).unwrap().to_object(py);
-        let input = black_box(input.bind(py));
+        let input = py.eval(code, None, None).unwrap();
+        let input = black_box(input);
 
         match validator.validate_python(py, &input, None, None, None, None, false.into()) {
             Ok(_) => panic!("unexpectedly valid"),
             Err(e) => {
-                let v = e.value_bound(py);
+                let v = e.value(py);
                 // println!("error: {}", v.to_string());
                 assert_eq!(v.getattr("title").unwrap().to_string(), "typed-dict");
                 let error_count: i64 = v.call_method0("error_count").unwrap().extract().unwrap();
@@ -487,10 +496,10 @@ fn typed_dict_deep_error(bench: &mut Bencher) {
 #[bench]
 fn complete_model(bench: &mut Bencher) {
     Python::with_gil(|py| {
-        let sys_path = py.import_bound("sys").unwrap().getattr("path").unwrap();
+        let sys_path = py.import("sys").unwrap().getattr("path").unwrap();
         sys_path.call_method1("append", ("./tests/benchmarks/",)).unwrap();
 
-        let complete_schema = py.import_bound("complete_schema").unwrap();
+        let complete_schema = py.import("complete_schema").unwrap();
         let mut schema = complete_schema.call_method0("schema").unwrap();
         schema = validate_core_schema(&schema, None).unwrap().extract().unwrap();
         let validator = SchemaValidator::py_new(py, &schema, None).unwrap();
@@ -511,10 +520,10 @@ fn complete_model(bench: &mut Bencher) {
 #[bench]
 fn nested_model_using_definitions(bench: &mut Bencher) {
     Python::with_gil(|py| {
-        let sys_path = py.import_bound("sys").unwrap().getattr("path").unwrap();
+        let sys_path = py.import("sys").unwrap().getattr("path").unwrap();
         sys_path.call_method1("append", ("./tests/benchmarks/",)).unwrap();
 
-        let complete_schema = py.import_bound("nested_schema").unwrap();
+        let complete_schema = py.import("nested_schema").unwrap();
         let mut schema = complete_schema.call_method0("schema_using_defs").unwrap();
         schema = validate_core_schema(&schema, None).unwrap().extract().unwrap();
         let validator = SchemaValidator::py_new(py, &schema, None).unwrap();
@@ -539,10 +548,10 @@ fn nested_model_using_definitions(bench: &mut Bencher) {
 #[bench]
 fn nested_model_inlined(bench: &mut Bencher) {
     Python::with_gil(|py| {
-        let sys_path = py.import_bound("sys").unwrap().getattr("path").unwrap();
+        let sys_path = py.import("sys").unwrap().getattr("path").unwrap();
         sys_path.call_method1("append", ("./tests/benchmarks/",)).unwrap();
 
-        let complete_schema = py.import_bound("nested_schema").unwrap();
+        let complete_schema = py.import("nested_schema").unwrap();
         let mut schema = complete_schema.call_method0("inlined_schema").unwrap();
         schema = validate_core_schema(&schema, None).unwrap().extract().unwrap();
         let validator = SchemaValidator::py_new(py, &schema, None).unwrap();
@@ -567,10 +576,9 @@ fn nested_model_inlined(bench: &mut Bencher) {
 #[bench]
 fn literal_ints_few_python(bench: &mut Bencher) {
     Python::with_gil(|py| {
-        let validator = build_schema_validator(py, "{'type': 'literal', 'expected': list(range(5))}");
+        let validator = build_schema_validator(py, c"{'type': 'literal', 'expected': list(range(5))}");
 
-        let input = 4_i64.into_py(py);
-        let input = input.bind(py);
+        let Ok(input) = 4_i64.into_pyobject(py);
         let result = validator
             .validate_python(py, &input, None, None, None, None, false.into())
             .unwrap();
@@ -591,10 +599,9 @@ fn literal_ints_few_python(bench: &mut Bencher) {
 #[bench]
 fn literal_strings_few_small_python(bench: &mut Bencher) {
     Python::with_gil(|py| {
-        let validator = build_schema_validator(py, "{'type': 'literal', 'expected': [f'{idx}' for idx in range(5)]}");
+        let validator = build_schema_validator(py, c"{'type': 'literal', 'expected': [f'{idx}' for idx in range(5)]}");
 
-        let input = py.eval_bound("'4'", None, None).unwrap();
-        let input = input.to_object(py).into_bound(py);
+        let input = py.eval(c"'4'", None, None).unwrap();
         let input_str: String = input.extract().unwrap();
         let result = validator
             .validate_python(py, &input, None, None, None, None, false.into())
@@ -618,11 +625,10 @@ fn literal_strings_few_large_python(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let validator = build_schema_validator(
             py,
-            "{'type': 'literal', 'expected': ['a' * 25 + f'{idx}' for idx in range(5)]}",
+            c"{'type': 'literal', 'expected': ['a' * 25 + f'{idx}' for idx in range(5)]}",
         );
 
-        let input = py.eval_bound("'a' * 25 + '4'", None, None).unwrap();
-        let input = input.to_object(py).into_bound(py);
+        let input = py.eval(c"'a' * 25 + '4'", None, None).unwrap();
         let input_str: String = input.extract().unwrap();
         let result = validator
             .validate_python(py, &input, None, None, None, None, false.into())
@@ -644,9 +650,9 @@ fn literal_strings_few_large_python(bench: &mut Bencher) {
 #[bench]
 fn literal_enums_few_python(bench: &mut Bencher) {
     Python::with_gil(|py| {
-        let globals = PyDict::new_bound(py);
-        py.run_bound(
-            r"
+        let globals = PyDict::new(py);
+        py.run(
+            cr"
 from enum import Enum
 
 class Foo(Enum):
@@ -662,12 +668,11 @@ class Foo(Enum):
 
         let validator = build_schema_validator_with_globals(
             py,
-            "{'type': 'literal', 'expected': [Foo.v1, Foo.v2, Foo.v3, Foo.v4]}",
+            c"{'type': 'literal', 'expected': [Foo.v1, Foo.v2, Foo.v3, Foo.v4]}",
             Some(&globals),
         );
 
-        let input = py.eval_bound("Foo.v4", Some(&globals), None).unwrap();
-        let input = input.to_object(py).into_bound(py);
+        let input = py.eval(c"Foo.v4", Some(&globals), None).unwrap();
         let result = validator
             .validate_python(py, &input, None, None, None, None, false.into())
             .unwrap();
@@ -687,9 +692,9 @@ class Foo(Enum):
 #[bench]
 fn literal_ints_many_python(bench: &mut Bencher) {
     Python::with_gil(|py| {
-        let validator = build_schema_validator(py, "{'type': 'literal', 'expected': list(range(100))}");
+        let validator = build_schema_validator(py, c"{'type': 'literal', 'expected': list(range(100))}");
 
-        let input = 99_i64.into_py(py).into_bound(py);
+        let Ok(input) = 99_i64.into_pyobject(py);
         let result = validator
             .validate_python(py, &input, None, None, None, None, false.into())
             .unwrap();
@@ -710,10 +715,10 @@ fn literal_ints_many_python(bench: &mut Bencher) {
 #[bench]
 fn literal_strings_many_small_python(bench: &mut Bencher) {
     Python::with_gil(|py| {
-        let validator = build_schema_validator(py, "{'type': 'literal', 'expected': [f'{idx}' for idx in range(100)]}");
+        let validator =
+            build_schema_validator(py, c"{'type': 'literal', 'expected': [f'{idx}' for idx in range(100)]}");
 
-        let input = py.eval_bound("'99'", None, None).unwrap();
-        let input = input.to_object(py).into_bound(py);
+        let input = py.eval(c"'99'", None, None).unwrap();
         let input_str: String = input.extract().unwrap();
         let result = validator
             .validate_python(py, &input, None, None, None, None, false.into())
@@ -737,11 +742,10 @@ fn literal_strings_many_large_python(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let validator = build_schema_validator(
             py,
-            "{'type': 'literal', 'expected': ['a' * 25 + f'{idx}' for idx in range(100)]}",
+            c"{'type': 'literal', 'expected': ['a' * 25 + f'{idx}' for idx in range(100)]}",
         );
 
-        let input = py.eval_bound("'a' * 25 + '99'", None, None).unwrap();
-        let input = input.to_object(py).into_bound(py);
+        let input = py.eval(c"'a' * 25 + '99'", None, None).unwrap();
         let input_str: String = input.extract().unwrap();
         let result = validator
             .validate_python(py, &input, None, None, None, None, false.into())
@@ -763,10 +767,9 @@ fn literal_strings_many_large_python(bench: &mut Bencher) {
 #[bench]
 fn literal_ints_many_json(bench: &mut Bencher) {
     Python::with_gil(|py| {
-        let validator = build_schema_validator(py, "{'type': 'literal', 'expected': list(range(100))}");
+        let validator = build_schema_validator(py, c"{'type': 'literal', 'expected': list(range(100))}");
 
-        let input_json = py.eval_bound("'99'", None, None).unwrap();
-        let input_json = input_json.to_object(py).into_bound(py);
+        let input_json = py.eval(c"'99'", None, None).unwrap();
         let result = validator
             .validate_json(py, &input_json, None, None, None, false.into())
             .unwrap();
@@ -789,13 +792,11 @@ fn literal_strings_many_large_json(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let validator = build_schema_validator(
             py,
-            "{'type': 'literal', 'expected': ['a' * 25 + f'{idx}' for idx in range(100)]}",
+            c"{'type': 'literal', 'expected': ['a' * 25 + f'{idx}' for idx in range(100)]}",
         );
 
-        let input = py.eval_bound("'a' * 25 + '99'", None, None).unwrap();
-        let input = input.to_object(py).into_bound(py);
-        let input_json = py.eval_bound("'\"' + 'a' * 25 + '99' + '\"'", None, None).unwrap();
-        let input_json = input_json.to_object(py).into_bound(py);
+        let input = py.eval(c"'a' * 25 + '99'", None, None).unwrap();
+        let input_json = py.eval(c"'\"' + 'a' * 25 + '99' + '\"'", None, None).unwrap();
         let input_str: String = input.extract().unwrap();
         let result = validator
             .validate_json(py, &input_json, None, None, None, false.into())
@@ -817,9 +818,9 @@ fn literal_strings_many_large_json(bench: &mut Bencher) {
 #[bench]
 fn literal_mixed_few_python(bench: &mut Bencher) {
     Python::with_gil(|py| {
-        let globals = PyDict::new_bound(py);
-        py.run_bound(
-            r"
+        let globals = PyDict::new(py);
+        py.run(
+            cr"
 from enum import Enum
 
 class Foo(Enum):
@@ -834,14 +835,13 @@ class Foo(Enum):
         .unwrap();
         let validator = build_schema_validator_with_globals(
             py,
-            "{'type': 'literal', 'expected': [None, 'null', -1, Foo.v4]}",
+            c"{'type': 'literal', 'expected': [None, 'null', -1, Foo.v4]}",
             Some(&globals),
         );
 
         // String
         {
-            let input = py.eval_bound("'null'", None, None).unwrap();
-            let input = input.to_object(py).into_bound(py);
+            let input = py.eval(c"'null'", None, None).unwrap();
             let input_str: String = input.extract().unwrap();
             let result = validator
                 .validate_python(py, &input, None, None, None, None, false.into())
@@ -861,8 +861,7 @@ class Foo(Enum):
 
         // Int
         {
-            let input = py.eval_bound("-1", None, None).unwrap();
-            let input = input.to_object(py).into_bound(py);
+            let input = py.eval(c"-1", None, None).unwrap();
             let input_int: i64 = input.extract().unwrap();
             let result = validator
                 .validate_python(py, &input, None, None, None, None, false.into())
@@ -882,8 +881,7 @@ class Foo(Enum):
 
         // None
         {
-            let input = py.eval_bound("None", None, None).unwrap();
-            let input = input.to_object(py).into_bound(py);
+            let input = py.eval(c"None", None, None).unwrap();
             let result = validator
                 .validate_python(py, &input, None, None, None, None, false.into())
                 .unwrap();
@@ -901,8 +899,7 @@ class Foo(Enum):
 
         // Enum
         {
-            let input = py.eval_bound("Foo.v4", Some(&globals), None).unwrap();
-            let input = input.to_object(py).into_bound(py);
+            let input = py.eval(c"Foo.v4", Some(&globals), None).unwrap();
             let result = validator
                 .validate_python(py, &input, None, None, None, None, false.into())
                 .unwrap();
diff --git a/tests/test.rs b/tests/test.rs
index 1b5beb0fe..b59fbec54 100644
--- a/tests/test.rs
+++ b/tests/test.rs
@@ -1,8 +1,7 @@
-#![allow(deprecated)] // FIXME: just used during upgrading PyO3 to 0.23
-
 #[cfg(test)]
 mod tests {
     use _pydantic_core::{SchemaSerializer, SchemaValidator, WarningsArg};
+    use pyo3::ffi::c_str; // can switch to c"" literals on MSRV >= 1.77
     use pyo3::prelude::*;
     use pyo3::types::PyDict;
 
@@ -24,7 +23,8 @@ mod tests {
             //         'type': 'function-wrap',
             //         'function': lambda: None,
             //     },
-            let code = r"{
+            let code = c_str!(
+                r"{
                 'type': 'definitions',
                 'schema': {'type': 'definition-ref', 'schema_ref': 'C-ref'},
                 'definitions': [
@@ -46,8 +46,9 @@ mod tests {
                         },
                     },
                 ]
-            }";
-            let schema: Bound<'_, PyDict> = py.eval_bound(code, None, None).unwrap().extract().unwrap();
+            }"
+            );
+            let schema: Bound<'_, PyDict> = py.eval(code, None, None).unwrap().extract().unwrap();
             SchemaSerializer::py_new(schema, None).unwrap();
         });
     }
@@ -55,7 +56,8 @@ mod tests {
     #[test]
     fn test_serialize_computed_fields() {
         Python::with_gil(|py| {
-            let code = r#"
+            let code = c_str!(
+                r#"
 class A:
     @property
     def b(self) -> str:
@@ -74,9 +76,10 @@ schema = {
     "type": "model",
 }
 a = A()
-            "#;
-            let locals = PyDict::new_bound(py);
-            py.run_bound(code, None, Some(&locals)).unwrap();
+            "#
+            );
+            let locals = PyDict::new(py);
+            py.run(code, None, Some(&locals)).unwrap();
             let a = locals.get_item("a").unwrap().unwrap();
             let schema = locals
                 .get_item("schema")
@@ -111,7 +114,8 @@ a = A()
     #[test]
     fn test_literal_schema() {
         Python::with_gil(|py| {
-            let code = r#"
+            let code = c_str!(
+                r#"
 schema = {
     "type": "dict",
     "keys_schema": {
@@ -124,9 +128,10 @@ schema = {
     "strict": False,
 }
 json_input = '{"a": "something"}'
-            "#;
-            let locals = PyDict::new_bound(py);
-            py.run_bound(code, None, Some(&locals)).unwrap();
+            "#
+            );
+            let locals = PyDict::new(py);
+            py.run(code, None, Some(&locals)).unwrap();
             let schema = locals.get_item("schema").unwrap().unwrap();
             let json_input = locals.get_item("json_input").unwrap().unwrap();
             let binding = SchemaValidator::py_new(py, &schema, None)
@@ -142,7 +147,8 @@ json_input = '{"a": "something"}'
     #[test]
     fn test_segfault_for_recursive_schemas() {
         Python::with_gil(|py| {
-            let code = r"
+            let code = c_str!(
+                r"
 schema = {
     'type': 'definitions',
     'schema': {
@@ -177,9 +183,10 @@ schema = {
 }
 dump_json_input_1 = 1
 dump_json_input_2 = {'a': 'something'}
-            ";
-            let locals = PyDict::new_bound(py);
-            py.run_bound(code, None, Some(&locals)).unwrap();
+            "
+            );
+            let locals = PyDict::new(py);
+            py.run(code, None, Some(&locals)).unwrap();
             let schema = locals
                 .get_item("schema")
                 .unwrap()

From 730adc347610779754c9e042993b1a27f2b53fba Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Thu, 12 Dec 2024 20:08:46 +0000
Subject: [PATCH 454/550] add benchmark for root model validation (#1581)

---
 tests/benchmarks/complete_schema.py         | 19 +++++++++++++++++++
 tests/benchmarks/test_complete_benchmark.py | 15 ++++++++++++++-
 2 files changed, 33 insertions(+), 1 deletion(-)

diff --git a/tests/benchmarks/complete_schema.py b/tests/benchmarks/complete_schema.py
index 7c661fb3e..e12cdb298 100644
--- a/tests/benchmarks/complete_schema.py
+++ b/tests/benchmarks/complete_schema.py
@@ -340,3 +340,22 @@ def input_data_wrong():
         'field_functions_model': {'field_before': 1, 'field_after': 1, 'field_wrap': 1, 'field_plain': 1},
         'field_recursive': {'name': 'foo', 'sub_branch': {'name': 'bar', 'sub_branch': {}}},
     }
+
+
+def wrap_schema_in_root_model(schema: dict) -> dict:
+    class MyRootModel:
+        # __slots__ is not required, but it avoids __pydantic_fields_set__ falling into __dict__
+        __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__'
+
+    return {
+        'type': 'model',
+        'cls': MyRootModel,
+        'config': {},
+        'schema': {
+            'type': 'model-fields',
+            'fields': {
+                'root': {'type': 'model-field', 'schema': schema},
+            },
+        },
+        'root_model': True,
+    }
diff --git a/tests/benchmarks/test_complete_benchmark.py b/tests/benchmarks/test_complete_benchmark.py
index 89c6d7efd..5552e43cc 100644
--- a/tests/benchmarks/test_complete_benchmark.py
+++ b/tests/benchmarks/test_complete_benchmark.py
@@ -11,7 +11,7 @@
 
 from pydantic_core import SchemaSerializer, SchemaValidator, ValidationError, validate_core_schema
 
-from .complete_schema import input_data_lax, input_data_strict, input_data_wrong, schema
+from .complete_schema import input_data_lax, input_data_strict, input_data_wrong, schema, wrap_schema_in_root_model
 
 
 def test_complete_valid():
@@ -99,6 +99,12 @@ def test_complete_core_strict(benchmark):
     benchmark(v.validate_python, input_data_strict())
 
 
+@pytest.mark.benchmark(group='complete')
+def test_complete_core_root(benchmark):
+    v = SchemaValidator(validate_core_schema(wrap_schema_in_root_model(schema())))
+    benchmark(v.validate_python, {'root': input_data_lax()})
+
+
 @pytest.mark.benchmark(group='complete-to-python')
 def test_complete_core_serializer_to_python(benchmark):
     core_schema = validate_core_schema(schema())
@@ -160,6 +166,13 @@ def test_complete_core_json(benchmark):
     benchmark(v.validate_json, json_data)
 
 
+@pytest.mark.benchmark(group='complete-json')
+def test_complete_core_root_json(benchmark):
+    v = SchemaValidator(validate_core_schema(wrap_schema_in_root_model(schema())))
+    json_data = json.dumps({'root': input_data_lax()}, default=default_json_encoder)
+    benchmark(v.validate_json, json_data)
+
+
 @pytest.mark.benchmark(group='build')
 def test_build_schema(benchmark):
     lax_schema = schema()

From bd91c180c66ef1728a31e714b726a65b1ff2e00e Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Thu, 12 Dec 2024 20:27:26 +0000
Subject: [PATCH 455/550] fix wasteful `to_python()` calls checking for
 undefined (#1580)

---
 src/validators/model.rs        | 4 ++--
 src/validators/with_default.rs | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/validators/model.rs b/src/validators/model.rs
index a514c5539..fddbcee24 100644
--- a/src/validators/model.rs
+++ b/src/validators/model.rs
@@ -263,7 +263,7 @@ impl ModelValidator {
         let output = self.validator.validate(py, input, state)?;
 
         if self.root_model {
-            let fields_set = if input.to_object(py).is(&self.undefined) {
+            let fields_set = if input.as_python().is_some_and(|py_input| py_input.is(&self.undefined)) {
                 PySet::empty(py)?
             } else {
                 PySet::new(py, [&String::from(ROOT_FIELD)])?
@@ -304,7 +304,7 @@ impl ModelValidator {
         let instance = create_class(self.class.bind(py))?;
 
         if self.root_model {
-            let fields_set = if input.to_object(py).is(&self.undefined) {
+            let fields_set = if input.as_python().is_some_and(|py_input| py_input.is(&self.undefined)) {
                 PySet::empty(py)?
             } else {
                 PySet::new(py, [&String::from(ROOT_FIELD)])?
diff --git a/src/validators/with_default.rs b/src/validators/with_default.rs
index 2014616b5..bc77e3886 100644
--- a/src/validators/with_default.rs
+++ b/src/validators/with_default.rs
@@ -157,7 +157,7 @@ impl Validator for WithDefaultValidator {
         input: &(impl Input<'py> + ?Sized),
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
-        if input.to_object(py).is(&self.undefined) {
+        if input.as_python().is_some_and(|py_input| py_input.is(&self.undefined)) {
             Ok(self.default_value(py, None::<usize>, state)?.unwrap())
         } else {
             match self.validator.validate(py, input, state) {

From 39435c236f011262011fd275b0eac310a0273e4f Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Tue, 17 Dec 2024 15:35:49 +0000
Subject: [PATCH 456/550] remove uses of IntoPy (#1578)

---
 src/argument_markers.rs                       |  50 ++----
 src/build_tools.rs                            |  11 +-
 src/errors/line_error.rs                      |  10 +-
 src/errors/mod.rs                             |   2 +-
 src/errors/types.rs                           |  11 +-
 src/errors/validation_exception.rs            |  80 +++++----
 src/input/datetime.rs                         | 157 ++++++++++--------
 src/input/return_enums.rs                     |  93 +++--------
 src/serializers/computed_fields.rs            |   4 +-
 src/serializers/config.rs                     |  18 +-
 src/serializers/fields.rs                     |   2 +-
 src/serializers/infer.rs                      |  79 +++++----
 src/serializers/shared.rs                     |   9 +-
 src/serializers/type_serializers/bytes.rs     |   8 +-
 src/serializers/type_serializers/complex.rs   |  10 +-
 src/serializers/type_serializers/dataclass.rs |   4 +-
 .../type_serializers/datetime_etc.rs          |   5 +-
 src/serializers/type_serializers/dict.rs      |   5 +-
 src/serializers/type_serializers/enum_.rs     |   2 +-
 src/serializers/type_serializers/float.rs     |   2 +-
 src/serializers/type_serializers/format.rs    |   8 +-
 src/serializers/type_serializers/function.rs  |  36 ++--
 src/serializers/type_serializers/generator.rs |   5 +-
 src/serializers/type_serializers/list.rs      |   3 +-
 src/serializers/type_serializers/nullable.rs  |   2 +-
 .../type_serializers/set_frozenset.rs         |   6 +-
 src/serializers/type_serializers/simple.rs    |   4 +-
 src/serializers/type_serializers/string.rs    |   8 +-
 src/serializers/type_serializers/timedelta.rs |   6 +-
 src/serializers/type_serializers/tuple.rs     |   4 +-
 src/serializers/type_serializers/url.rs       |   5 +-
 src/serializers/type_serializers/uuid.rs      |   6 +-
 src/url.rs                                    |  20 +--
 src/validators/arguments.rs                   |   2 +-
 src/validators/bool.rs                        |   4 +-
 src/validators/bytes.rs                       |   5 +-
 src/validators/complex.rs                     |   2 +-
 src/validators/dataclass.rs                   |   6 +-
 src/validators/date.rs                        |   3 +-
 src/validators/datetime.rs                    |  11 +-
 src/validators/float.rs                       |   5 +-
 src/validators/frozenset.rs                   |   4 +-
 src/validators/function.rs                    |   4 +-
 src/validators/generator.rs                   |  10 +-
 src/validators/int.rs                         |   5 +-
 src/validators/list.rs                        |   6 +-
 src/validators/mod.rs                         |  14 +-
 src/validators/model.rs                       |   6 +-
 src/validators/set.rs                         |   4 +-
 src/validators/string.rs                      |  10 +-
 src/validators/time.rs                        |   3 +-
 src/validators/timedelta.rs                   |   2 +-
 src/validators/tuple.rs                       |   2 +-
 src/validators/url.rs                         |  29 ++--
 src/validators/with_default.rs                |   4 +-
 55 files changed, 405 insertions(+), 411 deletions(-)

diff --git a/src/argument_markers.rs b/src/argument_markers.rs
index 23cd74f41..f22a32c78 100644
--- a/src/argument_markers.rs
+++ b/src/argument_markers.rs
@@ -1,4 +1,3 @@
-use pyo3::basic::CompareOp;
 use pyo3::exceptions::PyNotImplementedError;
 use pyo3::prelude::*;
 use pyo3::sync::GILOnceCell;
@@ -13,45 +12,26 @@ pub struct ArgsKwargs {
     pub(crate) kwargs: Option<Py<PyDict>>,
 }
 
-impl ArgsKwargs {
-    fn eq(&self, py: Python, other: &Self) -> PyResult<bool> {
-        if self.args.bind(py).eq(other.args.bind(py))? {
-            match (&self.kwargs, &other.kwargs) {
-                (Some(d1), Some(d2)) => d1.bind(py).eq(d2.bind(py)),
-                (None, None) => Ok(true),
-                _ => Ok(false),
-            }
-        } else {
-            Ok(false)
-        }
-    }
-}
-
 #[pymethods]
 impl ArgsKwargs {
     #[new]
     #[pyo3(signature = (args, kwargs = None))]
-    fn py_new(py: Python, args: &Bound<'_, PyTuple>, kwargs: Option<&Bound<'_, PyDict>>) -> Self {
+    fn py_new(args: Bound<'_, PyTuple>, kwargs: Option<Bound<'_, PyDict>>) -> Self {
         Self {
-            args: args.into_py(py),
-            kwargs: match kwargs {
-                Some(d) if !d.is_empty() => Some(d.to_owned().unbind()),
-                _ => None,
-            },
+            args: args.unbind(),
+            kwargs: kwargs.filter(|d| !d.is_empty()).map(Bound::unbind),
         }
     }
 
-    fn __richcmp__(&self, other: &Self, op: CompareOp, py: Python<'_>) -> PyObject {
-        match op {
-            CompareOp::Eq => match self.eq(py, other) {
-                Ok(b) => b.into_py(py),
-                Err(e) => e.into_py(py),
-            },
-            CompareOp::Ne => match self.eq(py, other) {
-                Ok(b) => (!b).into_py(py),
-                Err(e) => e.into_py(py),
-            },
-            _ => py.NotImplemented(),
+    fn __eq__(&self, py: Python, other: &Self) -> PyResult<bool> {
+        if !self.args.bind(py).eq(&other.args)? {
+            return Ok(false);
+        }
+
+        match (&self.kwargs, &other.kwargs) {
+            (Some(d1), Some(d2)) => d1.bind(py).eq(d2),
+            (None, None) => Ok(true),
+            _ => Ok(false),
         }
     }
 
@@ -82,8 +62,8 @@ impl PydanticUndefinedType {
     #[staticmethod]
     pub fn new(py: Python) -> Py<Self> {
         UNDEFINED_CELL
-            .get_or_init(py, || PydanticUndefinedType {}.into_py(py).extract(py).unwrap())
-            .clone()
+            .get_or_init(py, || Py::new(py, PydanticUndefinedType {}).unwrap())
+            .clone_ref(py)
     }
 
     fn __repr__(&self) -> &'static str {
@@ -91,7 +71,7 @@ impl PydanticUndefinedType {
     }
 
     fn __copy__(&self, py: Python) -> Py<Self> {
-        UNDEFINED_CELL.get(py).unwrap().clone()
+        UNDEFINED_CELL.get(py).unwrap().clone_ref(py)
     }
 
     #[pyo3(signature = (_memo, /))]
diff --git a/src/build_tools.rs b/src/build_tools.rs
index 000ffff34..9ada03e49 100644
--- a/src/build_tools.rs
+++ b/src/build_tools.rs
@@ -6,7 +6,7 @@ use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList, PyString};
 use pyo3::{intern, FromPyObject, PyErrArguments};
 
-use crate::errors::ValError;
+use crate::errors::{PyLineError, ValError};
 use crate::input::InputType;
 use crate::tools::SchemaDict;
 use crate::ValidationError;
@@ -85,7 +85,14 @@ impl SchemaError {
     pub fn from_val_error(py: Python, error: ValError) -> PyErr {
         match error {
             ValError::LineErrors(raw_errors) => {
-                let line_errors = raw_errors.into_iter().map(|e| e.into_py(py)).collect();
+                let line_errors = match raw_errors
+                    .into_iter()
+                    .map(|e| PyLineError::from_val_line_error(py, e))
+                    .collect::<PyResult<_>>()
+                {
+                    Ok(errors) => errors,
+                    Err(err) => return err,
+                };
                 let validation_error =
                     ValidationError::new(line_errors, "Schema".to_object(py), InputType::Python, false);
                 let schema_error = SchemaError(SchemaErrorEnum::ValidationError(validation_error));
diff --git a/src/errors/line_error.rs b/src/errors/line_error.rs
index 03e770cc3..ec8348556 100644
--- a/src/errors/line_error.rs
+++ b/src/errors/line_error.rs
@@ -1,3 +1,5 @@
+use std::convert::Infallible;
+
 use pyo3::exceptions::PyTypeError;
 use pyo3::prelude::*;
 use pyo3::DowncastError;
@@ -61,6 +63,12 @@ impl From<Vec<ValLineError>> for ValError {
     }
 }
 
+impl From<Infallible> for ValError {
+    fn from(infallible: Infallible) -> Self {
+        match infallible {}
+    }
+}
+
 impl ValError {
     pub fn new(error_type: ErrorType, input: impl ToErrorValue) -> ValError {
         Self::LineErrors(vec![ValLineError::new(error_type, input)])
@@ -156,7 +164,7 @@ impl ValLineError {
 }
 
 #[cfg_attr(debug_assertions, derive(Debug))]
-#[derive(Clone)]
+#[derive(Clone, IntoPyObject)]
 pub enum InputValue {
     Python(PyObject),
     Json(JsonValue<'static>),
diff --git a/src/errors/mod.rs b/src/errors/mod.rs
index 6cf38b186..c80f402bb 100644
--- a/src/errors/mod.rs
+++ b/src/errors/mod.rs
@@ -9,7 +9,7 @@ mod value_exception;
 pub use self::line_error::{InputValue, ToErrorValue, ValError, ValLineError, ValResult};
 pub use self::location::LocItem;
 pub use self::types::{list_all_errors, ErrorType, ErrorTypeDefaults, Number};
-pub use self::validation_exception::ValidationError;
+pub use self::validation_exception::{PyLineError, ValidationError};
 pub use self::value_exception::{PydanticCustomError, PydanticKnownError, PydanticOmit, PydanticUseDefault};
 
 pub fn py_err_string(py: Python, err: PyErr) -> String {
diff --git a/src/errors/types.rs b/src/errors/types.rs
index 8e36ec9f5..54d4c9c8f 100644
--- a/src/errors/types.rs
+++ b/src/errors/types.rs
@@ -3,9 +3,9 @@ use std::borrow::Cow;
 use std::fmt;
 
 use pyo3::exceptions::{PyKeyError, PyTypeError};
-use pyo3::prelude::*;
 use pyo3::sync::GILOnceCell;
 use pyo3::types::{PyDict, PyList};
+use pyo3::{prelude::*, IntoPyObjectExt};
 
 use ahash::AHashMap;
 use num_bigint::BigInt;
@@ -766,7 +766,7 @@ impl ErrorType {
     }
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, IntoPyObject, IntoPyObjectRef)]
 pub enum Number {
     Int(i64),
     BigInt(BigInt),
@@ -826,11 +826,6 @@ impl fmt::Display for Number {
 }
 impl ToPyObject for Number {
     fn to_object(&self, py: Python<'_>) -> PyObject {
-        match self {
-            Self::Int(i) => i.into_py(py),
-            Self::BigInt(i) => i.clone().into_py(py),
-            Self::Float(f) => f.into_py(py),
-            Self::String(s) => s.into_py(py),
-        }
+        self.into_py_any(py).unwrap()
     }
 }
diff --git a/src/errors/validation_exception.rs b/src/errors/validation_exception.rs
index acbce0d7f..89e082d02 100644
--- a/src/errors/validation_exception.rs
+++ b/src/errors/validation_exception.rs
@@ -7,7 +7,7 @@ use pyo3::ffi::{self, c_str};
 use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::sync::GILOnceCell;
-use pyo3::types::{PyDict, PyList, PyString, PyType};
+use pyo3::types::{PyDict, PyList, PyString, PyTuple, PyType};
 use serde::ser::{Error, SerializeMap, SerializeSeq};
 use serde::{Serialize, Serializer};
 
@@ -57,12 +57,19 @@ impl ValidationError {
     ) -> PyErr {
         match error {
             ValError::LineErrors(raw_errors) => {
-                let line_errors: Vec<PyLineError> = match outer_location {
+                let line_errors = match outer_location {
                     Some(outer_location) => raw_errors
                         .into_iter()
-                        .map(|e| e.with_outer_location(outer_location.clone()).into_py(py))
+                        .map(|e| PyLineError::from_val_line_error(py, e.with_outer_location(outer_location.clone())))
+                        .collect(),
+                    None => raw_errors
+                        .into_iter()
+                        .map(|e| PyLineError::from_val_line_error(py, e))
                         .collect(),
-                    None => raw_errors.into_iter().map(|e| e.into_py(py)).collect(),
+                };
+                let line_errors = match line_errors {
+                    Ok(errors) => errors,
+                    Err(err) => return err,
                 };
                 let validation_error = Self::new(line_errors, title, input_type, hide_input);
                 match Py::new(py, validation_error) {
@@ -117,15 +124,17 @@ impl ValidationError {
                 context: _,
             } = &line_error.error_type
             {
-                let note: PyObject = if let Location::Empty = &line_error.location {
-                    "Pydantic: cause of loc: root".into_py(py)
+                let note = if let Location::Empty = &line_error.location {
+                    PyString::new(py, "Pydantic: cause of loc: root")
                 } else {
-                    format!(
-                        "Pydantic: cause of loc: {}",
-                        // Location formats with a newline at the end, hence the trim()
-                        line_error.location.to_string().trim()
+                    PyString::new(
+                        py,
+                        &format!(
+                            "Pydantic: cause of loc: {}",
+                            // Location formats with a newline at the end, hence the trim()
+                            line_error.location.to_string().trim()
+                        ),
                     )
-                    .into_py(py)
                 };
 
                 // Notes only support 3.11 upwards:
@@ -144,7 +153,7 @@ impl ValidationError {
                 {
                     use pyo3::exceptions::PyUserWarning;
 
-                    let wrapped = PyUserWarning::new_err((note,));
+                    let wrapped = PyUserWarning::new_err((note.unbind(),));
                     wrapped.set_cause(py, Some(PyErr::from_value(err.clone_ref(py).into_bound(py))));
                     user_py_errs.push(wrapped);
                 }
@@ -159,7 +168,7 @@ impl ValidationError {
             #[cfg(Py_3_11)]
             let cause = {
                 use pyo3::exceptions::PyBaseExceptionGroup;
-                Some(PyBaseExceptionGroup::new_err((title, user_py_errs)).into_py(py))
+                Some(PyBaseExceptionGroup::new_err((title, user_py_errs)).into_value(py))
             };
 
             // Pre 3.11 ExceptionGroup support, use the python backport instead:
@@ -170,7 +179,7 @@ impl ValidationError {
                 match py.import("exceptiongroup") {
                     Ok(py_mod) => match py_mod.getattr("ExceptionGroup") {
                         Ok(group_cls) => match group_cls.call1((title, user_py_errs)) {
-                            Ok(group_instance) => Some(group_instance.into_py(py)),
+                            Ok(group_instance) => Some(group_instance),
                             Err(_) => None,
                         },
                         Err(_) => None,
@@ -308,10 +317,13 @@ impl ValidationError {
                     return py.None();
                 }
                 e.as_dict(py, url_prefix, include_context, self.input_type, include_input)
-                    .unwrap_or_else(|err| {
-                        iteration_error = Some(err);
-                        py.None()
-                    })
+                    .map_or_else(
+                        |err| {
+                            iteration_error = Some(err);
+                            py.None()
+                        },
+                        Into::into,
+                    )
             }),
         )?;
         if let Some(err) = iteration_error {
@@ -379,7 +391,7 @@ impl ValidationError {
         self.__repr__(py)
     }
 
-    fn __reduce__<'py>(slf: &Bound<'py, Self>) -> PyResult<(Bound<'py, PyAny>, PyObject)> {
+    fn __reduce__<'py>(slf: &Bound<'py, Self>) -> PyResult<(Bound<'py, PyAny>, Bound<'py, PyTuple>)> {
         let py = slf.py();
         let callable = slf.getattr("from_exception_data")?;
         let borrow = slf.try_borrow()?;
@@ -389,7 +401,7 @@ impl ValidationError {
             borrow.input_type.into_pyobject(py)?,
             borrow.hide_input,
         )
-            .into_py(slf.py());
+            .into_pyobject(slf.py())?;
         Ok((callable, args))
     }
 }
@@ -418,16 +430,6 @@ pub struct PyLineError {
     input_value: PyObject,
 }
 
-impl IntoPy<PyLineError> for ValLineError {
-    fn into_py(self, py: Python<'_>) -> PyLineError {
-        PyLineError {
-            error_type: self.error_type,
-            location: self.location,
-            input_value: self.input_value.to_object(py),
-        }
-    }
-}
-
 impl From<PyLineError> for ValLineError {
     /// Used to extract line errors from a validation error for wrap functions
     fn from(other: PyLineError) -> ValLineError {
@@ -464,7 +466,7 @@ impl TryFrom<&Bound<'_, PyAny>> for PyLineError {
         let location = Location::try_from(dict.get_item("loc")?.as_ref())?;
 
         let input_value = match dict.get_item("input")? {
-            Some(i) => i.into_py(py),
+            Some(i) => i.unbind(),
             None => py.None(),
         };
 
@@ -477,18 +479,26 @@ impl TryFrom<&Bound<'_, PyAny>> for PyLineError {
 }
 
 impl PyLineError {
+    pub fn from_val_line_error(py: Python, error: ValLineError) -> PyResult<Self> {
+        Ok(Self {
+            error_type: error.error_type,
+            location: error.location,
+            input_value: error.input_value.into_pyobject(py)?.unbind(),
+        })
+    }
+
     fn get_error_url(&self, url_prefix: &str) -> String {
         format!("{url_prefix}{}", self.error_type.type_string())
     }
 
-    pub fn as_dict(
+    pub fn as_dict<'py>(
         &self,
-        py: Python,
+        py: Python<'py>,
         url_prefix: Option<&str>,
         include_context: bool,
         input_type: InputType,
         include_input: bool,
-    ) -> PyResult<PyObject> {
+    ) -> PyResult<Bound<'py, PyDict>> {
         let dict = PyDict::new(py);
         dict.set_item("type", self.error_type.type_string())?;
         dict.set_item("loc", self.location.to_object(py))?;
@@ -511,7 +521,7 @@ impl PyLineError {
                 }
             }
         }
-        Ok(dict.into_py(py))
+        Ok(dict)
     }
 
     fn pretty(
diff --git a/src/input/datetime.rs b/src/input/datetime.rs
index 33a09dcb7..6e4093207 100644
--- a/src/input/datetime.rs
+++ b/src/input/datetime.rs
@@ -3,7 +3,9 @@ use pyo3::prelude::*;
 
 use pyo3::exceptions::PyValueError;
 use pyo3::pyclass::CompareOp;
+use pyo3::types::PyTuple;
 use pyo3::types::{PyDate, PyDateTime, PyDelta, PyDeltaAccess, PyDict, PyTime, PyTzInfo};
+use pyo3::IntoPyObjectExt;
 use speedate::MicrosecondsPrecisionOverflowBehavior;
 use speedate::{Date, DateTime, Duration, ParseError, Time, TimeConfig};
 use std::borrow::Cow;
@@ -19,9 +21,9 @@ use crate::errors::{ErrorType, ValError, ValResult};
 use crate::tools::py_err;
 
 #[cfg_attr(debug_assertions, derive(Debug))]
-pub enum EitherDate<'a> {
+pub enum EitherDate<'py> {
     Raw(Date),
-    Py(Bound<'a, PyDate>),
+    Py(Bound<'py, PyDate>),
 }
 
 impl From<Date> for EitherDate<'_> {
@@ -30,8 +32,8 @@ impl From<Date> for EitherDate<'_> {
     }
 }
 
-impl<'a> From<Bound<'a, PyDate>> for EitherDate<'a> {
-    fn from(date: Bound<'a, PyDate>) -> Self {
+impl<'py> From<Bound<'py, PyDate>> for EitherDate<'py> {
+    fn from(date: Bound<'py, PyDate>) -> Self {
         Self::Py(date)
     }
 }
@@ -45,6 +47,19 @@ pub fn pydate_as_date(py_date: &Bound<'_, PyAny>) -> PyResult<Date> {
     })
 }
 
+impl<'py> IntoPyObject<'py> for EitherDate<'py> {
+    type Target = PyDate;
+    type Output = Bound<'py, PyDate>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> PyResult<Self::Output> {
+        match self {
+            Self::Raw(date) => PyDate::new(py, date.year.into(), date.month, date.day),
+            Self::Py(date) => Ok(date),
+        }
+    }
+}
+
 impl EitherDate<'_> {
     pub fn as_raw(&self) -> PyResult<Date> {
         match self {
@@ -52,20 +67,12 @@ impl EitherDate<'_> {
             Self::Py(py_date) => pydate_as_date(py_date),
         }
     }
-
-    pub fn try_into_py(self, py: Python<'_>) -> PyResult<PyObject> {
-        let date = match self {
-            Self::Py(date) => Ok(date),
-            Self::Raw(date) => PyDate::new(py, date.year.into(), date.month, date.day),
-        }?;
-        Ok(date.into_py(py))
-    }
 }
 
 #[cfg_attr(debug_assertions, derive(Debug))]
-pub enum EitherTime<'a> {
+pub enum EitherTime<'py> {
     Raw(Time),
-    Py(Bound<'a, PyTime>),
+    Py(Bound<'py, PyTime>),
 }
 
 impl From<Time> for EitherTime<'_> {
@@ -74,17 +81,32 @@ impl From<Time> for EitherTime<'_> {
     }
 }
 
-impl<'a> From<Bound<'a, PyTime>> for EitherTime<'a> {
-    fn from(time: Bound<'a, PyTime>) -> Self {
+impl<'py> From<Bound<'py, PyTime>> for EitherTime<'py> {
+    fn from(time: Bound<'py, PyTime>) -> Self {
         Self::Py(time)
     }
 }
 
 #[cfg_attr(debug_assertions, derive(Debug))]
-pub enum EitherTimedelta<'a> {
+#[derive(Clone)]
+pub enum EitherTimedelta<'py> {
     Raw(Duration),
-    PyExact(Bound<'a, PyDelta>),
-    PySubclass(Bound<'a, PyDelta>),
+    PyExact(Bound<'py, PyDelta>),
+    PySubclass(Bound<'py, PyDelta>),
+}
+
+impl<'py> IntoPyObject<'py> for EitherTimedelta<'py> {
+    type Target = PyDelta;
+    type Output = Bound<'py, PyDelta>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> PyResult<Self::Output> {
+        match self {
+            Self::Raw(duration) => duration_as_pytimedelta(py, &duration),
+            Self::PyExact(py_timedelta) => Ok(py_timedelta),
+            Self::PySubclass(py_timedelta) => Ok(py_timedelta),
+        }
+    }
 }
 
 impl From<Duration> for EitherTimedelta<'_> {
@@ -93,7 +115,7 @@ impl From<Duration> for EitherTimedelta<'_> {
     }
 }
 
-impl<'a> EitherTimedelta<'a> {
+impl EitherTimedelta<'_> {
     pub fn to_duration(&self) -> PyResult<Duration> {
         match self {
             Self::Raw(timedelta) => Ok(timedelta.clone()),
@@ -101,20 +123,12 @@ impl<'a> EitherTimedelta<'a> {
             Self::PySubclass(py_timedelta) => pytimedelta_subclass_as_duration(py_timedelta),
         }
     }
-
-    pub fn try_into_py(&self, py: Python<'a>) -> PyResult<Bound<'a, PyDelta>> {
-        match self {
-            Self::PyExact(timedelta) => Ok(timedelta.clone()),
-            Self::PySubclass(timedelta) => Ok(timedelta.clone()),
-            Self::Raw(duration) => duration_as_pytimedelta(py, duration),
-        }
-    }
 }
 
-impl<'a> TryFrom<&'_ Bound<'a, PyAny>> for EitherTimedelta<'a> {
+impl<'py> TryFrom<&'_ Bound<'py, PyAny>> for EitherTimedelta<'py> {
     type Error = PyErr;
 
-    fn try_from(value: &Bound<'a, PyAny>) -> PyResult<Self> {
+    fn try_from(value: &Bound<'py, PyAny>) -> PyResult<Self> {
         if let Ok(dt) = value.downcast_exact() {
             Ok(EitherTimedelta::PyExact(dt.clone()))
         } else {
@@ -200,17 +214,13 @@ pub fn pytime_as_time(py_time: &Bound<'_, PyAny>, py_dt: Option<&Bound<'_, PyAny
     })
 }
 
-impl EitherTime<'_> {
-    pub fn as_raw(&self) -> PyResult<Time> {
-        match self {
-            Self::Raw(time) => Ok(time.clone()),
-            Self::Py(py_time) => pytime_as_time(py_time, None),
-        }
-    }
+impl<'py> IntoPyObject<'py> for EitherTime<'py> {
+    type Target = PyTime;
+    type Output = Bound<'py, PyTime>;
+    type Error = PyErr;
 
-    pub fn try_into_py(self, py: Python<'_>) -> PyResult<PyObject> {
-        let time = match self {
-            Self::Py(time) => Ok(time),
+    fn into_pyobject(self, py: Python<'py>) -> PyResult<Self::Output> {
+        match self {
             Self::Raw(time) => PyTime::new(
                 py,
                 time.hour,
@@ -219,8 +229,17 @@ impl EitherTime<'_> {
                 time.microsecond,
                 time_as_tzinfo(py, &time)?.as_ref(),
             ),
-        }?;
-        Ok(time.into_py(py))
+            Self::Py(time) => Ok(time),
+        }
+    }
+}
+
+impl EitherTime<'_> {
+    pub fn as_raw(&self) -> PyResult<Time> {
+        match self {
+            Self::Raw(time) => Ok(time.clone()),
+            Self::Py(py_time) => pytime_as_time(py_time, None),
+        }
     }
 }
 
@@ -259,31 +278,36 @@ pub fn pydatetime_as_datetime(py_dt: &Bound<'_, PyAny>) -> PyResult<DateTime> {
     })
 }
 
-impl<'a> EitherDateTime<'a> {
+impl<'py> IntoPyObject<'py> for EitherDateTime<'py> {
+    type Target = PyDateTime;
+    type Output = Bound<'py, PyDateTime>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> PyResult<Self::Output> {
+        match self {
+            Self::Raw(dt) => PyDateTime::new(
+                py,
+                dt.date.year.into(),
+                dt.date.month,
+                dt.date.day,
+                dt.time.hour,
+                dt.time.minute,
+                dt.time.second,
+                dt.time.microsecond,
+                time_as_tzinfo(py, &dt.time)?.as_ref(),
+            ),
+            Self::Py(dt) => Ok(dt),
+        }
+    }
+}
+
+impl EitherDateTime<'_> {
     pub fn as_raw(&self) -> PyResult<DateTime> {
         match self {
             Self::Raw(dt) => Ok(dt.clone()),
             Self::Py(py_dt) => pydatetime_as_datetime(py_dt),
         }
     }
-
-    pub fn try_into_py(self, py: Python<'a>) -> PyResult<PyObject> {
-        let dt = match self {
-            Self::Raw(datetime) => PyDateTime::new(
-                py,
-                datetime.date.year.into(),
-                datetime.date.month,
-                datetime.date.day,
-                datetime.time.hour,
-                datetime.time.minute,
-                datetime.time.second,
-                datetime.time.microsecond,
-                time_as_tzinfo(py, &datetime.time)?.as_ref(),
-            )?,
-            Self::Py(dt) => dt.clone(),
-        };
-        Ok(dt.into_py(py))
-    }
 }
 
 pub fn bytes_as_date<'py>(input: &(impl Input<'py> + ?Sized), bytes: &[u8]) -> ValResult<EitherDate<'py>> {
@@ -502,7 +526,7 @@ pub fn float_as_duration(input: impl ToErrorValue, total_seconds: f64) -> ValRes
         .map_err(|err| map_timedelta_err(input, err))
 }
 
-#[pyclass(module = "pydantic_core._pydantic_core", extends = PyTzInfo)]
+#[pyclass(module = "pydantic_core._pydantic_core", extends = PyTzInfo, frozen)]
 #[derive(Clone)]
 #[cfg_attr(debug_assertions, derive(Debug))]
 pub struct TzInfo {
@@ -575,7 +599,7 @@ impl TzInfo {
             }
             let offset_seconds: f64 = offset_delta.call_method0(intern!(py, "total_seconds"))?.extract()?;
             let offset = offset_seconds.round() as i32;
-            Ok(op.matches(self.seconds.cmp(&offset)).into_py(py))
+            op.matches(self.seconds.cmp(&offset)).into_py_any(py)
         } else {
             Ok(py.NotImplemented())
         }
@@ -585,10 +609,9 @@ impl TzInfo {
         Py::new(py, self.clone())
     }
 
-    pub fn __reduce__(&self, py: Python) -> PyResult<PyObject> {
-        let args = (self.seconds,);
-        let cls = Py::new(py, self.clone())?.getattr(py, "__class__")?;
-        Ok((cls, args).into_py(py))
+    pub fn __reduce__<'py>(slf: &Bound<'py, Self>) -> PyResult<Bound<'py, PyTuple>> {
+        let args = (slf.get().seconds,);
+        (slf.get_type(), args).into_pyobject(slf.py())
     }
 }
 
diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index 3fcf2a003..5e31242b2 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -1,5 +1,6 @@
 use std::borrow::Cow;
 use std::cmp::Ordering;
+use std::convert::Infallible;
 use std::ops::Rem;
 use std::str::FromStr;
 
@@ -14,6 +15,7 @@ use pyo3::prelude::*;
 use pyo3::types::PyFunction;
 use pyo3::types::{PyBytes, PyComplex, PyFloat, PyFrozenSet, PyIterator, PyMapping, PySet, PyString};
 
+use pyo3::IntoPyObjectExt;
 use serde::{ser::Error, Serialize, Serializer};
 
 use crate::errors::{
@@ -506,6 +508,7 @@ pub fn py_string_str<'a>(py_str: &'a Bound<'_, PyString>) -> ValResult<&'a str>
 }
 
 #[cfg_attr(debug_assertions, derive(Debug))]
+#[derive(IntoPyObject)]
 pub enum EitherBytes<'a, 'py> {
     Cow(Cow<'a, [u8]>),
     Py(Bound<'py, PyBytes>),
@@ -545,25 +548,17 @@ impl EitherBytes<'_, '_> {
     }
 }
 
-impl IntoPy<PyObject> for EitherBytes<'_, '_> {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        match self {
-            EitherBytes::Cow(bytes) => PyBytes::new(py, &bytes).into_py(py),
-            EitherBytes::Py(py_bytes) => py_bytes.into_py(py),
-        }
-    }
-}
-
 #[cfg_attr(debug_assertions, derive(Debug))]
-pub enum EitherInt<'a> {
+#[derive(IntoPyObject)]
+pub enum EitherInt<'py> {
     I64(i64),
     U64(u64),
     BigInt(BigInt),
-    Py(Bound<'a, PyAny>),
+    Py(Bound<'py, PyAny>),
 }
 
-impl<'a> EitherInt<'a> {
-    pub fn upcast(py_any: &Bound<'a, PyAny>) -> ValResult<Self> {
+impl<'py> EitherInt<'py> {
+    pub fn upcast(py_any: &Bound<'py, PyAny>) -> ValResult<Self> {
         // Safety: we know that py_any is a python int
         if let Some(int_64) = extract_i64(py_any) {
             Ok(Self::I64(int_64))
@@ -573,18 +568,21 @@ impl<'a> EitherInt<'a> {
         }
     }
 
-    pub fn into_i64(self, py: Python<'a>) -> ValResult<i64> {
+    pub fn into_i64(self, py: Python<'py>) -> ValResult<i64> {
         match self {
             EitherInt::I64(i) => Ok(i),
             EitherInt::U64(u) => match i64::try_from(u) {
                 Ok(u) => Ok(u),
-                Err(_) => Err(ValError::new(ErrorTypeDefaults::IntParsingSize, u.into_py(py).bind(py))),
+                Err(_) => Err(ValError::new(
+                    ErrorTypeDefaults::IntParsingSize,
+                    u.into_bound_py_any(py)?,
+                )),
             },
             EitherInt::BigInt(u) => match i64::try_from(u) {
                 Ok(u) => Ok(u),
                 Err(e) => Err(ValError::new(
                     ErrorTypeDefaults::IntParsingSize,
-                    e.into_original().into_py(py).bind(py),
+                    e.into_original().into_bound_py_any(py)?,
                 )),
             },
             EitherInt::Py(i) => i
@@ -633,22 +631,11 @@ impl<'a> EitherInt<'a> {
     }
 }
 
-impl IntoPy<PyObject> for EitherInt<'_> {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        match self {
-            Self::I64(int) => int.into_py(py),
-            Self::U64(int) => int.into_py(py),
-            Self::BigInt(int) => int.into_py(py),
-            Self::Py(int) => int.into_py(py),
-        }
-    }
-}
-
 #[cfg_attr(debug_assertions, derive(Debug))]
-#[derive(Clone)]
-pub enum EitherFloat<'a> {
+#[derive(Clone, IntoPyObject)]
+pub enum EitherFloat<'py> {
     F64(f64),
-    Py(Bound<'a, PyFloat>),
+    Py(Bound<'py, PyFloat>),
 }
 
 impl EitherFloat<'_> {
@@ -660,16 +647,7 @@ impl EitherFloat<'_> {
     }
 }
 
-impl IntoPy<PyObject> for EitherFloat<'_> {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        match self {
-            Self::F64(float) => float.into_py(py),
-            Self::Py(float) => float.into_py(py),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Serialize)]
+#[derive(Debug, Clone, Serialize, IntoPyObject)]
 #[serde(untagged)]
 pub enum Int {
     I64(i64),
@@ -677,15 +655,6 @@ pub enum Int {
     Big(BigInt),
 }
 
-impl IntoPy<PyObject> for Int {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        match self {
-            Self::I64(i) => i.into_py(py),
-            Self::Big(big_i) => big_i.into_py(py),
-        }
-    }
-}
-
 // The default serialization for BigInt is some internal representation which roundtrips efficiently
 // but is not the JSON value which users would expect to see.
 fn serialize_bigint_as_number<S>(big_int: &BigInt, serializer: S) -> Result<S::Ok, S::Error>
@@ -747,28 +716,20 @@ impl ToPyObject for Int {
 }
 
 #[derive(Clone)]
-pub enum EitherComplex<'a> {
+pub enum EitherComplex<'py> {
     Complex([f64; 2]),
-    Py(Bound<'a, PyComplex>),
+    Py(Bound<'py, PyComplex>),
 }
 
-impl IntoPy<PyObject> for EitherComplex<'_> {
-    fn into_py(self, py: Python<'_>) -> PyObject {
-        match self {
-            Self::Complex(c) => PyComplex::from_doubles(py, c[0], c[1]).into_py(py),
-            Self::Py(c) => c.into_py(py),
-        }
-    }
-}
+impl<'py> IntoPyObject<'py> for EitherComplex<'py> {
+    type Target = PyComplex;
+    type Output = Bound<'py, PyComplex>;
+    type Error = Infallible;
 
-impl EitherComplex<'_> {
-    pub fn as_f64(&self, py: Python<'_>) -> [f64; 2] {
+    fn into_pyobject(self, py: Python<'py>) -> Result<Bound<'py, PyComplex>, Infallible> {
         match self {
-            EitherComplex::Complex(f) => *f,
-            EitherComplex::Py(f) => [
-                f.getattr(intern!(py, "real")).unwrap().extract().unwrap(),
-                f.getattr(intern!(py, "imag")).unwrap().extract().unwrap(),
-            ],
+            EitherComplex::Complex(c) => Ok(PyComplex::from_doubles(py, c[0], c[1])),
+            EitherComplex::Py(c) => Ok(c),
         }
     }
 }
diff --git a/src/serializers/computed_fields.rs b/src/serializers/computed_fields.rs
index 42f95f2f2..3f81a825c 100644
--- a/src/serializers/computed_fields.rs
+++ b/src/serializers/computed_fields.rs
@@ -135,10 +135,10 @@ impl ComputedField {
             .unwrap_or_else(|| property_name.clone());
         Ok(Self {
             property_name: property_name.extract()?,
-            property_name_py: property_name.into_py(py),
+            property_name_py: property_name.into(),
             serializer,
             alias: alias_py.extract()?,
-            alias_py: alias_py.into_py(py),
+            alias_py: alias_py.into(),
         })
     }
 
diff --git a/src/serializers/config.rs b/src/serializers/config.rs
index dca555c82..e2cf85a53 100644
--- a/src/serializers/config.rs
+++ b/src/serializers/config.rs
@@ -2,9 +2,9 @@ use std::borrow::Cow;
 use std::str::{from_utf8, FromStr, Utf8Error};
 
 use base64::Engine;
-use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::{PyDelta, PyDict, PyString};
+use pyo3::{intern, IntoPyObjectExt};
 
 use serde::ser::Error;
 
@@ -112,30 +112,30 @@ impl TimedeltaMode {
         py_timedelta.call_method0(intern!(py_timedelta.py(), "total_seconds"))
     }
 
-    pub fn either_delta_to_json(self, py: Python, either_delta: &EitherTimedelta) -> PyResult<PyObject> {
+    pub fn either_delta_to_json(self, py: Python, either_delta: EitherTimedelta) -> PyResult<PyObject> {
         match self {
             Self::Iso8601 => {
                 let d = either_delta.to_duration()?;
-                Ok(d.to_string().into_py(py))
+                d.to_string().into_py_any(py)
             }
             Self::Float => {
                 // convert to int via a py timedelta not duration since we know this this case the input would have
                 // been a py timedelta
-                let py_timedelta = either_delta.try_into_py(py)?;
+                let py_timedelta = either_delta.into_pyobject(py)?;
                 let seconds = Self::total_seconds(&py_timedelta)?;
-                Ok(seconds.into_py(py))
+                Ok(seconds.unbind())
             }
         }
     }
 
-    pub fn json_key<'py>(self, py: Python, either_delta: &EitherTimedelta) -> PyResult<Cow<'py, str>> {
+    pub fn json_key<'py>(self, py: Python, either_delta: EitherTimedelta) -> PyResult<Cow<'py, str>> {
         match self {
             Self::Iso8601 => {
                 let d = either_delta.to_duration()?;
                 Ok(d.to_string().into())
             }
             Self::Float => {
-                let py_timedelta = either_delta.try_into_py(py)?;
+                let py_timedelta = either_delta.into_pyobject(py)?;
                 let seconds: f64 = Self::total_seconds(&py_timedelta)?.extract()?;
                 Ok(seconds.to_string().into())
             }
@@ -145,7 +145,7 @@ impl TimedeltaMode {
     pub fn timedelta_serialize<S: serde::ser::Serializer>(
         self,
         py: Python,
-        either_delta: &EitherTimedelta,
+        either_delta: EitherTimedelta,
         serializer: S,
     ) -> Result<S::Ok, S::Error> {
         match self {
@@ -154,7 +154,7 @@ impl TimedeltaMode {
                 serializer.serialize_str(&d.to_string())
             }
             Self::Float => {
-                let py_timedelta = either_delta.try_into_py(py).map_err(py_err_se_err)?;
+                let py_timedelta = either_delta.into_pyobject(py).map_err(py_err_se_err)?;
                 let seconds = Self::total_seconds(&py_timedelta).map_err(py_err_se_err)?;
                 let seconds: f64 = seconds.extract().map_err(py_err_se_err)?;
                 serializer.serialize_f64(seconds)
diff --git a/src/serializers/fields.rs b/src/serializers/fields.rs
index 74dd5b6c9..c7fe4c253 100644
--- a/src/serializers/fields.rs
+++ b/src/serializers/fields.rs
@@ -383,7 +383,7 @@ impl TypeSerializer for GeneralFieldsSerializer {
             }
         }
         self.add_computed_fields_python(model, &output_dict, include, exclude, extra)?;
-        Ok(output_dict.into_py(py))
+        Ok(output_dict.into())
     }
 
     fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
diff --git a/src/serializers/infer.rs b/src/serializers/infer.rs
index 6e4688d3d..7c14a2a03 100644
--- a/src/serializers/infer.rs
+++ b/src/serializers/infer.rs
@@ -7,6 +7,7 @@ use pyo3::pybacked::PyBackedStr;
 use pyo3::types::PyComplex;
 use pyo3::types::{PyByteArray, PyBytes, PyDict, PyFrozenSet, PyIterator, PyList, PySet, PyString, PyTuple};
 
+use pyo3::IntoPyObjectExt;
 use serde::ser::{Error, Serialize, SerializeMap, SerializeSeq, Serializer};
 
 use crate::input::{EitherTimedelta, Int};
@@ -52,7 +53,7 @@ pub(crate) fn infer_to_python_known(
             return match mode {
                 SerMode::Json => Err(e),
                 // if recursion is detected by we're serializing to python, we just return the value
-                _ => Ok(value.into_py(py)),
+                _ => Ok(value.clone().unbind()),
             };
         }
     };
@@ -114,11 +115,11 @@ pub(crate) fn infer_to_python_known(
     let value = match extra.mode {
         SerMode::Json => match ob_type {
             // `bool` and `None` can't be subclasses, `ObType::Int`, `ObType::Float`, `ObType::Str` refer to exact types
-            ObType::None | ObType::Bool | ObType::Int | ObType::Str => value.into_py(py),
+            ObType::None | ObType::Bool | ObType::Int | ObType::Str => value.clone().unbind(),
             // have to do this to make sure subclasses of for example str are upcast to `str`
             ObType::IntSubclass => {
                 if let Some(i) = extract_int(value) {
-                    i.into_py(py)
+                    i.into_py_any(py)?
                 } else {
                     return py_err!(PyTypeError; "Expected int, got {}", safe_repr(value));
                 }
@@ -126,43 +127,39 @@ pub(crate) fn infer_to_python_known(
             ObType::Float | ObType::FloatSubclass => {
                 let v = value.extract::<f64>()?;
                 if (v.is_nan() || v.is_infinite()) && extra.config.inf_nan_mode == InfNanMode::Null {
-                    return Ok(py.None().into_py(py));
+                    return Ok(py.None());
                 }
-                v.into_py(py)
+                v.into_py_any(py)?
             }
-            ObType::Decimal => value.to_string().into_py(py),
+            ObType::Decimal => value.to_string().into_py_any(py)?,
             ObType::StrSubclass => PyString::new(py, value.downcast::<PyString>()?.to_str()?).into(),
             ObType::Bytes => extra
                 .config
                 .bytes_mode
-                .bytes_to_string(py, value.downcast::<PyBytes>()?.as_bytes())
-                .map(|s| s.into_py(py))?,
+                .bytes_to_string(py, value.downcast::<PyBytes>()?.as_bytes())?
+                .into_py_any(py)?,
             ObType::Bytearray => {
                 let py_byte_array = value.downcast::<PyByteArray>()?;
                 // Safety: the GIL is held while bytes_to_string is running; it doesn't run
                 // arbitrary Python code, so py_byte_array cannot be mutated.
                 let bytes = unsafe { py_byte_array.as_bytes() };
-                extra
-                    .config
-                    .bytes_mode
-                    .bytes_to_string(py, bytes)
-                    .map(|s| s.into_py(py))?
+                extra.config.bytes_mode.bytes_to_string(py, bytes)?.into_py_any(py)?
             }
             ObType::Tuple => {
                 let elements = serialize_seq_filter!(PyTuple);
-                PyList::new(py, elements)?.into_py(py)
+                PyList::new(py, elements)?.into()
             }
             ObType::List => {
                 let elements = serialize_seq_filter!(PyList);
-                PyList::new(py, elements)?.into_py(py)
+                PyList::new(py, elements)?.into()
             }
             ObType::Set => {
                 let elements = serialize_seq!(PySet);
-                PyList::new(py, elements)?.into_py(py)
+                PyList::new(py, elements)?.into()
             }
             ObType::Frozenset => {
                 let elements = serialize_seq!(PyFrozenSet);
-                PyList::new(py, elements)?.into_py(py)
+                PyList::new(py, elements)?.into()
             }
             ObType::Dict => {
                 let dict = value.downcast::<PyDict>()?;
@@ -172,34 +169,34 @@ pub(crate) fn infer_to_python_known(
             }
             ObType::Datetime => {
                 let iso_dt = super::type_serializers::datetime_etc::datetime_to_string(value.downcast()?)?;
-                iso_dt.into_py(py)
+                iso_dt.into_py_any(py)?
             }
             ObType::Date => {
                 let iso_date = super::type_serializers::datetime_etc::date_to_string(value.downcast()?)?;
-                iso_date.into_py(py)
+                iso_date.into_py_any(py)?
             }
             ObType::Time => {
                 let iso_time = super::type_serializers::datetime_etc::time_to_string(value.downcast()?)?;
-                iso_time.into_py(py)
+                iso_time.into_py_any(py)?
             }
             ObType::Timedelta => {
                 let either_delta = EitherTimedelta::try_from(value)?;
                 extra
                     .config
                     .timedelta_mode
-                    .either_delta_to_json(value.py(), &either_delta)?
+                    .either_delta_to_json(value.py(), either_delta)?
             }
             ObType::Url => {
                 let py_url: PyUrl = value.extract()?;
-                py_url.__str__().into_py(py)
+                py_url.__str__().into_py_any(py)?
             }
             ObType::MultiHostUrl => {
                 let py_url: PyMultiHostUrl = value.extract()?;
-                py_url.__str__().into_py(py)
+                py_url.__str__().into_py_any(py)?
             }
             ObType::Uuid => {
                 let uuid = super::type_serializers::uuid::uuid_to_string(value)?;
-                uuid.into_py(py)
+                uuid.into_py_any(py)?
             }
             ObType::PydanticSerializable => serialize_with_serializer()?,
             ObType::Dataclass => {
@@ -209,7 +206,7 @@ pub(crate) fn infer_to_python_known(
             }
             ObType::Enum => {
                 let v = value.getattr(intern!(py, "value"))?;
-                infer_to_python(&v, include, exclude, extra)?.into_py(py)
+                infer_to_python(&v, include, exclude, extra)?
             }
             ObType::Generator => {
                 let py_seq = value.downcast::<PyIterator>()?;
@@ -228,22 +225,22 @@ pub(crate) fn infer_to_python_known(
                         )?);
                     }
                 }
-                PyList::new(py, items)?.into_py(py)
+                PyList::new(py, items)?.into()
             }
             ObType::Complex => {
                 let v = value.downcast::<PyComplex>()?;
                 let complex_str = type_serializers::complex::complex_to_str(v);
-                complex_str.into_py(py)
+                complex_str.into_py_any(py)?
             }
-            ObType::Path => value.str()?.into_py(py),
-            ObType::Pattern => value.getattr(intern!(py, "pattern"))?.into_py(py),
+            ObType::Path => value.str()?.into_py_any(py)?,
+            ObType::Pattern => value.getattr(intern!(py, "pattern"))?.unbind(),
             ObType::Unknown => {
                 if let Some(fallback) = extra.fallback {
                     let next_value = fallback.call1((value,))?;
                     let next_result = infer_to_python(&next_value, include, exclude, extra);
                     return next_result;
                 } else if extra.serialize_unknown {
-                    serialize_unknown(value).into_py(py)
+                    serialize_unknown(value).into_py_any(py)?
                 } else {
                     return Err(unknown_type_error(value));
                 }
@@ -252,19 +249,19 @@ pub(crate) fn infer_to_python_known(
         _ => match ob_type {
             ObType::Tuple => {
                 let elements = serialize_seq_filter!(PyTuple);
-                PyTuple::new(py, elements)?.into_py(py)
+                PyTuple::new(py, elements)?.into()
             }
             ObType::List => {
                 let elements = serialize_seq_filter!(PyList);
-                PyList::new(py, elements)?.into_py(py)
+                PyList::new(py, elements)?.into()
             }
             ObType::Set => {
                 let elements = serialize_seq!(PySet);
-                PySet::new(py, &elements)?.into_py(py)
+                PySet::new(py, &elements)?.into()
             }
             ObType::Frozenset => {
                 let elements = serialize_seq!(PyFrozenSet);
-                PyFrozenSet::new(py, &elements)?.into_py(py)
+                PyFrozenSet::new(py, &elements)?.into()
             }
             ObType::Dict => {
                 let dict = value.downcast::<PyDict>()?;
@@ -281,11 +278,11 @@ pub(crate) fn infer_to_python_known(
                     exclude,
                     extra,
                 );
-                iter.into_py(py)
+                iter.into_py_any(py)?
             }
             ObType::Complex => {
                 let v = value.downcast::<PyComplex>()?;
-                v.into_py(py)
+                v.into_py_any(py)?
             }
             ObType::Unknown => {
                 if let Some(fallback) = extra.fallback {
@@ -293,9 +290,9 @@ pub(crate) fn infer_to_python_known(
                     let next_result = infer_to_python(&next_value, include, exclude, extra);
                     return next_result;
                 }
-                value.into_py(py)
+                value.clone().unbind()
             }
-            _ => value.into_py(py),
+            _ => value.clone().unbind(),
         },
     };
     Ok(value)
@@ -470,7 +467,7 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
             extra
                 .config
                 .timedelta_mode
-                .timedelta_serialize(value.py(), &either_delta, serializer)
+                .timedelta_serialize(value.py(), either_delta, serializer)
         }
         ObType::Url => {
             let py_url: PyUrl = value.extract().map_err(py_err_se_err)?;
@@ -643,7 +640,7 @@ pub(crate) fn infer_json_key_known<'a>(
         }
         ObType::Timedelta => {
             let either_delta = EitherTimedelta::try_from(key)?;
-            extra.config.timedelta_mode.json_key(key.py(), &either_delta)
+            extra.config.timedelta_mode.json_key(key.py(), either_delta)
         }
         ObType::Url => {
             let py_url: PyUrl = key.extract()?;
@@ -720,7 +717,7 @@ fn serialize_pairs_python<'py>(
             new_dict.set_item(k, v)?;
         }
     }
-    Ok(new_dict.into_py(py))
+    Ok(new_dict.into())
 }
 
 fn serialize_pairs_json<'py, S: Serializer>(
diff --git a/src/serializers/shared.rs b/src/serializers/shared.rs
index 9ffdc1dab..f37810657 100644
--- a/src/serializers/shared.rs
+++ b/src/serializers/shared.rs
@@ -387,7 +387,7 @@ where
 
     let next = move |(field_name, field): (Bound<'py, PyAny>, Bound<'py, PyAny>)| -> PyResult<Option<(Bound<'py, PyAny>, Bound<'py, PyAny>)>> {
         let field_type = field.getattr(intern!(py, "_field_type"))?;
-        if field_type.is(&field_type_marker) {
+        if field_type.is(field_type_marker) {
             let value = dataclass.getattr(field_name.downcast::<PyString>()?)?;
             Ok(Some((field_name, value)))
         } else {
@@ -401,9 +401,6 @@ where
 static DC_FIELD_MARKER: GILOnceCell<PyObject> = GILOnceCell::new();
 
 /// needed to match the logic from dataclasses.fields `tuple(f for f in fields.values() if f._field_type is _FIELD)`
-fn get_field_marker(py: Python<'_>) -> PyResult<Bound<'_, PyAny>> {
-    let field_type_marker_obj = DC_FIELD_MARKER.get_or_try_init(py, || {
-        py.import("dataclasses")?.getattr("_FIELD").map(|f| f.into_py(py))
-    })?;
-    Ok(field_type_marker_obj.bind(py).clone())
+fn get_field_marker(py: Python<'_>) -> PyResult<&Bound<'_, PyAny>> {
+    DC_FIELD_MARKER.import(py, "dataclasses", "_FIELD")
 }
diff --git a/src/serializers/type_serializers/bytes.rs b/src/serializers/type_serializers/bytes.rs
index fa17b941a..86adbbdf6 100644
--- a/src/serializers/type_serializers/bytes.rs
+++ b/src/serializers/type_serializers/bytes.rs
@@ -1,7 +1,7 @@
 use std::borrow::Cow;
 
-use pyo3::prelude::*;
 use pyo3::types::{PyBytes, PyDict};
+use pyo3::{prelude::*, IntoPyObjectExt};
 
 use crate::definitions::DefinitionsBuilder;
 use crate::serializers::config::{BytesMode, FromConfig};
@@ -44,9 +44,9 @@ impl TypeSerializer for BytesSerializer {
             Ok(py_bytes) => match extra.mode {
                 SerMode::Json => self
                     .bytes_mode
-                    .bytes_to_string(py, py_bytes.as_bytes())
-                    .map(|s| s.into_py(py)),
-                _ => Ok(value.into_py(py)),
+                    .bytes_to_string(py, py_bytes.as_bytes())?
+                    .into_py_any(py),
+                _ => Ok(value.clone().unbind()),
             },
             Err(_) => {
                 extra.warnings.on_fallback_py(self.get_name(), value, extra)?;
diff --git a/src/serializers/type_serializers/complex.rs b/src/serializers/type_serializers/complex.rs
index 9847a25f5..1ec047395 100644
--- a/src/serializers/type_serializers/complex.rs
+++ b/src/serializers/type_serializers/complex.rs
@@ -1,7 +1,7 @@
 use std::borrow::Cow;
 
-use pyo3::prelude::*;
 use pyo3::types::{PyComplex, PyDict};
+use pyo3::{prelude::*, IntoPyObjectExt};
 
 use crate::definitions::DefinitionsBuilder;
 
@@ -33,10 +33,10 @@ impl TypeSerializer for ComplexSerializer {
     ) -> PyResult<PyObject> {
         let py = value.py();
         match value.downcast::<PyComplex>() {
-            Ok(py_complex) => Ok(match extra.mode {
-                SerMode::Json => complex_to_str(py_complex).into_py(py),
-                _ => value.into_py(py),
-            }),
+            Ok(py_complex) => match extra.mode {
+                SerMode::Json => complex_to_str(py_complex).into_py_any(py),
+                _ => Ok(value.clone().unbind()),
+            },
             Err(_) => {
                 extra.warnings.on_fallback_py(self.get_name(), value, extra)?;
                 infer_to_python(value, include, exclude, extra)
diff --git a/src/serializers/type_serializers/dataclass.rs b/src/serializers/type_serializers/dataclass.rs
index d85dd2f17..e5cf15199 100644
--- a/src/serializers/type_serializers/dataclass.rs
+++ b/src/serializers/type_serializers/dataclass.rs
@@ -89,7 +89,7 @@ impl BuildSerializer for DataclassSerializer {
         let fields = schema
             .get_as_req::<Bound<'_, PyList>>(intern!(py, "fields"))?
             .iter()
-            .map(|s| Ok(s.downcast::<PyString>()?.into_py(py)))
+            .map(|s| Ok(s.downcast_into::<PyString>()?.unbind()))
             .collect::<PyResult<Vec<_>>>()?;
 
         Ok(Self {
@@ -155,7 +155,7 @@ impl TypeSerializer for DataclassSerializer {
                 )?;
 
                 fields_serializer.add_computed_fields_python(model, &output_dict, include, exclude, extra)?;
-                Ok(output_dict.into_py(py))
+                Ok(output_dict.into())
             } else {
                 let inner_value = self.get_inner_value(value)?;
                 self.serializer.to_python(&inner_value, include, exclude, &dc_extra)
diff --git a/src/serializers/type_serializers/datetime_etc.rs b/src/serializers/type_serializers/datetime_etc.rs
index 957fbcf29..3486b5999 100644
--- a/src/serializers/type_serializers/datetime_etc.rs
+++ b/src/serializers/type_serializers/datetime_etc.rs
@@ -2,6 +2,7 @@ use std::borrow::Cow;
 
 use pyo3::prelude::*;
 use pyo3::types::{PyDate, PyDateTime, PyDict, PyTime};
+use pyo3::IntoPyObjectExt;
 
 use crate::definitions::DefinitionsBuilder;
 use crate::input::{pydate_as_date, pydatetime_as_datetime, pytime_as_time};
@@ -68,9 +69,9 @@ macro_rules! build_serializer {
                     Ok(py_value) => match extra.mode {
                         SerMode::Json => {
                             let s = $convert_func(py_value)?;
-                            Ok(s.into_py(py))
+                            s.into_py_any(py)
                         }
-                        _ => Ok(value.into_py(py)),
+                        _ => Ok(value.clone().unbind()),
                     },
                     Err(_) => {
                         extra.warnings.on_fallback_py(self.get_name(), value, extra)?;
diff --git a/src/serializers/type_serializers/dict.rs b/src/serializers/type_serializers/dict.rs
index 37f156b37..feb45090c 100644
--- a/src/serializers/type_serializers/dict.rs
+++ b/src/serializers/type_serializers/dict.rs
@@ -4,6 +4,7 @@ use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
 
+use pyo3::IntoPyObjectExt;
 use serde::ser::SerializeMap;
 
 use crate::definitions::DefinitionsBuilder;
@@ -88,7 +89,7 @@ impl TypeSerializer for DictSerializer {
                     let op_next = self.filter.key_filter(&key, include, exclude)?;
                     if let Some((next_include, next_exclude)) = op_next {
                         let key = match extra.mode {
-                            SerMode::Json => self.key_serializer.json_key(&key, extra)?.into_py(py),
+                            SerMode::Json => self.key_serializer.json_key(&key, extra)?.into_py_any(py)?,
                             _ => self.key_serializer.to_python(&key, None, None, extra)?,
                         };
                         let value =
@@ -96,7 +97,7 @@ impl TypeSerializer for DictSerializer {
                         new_dict.set_item(key, value)?;
                     }
                 }
-                Ok(new_dict.into_py(py))
+                Ok(new_dict.into())
             }
             Err(_) => {
                 extra.warnings.on_fallback_py(self.get_name(), value, extra)?;
diff --git a/src/serializers/type_serializers/enum_.rs b/src/serializers/type_serializers/enum_.rs
index 8a604e772..d2dc40314 100644
--- a/src/serializers/type_serializers/enum_.rs
+++ b/src/serializers/type_serializers/enum_.rs
@@ -67,7 +67,7 @@ impl TypeSerializer for EnumSerializer {
                 }
             } else {
                 // if we're not in JSON mode, we assume the value is safe to return directly
-                Ok(value.into_py(py))
+                Ok(value.clone().unbind())
             }
         } else {
             extra.warnings.on_fallback_py(self.get_name(), value, extra)?;
diff --git a/src/serializers/type_serializers/float.rs b/src/serializers/type_serializers/float.rs
index c6f80c2ca..69626e5ef 100644
--- a/src/serializers/type_serializers/float.rs
+++ b/src/serializers/type_serializers/float.rs
@@ -73,7 +73,7 @@ impl TypeSerializer for FloatSerializer {
     ) -> PyResult<PyObject> {
         let py = value.py();
         match extra.ob_type_lookup.is_type(value, ObType::Float) {
-            IsType::Exact => Ok(value.into_py(py)),
+            IsType::Exact => Ok(value.clone().unbind()),
             IsType::Subclass => match extra.check {
                 SerCheck::Strict => Err(PydanticSerializationUnexpectedValue::new_err(None)),
                 SerCheck::Lax | SerCheck::None => match extra.mode {
diff --git a/src/serializers/type_serializers/format.rs b/src/serializers/type_serializers/format.rs
index 959efb36c..cd90bdd7e 100644
--- a/src/serializers/type_serializers/format.rs
+++ b/src/serializers/type_serializers/format.rs
@@ -77,7 +77,7 @@ impl BuildSerializer for FormatSerializer {
                 format_func: py
                     .import(intern!(py, "builtins"))?
                     .getattr(intern!(py, "format"))?
-                    .into_py(py),
+                    .unbind(),
                 formatting_string: formatting_string.unbind(),
                 when_used: WhenUsed::new(schema, WhenUsed::JsonUnlessNone)?,
             }
@@ -117,7 +117,7 @@ impl TypeSerializer for FormatSerializer {
         if self.when_used.should_use(value, extra) {
             self.call(value).map_err(PydanticSerializationError::new_err)
         } else {
-            Ok(value.into_py(value.py()))
+            Ok(value.clone().unbind())
         }
     }
 
@@ -191,9 +191,9 @@ impl TypeSerializer for ToStringSerializer {
         extra: &Extra,
     ) -> PyResult<PyObject> {
         if self.when_used.should_use(value, extra) {
-            value.str().map(|s| s.into_py(value.py()))
+            value.str().map(Into::into)
         } else {
-            Ok(value.into_py(value.py()))
+            Ok(value.clone().unbind())
         }
     }
 
diff --git a/src/serializers/type_serializers/function.rs b/src/serializers/type_serializers/function.rs
index ec459a373..1214a666d 100644
--- a/src/serializers/type_serializers/function.rs
+++ b/src/serializers/type_serializers/function.rs
@@ -127,7 +127,7 @@ impl BuildSerializer for FunctionPlainSerializer {
 
         let name = format!("plain_function[{function_name}]");
         Ok(Self {
-            func: function.into_py(py),
+            func: function.unbind(),
             function_name,
             name,
             return_serializer,
@@ -153,7 +153,7 @@ impl FunctionPlainSerializer {
             let v = if self.is_field_serializer {
                 if let Some(model) = extra.model {
                     if self.info_arg {
-                        let info = SerializationInfo::new(py, include, exclude, extra, self.is_field_serializer)?;
+                        let info = SerializationInfo::new(include, exclude, extra, self.is_field_serializer)?;
                         self.func.call1(py, (model, value, info))?
                     } else {
                         self.func.call1(py, (model, value))?
@@ -162,14 +162,14 @@ impl FunctionPlainSerializer {
                     return Err(PyRuntimeError::new_err("Function plain serializer expected to be run inside the context of a model field but no model was found"));
                 }
             } else if self.info_arg {
-                let info = SerializationInfo::new(py, include, exclude, extra, self.is_field_serializer)?;
+                let info = SerializationInfo::new(include, exclude, extra, self.is_field_serializer)?;
                 self.func.call1(py, (value, info))?
             } else {
                 self.func.call1(py, (value,))?
             };
             Ok((true, v))
         } else {
-            Ok((false, value.into_py(py)))
+            Ok((false, value.clone().unbind()))
         }
     }
 
@@ -371,7 +371,7 @@ impl BuildSerializer for FunctionWrapSerializer {
         let name = format!("wrap_function[{function_name}, {}]", serializer.get_name());
         Ok(Self {
             serializer: Arc::new(serializer),
-            func: function.into_py(py),
+            func: function.into(),
             function_name,
             name,
             return_serializer: Arc::new(return_serializer),
@@ -393,11 +393,11 @@ impl FunctionWrapSerializer {
     ) -> PyResult<(bool, PyObject)> {
         let py = value.py();
         if self.when_used.should_use(value, extra) {
-            let serialize = SerializationCallable::new(py, &self.serializer, include, exclude, extra);
+            let serialize = SerializationCallable::new(&self.serializer, include, exclude, extra);
             let v = if self.is_field_serializer {
                 if let Some(model) = extra.model {
                     if self.info_arg {
-                        let info = SerializationInfo::new(py, include, exclude, extra, self.is_field_serializer)?;
+                        let info = SerializationInfo::new(include, exclude, extra, self.is_field_serializer)?;
                         self.func.call1(py, (model, value, serialize, info))?
                     } else {
                         self.func.call1(py, (model, value, serialize))?
@@ -406,14 +406,14 @@ impl FunctionWrapSerializer {
                     return Err(PyRuntimeError::new_err("Function wrap serializer expected to be run inside the context of a model field but no model was found"));
                 }
             } else if self.info_arg {
-                let info = SerializationInfo::new(py, include, exclude, extra, self.is_field_serializer)?;
+                let info = SerializationInfo::new(include, exclude, extra, self.is_field_serializer)?;
                 self.func.call1(py, (value, serialize, info))?
             } else {
                 self.func.call1(py, (value, serialize))?
             };
             Ok((true, v))
         } else {
-            Ok((false, value.into_py(py)))
+            Ok((false, value.clone().unbind()))
         }
     }
 
@@ -446,7 +446,6 @@ pub(crate) struct SerializationCallable {
 
 impl SerializationCallable {
     pub fn new(
-        py: Python,
         serializer: &Arc<CombinedSerializer>,
         include: Option<&Bound<'_, PyAny>>,
         exclude: Option<&Bound<'_, PyAny>>,
@@ -456,8 +455,8 @@ impl SerializationCallable {
             serializer: serializer.clone(),
             extra_owned: ExtraOwned::new(extra),
             filter: AnyFilter::new(),
-            include: include.map(|v| v.into_py(py)),
-            exclude: exclude.map(|v| v.into_py(py)),
+            include: include.map(|v| v.clone().unbind()),
+            exclude: exclude.map(|v| v.clone().unbind()),
         }
     }
 
@@ -563,7 +562,6 @@ struct SerializationInfo {
 
 impl SerializationInfo {
     fn new(
-        py: Python,
         include: Option<&Bound<'_, PyAny>>,
         exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
@@ -572,9 +570,9 @@ impl SerializationInfo {
         if is_field_serializer {
             match extra.field_name {
                 Some(field_name) => Ok(Self {
-                    include: include.map(|i| i.into_py(py)),
-                    exclude: exclude.map(|e| e.into_py(py)),
-                    context: extra.context.map(|c| c.into_py(py)),
+                    include: include.map(|i| i.clone().unbind()),
+                    exclude: exclude.map(|e| e.clone().unbind()),
+                    context: extra.context.map(|c| c.clone().unbind()),
                     _mode: extra.mode.clone(),
                     by_alias: extra.by_alias,
                     exclude_unset: extra.exclude_unset,
@@ -590,9 +588,9 @@ impl SerializationInfo {
             }
         } else {
             Ok(Self {
-                include: include.map(|i| i.into_py(py)),
-                exclude: exclude.map(|e| e.into_py(py)),
-                context: extra.context.map(|c| c.into_py(py)),
+                include: include.map(|i| i.clone().unbind()),
+                exclude: exclude.map(|e| e.clone().unbind()),
+                context: extra.context.map(|c| c.clone().unbind()),
                 _mode: extra.mode.clone(),
                 by_alias: extra.by_alias,
                 exclude_unset: extra.exclude_unset,
diff --git a/src/serializers/type_serializers/generator.rs b/src/serializers/type_serializers/generator.rs
index 94065aae8..86379bade 100644
--- a/src/serializers/type_serializers/generator.rs
+++ b/src/serializers/type_serializers/generator.rs
@@ -5,6 +5,7 @@ use pyo3::gc::PyVisit;
 use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyIterator};
+use pyo3::IntoPyObjectExt;
 use pyo3::PyTraverseError;
 
 use serde::ser::SerializeSeq;
@@ -78,7 +79,7 @@ impl TypeSerializer for GeneratorSerializer {
                                 )?);
                             }
                         }
-                        Ok(items.into_py(py))
+                        items.into_py_any(py)
                     }
                     _ => {
                         let iter = SerializationIterator::new(
@@ -89,7 +90,7 @@ impl TypeSerializer for GeneratorSerializer {
                             exclude,
                             extra,
                         );
-                        Ok(iter.into_py(py))
+                        iter.into_py_any(py)
                     }
                 }
             }
diff --git a/src/serializers/type_serializers/list.rs b/src/serializers/type_serializers/list.rs
index 713ce4f86..20947e222 100644
--- a/src/serializers/type_serializers/list.rs
+++ b/src/serializers/type_serializers/list.rs
@@ -4,6 +4,7 @@ use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList};
 
+use pyo3::IntoPyObjectExt;
 use serde::ser::SerializeSeq;
 
 use crate::definitions::DefinitionsBuilder;
@@ -72,7 +73,7 @@ impl TypeSerializer for ListSerializer {
                         )?);
                     }
                 }
-                Ok(items.into_py(py))
+                items.into_py_any(py)
             }
             Err(_) => {
                 extra.warnings.on_fallback_py(self.get_name(), value, extra)?;
diff --git a/src/serializers/type_serializers/nullable.rs b/src/serializers/type_serializers/nullable.rs
index fb63384d1..249410f16 100644
--- a/src/serializers/type_serializers/nullable.rs
+++ b/src/serializers/type_serializers/nullable.rs
@@ -42,7 +42,7 @@ impl TypeSerializer for NullableSerializer {
     ) -> PyResult<PyObject> {
         let py = value.py();
         match extra.ob_type_lookup.is_type(value, ObType::None) {
-            IsType::Exact => Ok(py.None().into_py(py)),
+            IsType::Exact => Ok(py.None()),
             // I don't think subclasses of None can exist
             _ => self.serializer.to_python(value, include, exclude, extra),
         }
diff --git a/src/serializers/type_serializers/set_frozenset.rs b/src/serializers/type_serializers/set_frozenset.rs
index 6356c8c1b..08f54c893 100644
--- a/src/serializers/type_serializers/set_frozenset.rs
+++ b/src/serializers/type_serializers/set_frozenset.rs
@@ -1,8 +1,8 @@
 use std::borrow::Cow;
 
-use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyFrozenSet, PyList, PySet};
+use pyo3::{intern, IntoPyObjectExt};
 
 use serde::ser::SerializeSeq;
 
@@ -65,8 +65,8 @@ macro_rules! build_serializer {
                             items.push(item_serializer.to_python(&element, include, exclude, extra)?);
                         }
                         match extra.mode {
-                            SerMode::Json => Ok(PyList::new(py, items)?.into_py(py)),
-                            _ => Ok(<$py_type>::new(py, &items)?.into_py(py)),
+                            SerMode::Json => Ok(PyList::new(py, items)?.into()),
+                            _ => <$py_type>::new(py, &items)?.into_py_any(py),
                         }
                     }
                     Err(_) => {
diff --git a/src/serializers/type_serializers/simple.rs b/src/serializers/type_serializers/simple.rs
index 5df8ec071..fa000e21f 100644
--- a/src/serializers/type_serializers/simple.rs
+++ b/src/serializers/type_serializers/simple.rs
@@ -44,7 +44,7 @@ impl TypeSerializer for NoneSerializer {
     ) -> PyResult<PyObject> {
         let py = value.py();
         match extra.ob_type_lookup.is_type(value, ObType::None) {
-            IsType::Exact => Ok(py.None().into_py(py)),
+            IsType::Exact => Ok(py.None()),
             // I don't think subclasses of None can exist
             _ => {
                 extra.warnings.on_fallback_py(self.get_name(), value, extra)?;
@@ -120,7 +120,7 @@ macro_rules! build_simple_serializer {
             ) -> PyResult<PyObject> {
                 let py = value.py();
                 match extra.ob_type_lookup.is_type(value, $ob_type) {
-                    IsType::Exact => Ok(value.into_py(py)),
+                    IsType::Exact => Ok(value.clone().unbind()),
                     IsType::Subclass => match extra.check {
                         SerCheck::Strict => Err(PydanticSerializationUnexpectedValue::new_err(None)),
                         SerCheck::Lax | SerCheck::None => match extra.mode {
diff --git a/src/serializers/type_serializers/string.rs b/src/serializers/type_serializers/string.rs
index 9e9a7162e..bdf64e1a1 100644
--- a/src/serializers/type_serializers/string.rs
+++ b/src/serializers/type_serializers/string.rs
@@ -1,7 +1,7 @@
 use std::borrow::Cow;
 
-use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyString};
+use pyo3::{prelude::*, IntoPyObjectExt};
 
 use crate::definitions::DefinitionsBuilder;
 
@@ -43,10 +43,10 @@ impl TypeSerializer for StrSerializer {
     ) -> PyResult<PyObject> {
         let py = value.py();
         match extra.ob_type_lookup.is_type(value, ObType::Str) {
-            IsType::Exact => Ok(value.into_py(py)),
+            IsType::Exact => Ok(value.clone().unbind()),
             IsType::Subclass => match extra.mode {
-                SerMode::Json => Ok(value.downcast::<PyString>()?.to_str()?.into_py(py)),
-                _ => Ok(value.into_py(py)),
+                SerMode::Json => value.downcast::<PyString>()?.to_str()?.into_py_any(py),
+                _ => Ok(value.clone().unbind()),
             },
             IsType::False => {
                 extra.warnings.on_fallback_py(self.get_name(), value, extra)?;
diff --git a/src/serializers/type_serializers/timedelta.rs b/src/serializers/type_serializers/timedelta.rs
index a62b595d0..f1fb99da7 100644
--- a/src/serializers/type_serializers/timedelta.rs
+++ b/src/serializers/type_serializers/timedelta.rs
@@ -42,7 +42,7 @@ impl TypeSerializer for TimeDeltaSerializer {
     ) -> PyResult<PyObject> {
         match extra.mode {
             SerMode::Json => match EitherTimedelta::try_from(value) {
-                Ok(either_timedelta) => self.timedelta_mode.either_delta_to_json(value.py(), &either_timedelta),
+                Ok(either_timedelta) => self.timedelta_mode.either_delta_to_json(value.py(), either_timedelta),
                 Err(_) => {
                     extra.warnings.on_fallback_py(self.get_name(), value, extra)?;
                     infer_to_python(value, include, exclude, extra)
@@ -54,7 +54,7 @@ impl TypeSerializer for TimeDeltaSerializer {
 
     fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
         match EitherTimedelta::try_from(key) {
-            Ok(either_timedelta) => self.timedelta_mode.json_key(key.py(), &either_timedelta),
+            Ok(either_timedelta) => self.timedelta_mode.json_key(key.py(), either_timedelta),
             Err(_) => {
                 extra.warnings.on_fallback_py(self.get_name(), key, extra)?;
                 infer_json_key(key, extra)
@@ -73,7 +73,7 @@ impl TypeSerializer for TimeDeltaSerializer {
         match EitherTimedelta::try_from(value) {
             Ok(either_timedelta) => self
                 .timedelta_mode
-                .timedelta_serialize(value.py(), &either_timedelta, serializer),
+                .timedelta_serialize(value.py(), either_timedelta, serializer),
             Err(_) => {
                 extra.warnings.on_fallback_ser::<S>(self.get_name(), value, extra)?;
                 infer_serialize(value, serializer, include, exclude, extra)
diff --git a/src/serializers/type_serializers/tuple.rs b/src/serializers/type_serializers/tuple.rs
index 87ff4002c..1d8057475 100644
--- a/src/serializers/type_serializers/tuple.rs
+++ b/src/serializers/type_serializers/tuple.rs
@@ -82,8 +82,8 @@ impl TypeSerializer for TupleSerializer {
                 })??;
 
                 match extra.mode {
-                    SerMode::Json => Ok(PyList::new(py, items)?.into_py(py)),
-                    _ => Ok(PyTuple::new(py, items)?.into_py(py)),
+                    SerMode::Json => Ok(PyList::new(py, items)?.into()),
+                    _ => Ok(PyTuple::new(py, items)?.into()),
                 }
             }
             Err(_) => {
diff --git a/src/serializers/type_serializers/url.rs b/src/serializers/type_serializers/url.rs
index 2ed2af739..1e697d78b 100644
--- a/src/serializers/type_serializers/url.rs
+++ b/src/serializers/type_serializers/url.rs
@@ -2,6 +2,7 @@ use std::borrow::Cow;
 
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
+use pyo3::IntoPyObjectExt;
 
 use crate::definitions::DefinitionsBuilder;
 
@@ -42,8 +43,8 @@ macro_rules! build_serializer {
                 let py = value.py();
                 match value.extract::<$extract>() {
                     Ok(py_url) => match extra.mode {
-                        SerMode::Json => Ok(py_url.__str__().into_py(py)),
-                        _ => Ok(value.into_py(py)),
+                        SerMode::Json => py_url.__str__().into_py_any(py),
+                        _ => Ok(value.clone().unbind()),
                     },
                     Err(_) => {
                         extra.warnings.on_fallback_py(self.get_name(), value, extra)?;
diff --git a/src/serializers/type_serializers/uuid.rs b/src/serializers/type_serializers/uuid.rs
index 01627c27c..35e62bddd 100644
--- a/src/serializers/type_serializers/uuid.rs
+++ b/src/serializers/type_serializers/uuid.rs
@@ -1,7 +1,7 @@
 use std::borrow::Cow;
 
 use pyo3::types::PyDict;
-use pyo3::{intern, prelude::*};
+use pyo3::{intern, prelude::*, IntoPyObjectExt};
 use uuid::Uuid;
 
 use crate::definitions::DefinitionsBuilder;
@@ -46,8 +46,8 @@ impl TypeSerializer for UuidSerializer {
         let py = value.py();
         match extra.ob_type_lookup.is_type(value, ObType::Uuid) {
             IsType::Exact | IsType::Subclass => match extra.mode {
-                SerMode::Json => Ok(uuid_to_string(value)?.into_py(py)),
-                _ => Ok(value.into_py(py)),
+                SerMode::Json => uuid_to_string(value)?.into_py_any(py),
+                _ => Ok(value.clone().unbind()),
             },
             IsType::False => {
                 extra.warnings.on_fallback_py(self.get_name(), value, extra)?;
diff --git a/src/url.rs b/src/url.rs
index a4f3a83e5..05a13d518 100644
--- a/src/url.rs
+++ b/src/url.rs
@@ -8,7 +8,7 @@ use pyo3::exceptions::PyValueError;
 use pyo3::pyclass::CompareOp;
 use pyo3::sync::GILOnceCell;
 use pyo3::types::{PyDict, PyType};
-use pyo3::{intern, prelude::*};
+use pyo3::{intern, prelude::*, IntoPyObjectExt};
 use url::Url;
 
 use crate::tools::SchemaDict;
@@ -98,13 +98,13 @@ impl PyUrl {
         self.lib_url.query()
     }
 
-    pub fn query_params(&self, py: Python) -> PyObject {
+    pub fn query_params<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
         // `query_pairs` is a pure iterator, so can't implement `ExactSizeIterator`, hence we need the temporary `Vec`
         self.lib_url
             .query_pairs()
-            .map(|(key, value)| (key, value).into_py(py))
-            .collect::<Vec<PyObject>>()
-            .into_py(py)
+            .map(|(key, value)| (key, value).into_pyobject(py))
+            .collect::<PyResult<Vec<_>>>()?
+            .into_pyobject(py)
     }
 
     #[getter]
@@ -147,8 +147,8 @@ impl PyUrl {
     }
 
     #[pyo3(signature = (_memo, /))]
-    pub fn __deepcopy__(&self, py: Python, _memo: Bound<'_, PyAny>) -> Py<PyAny> {
-        self.clone().into_py(py)
+    pub fn __deepcopy__(&self, py: Python, _memo: Bound<'_, PyAny>) -> PyResult<Py<PyAny>> {
+        self.clone().into_py_any(py)
     }
 
     fn __getnewargs__(&self) -> (&str,) {
@@ -259,7 +259,7 @@ impl PyMultiHostUrl {
         self.ref_url.query()
     }
 
-    pub fn query_params(&self, py: Python) -> PyObject {
+    pub fn query_params<'py>(&self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
         self.ref_url.query_params(py)
     }
 
@@ -350,8 +350,8 @@ impl PyMultiHostUrl {
         true // an empty string is not a valid URL
     }
 
-    pub fn __deepcopy__(&self, py: Python, _memo: &Bound<'_, PyDict>) -> Py<PyAny> {
-        self.clone().into_py(py)
+    pub fn __deepcopy__(&self, py: Python, _memo: &Bound<'_, PyDict>) -> PyResult<Py<PyAny>> {
+        self.clone().into_py_any(py)
     }
 
     fn __getnewargs__(&self) -> (String,) {
diff --git a/src/validators/arguments.rs b/src/validators/arguments.rs
index e6a9d0415..b7172af90 100644
--- a/src/validators/arguments.rs
+++ b/src/validators/arguments.rs
@@ -106,7 +106,7 @@ impl BuildValidator for ArgumentsValidator {
                     }
                     None => Some(LookupKey::from_string(py, &name)),
                 };
-                kwarg_key = Some(py_name.into_py(py));
+                kwarg_key = Some(py_name.unbind());
             }
 
             let schema = arg.get_as_req(intern!(py, "schema"))?;
diff --git a/src/validators/bool.rs b/src/validators/bool.rs
index d09fbd5f0..1167bab5e 100644
--- a/src/validators/bool.rs
+++ b/src/validators/bool.rs
@@ -1,5 +1,5 @@
-use pyo3::prelude::*;
 use pyo3::types::PyDict;
+use pyo3::{prelude::*, IntoPyObjectExt};
 
 use crate::build_tools::is_strict;
 use crate::errors::ValResult;
@@ -40,7 +40,7 @@ impl Validator for BoolValidator {
         // and back again, might be worth profiling?
         input
             .validate_bool(state.strict_or(self.strict))
-            .map(|val_match| val_match.unpack(state).into_py(py))
+            .and_then(|val_match| Ok(val_match.unpack(state).into_py_any(py)?))
     }
 
     fn get_name(&self) -> &str {
diff --git a/src/validators/bytes.rs b/src/validators/bytes.rs
index c51d77171..b9cc2dc69 100644
--- a/src/validators/bytes.rs
+++ b/src/validators/bytes.rs
@@ -1,6 +1,7 @@
 use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
+use pyo3::IntoPyObjectExt;
 
 use crate::build_tools::is_strict;
 use crate::errors::{ErrorType, ValError, ValResult};
@@ -51,7 +52,7 @@ impl Validator for BytesValidator {
     ) -> ValResult<PyObject> {
         input
             .validate_bytes(state.strict_or(self.strict), self.bytes_mode)
-            .map(|m| m.unpack(state).into_py(py))
+            .and_then(|m| Ok(m.unpack(state).into_py_any(py)?))
     }
 
     fn get_name(&self) -> &str {
@@ -103,7 +104,7 @@ impl Validator for BytesConstrainedValidator {
                 ));
             }
         }
-        Ok(either_bytes.into_py(py))
+        Ok(either_bytes.into_py_any(py)?)
     }
 
     fn get_name(&self) -> &str {
diff --git a/src/validators/complex.rs b/src/validators/complex.rs
index d1d9f6c35..ff756707a 100644
--- a/src/validators/complex.rs
+++ b/src/validators/complex.rs
@@ -46,7 +46,7 @@ impl Validator for ComplexValidator {
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let res = input.validate_complex(self.strict, py)?.unpack(state);
-        Ok(res.into_py(py))
+        Ok(res.into_pyobject(py)?.into())
     }
 
     fn get_name(&self) -> &str {
diff --git a/src/validators/dataclass.rs b/src/validators/dataclass.rs
index 2bdd27b3c..07595baab 100644
--- a/src/validators/dataclass.rs
+++ b/src/validators/dataclass.rs
@@ -378,7 +378,7 @@ impl Validator for DataclassArgsValidator {
             // which doesn't make much sense in this context but we need to put something there
             // so that function validators that sit between DataclassValidator and DataclassArgsValidator
             // always get called the same shape of data.
-            Ok(PyTuple::new(py, vec![dict.to_object(py), py.None()])?.into_py(py))
+            Ok(PyTuple::new(py, vec![dict.to_object(py), py.None()])?.into())
         };
 
         if let Some(field) = self.fields.iter().find(|f| f.name == field_name) {
@@ -476,7 +476,7 @@ impl BuildValidator for DataclassValidator {
         let validator = build_validator(&sub_schema, config, definitions)?;
 
         let post_init = if schema.get_as::<bool>(intern!(py, "post_init"))?.unwrap_or(false) {
-            Some(intern!(py, "__post_init__").into_py(py))
+            Some(intern!(py, "__post_init__").clone().unbind())
         } else {
             None
         };
@@ -626,7 +626,7 @@ impl DataclassValidator {
 
         self.set_dict_call(py, self_instance, val_output, input)?;
 
-        Ok(self_instance.into_py(py))
+        Ok(self_instance.clone().unbind())
     }
 
     fn dataclass_to_dict<'py>(&self, dc: &Bound<'py, PyAny>) -> PyResult<Bound<'py, PyDict>> {
diff --git a/src/validators/date.rs b/src/validators/date.rs
index 75aefa935..b814dd1f6 100644
--- a/src/validators/date.rs
+++ b/src/validators/date.rs
@@ -1,6 +1,7 @@
 use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::{PyDate, PyDict, PyString};
+use pyo3::IntoPyObjectExt;
 use speedate::{Date, Time};
 use strum::EnumMessage;
 
@@ -97,7 +98,7 @@ impl Validator for DateValidator {
                 }
             }
         }
-        Ok(date.try_into_py(py)?)
+        Ok(date.into_py_any(py)?)
     }
 
     fn get_name(&self) -> &str {
diff --git a/src/validators/datetime.rs b/src/validators/datetime.rs
index 48537000f..2b3c7661a 100644
--- a/src/validators/datetime.rs
+++ b/src/validators/datetime.rs
@@ -2,6 +2,7 @@ use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::sync::GILOnceCell;
 use pyo3::types::{PyDict, PyString};
+use pyo3::IntoPyObjectExt;
 use speedate::{DateTime, Time};
 use std::cmp::Ordering;
 use strum::EnumMessage;
@@ -130,7 +131,7 @@ impl Validator for DateTimeValidator {
                 tz_constraint.tz_check(speedate_dt.time.tz_offset, input)?;
             }
         }
-        Ok(datetime.try_into_py(py)?)
+        Ok(datetime.into_py_any(py)?)
     }
 
     fn get_name(&self) -> &str {
@@ -247,10 +248,6 @@ pub struct NowConstraint {
 
 static TIME_LOCALTIME: GILOnceCell<PyObject> = GILOnceCell::new();
 
-fn get_localtime(py: Python) -> PyResult<PyObject> {
-    Ok(py.import("time")?.getattr("localtime")?.into_py(py))
-}
-
 impl NowConstraint {
     /// Get the UTC offset in seconds either from the utc_offset field or by calling `time.localtime().tm_gmtoff`.
     /// Note: although the attribute is called "gmtoff", it is actually the offset in the UTC direction,
@@ -259,8 +256,8 @@ impl NowConstraint {
         if let Some(utc_offset) = self.utc_offset {
             Ok(utc_offset)
         } else {
-            let localtime = TIME_LOCALTIME.get_or_init(py, || get_localtime(py).unwrap());
-            localtime.bind(py).call0()?.getattr(intern!(py, "tm_gmtoff"))?.extract()
+            let localtime = TIME_LOCALTIME.import(py, "time", "localtime")?;
+            localtime.call0()?.getattr(intern!(py, "tm_gmtoff"))?.extract()
         }
     }
 
diff --git a/src/validators/float.rs b/src/validators/float.rs
index 3a79de9fe..f2e662b08 100644
--- a/src/validators/float.rs
+++ b/src/validators/float.rs
@@ -3,6 +3,7 @@ use std::cmp::Ordering;
 use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
+use pyo3::IntoPyObjectExt;
 
 use crate::build_tools::{is_strict, schema_or_config_same};
 use crate::errors::{ErrorType, ErrorTypeDefaults, ValError, ValResult};
@@ -74,7 +75,7 @@ impl Validator for FloatValidator {
         if !self.allow_inf_nan && !either_float.as_f64().is_finite() {
             return Err(ValError::new(ErrorTypeDefaults::FiniteNumber, input));
         }
-        Ok(either_float.into_py(py))
+        Ok(either_float.into_py_any(py)?)
     }
 
     fn get_name(&self) -> &str {
@@ -164,7 +165,7 @@ impl Validator for ConstrainedFloatValidator {
                 ));
             }
         }
-        Ok(either_float.into_py(py))
+        Ok(either_float.into_py_any(py)?)
     }
 
     fn get_name(&self) -> &str {
diff --git a/src/validators/frozenset.rs b/src/validators/frozenset.rs
index 06859ff43..5bbd91a7b 100644
--- a/src/validators/frozenset.rs
+++ b/src/validators/frozenset.rs
@@ -1,5 +1,5 @@
-use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyFrozenSet};
+use pyo3::{prelude::*, IntoPyObjectExt};
 
 use crate::errors::ValResult;
 use crate::input::{validate_iter_to_set, BorrowInput, ConsumeIterator, Input, ValidatedSet};
@@ -46,7 +46,7 @@ impl Validator for FrozenSetValidator {
             fail_fast: self.fail_fast,
         })??;
         min_length_check!(input, "Frozenset", self.min_length, f_set);
-        Ok(f_set.into_py(py))
+        Ok(f_set.into_py_any(py)?)
     }
 
     fn get_name(&self) -> &str {
diff --git a/src/validators/function.rs b/src/validators/function.rs
index 8095d6298..512d4dcc2 100644
--- a/src/validators/function.rs
+++ b/src/validators/function.rs
@@ -346,7 +346,6 @@ impl Validator for FunctionWrapValidator {
     ) -> ValResult<PyObject> {
         let handler = ValidatorCallable {
             validator: InternalValidator::new(
-                py,
                 "ValidatorCallable",
                 self.validator.clone(),
                 state,
@@ -371,7 +370,6 @@ impl Validator for FunctionWrapValidator {
     ) -> ValResult<PyObject> {
         let handler = AssignmentValidatorCallable {
             validator: InternalValidator::new(
-                py,
                 "AssignmentValidatorCallable",
                 self.validator.clone(),
                 state,
@@ -464,7 +462,7 @@ macro_rules! py_err_string {
             Ok(py_string) => match py_string.to_str() {
                 Ok(_) => ValError::new(
                     ErrorType::$type_member {
-                        error: Some($py_err.into_py($py)),
+                        error: pyo3::IntoPyObjectExt::into_py_any($py_err, $py).ok(),
                         context: None,
                     },
                     $input,
diff --git a/src/validators/generator.rs b/src/validators/generator.rs
index 1e8d41c85..ba83e6d91 100644
--- a/src/validators/generator.rs
+++ b/src/validators/generator.rs
@@ -2,7 +2,7 @@ use std::fmt;
 use std::sync::Arc;
 
 use pyo3::types::PyDict;
-use pyo3::{prelude::*, PyTraverseError, PyVisit};
+use pyo3::{prelude::*, IntoPyObjectExt, PyTraverseError, PyVisit};
 
 use crate::errors::{ErrorType, LocItem, ValError, ValResult};
 use crate::input::{BorrowInput, GenericIterator, Input};
@@ -72,7 +72,6 @@ impl Validator for GeneratorValidator {
         let iterator = input.validate_iter()?.into_static();
         let validator = self.item_validator.as_ref().map(|v| {
             InternalValidator::new(
-                py,
                 "ValidatorIterator",
                 v.clone(),
                 state,
@@ -89,7 +88,7 @@ impl Validator for GeneratorValidator {
             hide_input_in_errors: self.hide_input_in_errors,
             validation_error_cause: self.validation_error_cause,
         };
-        Ok(v_iterator.into_py(py))
+        Ok(v_iterator.into_py_any(py)?)
     }
 
     fn get_name(&self) -> &str {
@@ -240,7 +239,6 @@ impl fmt::Debug for InternalValidator {
 
 impl InternalValidator {
     pub fn new(
-        py: Python,
         name: &str,
         validator: Arc<CombinedValidator>,
         state: &ValidationState,
@@ -254,8 +252,8 @@ impl InternalValidator {
             data: extra.data.as_ref().map(|d| d.clone().into()),
             strict: extra.strict,
             from_attributes: extra.from_attributes,
-            context: extra.context.map(|d| d.into_py(py)),
-            self_instance: extra.self_instance.map(|d| d.into_py(py)),
+            context: extra.context.map(|d| d.clone().unbind()),
+            self_instance: extra.self_instance.map(|d| d.clone().unbind()),
             recursion_guard: state.recursion_guard.clone(),
             exactness: state.exactness,
             validation_mode: extra.input_type,
diff --git a/src/validators/int.rs b/src/validators/int.rs
index e5b233322..806584c60 100644
--- a/src/validators/int.rs
+++ b/src/validators/int.rs
@@ -2,6 +2,7 @@ use num_bigint::BigInt;
 use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
+use pyo3::IntoPyObjectExt;
 
 use crate::build_tools::is_strict;
 use crate::errors::{ErrorType, ValError, ValResult};
@@ -51,7 +52,7 @@ impl Validator for IntValidator {
     ) -> ValResult<PyObject> {
         input
             .validate_int(state.strict_or(self.strict))
-            .map(|val_match| val_match.unpack(state).into_py(py))
+            .and_then(|val_match| Ok(val_match.unpack(state).into_py_any(py)?))
     }
 
     fn get_name(&self) -> &str {
@@ -136,7 +137,7 @@ impl Validator for ConstrainedIntValidator {
                 ));
             }
         }
-        Ok(either_int.into_py(py))
+        Ok(either_int.into_py_any(py)?)
     }
 
     fn get_name(&self) -> &str {
diff --git a/src/validators/list.rs b/src/validators/list.rs
index 87600fb81..96d4bf135 100644
--- a/src/validators/list.rs
+++ b/src/validators/list.rs
@@ -1,7 +1,7 @@
 use std::sync::OnceLock;
 
-use pyo3::prelude::*;
 use pyo3::types::PyDict;
+use pyo3::{prelude::*, IntoPyObjectExt};
 
 use crate::errors::ValResult;
 use crate::input::{
@@ -143,7 +143,7 @@ impl Validator for ListValidator {
                 if let Some(py_list) = seq.as_py_list() {
                     length_check!(input, "List", self.min_length, self.max_length, py_list);
                     let list_copy = py_list.get_slice(0, usize::MAX);
-                    return Ok(list_copy.into_py(py));
+                    return Ok(list_copy.into());
                 }
 
                 seq.iterate(ToVec {
@@ -156,7 +156,7 @@ impl Validator for ListValidator {
             }
         };
         min_length_check!(input, "List", self.min_length, output);
-        Ok(output.into_py(py))
+        Ok(output.into_py_any(py)?)
     }
 
     fn get_name(&self) -> &str {
diff --git a/src/validators/mod.rs b/src/validators/mod.rs
index b84ed811b..9bf568731 100644
--- a/src/validators/mod.rs
+++ b/src/validators/mod.rs
@@ -5,10 +5,10 @@ use jiter::{PartialMode, StringCacheMode};
 
 use pyo3::exceptions::PyTypeError;
 use pyo3::ffi::c_str;
-use pyo3::prelude::*;
 use pyo3::sync::GILOnceCell;
 use pyo3::types::{PyAny, PyDict, PyString, PyTuple, PyType};
 use pyo3::{intern, PyTraverseError, PyVisit};
+use pyo3::{prelude::*, IntoPyObjectExt};
 
 use crate::build_tools::{py_schema_err, py_schema_error_type, SchemaError};
 use crate::definitions::{Definitions, DefinitionsBuilder};
@@ -127,7 +127,7 @@ impl SchemaValidator {
 
         let validator = build_validator(schema, config, &mut definitions_builder)?;
         let definitions = definitions_builder.finish()?;
-        let py_schema = schema.into_py(py);
+        let py_schema = schema.clone().unbind();
         let py_config = match config {
             Some(c) if !c.is_empty() => Some(c.clone().into()),
             _ => None,
@@ -137,8 +137,8 @@ impl SchemaValidator {
             None => None,
         };
         let title = match config_title {
-            Some(t) => t.into_py(py),
-            None => validator.get_name().into_py(py),
+            Some(t) => t.unbind(),
+            None => validator.get_name().into_py_any(py)?,
         };
         let hide_input_in_errors: bool = config.get_as(intern!(py, "hide_input_in_errors"))?.unwrap_or(false);
         let validation_error_cause: bool = config.get_as(intern!(py, "validation_error_cause"))?.unwrap_or(false);
@@ -315,8 +315,8 @@ impl SchemaValidator {
         let r = self.validator.default_value(py, None::<i64>, &mut state);
         match r {
             Ok(maybe_default) => match maybe_default {
-                Some(v) => Ok(PySome::new(v).into_py(py)),
-                None => Ok(py.None().into_py(py)),
+                Some(v) => PySome::new(v).into_py_any(py),
+                None => Ok(py.None()),
             },
             Err(e) => Err(self.prepare_validation_err(py, e, InputType::Python)),
         }
@@ -462,7 +462,7 @@ impl<'py> SelfValidator<'py> {
             definitions,
             py_schema: py.None(),
             py_config: None,
-            title: "Self Schema".into_py(py),
+            title: "Self Schema".into_py_any(py)?,
             hide_input_in_errors: false,
             validation_error_cause: false,
             cache_str: true.into(),
diff --git a/src/validators/model.rs b/src/validators/model.rs
index fddbcee24..7dfb3b7cc 100644
--- a/src/validators/model.rs
+++ b/src/validators/model.rs
@@ -1,8 +1,8 @@
 use std::ptr::null_mut;
 
 use pyo3::exceptions::PyTypeError;
-use pyo3::ffi;
 use pyo3::types::{PyDict, PySet, PyString, PyTuple, PyType};
+use pyo3::{ffi, IntoPyObjectExt};
 use pyo3::{intern, prelude::*};
 
 use super::function::convert_err;
@@ -205,7 +205,7 @@ impl Validator for ModelValidator {
                 let output = self.validator.validate(py, field_value, state)?;
 
                 force_setattr(py, model, intern!(py, ROOT_FIELD), output)?;
-                Ok(model.into_py(py))
+                Ok(model.into_py_any(py)?)
             };
         }
         let old_dict = model.getattr(intern!(py, DUNDER_DICT))?.downcast_into::<PyDict>()?;
@@ -240,7 +240,7 @@ impl Validator for ModelValidator {
             intern!(py, DUNDER_MODEL_EXTRA_KEY),
             validated_extra.to_object(py),
         )?;
-        Ok(model.into_py(py))
+        Ok(model.into_py_any(py)?)
     }
 
     fn get_name(&self) -> &str {
diff --git a/src/validators/set.rs b/src/validators/set.rs
index c8900f7dc..cd6b62595 100644
--- a/src/validators/set.rs
+++ b/src/validators/set.rs
@@ -1,5 +1,5 @@
-use pyo3::prelude::*;
 use pyo3::types::{PyDict, PySet};
+use pyo3::{prelude::*, IntoPyObjectExt};
 
 use crate::errors::ValResult;
 use crate::input::{validate_iter_to_set, BorrowInput, ConsumeIterator, Input, ValidatedSet};
@@ -77,7 +77,7 @@ impl Validator for SetValidator {
             fail_fast: self.fail_fast,
         })??;
         min_length_check!(input, "Set", self.min_length, set);
-        Ok(set.into_py(py))
+        Ok(set.into_py_any(py)?)
     }
 
     fn get_name(&self) -> &str {
diff --git a/src/validators/string.rs b/src/validators/string.rs
index 341567355..3dfd3c8d1 100644
--- a/src/validators/string.rs
+++ b/src/validators/string.rs
@@ -1,6 +1,7 @@
 use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyString};
+use pyo3::IntoPyObjectExt;
 use regex::Regex;
 
 use crate::build_tools::{is_strict, py_schema_error_type, schema_or_config, schema_or_config_same};
@@ -49,7 +50,12 @@ impl Validator for StrValidator {
     ) -> ValResult<PyObject> {
         input
             .validate_str(state.strict_or(self.strict), self.coerce_numbers_to_str)
-            .map(|val_match| val_match.unpack(state).as_py_string(py, state.cache_str()).into_py(py))
+            .and_then(|val_match| {
+                Ok(val_match
+                    .unpack(state)
+                    .as_py_string(py, state.cache_str())
+                    .into_py_any(py)?)
+            })
     }
 
     fn get_name(&self) -> &str {
@@ -138,7 +144,7 @@ impl Validator for StrConstrainedValidator {
             // we haven't modified the string, return the original as it might be a PyString
             either_str.as_py_string(py, state.cache_str())
         };
-        Ok(py_string.into_py(py))
+        Ok(py_string.into_py_any(py)?)
     }
 
     fn get_name(&self) -> &str {
diff --git a/src/validators/time.rs b/src/validators/time.rs
index a9c6ae561..eda4935a3 100644
--- a/src/validators/time.rs
+++ b/src/validators/time.rs
@@ -2,6 +2,7 @@ use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyString};
 
+use pyo3::IntoPyObjectExt;
 use speedate::Time;
 
 use crate::build_tools::is_strict;
@@ -77,7 +78,7 @@ impl Validator for TimeValidator {
                 tz_constraint.tz_check(raw_time.tz_offset, input)?;
             }
         }
-        Ok(time.try_into_py(py)?)
+        Ok(time.into_py_any(py)?)
     }
 
     fn get_name(&self) -> &str {
diff --git a/src/validators/timedelta.rs b/src/validators/timedelta.rs
index 47817662d..a4c755f8a 100644
--- a/src/validators/timedelta.rs
+++ b/src/validators/timedelta.rs
@@ -74,7 +74,7 @@ impl Validator for TimeDeltaValidator {
         let timedelta = input
             .validate_timedelta(state.strict_or(self.strict), self.microseconds_precision)?
             .unpack(state);
-        let py_timedelta = timedelta.try_into_py(py)?;
+        let py_timedelta = timedelta.clone().into_pyobject(py)?;
         if let Some(constraints) = &self.constraints {
             let raw_timedelta = timedelta.to_duration()?;
 
diff --git a/src/validators/tuple.rs b/src/validators/tuple.rs
index 364f26b59..e49d6a942 100644
--- a/src/validators/tuple.rs
+++ b/src/validators/tuple.rs
@@ -306,7 +306,7 @@ impl Validator for TupleValidator {
         }
 
         if errors.is_empty() {
-            Ok(PyTuple::new(py, output)?.into_py(py))
+            Ok(PyTuple::new(py, output)?.into())
         } else {
             Err(ValError::LineErrors(errors))
         }
diff --git a/src/validators/url.rs b/src/validators/url.rs
index 69e1e668d..fd386074f 100644
--- a/src/validators/url.rs
+++ b/src/validators/url.rs
@@ -7,6 +7,7 @@ use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList};
 
 use ahash::AHashSet;
+use pyo3::IntoPyObjectExt;
 use url::{ParseError, SyntaxViolation, Url};
 
 use crate::build_tools::{is_strict, py_schema_err};
@@ -93,7 +94,7 @@ impl Validator for UrlValidator {
             Ok(()) => {
                 // Lax rather than strict to preserve V2.4 semantic that str wins over url in union
                 state.floor_exactness(Exactness::Lax);
-                Ok(either_url.into_py(py))
+                Ok(either_url.into_py_any(py)?)
             }
             Err(error_type) => Err(ValError::new(error_type, input)),
         }
@@ -155,11 +156,15 @@ enum EitherUrl<'py> {
     Rust(Url),
 }
 
-impl EitherUrl<'_> {
-    fn into_py(self, py: Python) -> PyObject {
+impl<'py> IntoPyObject<'py> for EitherUrl<'py> {
+    type Target = PyUrl;
+    type Output = Bound<'py, PyUrl>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> PyResult<Self::Output> {
         match self {
-            EitherUrl::Py(py_url) => py_url.into_py(py),
-            EitherUrl::Rust(rust_url) => PyUrl::new(rust_url).into_py(py),
+            EitherUrl::Py(py_url) => Ok(py_url),
+            EitherUrl::Rust(rust_url) => Bound::new(py, PyUrl::new(rust_url)),
         }
     }
 }
@@ -258,7 +263,7 @@ impl Validator for MultiHostUrlValidator {
             Ok(()) => {
                 // Lax rather than strict to preserve V2.4 semantic that str wins over url in union
                 state.floor_exactness(Exactness::Lax);
-                Ok(multi_url.into_py(py))
+                Ok(multi_url.into_py_any(py)?)
             }
             Err(error_type) => Err(ValError::new(error_type, input)),
         }
@@ -324,11 +329,15 @@ enum EitherMultiHostUrl<'py> {
     Rust(PyMultiHostUrl),
 }
 
-impl EitherMultiHostUrl<'_> {
-    fn into_py(self, py: Python) -> PyObject {
+impl<'py> IntoPyObject<'py> for EitherMultiHostUrl<'py> {
+    type Target = PyMultiHostUrl;
+    type Output = Bound<'py, PyMultiHostUrl>;
+    type Error = PyErr;
+
+    fn into_pyobject(self, py: Python<'py>) -> PyResult<Self::Output> {
         match self {
-            EitherMultiHostUrl::Py(py_multi_url) => py_multi_url.into_py(py),
-            EitherMultiHostUrl::Rust(rust_multi_url) => rust_multi_url.into_py(py),
+            EitherMultiHostUrl::Py(py_multi_url) => Ok(py_multi_url),
+            EitherMultiHostUrl::Rust(rust_multi_url) => Bound::new(py, rust_multi_url),
         }
     }
 }
diff --git a/src/validators/with_default.rs b/src/validators/with_default.rs
index bc77e3886..55fbc6ce5 100644
--- a/src/validators/with_default.rs
+++ b/src/validators/with_default.rs
@@ -18,7 +18,7 @@ use crate::PydanticUndefinedType;
 static COPY_DEEPCOPY: GILOnceCell<PyObject> = GILOnceCell::new();
 
 fn get_deepcopy(py: Python) -> PyResult<PyObject> {
-    Ok(py.import("copy")?.getattr("deepcopy")?.into_py(py))
+    Ok(py.import("copy")?.getattr("deepcopy")?.unbind())
 }
 
 #[derive(Debug, Clone)]
@@ -184,7 +184,7 @@ impl Validator for WithDefaultValidator {
             Some(stored_dft) => {
                 let dft: Py<PyAny> = if self.copy_default {
                     let deepcopy_func = COPY_DEEPCOPY.get_or_init(py, || get_deepcopy(py).unwrap());
-                    deepcopy_func.call1(py, (&stored_dft,))?.into_py(py)
+                    deepcopy_func.call1(py, (&stored_dft,))?
                 } else {
                     stored_dft
                 };

From 15adfc78716b085c9de54b944bc86e76c4ae34ec Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Wed, 18 Dec 2024 09:22:43 +0000
Subject: [PATCH 457/550] fix `ValueError` on year zero (#1583)

---
 src/input/datetime.rs             | 72 ++++++++++++++++++-------------
 src/validators/date.rs            |  3 +-
 src/validators/datetime.rs        |  3 +-
 tests/validators/test_date.py     |  6 +++
 tests/validators/test_datetime.py |  8 ++++
 5 files changed, 58 insertions(+), 34 deletions(-)

diff --git a/src/input/datetime.rs b/src/input/datetime.rs
index 6e4093207..f00c00aff 100644
--- a/src/input/datetime.rs
+++ b/src/input/datetime.rs
@@ -47,20 +47,26 @@ pub fn pydate_as_date(py_date: &Bound<'_, PyAny>) -> PyResult<Date> {
     })
 }
 
-impl<'py> IntoPyObject<'py> for EitherDate<'py> {
-    type Target = PyDate;
-    type Output = Bound<'py, PyDate>;
-    type Error = PyErr;
-
-    fn into_pyobject(self, py: Python<'py>) -> PyResult<Self::Output> {
+impl<'py> EitherDate<'py> {
+    pub fn try_into_py(&self, py: Python<'py>, input: &(impl Input<'py> + ?Sized)) -> ValResult<PyObject> {
         match self {
-            Self::Raw(date) => PyDate::new(py, date.year.into(), date.month, date.day),
-            Self::Py(date) => Ok(date),
+            Self::Raw(date) => {
+                if date.year == 0 {
+                    return Err(ValError::new(
+                        ErrorType::DateParsing {
+                            error: Cow::Borrowed("year 0 is out of range"),
+                            context: None,
+                        },
+                        input,
+                    ));
+                };
+                let py_date = PyDate::new(py, date.year.into(), date.month, date.day)?;
+                Ok(py_date.into())
+            }
+            Self::Py(py_date) => Ok(py_date.clone().into()),
         }
     }
-}
 
-impl EitherDate<'_> {
     pub fn as_raw(&self) -> PyResult<Date> {
         match self {
             Self::Raw(date) => Ok(date.clone()),
@@ -278,30 +284,36 @@ pub fn pydatetime_as_datetime(py_dt: &Bound<'_, PyAny>) -> PyResult<DateTime> {
     })
 }
 
-impl<'py> IntoPyObject<'py> for EitherDateTime<'py> {
-    type Target = PyDateTime;
-    type Output = Bound<'py, PyDateTime>;
-    type Error = PyErr;
-
-    fn into_pyobject(self, py: Python<'py>) -> PyResult<Self::Output> {
+impl<'py> EitherDateTime<'py> {
+    pub fn try_into_py(&self, py: Python<'py>, input: &(impl Input<'py> + ?Sized)) -> ValResult<PyObject> {
         match self {
-            Self::Raw(dt) => PyDateTime::new(
-                py,
-                dt.date.year.into(),
-                dt.date.month,
-                dt.date.day,
-                dt.time.hour,
-                dt.time.minute,
-                dt.time.second,
-                dt.time.microsecond,
-                time_as_tzinfo(py, &dt.time)?.as_ref(),
-            ),
-            Self::Py(dt) => Ok(dt),
+            Self::Raw(dt) => {
+                if dt.date.year == 0 {
+                    return Err(ValError::new(
+                        ErrorType::DatetimeParsing {
+                            error: Cow::Borrowed("year 0 is out of range"),
+                            context: None,
+                        },
+                        input,
+                    ));
+                };
+                let py_dt = PyDateTime::new(
+                    py,
+                    dt.date.year.into(),
+                    dt.date.month,
+                    dt.date.day,
+                    dt.time.hour,
+                    dt.time.minute,
+                    dt.time.second,
+                    dt.time.microsecond,
+                    time_as_tzinfo(py, &dt.time)?.as_ref(),
+                )?;
+                Ok(py_dt.into())
+            }
+            Self::Py(py_dt) => Ok(py_dt.clone().into()),
         }
     }
-}
 
-impl EitherDateTime<'_> {
     pub fn as_raw(&self) -> PyResult<DateTime> {
         match self {
             Self::Raw(dt) => Ok(dt.clone()),
diff --git a/src/validators/date.rs b/src/validators/date.rs
index b814dd1f6..2b64b71c6 100644
--- a/src/validators/date.rs
+++ b/src/validators/date.rs
@@ -1,7 +1,6 @@
 use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::{PyDate, PyDict, PyString};
-use pyo3::IntoPyObjectExt;
 use speedate::{Date, Time};
 use strum::EnumMessage;
 
@@ -98,7 +97,7 @@ impl Validator for DateValidator {
                 }
             }
         }
-        Ok(date.into_py_any(py)?)
+        date.try_into_py(py, input)
     }
 
     fn get_name(&self) -> &str {
diff --git a/src/validators/datetime.rs b/src/validators/datetime.rs
index 2b3c7661a..0d685216f 100644
--- a/src/validators/datetime.rs
+++ b/src/validators/datetime.rs
@@ -2,7 +2,6 @@ use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::sync::GILOnceCell;
 use pyo3::types::{PyDict, PyString};
-use pyo3::IntoPyObjectExt;
 use speedate::{DateTime, Time};
 use std::cmp::Ordering;
 use strum::EnumMessage;
@@ -131,7 +130,7 @@ impl Validator for DateTimeValidator {
                 tz_constraint.tz_check(speedate_dt.time.tz_offset, input)?;
             }
         }
-        Ok(datetime.into_py_any(py)?)
+        datetime.try_into_py(py, input)
     }
 
     fn get_name(&self) -> &str {
diff --git a/tests/validators/test_date.py b/tests/validators/test_date.py
index 3a1f77134..63e87556c 100644
--- a/tests/validators/test_date.py
+++ b/tests/validators/test_date.py
@@ -64,6 +64,12 @@
         ),
         pytest.param('-', Err('Input should be a valid date or datetime, input is too short'), id='minus'),
         pytest.param('+', Err('Input should be a valid date or datetime, input is too short'), id='pus'),
+        pytest.param('0001-01-01', date(1, 1, 1), id='min-date'),
+        pytest.param(
+            '0000-12-31',
+            Err('Input should be a valid date in the format YYYY-MM-DD, year 0 is out of range [type=date_parsing,'),
+            id='year-0',
+        ),
     ],
 )
 def test_date(input_value, expected):
diff --git a/tests/validators/test_datetime.py b/tests/validators/test_datetime.py
index d98daa3c5..96e12cf9c 100644
--- a/tests/validators/test_datetime.py
+++ b/tests/validators/test_datetime.py
@@ -53,6 +53,14 @@
                 'Input should be a valid datetime or date, day value is outside expected range [type=datetime_from_date_parsing,'
             ),
         ),
+        (
+            '0001-01-01T00:00:00.000000Z',
+            datetime(1, 1, 1, tzinfo=timezone.utc),
+        ),
+        (
+            '0000-12-31T23:59:59.999999Z',
+            Err('Input should be a valid datetime, year 0 is out of range [type=datetime_parsing,'),
+        ),
     ],
 )
 def test_datetime(input_value, expected):

From d3a2f47192f175883f0a0aa78864b3284c68305b Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 18 Dec 2024 09:28:53 +0000
Subject: [PATCH 458/550] Bump serde from 1.0.215 to 1.0.216 (#1586)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 8 ++++----
 Cargo.toml | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index ba9644655..c202d6d71 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -589,18 +589,18 @@ checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
 
 [[package]]
 name = "serde"
-version = "1.0.215"
+version = "1.0.216"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6513c1ad0b11a9376da888e3e0baa0077f1aed55c17f50e7b2397136129fb88f"
+checksum = "0b9781016e935a97e8beecf0c933758c97a5520d32930e460142b4cd80c6338e"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.215"
+version = "1.0.216"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "ad1e866f866923f252f05c889987993144fb74e722403468a4ebd70c3cd756c0"
+checksum = "46f859dbbf73865c6627ed570e78961cd3ac92407a2d117204c49232485da55e"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/Cargo.toml b/Cargo.toml
index 9b32263da..99616b743 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -35,7 +35,7 @@ strum = { version = "0.26.3", features = ["derive"] }
 strum_macros = "0.26.4"
 serde_json = {version = "1.0.133", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.13"
-serde = { version = "1.0.215", features = ["derive"] }
+serde = { version = "1.0.216", features = ["derive"] }
 speedate = "0.15.0"
 smallvec = "1.13.2"
 ahash = "0.8.10"

From b5c3e141e3e103d6ea88c44082354abbac5a0550 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Wed, 18 Dec 2024 11:07:53 +0000
Subject: [PATCH 459/550] bump version to 2.27.2 (#1589)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index c202d6d71..2fb6ee4a9 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -434,7 +434,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.27.1"
+version = "2.27.2"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index 99616b743..0abfc5450 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.27.1"
+version = "2.27.2"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From b6395cf78879c5b8d8770d3170b4d5e4063bacf6 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Wed, 18 Dec 2024 14:44:51 +0000
Subject: [PATCH 460/550] optimize refcounting op in datetime creation (#1590)

---
 src/input/datetime.rs | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/input/datetime.rs b/src/input/datetime.rs
index f00c00aff..9afe49a0a 100644
--- a/src/input/datetime.rs
+++ b/src/input/datetime.rs
@@ -48,7 +48,7 @@ pub fn pydate_as_date(py_date: &Bound<'_, PyAny>) -> PyResult<Date> {
 }
 
 impl<'py> EitherDate<'py> {
-    pub fn try_into_py(&self, py: Python<'py>, input: &(impl Input<'py> + ?Sized)) -> ValResult<PyObject> {
+    pub fn try_into_py(self, py: Python<'py>, input: &(impl Input<'py> + ?Sized)) -> ValResult<PyObject> {
         match self {
             Self::Raw(date) => {
                 if date.year == 0 {
@@ -63,7 +63,7 @@ impl<'py> EitherDate<'py> {
                 let py_date = PyDate::new(py, date.year.into(), date.month, date.day)?;
                 Ok(py_date.into())
             }
-            Self::Py(py_date) => Ok(py_date.clone().into()),
+            Self::Py(py_date) => Ok(py_date.into()),
         }
     }
 
@@ -285,7 +285,7 @@ pub fn pydatetime_as_datetime(py_dt: &Bound<'_, PyAny>) -> PyResult<DateTime> {
 }
 
 impl<'py> EitherDateTime<'py> {
-    pub fn try_into_py(&self, py: Python<'py>, input: &(impl Input<'py> + ?Sized)) -> ValResult<PyObject> {
+    pub fn try_into_py(self, py: Python<'py>, input: &(impl Input<'py> + ?Sized)) -> ValResult<PyObject> {
         match self {
             Self::Raw(dt) => {
                 if dt.date.year == 0 {
@@ -310,7 +310,7 @@ impl<'py> EitherDateTime<'py> {
                 )?;
                 Ok(py_dt.into())
             }
-            Self::Py(py_dt) => Ok(py_dt.clone().into()),
+            Self::Py(py_dt) => Ok(py_dt.into()),
         }
     }
 

From 562fad3e34805c3d5a2c2e8aec8d8d0193695a8e Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Wed, 18 Dec 2024 19:35:55 +0000
Subject: [PATCH 461/550] pass `--uv` flag to `maturin develop` (#1591)

---
 Makefile | 12 ++++++------
 uv.lock  |  2 +-
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/Makefile b/Makefile
index 0f47e2d22..496f19ced 100644
--- a/Makefile
+++ b/Makefile
@@ -39,7 +39,7 @@ install-rust-coverage:
 build-dev:
 	@rm -f python/pydantic_core/*.so
 ifneq ($(USE_MATURIN),)
-	uv run maturin develop
+	uv run maturin develop --uv
 else
 	uv pip install --force-reinstall -v -e . --config-settings=build-args='--profile dev'
 endif
@@ -48,7 +48,7 @@ endif
 build-prod:
 	@rm -f python/pydantic_core/*.so
 ifneq ($(USE_MATURIN),)
-	uv run maturin develop --release
+	uv run maturin develop --uv --release
 else
 	uv pip install -v -e .
 endif
@@ -57,7 +57,7 @@ endif
 build-profiling:
 	@rm -f python/pydantic_core/*.so
 ifneq ($(USE_MATURIN),)
-	uv run maturin develop --profile profiling
+	uv run maturin develop --uv --profile profiling
 else
 	uv pip install --force-reinstall -v -e . --config-settings=build-args='--profile profiling'
 endif
@@ -66,7 +66,7 @@ endif
 build-coverage:
 	@rm -f python/pydantic_core/*.so
 ifneq ($(USE_MATURIN),)
-	RUSTFLAGS='-C instrument-coverage' uv run maturin develop --release
+	RUSTFLAGS='-C instrument-coverage' uv run maturin develop --uv --release
 else
 	RUSTFLAGS='-C instrument-coverage' uv pip install -v -e .
 endif
@@ -76,7 +76,7 @@ build-pgo:
 	@rm -f python/pydantic_core/*.so
 	$(eval PROFDATA := $(shell mktemp -d))
 ifneq ($(USE_MATURIN),)
-	RUSTFLAGS='-Cprofile-generate=$(PROFDATA)' uv run maturin develop --release
+	RUSTFLAGS='-Cprofile-generate=$(PROFDATA)' uv run maturin develop --uv --release
 else
 	RUSTFLAGS='-Cprofile-generate=$(PROFDATA)' uv pip install --force-reinstall -v -e .
 endif
@@ -84,7 +84,7 @@ endif
 	$(eval LLVM_PROFDATA := $(shell rustup run stable bash -c 'echo $$RUSTUP_HOME/toolchains/$$RUSTUP_TOOLCHAIN/lib/rustlib/$$(rustc -Vv | grep host | cut -d " " -f 2)/bin/llvm-profdata'))
 	$(LLVM_PROFDATA) merge -o $(PROFDATA)/merged.profdata $(PROFDATA)
 ifneq ($(USE_MATURIN),)
-	RUSTFLAGS='-Cprofile-use=$(PROFDATA)/merged.profdata' uv run maturin develop --release
+	RUSTFLAGS='-Cprofile-use=$(PROFDATA)/merged.profdata' uv run maturin develop --uv --release
 else
 	RUSTFLAGS='-Cprofile-use=$(PROFDATA)/merged.profdata' uv pip install --force-reinstall -v -e .
 endif
diff --git a/uv.lock b/uv.lock
index 34afc1275..17e350df9 100644
--- a/uv.lock
+++ b/uv.lock
@@ -624,7 +624,7 @@ wheels = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.27.1"
+version = "2.27.2"
 source = { virtual = "." }
 dependencies = [
     { name = "typing-extensions" },

From e7c5dc7625c7c33a7a82f675292f85e2ce21ea15 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 6 Jan 2025 18:23:15 +0100
Subject: [PATCH 462/550] Bump astral-sh/setup-uv from 4 to 5 (#1596)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
Co-authored-by: Viicos <65306057+Viicos@users.noreply.github.com>
---
 .github/workflows/ci.yml       | 54 +++++++++-------------------------
 .github/workflows/codspeed.yml |  2 +-
 2 files changed, 15 insertions(+), 41 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 18228feb1..334e4c44c 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -32,9 +32,7 @@ jobs:
       - run: rustup component add llvm-tools-preview
 
       - name: install uv
-        uses: astral-sh/setup-uv@v4
-        with:
-          enable-cache: true
+        uses: astral-sh/setup-uv@v5
 
       - name: install deps
         run: uv sync --group testing
@@ -88,9 +86,9 @@ jobs:
           key: test-v3
 
       - name: install uv
-        uses: astral-sh/setup-uv@v4
+        uses: astral-sh/setup-uv@v5
         with:
-          enable-cache: true
+          python-version: ${{ matrix.python-version }}
 
       - name: install deps
         run: uv sync --group testing
@@ -105,9 +103,6 @@ jobs:
         env:
           HYPOTHESIS_PROFILE: slow
 
-    env:
-      UV_PYTHON: ${{ matrix.python-version }}
-
   test-os:
     name: test on ${{ matrix.os }}
 
@@ -127,9 +122,7 @@ jobs:
         uses: Swatinem/rust-cache@v2
 
       - name: install uv
-        uses: astral-sh/setup-uv@v4
-        with:
-          enable-cache: true
+        uses: astral-sh/setup-uv@v5
 
       - name: install deps
         run: uv sync --group testing
@@ -152,9 +145,7 @@ jobs:
       - uses: actions/checkout@v4
 
       - name: install uv
-        uses: astral-sh/setup-uv@v4
-        with:
-          enable-cache: true
+        uses: astral-sh/setup-uv@v5
 
       - name: install deps
         run: uv sync --group testing
@@ -197,9 +188,9 @@ jobs:
       - uses: actions/checkout@v4
 
       - name: install uv
-        uses: astral-sh/setup-uv@v4
+        uses: astral-sh/setup-uv@v5
         with:
-          enable-cache: true
+          python-version: ${{ matrix.python-version }}
 
       - name: install rust stable
         uses: dtolnay/rust-toolchain@stable
@@ -215,9 +206,6 @@ jobs:
       - run: uv pip freeze
       - run: uv run pytest
 
-    env:
-      UV_PYTHON: ${{ matrix.python-version }}
-
   test-pydantic-integration:
     runs-on: ubuntu-latest
     continue-on-error: true
@@ -239,9 +227,7 @@ jobs:
         uses: Swatinem/rust-cache@v2
 
       - name: install uv
-        uses: astral-sh/setup-uv@v4
-        with:
-          enable-cache: true
+        uses: astral-sh/setup-uv@v5
 
       - name: install deps
         run: |
@@ -283,9 +269,7 @@ jobs:
           node-version: '18'
 
       - name: install uv
-        uses: astral-sh/setup-uv@v4
-        with:
-          enable-cache: true
+        uses: astral-sh/setup-uv@v5
 
       - name: install deps
         run: |
@@ -343,9 +327,7 @@ jobs:
           actions-cache-folder: emsdk-cache
 
       - name: install uv
-        uses: astral-sh/setup-uv@v4
-        with:
-          enable-cache: true
+        uses: astral-sh/setup-uv@v5
 
       - name: install deps
         run: uv sync --group wasm
@@ -370,9 +352,6 @@ jobs:
           name: wasm_wheels
           path: dist
 
-    env:
-      UV_PYTHON: 3.12
-
   # https://github.com/marketplace/actions/alls-green#why used for branch protection checks
   check:
     if: always()
@@ -543,9 +522,9 @@ jobs:
       - uses: actions/checkout@v4
 
       - name: install uv
-        uses: astral-sh/setup-uv@v4
+        uses: astral-sh/setup-uv@v5
         with:
-          enable-cache: true
+          python-version: ${{ matrix.interpreter }}
 
       - name: install rust stable
         id: rust-toolchain
@@ -560,7 +539,7 @@ jobs:
         id: pgo-wheel
         uses: ./.github/actions/build-pgo-wheel
         with:
-          interpreter: ${{ env.UV_PYTHON }}
+          interpreter: ${{ matrix.interpreter }}
           rust-toolchain: ${{ steps.rust-toolchain.outputs.name }}
 
       - run: ${{ matrix.ls || 'ls -lh' }} dist/
@@ -570,9 +549,6 @@ jobs:
           name: pypi_files_${{ matrix.os }}_${{ matrix.interpreter }}
           path: dist
 
-    env:
-      UV_PYTHON: ${{ matrix.interpreter }}
-
   inspect-pypi-assets:
     needs: [build, build-sdist, build-pgo]
     runs-on: ubuntu-latest
@@ -668,9 +644,7 @@ jobs:
       - uses: actions/checkout@v4
 
       - name: install uv
-        uses: astral-sh/setup-uv@v4
-        with:
-          enable-cache: true
+        uses: astral-sh/setup-uv@v5
 
       - name: get dist artifacts
         uses: actions/download-artifact@v4
diff --git a/.github/workflows/codspeed.yml b/.github/workflows/codspeed.yml
index d3d2a59ac..3a4f2302a 100644
--- a/.github/workflows/codspeed.yml
+++ b/.github/workflows/codspeed.yml
@@ -26,7 +26,7 @@ jobs:
           python-version: ${{ env.UV_PYTHON}}
 
       - name: install uv
-        uses: astral-sh/setup-uv@v4
+        uses: astral-sh/setup-uv@v5
         with:
           enable-cache: true
 

From ecaa1a03a4810351b77030c1129241b4d6520f2a Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 21 Jan 2025 18:20:04 +0000
Subject: [PATCH 463/550] Bump serde from 1.0.216 to 1.0.217 (#1595)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 8 ++++----
 Cargo.toml | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 2fb6ee4a9..6c89e1647 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -589,18 +589,18 @@ checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
 
 [[package]]
 name = "serde"
-version = "1.0.216"
+version = "1.0.217"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "0b9781016e935a97e8beecf0c933758c97a5520d32930e460142b4cd80c6338e"
+checksum = "02fc4265df13d6fa1d00ecff087228cc0a2b5f3c0e87e258d8b94a156e984c70"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.216"
+version = "1.0.217"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "46f859dbbf73865c6627ed570e78961cd3ac92407a2d117204c49232485da55e"
+checksum = "5a9bf7cf98d04a2b28aead066b7496853d4779c9cc183c440dbac457641e19a0"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/Cargo.toml b/Cargo.toml
index 0abfc5450..f49db22fc 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -35,7 +35,7 @@ strum = { version = "0.26.3", features = ["derive"] }
 strum_macros = "0.26.4"
 serde_json = {version = "1.0.133", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.13"
-serde = { version = "1.0.216", features = ["derive"] }
+serde = { version = "1.0.217", features = ["derive"] }
 speedate = "0.15.0"
 smallvec = "1.13.2"
 ahash = "0.8.10"

From 2c273197096b8d12ddfb4b0bcbbfcb111f47bec5 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 21 Jan 2025 18:20:14 +0000
Subject: [PATCH 464/550] Bump serde_json from 1.0.133 to 1.0.134 (#1594)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 6c89e1647..2c68dcac2 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -609,9 +609,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.133"
+version = "1.0.134"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7fceb2473b9166b2294ef05efcb65a3db80803f0b03ef86a5fc88a2b85ee377"
+checksum = "d00f4175c42ee48b15416f6193a959ba3a0d67fc699a0db9ad12df9f83991c7d"
 dependencies = [
  "indexmap",
  "itoa",
diff --git a/Cargo.toml b/Cargo.toml
index f49db22fc..efa05db7f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -33,7 +33,7 @@ pyo3 = { version = "0.23.3", features = ["generate-import-lib", "num-bigint", "p
 regex = "1.11.1"
 strum = { version = "0.26.3", features = ["derive"] }
 strum_macros = "0.26.4"
-serde_json = {version = "1.0.133", features = ["arbitrary_precision", "preserve_order"]}
+serde_json = {version = "1.0.134", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.13"
 serde = { version = "1.0.217", features = ["derive"] }
 speedate = "0.15.0"

From e572f55aa6280d90d7967f55b8b72121ab593d3a Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Tue, 21 Jan 2025 13:52:24 -0500
Subject: [PATCH 465/550] Linting / formatting updates (#1603)

---
 src/serializers/fields.rs                    | 2 +-
 src/serializers/type_serializers/complex.rs  | 2 +-
 src/serializers/type_serializers/function.rs | 2 +-
 src/validators/bytes.rs                      | 2 +-
 src/validators/complex.rs                    | 2 +-
 src/validators/float.rs                      | 2 +-
 src/validators/int.rs                        | 2 +-
 src/validators/string.rs                     | 2 +-
 src/validators/typed_dict.rs                 | 5 +----
 tests/benchmarks/nested_schema.py            | 2 +-
 tests/test_json.py                           | 2 +-
 tests/validators/test_int.py                 | 5 +----
 tests/validators/test_json.py                | 3 +--
 tests/validators/test_string.py              | 6 +-----
 14 files changed, 14 insertions(+), 25 deletions(-)

diff --git a/src/serializers/fields.rs b/src/serializers/fields.rs
index c7fe4c253..662ec936f 100644
--- a/src/serializers/fields.rs
+++ b/src/serializers/fields.rs
@@ -458,7 +458,7 @@ impl TypeSerializer for GeneralFieldsSerializer {
         map.end()
     }
 
-    fn get_name(&self) -> &str {
+    fn get_name(&self) -> &'static str {
         "general-fields"
     }
 }
diff --git a/src/serializers/type_serializers/complex.rs b/src/serializers/type_serializers/complex.rs
index 1ec047395..d55c4b295 100644
--- a/src/serializers/type_serializers/complex.rs
+++ b/src/serializers/type_serializers/complex.rs
@@ -68,7 +68,7 @@ impl TypeSerializer for ComplexSerializer {
         }
     }
 
-    fn get_name(&self) -> &str {
+    fn get_name(&self) -> &'static str {
         "complex"
     }
 }
diff --git a/src/serializers/type_serializers/function.rs b/src/serializers/type_serializers/function.rs
index 1214a666d..5916e60d7 100644
--- a/src/serializers/type_serializers/function.rs
+++ b/src/serializers/type_serializers/function.rs
@@ -183,7 +183,7 @@ impl FunctionPlainSerializer {
     fn retry_with_lax_check(&self) -> bool {
         self.fallback_serializer
             .as_ref()
-            .map_or(false, |f| f.retry_with_lax_check())
+            .is_some_and(|f| f.retry_with_lax_check())
             || self.return_serializer.retry_with_lax_check()
     }
 }
diff --git a/src/validators/bytes.rs b/src/validators/bytes.rs
index b9cc2dc69..d7c71e021 100644
--- a/src/validators/bytes.rs
+++ b/src/validators/bytes.rs
@@ -107,7 +107,7 @@ impl Validator for BytesConstrainedValidator {
         Ok(either_bytes.into_py_any(py)?)
     }
 
-    fn get_name(&self) -> &str {
+    fn get_name(&self) -> &'static str {
         "constrained-bytes"
     }
 }
diff --git a/src/validators/complex.rs b/src/validators/complex.rs
index ff756707a..161daf1b8 100644
--- a/src/validators/complex.rs
+++ b/src/validators/complex.rs
@@ -49,7 +49,7 @@ impl Validator for ComplexValidator {
         Ok(res.into_pyobject(py)?.into())
     }
 
-    fn get_name(&self) -> &str {
+    fn get_name(&self) -> &'static str {
         "complex"
     }
 }
diff --git a/src/validators/float.rs b/src/validators/float.rs
index f2e662b08..30d3f3aa9 100644
--- a/src/validators/float.rs
+++ b/src/validators/float.rs
@@ -168,7 +168,7 @@ impl Validator for ConstrainedFloatValidator {
         Ok(either_float.into_py_any(py)?)
     }
 
-    fn get_name(&self) -> &str {
+    fn get_name(&self) -> &'static str {
         "constrained-float"
     }
 }
diff --git a/src/validators/int.rs b/src/validators/int.rs
index 806584c60..dd30ef5c3 100644
--- a/src/validators/int.rs
+++ b/src/validators/int.rs
@@ -140,7 +140,7 @@ impl Validator for ConstrainedIntValidator {
         Ok(either_int.into_py_any(py)?)
     }
 
-    fn get_name(&self) -> &str {
+    fn get_name(&self) -> &'static str {
         "constrained-int"
     }
 }
diff --git a/src/validators/string.rs b/src/validators/string.rs
index 3dfd3c8d1..69d126c8f 100644
--- a/src/validators/string.rs
+++ b/src/validators/string.rs
@@ -147,7 +147,7 @@ impl Validator for StrConstrainedValidator {
         Ok(py_string.into_py_any(py)?)
     }
 
-    fn get_name(&self) -> &str {
+    fn get_name(&self) -> &'static str {
         "constrained-str"
     }
 }
diff --git a/src/validators/typed_dict.rs b/src/validators/typed_dict.rs
index 9c6523189..4dc72a9e1 100644
--- a/src/validators/typed_dict.rs
+++ b/src/validators/typed_dict.rs
@@ -312,10 +312,7 @@ impl Validator for TypedDictValidator {
                             ExtraBehavior::Allow => {
                                 let py_key = either_str.as_py_string(self.py, self.state.cache_str());
                                 if let Some(validator) = self.extras_validator {
-                                    let last_partial = self.partial_last_key.as_ref().map_or(false, |last_key| {
-                                        let key_loc: LocItem = raw_key.clone().into();
-                                        &key_loc == last_key
-                                    });
+                                    let last_partial = self.partial_last_key.as_ref() == Some(&raw_key.clone().into());
                                     self.state.allow_partial = match last_partial {
                                         true => self.allow_partial,
                                         false => false.into(),
diff --git a/tests/benchmarks/nested_schema.py b/tests/benchmarks/nested_schema.py
index 0d91d1217..423e7f1b8 100644
--- a/tests/benchmarks/nested_schema.py
+++ b/tests/benchmarks/nested_schema.py
@@ -40,7 +40,7 @@ def schema_using_defs() -> cs.CoreSchema:
                     'fields': {
                         str(c): {
                             'type': 'model-field',
-                            'schema': {'type': 'definition-ref', 'schema_ref': f'model_{level+1}'},
+                            'schema': {'type': 'definition-ref', 'schema_ref': f'model_{level + 1}'},
                         }
                         for c in range(N)
                     },
diff --git a/tests/test_json.py b/tests/test_json.py
index c78ed3ad0..378214680 100644
--- a/tests/test_json.py
+++ b/tests/test_json.py
@@ -416,7 +416,7 @@ def test_json_bytes_base64_invalid():
         {
             'type': 'bytes_invalid_encoding',
             'loc': (),
-            'msg': f'Data should be valid base64: Invalid symbol {ord("!")}, offset {len(wrong_input)-1}.',
+            'msg': f'Data should be valid base64: Invalid symbol {ord("!")}, offset {len(wrong_input) - 1}.',
             'input': wrong_input,
         }
     ]
diff --git a/tests/validators/test_int.py b/tests/validators/test_int.py
index 47944126a..a07be2994 100644
--- a/tests/validators/test_int.py
+++ b/tests/validators/test_int.py
@@ -311,10 +311,7 @@ def test_int_strict(py_and_json: PyAndJson, input_value, expected):
         (
             {'ge': 0},
             -1,
-            Err(
-                'Input should be greater than or equal to 0 '
-                '[type=greater_than_equal, input_value=-1, input_type=int]'
-            ),
+            Err('Input should be greater than or equal to 0 [type=greater_than_equal, input_value=-1, input_type=int]'),
         ),
         ({'gt': 0}, 1, 1),
         ({'gt': 0}, 0, Err('Input should be greater than 0 [type=greater_than, input_value=0, input_type=int]')),
diff --git a/tests/validators/test_json.py b/tests/validators/test_json.py
index 9bd553d46..5d60d58f3 100644
--- a/tests/validators/test_json.py
+++ b/tests/validators/test_json.py
@@ -63,8 +63,7 @@ def test_any(py_and_json: PyAndJson, input_value, expected):
         pytest.param(
             'xx',
             Err(
-                'Invalid JSON: expected value at line 1 column 1 '
-                "[type=json_invalid, input_value='xx', input_type=str]"
+                "Invalid JSON: expected value at line 1 column 1 [type=json_invalid, input_value='xx', input_type=str]"
             ),
             id='str_invalid',
         ),
diff --git a/tests/validators/test_string.py b/tests/validators/test_string.py
index ae5ced611..d7ae3e5ab 100644
--- a/tests/validators/test_string.py
+++ b/tests/validators/test_string.py
@@ -183,11 +183,7 @@ def test_invalid_regex(engine):
 
     if engine is None or engine == 'rust-regex':
         assert exc_info.value.args[0] == (
-            'Error building "str" validator:\n'
-            '  SchemaError: regex parse error:\n'
-            '    (abc\n'
-            '    ^\n'
-            'error: unclosed group'
+            'Error building "str" validator:\n  SchemaError: regex parse error:\n    (abc\n    ^\nerror: unclosed group'
         )
     elif engine == 'python-re':
         prefix = 'PatternError' if sys.version_info >= (3, 13) else 'error'

From b426cce3c2040d1cd2dece7f6530b93e7802cb4a Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Wed, 22 Jan 2025 14:41:22 -0500
Subject: [PATCH 466/550] Drop 3.8 support (#1604)

---
 .github/check_version.py                      |   3 +-
 .github/workflows/ci.yml                      |  25 +-
 README.md                                     |   2 +-
 generate_self_schema.py                       |  27 +-
 pyproject.toml                                |  10 +-
 python/pydantic_core/core_schema.py           | 336 +++++----
 src/errors/location.rs                        |   2 +-
 src/lookup_key.rs                             |   2 +-
 tests/benchmarks/test_micro_benchmarks.py     |  26 +-
 tests/conftest.py                             |   7 +-
 tests/serializers/test_model.py               |   8 +-
 tests/serializers/test_model_root.py          |   6 +-
 tests/serializers/test_typed_dict.py          |   4 +-
 tests/serializers/test_union.py               |   3 +-
 tests/test_custom_errors.py                   |   6 +-
 tests/test_garbage_collection.py              |   9 +-
 tests/test_json.py                            |   3 +-
 tests/test_tzinfo.py                          |   6 +-
 tests/validators/test_allow_partial.py        |   2 +-
 tests/validators/test_bytes.py                |   6 +-
 tests/validators/test_dataclasses.py          |  14 +-
 tests/validators/test_datetime.py             |  10 +-
 .../validators/test_definitions_recursive.py  |   6 +-
 tests/validators/test_dict.py                 |   4 +-
 tests/validators/test_float.py                |   4 +-
 tests/validators/test_frozenset.py            |   4 +-
 tests/validators/test_function.py             |   8 +-
 tests/validators/test_int.py                  |   4 +-
 tests/validators/test_list.py                 |  11 +-
 tests/validators/test_literal.py              |   6 +-
 tests/validators/test_model.py                |  14 +-
 tests/validators/test_model_fields.py         |  13 +-
 tests/validators/test_model_root.py           |   6 +-
 tests/validators/test_set.py                  |   4 +-
 tests/validators/test_string.py               |   6 +-
 tests/validators/test_time.py                 |   4 +-
 tests/validators/test_timedelta.py            |   4 +-
 tests/validators/test_tuple.py                |   6 +-
 tests/validators/test_typed_dict.py           |  17 +-
 tests/validators/test_union.py                |   4 +-
 tests/validators/test_url.py                  |   6 +-
 tests/validators/test_with_default.py         |   6 +-
 uv.lock                                       | 675 +++++++++---------
 43 files changed, 648 insertions(+), 681 deletions(-)

diff --git a/.github/check_version.py b/.github/check_version.py
index be80a3e85..11cc01f40 100755
--- a/.github/check_version.py
+++ b/.github/check_version.py
@@ -2,6 +2,7 @@
 """
 Check the version in Cargo.toml matches the version from `GITHUB_REF` environment variable.
 """
+
 import os
 import re
 import sys
@@ -18,7 +19,7 @@ def main() -> int:
     if version_ref:
         version = re.sub('^refs/tags/v*', '', version_ref.lower())
     else:
-        print(f'✖ "GITHUB_REF" env variables not found')
+        print('✖ "GITHUB_REF" env variables not found')
         return 1
 
     # convert from python pre-release version to rust pre-release version
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 334e4c44c..c23f784eb 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -63,7 +63,6 @@ jobs:
       fail-fast: false
       matrix:
         python-version:
-          - '3.8'
           - '3.9'
           - '3.10'
           - '3.11'
@@ -403,15 +402,15 @@ jobs:
           - os: linux
             manylinux: auto
             target: armv7
-            interpreter: 3.8 3.9 3.10 3.11 3.12 3.13
+            interpreter: 3.9 3.10 3.11 3.12 3.13
           - os: linux
             manylinux: auto
             target: ppc64le
-            interpreter: 3.8 3.9 3.10 3.11 3.12 3.13
+            interpreter: 3.9 3.10 3.11 3.12 3.13
           - os: linux
             manylinux: auto
             target: s390x
-            interpreter: 3.8 3.9 3.10 3.11 3.12 3.13
+            interpreter: 3.9 3.10 3.11 3.12 3.13
           - os: linux
             manylinux: auto
             target: x86_64
@@ -435,7 +434,7 @@ jobs:
             target: x86_64
           - os: macos
             target: aarch64
-            interpreter: 3.8 3.9 pypy3.9 pypy3.10
+            interpreter: 3.9 pypy3.9 pypy3.10
 
           # windows;
           # x86_64 pypy builds are not PGO optimized
@@ -447,7 +446,7 @@ jobs:
           - os: windows
             target: i686
             python-architecture: x86
-            interpreter: 3.8 3.9 3.10 3.11 3.12 3.13
+            interpreter: 3.9 3.10 3.11 3.12 3.13
           - os: windows
             target: aarch64
             interpreter: 3.11 3.12 3.13
@@ -477,10 +476,8 @@ jobs:
         with:
           target: ${{ matrix.target }}
           manylinux: ${{ matrix.manylinux }}
-          args: --release --out dist --interpreter ${{ matrix.interpreter || '3.8 3.9 3.10 3.11 3.12 3.13 pypy3.9 pypy3.10' }}
-          # Limit windows builds to 1.77 to keep Windows 7 support.
-          # FIXME: Unpin when Python 3.8 support is dropped. (3.9 requires Windows 10)
-          rust-toolchain: ${{ (matrix.os == 'windows' && '1.77') || 'stable' }}
+          args: --release --out dist --interpreter ${{ matrix.interpreter || '3.9 3.10 3.11 3.12 3.13 pypy3.9 pypy3.10' }}
+          rust-toolchain: stable
           docker-options: -e CI
 
       - run: ${{ (matrix.os == 'windows' && 'dir') || 'ls -lh' }} dist/
@@ -500,7 +497,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [linux, windows, macos]
-        interpreter: ['3.8', '3.9', '3.10', '3.11', '3.12', '3.13']
+        interpreter: ['3.9', '3.10', '3.11', '3.12', '3.13']
         include:
           # standard runners with override for macos arm
           - os: linux
@@ -512,8 +509,6 @@ jobs:
             runs-on: macos-latest-xlarge
         exclude:
           # macos arm only supported from 3.10 and up
-          - os: macos
-            interpreter: '3.8'
           - os: macos
             interpreter: '3.9'
 
@@ -531,9 +526,7 @@ jobs:
         uses: dtolnay/rust-toolchain@master
         with:
           components: llvm-tools
-          # Limit windows builds to 1.77 to keep Windows 7 support.
-          # FIXME: Unpin when Python 3.8 support is dropped. (3.9 requires Windows 10)
-          toolchain: ${{ (matrix.os == 'windows' && '1.77') || 'stable' }}
+          toolchain: stable
 
       - name: Build PGO wheel
         id: pgo-wheel
diff --git a/README.md b/README.md
index ec625ad26..bac3a4758 100644
--- a/README.md
+++ b/README.md
@@ -71,7 +71,7 @@ except ValidationError as e:
 
 You'll need rust stable [installed](https://rustup.rs/), or rust nightly if you want to generate accurate coverage.
 
-With rust and python 3.8+ installed, compiling pydantic-core should be possible with roughly the following:
+With rust and python 3.9+ installed, compiling pydantic-core should be possible with roughly the following:
 
 ```bash
 # clone this repo or your fork
diff --git a/generate_self_schema.py b/generate_self_schema.py
index aeb411c6d..623acba58 100644
--- a/generate_self_schema.py
+++ b/generate_self_schema.py
@@ -14,11 +14,12 @@
 from collections.abc import Callable
 from datetime import date, datetime, time, timedelta
 from pathlib import Path
-from typing import TYPE_CHECKING, Any, Dict, ForwardRef, List, Pattern, Set, Type, Union
+from re import Pattern
+from typing import TYPE_CHECKING, Any, ForwardRef, Union
 
 from typing_extensions import TypedDict, get_args, get_origin, is_typeddict
 
-TypingUnionType = Type[Union[str, int]]
+TypingUnionType = type[Union[str, int]]
 
 try:
     from types import UnionType as TypesUnionType
@@ -69,17 +70,17 @@ def get_schema(obj: Any, definitions: dict[str, core_schema.CoreSchema]) -> core
         expected = all_literal_values(obj)
         assert expected, f'literal "expected" cannot be empty, obj={obj}'
         return {'type': 'literal', 'expected': expected}
-    elif issubclass(origin, List):
+    elif issubclass(origin, list):
         return {'type': 'list', 'items_schema': get_schema(obj.__args__[0], definitions)}
-    elif issubclass(origin, Set):
+    elif issubclass(origin, set):
         return {'type': 'set', 'items_schema': get_schema(obj.__args__[0], definitions)}
-    elif issubclass(origin, Dict):
+    elif issubclass(origin, dict):
         return {
             'type': 'dict',
             'keys_schema': get_schema(obj.__args__[0], definitions),
             'values_schema': get_schema(obj.__args__[1], definitions),
         }
-    elif issubclass(origin, Type):
+    elif issubclass(origin, type):
         # can't really use 'is-instance' since this is used for the class_ parameter of 'is-instance' validators
         return {'type': 'any'}
     elif origin in (Pattern, re.Pattern):
@@ -90,7 +91,7 @@ def get_schema(obj: Any, definitions: dict[str, core_schema.CoreSchema]) -> core
         raise TypeError(f'Unknown type: {obj!r}')
 
 
-def tagged_union(std_union_schema: Dict[str, Any], discriminator_key: str, ref: str | None = None) -> Dict[str, Any]:
+def tagged_union(std_union_schema: dict[str, Any], discriminator_key: str, ref: str | None = None) -> dict[str, Any]:
     """
     Build a tagged union schema from a standard union schema.
     """
@@ -134,13 +135,13 @@ def type_dict_schema(  # noqa: C901
             if 'CoreSchema' == fr_arg or re.search('[^a-zA-Z]CoreSchema', fr_arg):
                 if fr_arg == 'CoreSchema':
                     schema = schema_ref_validator
-                elif fr_arg == 'List[CoreSchema]':
+                elif fr_arg == 'list[CoreSchema]':
                     schema = {'type': 'list', 'items_schema': schema_ref_validator}
-                elif fr_arg == 'Dict[str, CoreSchema]':
+                elif fr_arg == 'dict[str, CoreSchema]':
                     schema = {'type': 'dict', 'keys_schema': {'type': 'str'}, 'values_schema': schema_ref_validator}
-                elif fr_arg == 'Dict[Hashable, CoreSchema]':
+                elif fr_arg == 'dict[Hashable, CoreSchema]':
                     schema = {'type': 'dict', 'keys_schema': {'type': 'any'}, 'values_schema': schema_ref_validator}
-                elif fr_arg == 'List[Union[CoreSchema, Tuple[CoreSchema, str]]]':
+                elif fr_arg == 'list[Union[CoreSchema, tuple[CoreSchema, str]]]':
                     schema = {
                         'type': 'list',
                         'items_schema': {
@@ -193,9 +194,7 @@ def all_literal_values(type_: type[core_schema.Literal]) -> list[any]:
 
 
 def eval_forward_ref(type_: Any) -> Any:
-    if sys.version_info < (3, 9):
-        return type_._evaluate(core_schema.__dict__, None)
-    elif sys.version_info < (3, 12, 4):
+    if sys.version_info < (3, 12, 4):
         return type_._evaluate(core_schema.__dict__, None, recursive_guard=set())
     else:
         return type_._evaluate(core_schema.__dict__, None, type_params=set(), recursive_guard=set())
diff --git a/pyproject.toml b/pyproject.toml
index 9edafc5cd..ef6e4a9ce 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -8,7 +8,7 @@ build-backend = 'maturin'
 [project]
 name = 'pydantic_core'
 description = "Core functionality for Pydantic validation and serialization"
-requires-python = '>=3.8'
+requires-python = '>=3.9'
 authors = [
     {name = 'Samuel Colvin', email = 's@muelcolvin.com'}
 ]
@@ -17,7 +17,6 @@ classifiers = [
     'Programming Language :: Python',
     'Programming Language :: Python :: 3',
     'Programming Language :: Python :: 3 :: Only',
-    'Programming Language :: Python :: 3.8',
     'Programming Language :: Python :: 3.9',
     'Programming Language :: Python :: 3.10',
     'Programming Language :: Python :: 3.11',
@@ -76,6 +75,7 @@ linting = [
     'pyright',
     'ruff',
     'mypy',
+    'pyupgrade',
 ]
 wasm = [
     'typing_extensions',
@@ -101,9 +101,10 @@ features = ["pyo3/extension-module"]
 
 [tool.ruff]
 line-length = 120
+target-version = 'py39'
 
 [tool.ruff.lint]
-extend-select = ['Q', 'RUF100', 'C90', 'I']
+extend-select = ['Q', 'RUF100', 'C90', 'I', 'UP']
 extend-ignore = [
     'E721',  # using type() instead of isinstance() - we use this in tests
 ]
@@ -111,6 +112,9 @@ flake8-quotes = {inline-quotes = 'single', multiline-quotes = 'double'}
 mccabe = { max-complexity = 13 }
 isort = { known-first-party = ['pydantic_core', 'tests'] }
 
+[tool.ruff.lint.pyupgrade]
+keep-runtime-typing = true
+
 [tool.ruff.format]
 quote-style = 'single'
 
diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index a45d82f9c..65e4a7a1f 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -7,10 +7,11 @@
 
 import sys
 import warnings
-from collections.abc import Mapping
+from collections.abc import Hashable, Mapping
 from datetime import date, datetime, time, timedelta
 from decimal import Decimal
-from typing import TYPE_CHECKING, Any, Callable, Dict, Hashable, List, Pattern, Set, Tuple, Type, Union
+from re import Pattern
+from typing import TYPE_CHECKING, Any, Callable, Literal, Union
 
 from typing_extensions import deprecated
 
@@ -24,11 +25,6 @@
 else:
     from typing import Protocol, Required, TypeAlias
 
-if sys.version_info < (3, 9):
-    from typing_extensions import Literal
-else:
-    from typing import Literal
-
 if TYPE_CHECKING:
     from pydantic_core import PydanticUndefined
 else:
@@ -185,7 +181,7 @@ def mode(self) -> Literal['python', 'json']:
         ...
 
     @property
-    def data(self) -> Dict[str, Any]:
+    def data(self) -> dict[str, Any]:
         """The data being validated for this model."""
         ...
 
@@ -411,11 +407,11 @@ def to_string_ser_schema(*, when_used: WhenUsed = 'json-unless-none') -> ToStrin
 
 class ModelSerSchema(TypedDict, total=False):
     type: Required[Literal['model']]
-    cls: Required[Type[Any]]
+    cls: Required[type[Any]]
     schema: Required[CoreSchema]
 
 
-def model_ser_schema(cls: Type[Any], schema: CoreSchema) -> ModelSerSchema:
+def model_ser_schema(cls: type[Any], schema: CoreSchema) -> ModelSerSchema:
     """
     Returns a schema for serialization using a model.
 
@@ -439,13 +435,13 @@ def model_ser_schema(cls: Type[Any], schema: CoreSchema) -> ModelSerSchema:
 class InvalidSchema(TypedDict, total=False):
     type: Required[Literal['invalid']]
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     # note, we never plan to use this, but include it for type checking purposes to match
     # all other CoreSchema union members
     serialization: SerSchema
 
 
-def invalid_schema(ref: str | None = None, metadata: Dict[str, Any] | None = None) -> InvalidSchema:
+def invalid_schema(ref: str | None = None, metadata: dict[str, Any] | None = None) -> InvalidSchema:
     """
     Returns an invalid schema, used to indicate that a schema is invalid.
 
@@ -464,11 +460,11 @@ class ComputedField(TypedDict, total=False):
     property_name: Required[str]
     return_schema: Required[CoreSchema]
     alias: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
 
 
 def computed_field(
-    property_name: str, return_schema: CoreSchema, *, alias: str | None = None, metadata: Dict[str, Any] | None = None
+    property_name: str, return_schema: CoreSchema, *, alias: str | None = None, metadata: dict[str, Any] | None = None
 ) -> ComputedField:
     """
     ComputedFields are properties of a model or dataclass that are included in serialization.
@@ -487,12 +483,12 @@ def computed_field(
 class AnySchema(TypedDict, total=False):
     type: Required[Literal['any']]
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
 def any_schema(
-    *, ref: str | None = None, metadata: Dict[str, Any] | None = None, serialization: SerSchema | None = None
+    *, ref: str | None = None, metadata: dict[str, Any] | None = None, serialization: SerSchema | None = None
 ) -> AnySchema:
     """
     Returns a schema that matches any value, e.g.:
@@ -516,12 +512,12 @@ def any_schema(
 class NoneSchema(TypedDict, total=False):
     type: Required[Literal['none']]
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
 def none_schema(
-    *, ref: str | None = None, metadata: Dict[str, Any] | None = None, serialization: SerSchema | None = None
+    *, ref: str | None = None, metadata: dict[str, Any] | None = None, serialization: SerSchema | None = None
 ) -> NoneSchema:
     """
     Returns a schema that matches a None value, e.g.:
@@ -546,14 +542,14 @@ class BoolSchema(TypedDict, total=False):
     type: Required[Literal['bool']]
     strict: bool
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
 def bool_schema(
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> BoolSchema:
     """
@@ -585,7 +581,7 @@ class IntSchema(TypedDict, total=False):
     gt: int
     strict: bool
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
@@ -598,7 +594,7 @@ def int_schema(
     gt: int | None = None,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> IntSchema:
     """
@@ -647,7 +643,7 @@ class FloatSchema(TypedDict, total=False):
     gt: float
     strict: bool
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
@@ -661,7 +657,7 @@ def float_schema(
     gt: float | None = None,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> FloatSchema:
     """
@@ -714,7 +710,7 @@ class DecimalSchema(TypedDict, total=False):
     decimal_places: int
     strict: bool
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
@@ -730,7 +726,7 @@ def decimal_schema(
     decimal_places: int | None = None,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> DecimalSchema:
     """
@@ -780,7 +776,7 @@ class ComplexSchema(TypedDict, total=False):
     type: Required[Literal['complex']]
     strict: bool
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
@@ -788,7 +784,7 @@ def complex_schema(
     *,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> ComplexSchema:
     """
@@ -830,7 +826,7 @@ class StringSchema(TypedDict, total=False):
     strict: bool
     coerce_numbers_to_str: bool
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
@@ -846,7 +842,7 @@ def str_schema(
     strict: bool | None = None,
     coerce_numbers_to_str: bool | None = None,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> StringSchema:
     """
@@ -902,7 +898,7 @@ class BytesSchema(TypedDict, total=False):
     min_length: int
     strict: bool
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
@@ -912,7 +908,7 @@ def bytes_schema(
     min_length: int | None = None,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> BytesSchema:
     """
@@ -957,7 +953,7 @@ class DateSchema(TypedDict, total=False):
     # value is restricted to -86_400 < offset < 86_400 by bounds in generate_self_schema.py
     now_utc_offset: int
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
@@ -971,7 +967,7 @@ def date_schema(
     now_op: Literal['past', 'future'] | None = None,
     now_utc_offset: int | None = None,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> DateSchema:
     """
@@ -1023,7 +1019,7 @@ class TimeSchema(TypedDict, total=False):
     tz_constraint: Union[Literal['aware', 'naive'], int]
     microseconds_precision: Literal['truncate', 'error']
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
@@ -1037,7 +1033,7 @@ def time_schema(
     tz_constraint: Literal['aware', 'naive'] | int | None = None,
     microseconds_precision: Literal['truncate', 'error'] = 'truncate',
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> TimeSchema:
     """
@@ -1093,7 +1089,7 @@ class DatetimeSchema(TypedDict, total=False):
     now_utc_offset: int
     microseconds_precision: Literal['truncate', 'error']  # default: 'truncate'
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
@@ -1109,7 +1105,7 @@ def datetime_schema(
     now_utc_offset: int | None = None,
     microseconds_precision: Literal['truncate', 'error'] = 'truncate',
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> DatetimeSchema:
     """
@@ -1166,7 +1162,7 @@ class TimedeltaSchema(TypedDict, total=False):
     gt: timedelta
     microseconds_precision: Literal['truncate', 'error']
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
@@ -1179,7 +1175,7 @@ def timedelta_schema(
     gt: timedelta | None = None,
     microseconds_precision: Literal['truncate', 'error'] = 'truncate',
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> TimedeltaSchema:
     """
@@ -1221,9 +1217,9 @@ def timedelta_schema(
 
 class LiteralSchema(TypedDict, total=False):
     type: Required[Literal['literal']]
-    expected: Required[List[Any]]
+    expected: Required[list[Any]]
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
@@ -1231,7 +1227,7 @@ def literal_schema(
     expected: list[Any],
     *,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> LiteralSchema:
     """
@@ -1257,12 +1253,12 @@ def literal_schema(
 class EnumSchema(TypedDict, total=False):
     type: Required[Literal['enum']]
     cls: Required[Any]
-    members: Required[List[Any]]
+    members: Required[list[Any]]
     sub_type: Literal['str', 'int', 'float']
     missing: Callable[[Any], Any]
     strict: bool
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
@@ -1274,7 +1270,7 @@ def enum_schema(
     missing: Callable[[Any], Any] | None = None,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> EnumSchema:
     """
@@ -1326,7 +1322,7 @@ class IsInstanceSchema(TypedDict, total=False):
     cls: Required[Any]
     cls_repr: str
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
@@ -1335,7 +1331,7 @@ def is_instance_schema(
     *,
     cls_repr: str | None = None,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> IsInstanceSchema:
     """
@@ -1366,19 +1362,19 @@ class A:
 
 class IsSubclassSchema(TypedDict, total=False):
     type: Required[Literal['is-subclass']]
-    cls: Required[Type[Any]]
+    cls: Required[type[Any]]
     cls_repr: str
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
 def is_subclass_schema(
-    cls: Type[Any],
+    cls: type[Any],
     *,
     cls_repr: str | None = None,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> IsInstanceSchema:
     """
@@ -1413,12 +1409,12 @@ class B(A):
 class CallableSchema(TypedDict, total=False):
     type: Required[Literal['callable']]
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
 def callable_schema(
-    *, ref: str | None = None, metadata: Dict[str, Any] | None = None, serialization: SerSchema | None = None
+    *, ref: str | None = None, metadata: dict[str, Any] | None = None, serialization: SerSchema | None = None
 ) -> CallableSchema:
     """
     Returns a schema that checks if a value is callable, equivalent to python's `callable` method, e.g.:
@@ -1444,7 +1440,7 @@ class UuidSchema(TypedDict, total=False):
     version: Literal[1, 3, 4, 5]
     strict: bool
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
@@ -1453,7 +1449,7 @@ def uuid_schema(
     version: Literal[1, 3, 4, 5] | None = None,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> UuidSchema:
     return _dict_not_none(
@@ -1463,11 +1459,11 @@ def uuid_schema(
 
 class IncExSeqSerSchema(TypedDict, total=False):
     type: Required[Literal['include-exclude-sequence']]
-    include: Set[int]
-    exclude: Set[int]
+    include: set[int]
+    exclude: set[int]
 
 
-def filter_seq_schema(*, include: Set[int] | None = None, exclude: Set[int] | None = None) -> IncExSeqSerSchema:
+def filter_seq_schema(*, include: set[int] | None = None, exclude: set[int] | None = None) -> IncExSeqSerSchema:
     return _dict_not_none(type='include-exclude-sequence', include=include, exclude=exclude)
 
 
@@ -1482,7 +1478,7 @@ class ListSchema(TypedDict, total=False):
     fail_fast: bool
     strict: bool
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: IncExSeqOrElseSerSchema
 
 
@@ -1494,7 +1490,7 @@ def list_schema(
     fail_fast: bool | None = None,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: IncExSeqOrElseSerSchema | None = None,
 ) -> ListSchema:
     """
@@ -1538,7 +1534,7 @@ def tuple_positional_schema(
     extras_schema: CoreSchema | None = None,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: IncExSeqOrElseSerSchema | None = None,
 ) -> TupleSchema:
     """
@@ -1588,7 +1584,7 @@ def tuple_variable_schema(
     max_length: int | None = None,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: IncExSeqOrElseSerSchema | None = None,
 ) -> TupleSchema:
     """
@@ -1627,14 +1623,14 @@ def tuple_variable_schema(
 
 class TupleSchema(TypedDict, total=False):
     type: Required[Literal['tuple']]
-    items_schema: Required[List[CoreSchema]]
+    items_schema: Required[list[CoreSchema]]
     variadic_item_index: int
     min_length: int
     max_length: int
     fail_fast: bool
     strict: bool
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: IncExSeqOrElseSerSchema
 
 
@@ -1647,7 +1643,7 @@ def tuple_schema(
     fail_fast: bool | None = None,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: IncExSeqOrElseSerSchema | None = None,
 ) -> TupleSchema:
     """
@@ -1697,7 +1693,7 @@ class SetSchema(TypedDict, total=False):
     fail_fast: bool
     strict: bool
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
@@ -1709,7 +1705,7 @@ def set_schema(
     fail_fast: bool | None = None,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> SetSchema:
     """
@@ -1756,7 +1752,7 @@ class FrozenSetSchema(TypedDict, total=False):
     fail_fast: bool
     strict: bool
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
@@ -1768,7 +1764,7 @@ def frozenset_schema(
     fail_fast: bool | None = None,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> FrozenSetSchema:
     """
@@ -1813,7 +1809,7 @@ class GeneratorSchema(TypedDict, total=False):
     min_length: int
     max_length: int
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: IncExSeqOrElseSerSchema
 
 
@@ -1823,7 +1819,7 @@ def generator_schema(
     min_length: int | None = None,
     max_length: int | None = None,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: IncExSeqOrElseSerSchema | None = None,
 ) -> GeneratorSchema:
     """
@@ -1864,7 +1860,7 @@ def gen() -> Iterator[int]:
     )
 
 
-IncExDict = Set[Union[int, str]]
+IncExDict = set[Union[int, str]]
 
 
 class IncExDictSerSchema(TypedDict, total=False):
@@ -1888,7 +1884,7 @@ class DictSchema(TypedDict, total=False):
     max_length: int
     strict: bool
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: IncExDictOrElseSerSchema
 
 
@@ -1900,7 +1896,7 @@ def dict_schema(
     max_length: int | None = None,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> DictSchema:
     """
@@ -1965,7 +1961,7 @@ class _ValidatorFunctionSchema(TypedDict, total=False):
     function: Required[ValidationFunction]
     schema: Required[CoreSchema]
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
@@ -1980,7 +1976,7 @@ def no_info_before_validator_function(
     *,
     ref: str | None = None,
     json_schema_input_schema: CoreSchema | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> BeforeValidatorFunctionSchema:
     """
@@ -2027,7 +2023,7 @@ def with_info_before_validator_function(
     field_name: str | None = None,
     ref: str | None = None,
     json_schema_input_schema: CoreSchema | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> BeforeValidatorFunctionSchema:
     """
@@ -2081,7 +2077,7 @@ def no_info_after_validator_function(
     *,
     ref: str | None = None,
     json_schema_input_schema: CoreSchema | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> AfterValidatorFunctionSchema:
     """
@@ -2125,7 +2121,7 @@ def with_info_after_validator_function(
     *,
     field_name: str | None = None,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> AfterValidatorFunctionSchema:
     """
@@ -2200,7 +2196,7 @@ class WrapValidatorFunctionSchema(TypedDict, total=False):
     schema: Required[CoreSchema]
     ref: str
     json_schema_input_schema: CoreSchema
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
@@ -2210,7 +2206,7 @@ def no_info_wrap_validator_function(
     *,
     ref: str | None = None,
     json_schema_input_schema: CoreSchema | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> WrapValidatorFunctionSchema:
     """
@@ -2260,7 +2256,7 @@ def with_info_wrap_validator_function(
     field_name: str | None = None,
     json_schema_input_schema: CoreSchema | None = None,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> WrapValidatorFunctionSchema:
     """
@@ -2310,7 +2306,7 @@ class PlainValidatorFunctionSchema(TypedDict, total=False):
     function: Required[ValidationFunction]
     ref: str
     json_schema_input_schema: CoreSchema
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
@@ -2319,7 +2315,7 @@ def no_info_plain_validator_function(
     *,
     ref: str | None = None,
     json_schema_input_schema: CoreSchema | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> PlainValidatorFunctionSchema:
     """
@@ -2360,7 +2356,7 @@ def with_info_plain_validator_function(
     field_name: str | None = None,
     ref: str | None = None,
     json_schema_input_schema: CoreSchema | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> PlainValidatorFunctionSchema:
     """
@@ -2400,13 +2396,13 @@ class WithDefaultSchema(TypedDict, total=False):
     type: Required[Literal['default']]
     schema: Required[CoreSchema]
     default: Any
-    default_factory: Union[Callable[[], Any], Callable[[Dict[str, Any]], Any]]
+    default_factory: Union[Callable[[], Any], Callable[[dict[str, Any]], Any]]
     default_factory_takes_data: bool
     on_error: Literal['raise', 'omit', 'default']  # default: 'raise'
     validate_default: bool  # default: False
     strict: bool
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
@@ -2414,13 +2410,13 @@ def with_default_schema(
     schema: CoreSchema,
     *,
     default: Any = PydanticUndefined,
-    default_factory: Union[Callable[[], Any], Callable[[Dict[str, Any]], Any], None] = None,
+    default_factory: Union[Callable[[], Any], Callable[[dict[str, Any]], Any], None] = None,
     default_factory_takes_data: bool | None = None,
     on_error: Literal['raise', 'omit', 'default'] | None = None,
     validate_default: bool | None = None,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> WithDefaultSchema:
     """
@@ -2471,7 +2467,7 @@ class NullableSchema(TypedDict, total=False):
     schema: Required[CoreSchema]
     strict: bool
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
@@ -2480,7 +2476,7 @@ def nullable_schema(
     *,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> NullableSchema:
     """
@@ -2508,16 +2504,16 @@ def nullable_schema(
 
 class UnionSchema(TypedDict, total=False):
     type: Required[Literal['union']]
-    choices: Required[List[Union[CoreSchema, Tuple[CoreSchema, str]]]]
+    choices: Required[list[Union[CoreSchema, tuple[CoreSchema, str]]]]
     # default true, whether to automatically collapse unions with one element to the inner validator
     auto_collapse: bool
     custom_error_type: str
     custom_error_message: str
-    custom_error_context: Dict[str, Union[str, int, float]]
+    custom_error_context: dict[str, Union[str, int, float]]
     mode: Literal['smart', 'left_to_right']  # default: 'smart'
     strict: bool
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
@@ -2531,7 +2527,7 @@ def union_schema(
     mode: Literal['smart', 'left_to_right'] | None = None,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> UnionSchema:
     """
@@ -2577,20 +2573,20 @@ def union_schema(
 
 class TaggedUnionSchema(TypedDict, total=False):
     type: Required[Literal['tagged-union']]
-    choices: Required[Dict[Hashable, CoreSchema]]
-    discriminator: Required[Union[str, List[Union[str, int]], List[List[Union[str, int]]], Callable[[Any], Hashable]]]
+    choices: Required[dict[Hashable, CoreSchema]]
+    discriminator: Required[Union[str, list[Union[str, int]], list[list[Union[str, int]]], Callable[[Any], Hashable]]]
     custom_error_type: str
     custom_error_message: str
-    custom_error_context: Dict[str, Union[str, int, float]]
+    custom_error_context: dict[str, Union[str, int, float]]
     strict: bool
     from_attributes: bool  # default: True
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
 def tagged_union_schema(
-    choices: Dict[Any, CoreSchema],
+    choices: dict[Any, CoreSchema],
     discriminator: str | list[str | int] | list[list[str | int]] | Callable[[Any], Any],
     *,
     custom_error_type: str | None = None,
@@ -2599,7 +2595,7 @@ def tagged_union_schema(
     strict: bool | None = None,
     from_attributes: bool | None = None,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> TaggedUnionSchema:
     """
@@ -2674,9 +2670,9 @@ def tagged_union_schema(
 
 class ChainSchema(TypedDict, total=False):
     type: Required[Literal['chain']]
-    steps: Required[List[CoreSchema]]
+    steps: Required[list[CoreSchema]]
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
@@ -2684,7 +2680,7 @@ def chain_schema(
     steps: list[CoreSchema],
     *,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> ChainSchema:
     """
@@ -2720,7 +2716,7 @@ class LaxOrStrictSchema(TypedDict, total=False):
     strict_schema: Required[CoreSchema]
     strict: bool
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
@@ -2730,7 +2726,7 @@ def lax_or_strict_schema(
     *,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> LaxOrStrictSchema:
     """
@@ -2783,7 +2779,7 @@ class JsonOrPythonSchema(TypedDict, total=False):
     json_schema: Required[CoreSchema]
     python_schema: Required[CoreSchema]
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
@@ -2792,7 +2788,7 @@ def json_or_python_schema(
     python_schema: CoreSchema,
     *,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> JsonOrPythonSchema:
     """
@@ -2839,10 +2835,10 @@ class TypedDictField(TypedDict, total=False):
     type: Required[Literal['typed-dict-field']]
     schema: Required[CoreSchema]
     required: bool
-    validation_alias: Union[str, List[Union[str, int]], List[List[Union[str, int]]]]
+    validation_alias: Union[str, list[Union[str, int]], list[list[Union[str, int]]]]
     serialization_alias: str
     serialization_exclude: bool  # default: False
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
 
 
 def typed_dict_field(
@@ -2852,7 +2848,7 @@ def typed_dict_field(
     validation_alias: str | list[str | int] | list[list[str | int]] | None = None,
     serialization_alias: str | None = None,
     serialization_exclude: bool | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
 ) -> TypedDictField:
     """
     Returns a schema that matches a typed dict field, e.g.:
@@ -2884,9 +2880,9 @@ def typed_dict_field(
 
 class TypedDictSchema(TypedDict, total=False):
     type: Required[Literal['typed-dict']]
-    fields: Required[Dict[str, TypedDictField]]
-    cls: Type[Any]
-    computed_fields: List[ComputedField]
+    fields: Required[dict[str, TypedDictField]]
+    cls: type[Any]
+    computed_fields: list[ComputedField]
     strict: bool
     extras_schema: CoreSchema
     # all these values can be set via config, equivalent fields have `typed_dict_` prefix
@@ -2894,15 +2890,15 @@ class TypedDictSchema(TypedDict, total=False):
     total: bool  # default: True
     populate_by_name: bool  # replaces `allow_population_by_field_name` in pydantic v1
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
     config: CoreConfig
 
 
 def typed_dict_schema(
-    fields: Dict[str, TypedDictField],
+    fields: dict[str, TypedDictField],
     *,
-    cls: Type[Any] | None = None,
+    cls: type[Any] | None = None,
     computed_fields: list[ComputedField] | None = None,
     strict: bool | None = None,
     extras_schema: CoreSchema | None = None,
@@ -2910,7 +2906,7 @@ def typed_dict_schema(
     total: bool | None = None,
     populate_by_name: bool | None = None,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
     config: CoreConfig | None = None,
 ) -> TypedDictSchema:
@@ -2965,11 +2961,11 @@ class MyTypedDict(TypedDict):
 class ModelField(TypedDict, total=False):
     type: Required[Literal['model-field']]
     schema: Required[CoreSchema]
-    validation_alias: Union[str, List[Union[str, int]], List[List[Union[str, int]]]]
+    validation_alias: Union[str, list[Union[str, int]], list[list[Union[str, int]]]]
     serialization_alias: str
     serialization_exclude: bool  # default: False
     frozen: bool
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
 
 
 def model_field(
@@ -2979,7 +2975,7 @@ def model_field(
     serialization_alias: str | None = None,
     serialization_exclude: bool | None = None,
     frozen: bool | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
 ) -> ModelField:
     """
     Returns a schema for a model field, e.g.:
@@ -3011,9 +3007,9 @@ def model_field(
 
 class ModelFieldsSchema(TypedDict, total=False):
     type: Required[Literal['model-fields']]
-    fields: Required[Dict[str, ModelField]]
+    fields: Required[dict[str, ModelField]]
     model_name: str
-    computed_fields: List[ComputedField]
+    computed_fields: list[ComputedField]
     strict: bool
     extras_schema: CoreSchema
     # all these values can be set via config, equivalent fields have `typed_dict_` prefix
@@ -3021,12 +3017,12 @@ class ModelFieldsSchema(TypedDict, total=False):
     populate_by_name: bool  # replaces `allow_population_by_field_name` in pydantic v1
     from_attributes: bool
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
 def model_fields_schema(
-    fields: Dict[str, ModelField],
+    fields: dict[str, ModelField],
     *,
     model_name: str | None = None,
     computed_fields: list[ComputedField] | None = None,
@@ -3036,7 +3032,7 @@ def model_fields_schema(
     populate_by_name: bool | None = None,
     from_attributes: bool | None = None,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> ModelFieldsSchema:
     """
@@ -3084,8 +3080,8 @@ def model_fields_schema(
 
 class ModelSchema(TypedDict, total=False):
     type: Required[Literal['model']]
-    cls: Required[Type[Any]]
-    generic_origin: Type[Any]
+    cls: Required[type[Any]]
+    generic_origin: type[Any]
     schema: Required[CoreSchema]
     custom_init: bool
     root_model: bool
@@ -3096,15 +3092,15 @@ class ModelSchema(TypedDict, total=False):
     extra_behavior: ExtraBehavior
     config: CoreConfig
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
 def model_schema(
-    cls: Type[Any],
+    cls: type[Any],
     schema: CoreSchema,
     *,
-    generic_origin: Type[Any] | None = None,
+    generic_origin: type[Any] | None = None,
     custom_init: bool | None = None,
     root_model: bool | None = None,
     post_init: str | None = None,
@@ -3114,7 +3110,7 @@ def model_schema(
     extra_behavior: ExtraBehavior | None = None,
     config: CoreConfig | None = None,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> ModelSchema:
     """
@@ -3193,10 +3189,10 @@ class DataclassField(TypedDict, total=False):
     init: bool  # default: True
     init_only: bool  # default: False
     frozen: bool  # default: False
-    validation_alias: Union[str, List[Union[str, int]], List[List[Union[str, int]]]]
+    validation_alias: Union[str, list[Union[str, int]], list[list[Union[str, int]]]]
     serialization_alias: str
     serialization_exclude: bool  # default: False
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
 
 
 def dataclass_field(
@@ -3209,7 +3205,7 @@ def dataclass_field(
     validation_alias: str | list[str | int] | list[list[str | int]] | None = None,
     serialization_alias: str | None = None,
     serialization_exclude: bool | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     frozen: bool | None = None,
 ) -> DataclassField:
     """
@@ -3256,12 +3252,12 @@ def dataclass_field(
 class DataclassArgsSchema(TypedDict, total=False):
     type: Required[Literal['dataclass-args']]
     dataclass_name: Required[str]
-    fields: Required[List[DataclassField]]
-    computed_fields: List[ComputedField]
+    fields: Required[list[DataclassField]]
+    computed_fields: list[ComputedField]
     populate_by_name: bool  # default: False
     collect_init_only: bool  # default: False
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
     extra_behavior: ExtraBehavior
 
@@ -3270,11 +3266,11 @@ def dataclass_args_schema(
     dataclass_name: str,
     fields: list[DataclassField],
     *,
-    computed_fields: List[ComputedField] | None = None,
+    computed_fields: list[ComputedField] | None = None,
     populate_by_name: bool | None = None,
     collect_init_only: bool | None = None,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
     extra_behavior: ExtraBehavior | None = None,
 ) -> DataclassArgsSchema:
@@ -3322,34 +3318,34 @@ def dataclass_args_schema(
 
 class DataclassSchema(TypedDict, total=False):
     type: Required[Literal['dataclass']]
-    cls: Required[Type[Any]]
-    generic_origin: Type[Any]
+    cls: Required[type[Any]]
+    generic_origin: type[Any]
     schema: Required[CoreSchema]
-    fields: Required[List[str]]
+    fields: Required[list[str]]
     cls_name: str
     post_init: bool  # default: False
     revalidate_instances: Literal['always', 'never', 'subclass-instances']  # default: 'never'
     strict: bool  # default: False
     frozen: bool  # default False
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
     slots: bool
     config: CoreConfig
 
 
 def dataclass_schema(
-    cls: Type[Any],
+    cls: type[Any],
     schema: CoreSchema,
-    fields: List[str],
+    fields: list[str],
     *,
-    generic_origin: Type[Any] | None = None,
+    generic_origin: type[Any] | None = None,
     cls_name: str | None = None,
     post_init: bool | None = None,
     revalidate_instances: Literal['always', 'never', 'subclass-instances'] | None = None,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
     frozen: bool | None = None,
     slots: bool | None = None,
@@ -3401,7 +3397,7 @@ class ArgumentsParameter(TypedDict, total=False):
     name: Required[str]
     schema: Required[CoreSchema]
     mode: Literal['positional_only', 'positional_or_keyword', 'keyword_only']  # default positional_or_keyword
-    alias: Union[str, List[Union[str, int]], List[List[Union[str, int]]]]
+    alias: Union[str, list[Union[str, int]], list[list[Union[str, int]]]]
 
 
 def arguments_parameter(
@@ -3439,13 +3435,13 @@ def arguments_parameter(
 
 class ArgumentsSchema(TypedDict, total=False):
     type: Required[Literal['arguments']]
-    arguments_schema: Required[List[ArgumentsParameter]]
+    arguments_schema: Required[list[ArgumentsParameter]]
     populate_by_name: bool
     var_args_schema: CoreSchema
     var_kwargs_mode: VarKwargsMode
     var_kwargs_schema: CoreSchema
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
@@ -3457,7 +3453,7 @@ def arguments_schema(
     var_kwargs_mode: VarKwargsMode | None = None,
     var_kwargs_schema: CoreSchema | None = None,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> ArgumentsSchema:
     """
@@ -3509,7 +3505,7 @@ class CallSchema(TypedDict, total=False):
     function_name: str  # default function.__name__
     return_schema: CoreSchema
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
@@ -3520,7 +3516,7 @@ def call_schema(
     function_name: str | None = None,
     return_schema: CoreSchema | None = None,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> CallSchema:
     """
@@ -3572,9 +3568,9 @@ class CustomErrorSchema(TypedDict, total=False):
     schema: Required[CoreSchema]
     custom_error_type: Required[str]
     custom_error_message: str
-    custom_error_context: Dict[str, Union[str, int, float]]
+    custom_error_context: dict[str, Union[str, int, float]]
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
@@ -3585,7 +3581,7 @@ def custom_error_schema(
     custom_error_message: str | None = None,
     custom_error_context: dict[str, Any] | None = None,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> CustomErrorSchema:
     """
@@ -3628,7 +3624,7 @@ class JsonSchema(TypedDict, total=False):
     type: Required[Literal['json']]
     schema: CoreSchema
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
@@ -3636,7 +3632,7 @@ def json_schema(
     schema: CoreSchema | None = None,
     *,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> JsonSchema:
     """
@@ -3681,14 +3677,14 @@ class MyModel:
 class UrlSchema(TypedDict, total=False):
     type: Required[Literal['url']]
     max_length: int
-    allowed_schemes: List[str]
+    allowed_schemes: list[str]
     host_required: bool  # default False
     default_host: str
     default_port: int
     default_path: str
     strict: bool
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
@@ -3702,7 +3698,7 @@ def url_schema(
     default_path: str | None = None,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> UrlSchema:
     """
@@ -3747,14 +3743,14 @@ def url_schema(
 class MultiHostUrlSchema(TypedDict, total=False):
     type: Required[Literal['multi-host-url']]
     max_length: int
-    allowed_schemes: List[str]
+    allowed_schemes: list[str]
     host_required: bool  # default False
     default_host: str
     default_port: int
     default_path: str
     strict: bool
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
@@ -3768,7 +3764,7 @@ def multi_host_url_schema(
     default_path: str | None = None,
     strict: bool | None = None,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> MultiHostUrlSchema:
     """
@@ -3813,8 +3809,8 @@ def multi_host_url_schema(
 class DefinitionsSchema(TypedDict, total=False):
     type: Required[Literal['definitions']]
     schema: Required[CoreSchema]
-    definitions: Required[List[CoreSchema]]
-    metadata: Dict[str, Any]
+    definitions: Required[list[CoreSchema]]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
@@ -3845,14 +3841,14 @@ class DefinitionReferenceSchema(TypedDict, total=False):
     type: Required[Literal['definition-ref']]
     schema_ref: Required[str]
     ref: str
-    metadata: Dict[str, Any]
+    metadata: dict[str, Any]
     serialization: SerSchema
 
 
 def definition_reference_schema(
     schema_ref: str,
     ref: str | None = None,
-    metadata: Dict[str, Any] | None = None,
+    metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
 ) -> DefinitionReferenceSchema:
     """
diff --git a/src/errors/location.rs b/src/errors/location.rs
index 9449e26a2..e544eeb38 100644
--- a/src/errors/location.rs
+++ b/src/errors/location.rs
@@ -20,7 +20,7 @@ pub enum LocItem {
     /// integer key, used to get:
     ///   * items from a list
     ///   * items from a tuple
-    ///   * dict with int keys `Dict[int, ...]` (python only)
+    ///   * dict with int keys `dict[int, ...]` (python only)
     ///   * with integer keys in tagged unions
     I(i64),
 }
diff --git a/src/lookup_key.rs b/src/lookup_key.rs
index b3352da70..a89d46522 100644
--- a/src/lookup_key.rs
+++ b/src/lookup_key.rs
@@ -393,7 +393,7 @@ pub(crate) enum PathItem {
     /// string type key, used to get or identify items from a dict or anything that implements `__getitem__`
     /// as above we store both the string and pystring to save creating the pystring for python
     S(String, Py<PyString>),
-    /// integer key, used to get items from a list, tuple OR a dict with int keys `Dict[int, ...]` (python only)
+    /// integer key, used to get items from a list, tuple OR a dict with int keys `dict[int, ...]` (python only)
     Pos(usize),
     Neg(usize),
 }
diff --git a/tests/benchmarks/test_micro_benchmarks.py b/tests/benchmarks/test_micro_benchmarks.py
index a86f698c1..2caa6fc83 100644
--- a/tests/benchmarks/test_micro_benchmarks.py
+++ b/tests/benchmarks/test_micro_benchmarks.py
@@ -9,7 +9,7 @@
 from datetime import date, datetime, timedelta, timezone
 from decimal import Decimal
 from enum import Enum
-from typing import Any, List
+from typing import Any
 from uuid import UUID
 
 import pytest
@@ -325,7 +325,7 @@ class CoreBranch:
     benchmark(v.validate_python, definition_model_data)
 
 
-@pytest.mark.benchmark(group='List[TypedDict]')
+@pytest.mark.benchmark(group='list[TypedDict]')
 def test_list_of_dict_models_core(benchmark):
     v = SchemaValidator(
         {
@@ -344,7 +344,7 @@ def test_list_of_dict_models_core(benchmark):
 list_of_ints_data = ([i for i in range(1000)], [str(i) for i in range(1000)])
 
 
-@pytest.mark.benchmark(group='List[int]')
+@pytest.mark.benchmark(group='list[int]')
 def test_list_of_ints_core_py(benchmark):
     v = SchemaValidator({'type': 'list', 'items_schema': {'type': 'int'}})
 
@@ -354,7 +354,7 @@ def t():
         v.validate_python(list_of_ints_data[1])
 
 
-@pytest.mark.benchmark(group='List[int] JSON')
+@pytest.mark.benchmark(group='list[int] JSON')
 def test_list_of_ints_core_json(benchmark):
     v = SchemaValidator({'type': 'list', 'items_schema': {'type': 'int'}})
 
@@ -392,7 +392,7 @@ def test_list_of_strs_json_uncached(benchmark):
     benchmark(v.validate_json, json_data)
 
 
-@pytest.mark.benchmark(group='List[Any]')
+@pytest.mark.benchmark(group='list[Any]')
 def test_list_of_any_core_py(benchmark):
     v = SchemaValidator({'type': 'list'})
 
@@ -481,7 +481,7 @@ def test_frozenset_of_ints_duplicates_core(benchmark):
 dict_of_ints_data = ({str(i): i for i in range(1000)}, {str(i): str(i) for i in range(1000)})
 
 
-@pytest.mark.benchmark(group='Dict[str, int]')
+@pytest.mark.benchmark(group='dict[str, int]')
 def test_dict_of_ints_core(benchmark):
     v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'str'}, 'values_schema': {'type': 'int'}})
 
@@ -491,7 +491,7 @@ def t():
         v.validate_python(dict_of_ints_data[1])
 
 
-@pytest.mark.benchmark(group='Dict[any, any]')
+@pytest.mark.benchmark(group='dict[any, any]')
 def test_dict_of_any_core(benchmark):
     v = SchemaValidator({'type': 'dict'})
 
@@ -501,7 +501,7 @@ def t():
         v.validate_python(dict_of_ints_data[1])
 
 
-@pytest.mark.benchmark(group='Dict[str, int] JSON')
+@pytest.mark.benchmark(group='dict[str, int] JSON')
 def test_dict_of_ints_core_json(benchmark):
     v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'str'}, 'values_schema': {'type': 'int'}})
 
@@ -516,7 +516,7 @@ def t():
 many_models_data = [{'age': i} for i in range(1000)]
 
 
-@pytest.mark.benchmark(group='List[DictSimpleMode]')
+@pytest.mark.benchmark(group='list[DictSimpleMode]')
 def test_many_models_core_dict(benchmark):
     model_schema = {
         'type': 'list',
@@ -529,7 +529,7 @@ def test_many_models_core_dict(benchmark):
     benchmark(v.validate_python, many_models_data)
 
 
-@pytest.mark.benchmark(group='List[SimpleMode]')
+@pytest.mark.benchmark(group='list[SimpleMode]')
 def test_many_models_core_model(benchmark):
     class MyCoreModel:
         __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__'
@@ -553,7 +553,7 @@ class MyCoreModel:
 list_of_nullable_data = [None if i % 2 else i for i in range(1000)]
 
 
-@pytest.mark.benchmark(group='List[Nullable[int]]')
+@pytest.mark.benchmark(group='list[Nullable[int]]')
 def test_list_of_nullable_core(benchmark):
     v = SchemaValidator({'type': 'list', 'items_schema': {'type': 'nullable', 'schema': {'type': 'int'}}})
 
@@ -1221,7 +1221,7 @@ class SomeStrEnum(str, Enum):
 )
 @pytest.mark.parametrize('py_or_json', ['python', 'json'])
 def test_validate_literal(
-    benchmark: Any, allowed_values: List[Any], input: Any, expected_val_res: Any, py_or_json: str
+    benchmark: Any, allowed_values: list[Any], input: Any, expected_val_res: Any, py_or_json: str
 ) -> None:
     validator = SchemaValidator(core_schema.literal_schema(expected=allowed_values))
 
@@ -1242,7 +1242,7 @@ def test_validate_literal(
 def test_core_root_model(benchmark):
     class MyModel:
         __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__'
-        root: List[int]
+        root: list[int]
 
     v = SchemaValidator(
         core_schema.model_schema(MyModel, core_schema.list_schema(core_schema.int_schema()), root_model=True)
diff --git a/tests/conftest.py b/tests/conftest.py
index bdf59a73c..f41d36b88 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -7,11 +7,10 @@
 import re
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Type
+from typing import Any, Literal
 
 import hypothesis
 import pytest
-from typing_extensions import Literal
 
 from pydantic_core import ArgsKwargs, SchemaValidator, ValidationError, validate_core_schema
 from pydantic_core.core_schema import CoreConfig
@@ -83,7 +82,7 @@ def isinstance_test(self, py_input, strict: bool | None = None, context: Any = N
             return self.validator.isinstance_python(py_input, strict=strict, context=context)
 
 
-PyAndJson = Type[PyAndJsonValidator]
+PyAndJson = type[PyAndJsonValidator]
 
 
 @pytest.fixture(params=['python', 'json'])
@@ -128,7 +127,7 @@ def tmp_work_path(tmp_path: Path):
 
 @pytest.fixture
 def import_execute(request, tmp_work_path: Path):
-    def _import_execute(source: str, *, custom_module_name: 'str | None' = None):
+    def _import_execute(source: str, *, custom_module_name: str | None = None):
         module_name = custom_module_name or request.node.name
 
         module_path = tmp_work_path / f'{module_name}.py'
diff --git a/tests/serializers/test_model.py b/tests/serializers/test_model.py
index 9fa44032a..cb0298622 100644
--- a/tests/serializers/test_model.py
+++ b/tests/serializers/test_model.py
@@ -3,7 +3,7 @@
 import platform
 import warnings
 from random import randint
-from typing import Any, ClassVar, Dict
+from typing import Any, ClassVar
 
 try:
     from functools import cached_property
@@ -407,7 +407,7 @@ def test_advanced_exclude_nested_lists(exclude, expected):
 
     # class SubModel(BaseModel):
     #     k: int
-    #     subsubs: List[SubSubModel]
+    #     subsubs: list[SubSubModel]
 
     sub_model_schema = core_schema.model_schema(
         type('SubModel', (), {}),
@@ -420,7 +420,7 @@ def test_advanced_exclude_nested_lists(exclude, expected):
     )
 
     # class Model(BaseModel):
-    #     subs: List[SubModel]
+    #     subs: list[SubModel]
 
     model_schema = core_schema.model_schema(
         BasicModel,
@@ -1067,7 +1067,7 @@ class InnerModel:
 def test_extra_custom_serializer():
     class Model:
         __slots__ = ('__pydantic_extra__', '__dict__')
-        __pydantic_extra__: Dict[str, Any]
+        __pydantic_extra__: dict[str, Any]
 
     schema = core_schema.model_schema(
         Model,
diff --git a/tests/serializers/test_model_root.py b/tests/serializers/test_model_root.py
index 05600b5b6..b663a2f74 100644
--- a/tests/serializers/test_model_root.py
+++ b/tests/serializers/test_model_root.py
@@ -1,6 +1,6 @@
 import json
 import platform
-from typing import Any, List, Union
+from typing import Any, Union
 
 import pytest
 
@@ -158,14 +158,14 @@ class RModel(RootModel):
     if order == 'BR':
 
         class Model(RootModel):
-            root: List[Union[BModel, RModel]]
+            root: list[Union[BModel, RModel]]
 
         choices = [b_schema, r_schema]
 
     elif order == 'RB':
 
         class Model(RootModel):
-            root: List[Union[RModel, BModel]]
+            root: list[Union[RModel, BModel]]
 
         choices = [r_schema, b_schema]
 
diff --git a/tests/serializers/test_typed_dict.py b/tests/serializers/test_typed_dict.py
index df507a248..5fc9adcda 100644
--- a/tests/serializers/test_typed_dict.py
+++ b/tests/serializers/test_typed_dict.py
@@ -1,5 +1,5 @@
 import json
-from typing import Any, Dict
+from typing import Any
 
 import pytest
 from dirty_equals import IsStrictDict
@@ -9,7 +9,7 @@
 
 
 @pytest.mark.parametrize('extra_behavior_kw', [{}, {'extra_behavior': 'ignore'}, {'extra_behavior': None}])
-def test_typed_dict(extra_behavior_kw: Dict[str, Any]):
+def test_typed_dict(extra_behavior_kw: dict[str, Any]):
     v = SchemaSerializer(
         core_schema.typed_dict_schema(
             {
diff --git a/tests/serializers/test_union.py b/tests/serializers/test_union.py
index 3302741bb..96bfb54f7 100644
--- a/tests/serializers/test_union.py
+++ b/tests/serializers/test_union.py
@@ -5,10 +5,9 @@
 import uuid
 import warnings
 from decimal import Decimal
-from typing import Any, ClassVar, Union
+from typing import Any, ClassVar, Literal, Union
 
 import pytest
-from typing_extensions import Literal
 
 from pydantic_core import PydanticSerializationUnexpectedValue, SchemaSerializer, core_schema
 
diff --git a/tests/test_custom_errors.py b/tests/test_custom_errors.py
index 741ab9679..aa547b085 100644
--- a/tests/test_custom_errors.py
+++ b/tests/test_custom_errors.py
@@ -1,4 +1,4 @@
-from typing import Any, Dict, List, Optional
+from typing import Any, Optional
 from unittest import TestCase
 from unittest.mock import ANY
 
@@ -42,7 +42,7 @@ class CustomLocOverridesError(ValidationError):
         @override
         def errors(
             self, *, include_url: bool = True, include_context: bool = True, include_input: bool = True
-        ) -> List[ErrorDetails]:
+        ) -> list[ErrorDetails]:
             errors = super().errors(
                 include_url=include_url, include_context=include_context, include_input=include_input
             )
@@ -131,7 +131,7 @@ def test_custom_pydantic_error_overrides():
     class CustomErrorWithCustomTemplate(PydanticCustomError):
         @override
         def __new__(
-            cls, error_type: LiteralString, my_custom_setting: str, context: Optional[Dict[str, Any]] = None
+            cls, error_type: LiteralString, my_custom_setting: str, context: Optional[dict[str, Any]] = None
         ) -> Self:
             message_template = (
                 "'{my_custom_value}' setting requires a specific my custom field value, got '{wrong_value}'"
diff --git a/tests/test_garbage_collection.py b/tests/test_garbage_collection.py
index f4e178f26..2b26bf008 100644
--- a/tests/test_garbage_collection.py
+++ b/tests/test_garbage_collection.py
@@ -1,6 +1,7 @@
 import gc
 import platform
-from typing import Any, Iterable
+from collections.abc import Iterable
+from typing import Any
 from weakref import WeakValueDictionary
 
 import pytest
@@ -31,7 +32,7 @@ def __init_subclass__(cls) -> None:
                 core_schema.model_schema(cls, GC_TEST_SCHEMA_INNER), config={'ser_json_timedelta': 'float'}
             )
 
-    cache: 'WeakValueDictionary[int, Any]' = WeakValueDictionary()
+    cache: WeakValueDictionary[int, Any] = WeakValueDictionary()
 
     for _ in range(10_000):
 
@@ -63,7 +64,7 @@ def __init_subclass__(cls) -> None:
                 config=core_schema.CoreConfig(extra_fields_behavior='allow'),
             )
 
-    cache: 'WeakValueDictionary[int, Any]' = WeakValueDictionary()
+    cache: WeakValueDictionary[int, Any] = WeakValueDictionary()
 
     for _ in range(10_000):
 
@@ -105,7 +106,7 @@ def __iter__(self):
         def __next__(self):
             raise StopIteration()
 
-    cache: 'WeakValueDictionary[int, Any]' = WeakValueDictionary()
+    cache: WeakValueDictionary[int, Any] = WeakValueDictionary()
 
     for _ in range(10_000):
         iterable = MyIterable()
diff --git a/tests/test_json.py b/tests/test_json.py
index 378214680..dfa3597e1 100644
--- a/tests/test_json.py
+++ b/tests/test_json.py
@@ -1,7 +1,6 @@
 import json
 import platform
 import re
-from typing import List
 
 import pytest
 from dirty_equals import IsFloatNan, IsList
@@ -249,7 +248,7 @@ def test_to_jsonable_python_fallback():
 
 def test_to_jsonable_python_schema_serializer():
     class Foobar:
-        def __init__(self, my_foo: int, my_inners: List['Foobar']):
+        def __init__(self, my_foo: int, my_inners: list['Foobar']):
             self.my_foo = my_foo
             self.my_inners = my_inners
 
diff --git a/tests/test_tzinfo.py b/tests/test_tzinfo.py
index e67bf9098..4d4279d22 100644
--- a/tests/test_tzinfo.py
+++ b/tests/test_tzinfo.py
@@ -4,12 +4,10 @@
 import sys
 import unittest
 from datetime import datetime, timedelta, timezone, tzinfo
+from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
 
 from pydantic_core import SchemaValidator, TzInfo, core_schema
 
-if sys.version_info >= (3, 9):
-    from zoneinfo import ZoneInfo, ZoneInfoNotFoundError
-
 
 class _ALWAYS_EQ:
     """
@@ -175,7 +173,7 @@ def test_comparison(self):
         self.assertTrue(self.EST == estdatetime.tzinfo)
         self.assertTrue(tz > estdatetime.tzinfo)
 
-        if sys.version_info >= (3, 9) and sys.platform == 'linux':
+        if sys.platform == 'linux':
             try:
                 europe_london = ZoneInfo('Europe/London')
             except ZoneInfoNotFoundError:
diff --git a/tests/validators/test_allow_partial.py b/tests/validators/test_allow_partial.py
index 2cd5a2735..6880283a8 100644
--- a/tests/validators/test_allow_partial.py
+++ b/tests/validators/test_allow_partial.py
@@ -1,4 +1,4 @@
-from typing import Mapping
+from collections.abc import Mapping
 
 import pytest
 from dirty_equals import IsStrictDict
diff --git a/tests/validators/test_bytes.py b/tests/validators/test_bytes.py
index 1a932629e..8b9e6318b 100644
--- a/tests/validators/test_bytes.py
+++ b/tests/validators/test_bytes.py
@@ -1,5 +1,5 @@
 import re
-from typing import Any, Dict
+from typing import Any
 
 import pytest
 
@@ -55,7 +55,7 @@ def test_lax_bytes_validator():
         ({'min_length': 1, 'max_length': 6, 'strict': True}, b'bytes?', b'bytes?'),
     ],
 )
-def test_constrained_bytes_python_bytes(opts: Dict[str, Any], input, expected):
+def test_constrained_bytes_python_bytes(opts: dict[str, Any], input, expected):
     v = SchemaValidator({'type': 'bytes', **opts})
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
@@ -78,7 +78,7 @@ def test_constrained_bytes_python_bytes(opts: Dict[str, Any], input, expected):
         ({}, {}, Err('Input should be a valid bytes')),
     ],
 )
-def test_constrained_bytes(py_and_json: PyAndJson, opts: Dict[str, Any], input, expected):
+def test_constrained_bytes(py_and_json: PyAndJson, opts: dict[str, Any], input, expected):
     v = py_and_json({'type': 'bytes', **opts})
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
diff --git a/tests/validators/test_dataclasses.py b/tests/validators/test_dataclasses.py
index a9b367008..2555c733d 100644
--- a/tests/validators/test_dataclasses.py
+++ b/tests/validators/test_dataclasses.py
@@ -4,7 +4,7 @@
 import re
 import sys
 import weakref
-from typing import Any, ClassVar, Dict, List, Optional, Union
+from typing import Any, ClassVar, Optional, Union
 
 import pytest
 from dirty_equals import IsListOrTuple, IsStr
@@ -968,7 +968,7 @@ class MyModel:
         (core_schema.CoreConfig(extra_fields_behavior='allow'), {'extra_behavior': 'ignore'}),
     ],
 )
-def test_extra_behavior_ignore(config: Union[core_schema.CoreConfig, None], schema_extra_behavior_kw: Dict[str, Any]):
+def test_extra_behavior_ignore(config: Union[core_schema.CoreConfig, None], schema_extra_behavior_kw: dict[str, Any]):
     @dataclasses.dataclass
     class MyModel:
         f: str
@@ -1016,7 +1016,7 @@ class MyModel:
         (core_schema.CoreConfig(extra_fields_behavior='ignore'), {'extra_behavior': 'forbid'}),
     ],
 )
-def test_extra_behavior_forbid(config: Union[core_schema.CoreConfig, None], schema_extra_behavior_kw: Dict[str, Any]):
+def test_extra_behavior_forbid(config: Union[core_schema.CoreConfig, None], schema_extra_behavior_kw: dict[str, Any]):
     @dataclasses.dataclass
     class MyModel:
         f: str
@@ -1062,7 +1062,7 @@ class MyModel:
         (core_schema.CoreConfig(extra_fields_behavior='forbid'), {'extra_behavior': 'allow'}),
     ],
 )
-def test_extra_behavior_allow(config: Union[core_schema.CoreConfig, None], schema_extra_behavior_kw: Dict[str, Any]):
+def test_extra_behavior_allow(config: Union[core_schema.CoreConfig, None], schema_extra_behavior_kw: dict[str, Any]):
     @dataclasses.dataclass
     class MyModel:
         f: str
@@ -1090,7 +1090,7 @@ class MyModel:
 
 
 def test_function_validator_wrapping_args_schema_after() -> None:
-    calls: List[Any] = []
+    calls: list[Any] = []
 
     def func(*args: Any) -> Any:
         calls.append(args)
@@ -1122,7 +1122,7 @@ class Model:
 
 
 def test_function_validator_wrapping_args_schema_before() -> None:
-    calls: List[Any] = []
+    calls: list[Any] = []
 
     def func(*args: Any) -> Any:
         calls.append(args)
@@ -1154,7 +1154,7 @@ class Model:
 
 
 def test_function_validator_wrapping_args_schema_wrap() -> None:
-    calls: List[Any] = []
+    calls: list[Any] = []
 
     def func(*args: Any) -> Any:
         assert len(args) == 2
diff --git a/tests/validators/test_datetime.py b/tests/validators/test_datetime.py
index 96e12cf9c..a48a78a78 100644
--- a/tests/validators/test_datetime.py
+++ b/tests/validators/test_datetime.py
@@ -2,18 +2,12 @@
 import json
 import platform
 import re
+import zoneinfo
 from datetime import date, datetime, time, timedelta, timezone, tzinfo
 from decimal import Decimal
-from typing import Dict
 
 import pytest
 
-try:
-    import zoneinfo
-except ImportError:
-    # TODO: can remove this once we drop support for python 3.8
-    from backports import zoneinfo
-
 from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema, validate_core_schema
 
 from ..conftest import Err, PyAndJson
@@ -508,7 +502,7 @@ def test_tz_constraint_wrong():
 
 def test_tz_hash() -> None:
     v = SchemaValidator(core_schema.datetime_schema())
-    lookup: Dict[datetime, str] = {}
+    lookup: dict[datetime, str] = {}
     for day in range(1, 10):
         input_str = f'2022-06-{day:02}T12:13:14-12:15'
         validated = v.validate_python(input_str)
diff --git a/tests/validators/test_definitions_recursive.py b/tests/validators/test_definitions_recursive.py
index 1d7994054..e835b9075 100644
--- a/tests/validators/test_definitions_recursive.py
+++ b/tests/validators/test_definitions_recursive.py
@@ -1,7 +1,7 @@
 import datetime
 import platform
 from dataclasses import dataclass
-from typing import List, Optional
+from typing import Optional
 
 import pytest
 from dirty_equals import AnyThing, HasAttributes, IsList, IsPartialDict, IsStr, IsTuple
@@ -145,7 +145,7 @@ class Foo:
         height: int
         class Bar:
             width: int
-            bars: List['Bar']
+            bars: list['Bar']
             foo: Optional['Foo']
         bar = Bar
     """
@@ -852,7 +852,7 @@ def test_unsorted_definitions_schema() -> None:
 def test_validate_assignment(pydantic_version) -> None:
     @dataclass
     class Model:
-        x: List['Model']
+        x: list['Model']
 
     schema = core_schema.definitions_schema(
         core_schema.definition_reference_schema('model'),
diff --git a/tests/validators/test_dict.py b/tests/validators/test_dict.py
index 4057ce76e..0d348b347 100644
--- a/tests/validators/test_dict.py
+++ b/tests/validators/test_dict.py
@@ -1,7 +1,7 @@
 import re
 from collections import OrderedDict
 from collections.abc import Mapping
-from typing import Any, Dict
+from typing import Any
 
 import pytest
 from dirty_equals import HasRepr, IsStr
@@ -218,7 +218,7 @@ def __len__(self):
         ),
     ],
 )
-def test_dict_length_constraints(kwargs: Dict[str, Any], input_value, expected):
+def test_dict_length_constraints(kwargs: dict[str, Any], input_value, expected):
     v = SchemaValidator({'type': 'dict', **kwargs})
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
diff --git a/tests/validators/test_float.py b/tests/validators/test_float.py
index c397f453c..c572fc68b 100644
--- a/tests/validators/test_float.py
+++ b/tests/validators/test_float.py
@@ -1,7 +1,7 @@
 import math
 import re
 from decimal import Decimal
-from typing import Any, Dict
+from typing import Any
 
 import pytest
 from dirty_equals import FunctionCheck, IsFloatNan, IsStr
@@ -91,7 +91,7 @@ def test_float_strict(py_and_json: PyAndJson, input_value, expected):
         ({'gt': 0, 'allow_inf_nan': True}, float('inf'), float('inf')),
     ],
 )
-def test_float_kwargs(py_and_json: PyAndJson, kwargs: Dict[str, Any], input_value, expected):
+def test_float_kwargs(py_and_json: PyAndJson, kwargs: dict[str, Any], input_value, expected):
     v = py_and_json({'type': 'float', **kwargs})
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
diff --git a/tests/validators/test_frozenset.py b/tests/validators/test_frozenset.py
index e8ddbfc3b..b17feb95a 100644
--- a/tests/validators/test_frozenset.py
+++ b/tests/validators/test_frozenset.py
@@ -1,6 +1,6 @@
 import re
 from collections import deque
-from typing import Any, Dict
+from typing import Any
 
 import pytest
 
@@ -165,7 +165,7 @@ def generate_repeats():
         ),
     ],
 )
-def test_frozenset_kwargs_python(kwargs: Dict[str, Any], input_value, expected):
+def test_frozenset_kwargs_python(kwargs: dict[str, Any], input_value, expected):
     v = SchemaValidator({'type': 'frozenset', **kwargs})
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
diff --git a/tests/validators/test_function.py b/tests/validators/test_function.py
index e5ccba1e3..544bf416d 100644
--- a/tests/validators/test_function.py
+++ b/tests/validators/test_function.py
@@ -2,7 +2,7 @@
 import platform
 import re
 from copy import deepcopy
-from typing import Any, Dict, List, Type
+from typing import Any
 
 import pytest
 from dirty_equals import HasRepr
@@ -12,7 +12,7 @@
 from ..conftest import plain_repr
 
 
-def deepcopy_info(info: core_schema.ValidationInfo) -> Dict[str, Any]:
+def deepcopy_info(info: core_schema.ValidationInfo) -> dict[str, Any]:
     return {
         'context': deepcopy(info.context),
         'data': deepcopy(info.data),
@@ -560,7 +560,7 @@ def f(input_value, info):
 
 
 @pytest.mark.parametrize('base_error', [ValueError, AssertionError])
-def test_error_with_error(base_error: Type[Exception]):
+def test_error_with_error(base_error: type[Exception]):
     class MyError(base_error):
         def __str__(self):
             raise RuntimeError('internal error')
@@ -915,7 +915,7 @@ def f_w(v: Any, handler: core_schema.ValidatorFunctionWrapHandler, info: core_sc
 
 
 def test_reprs() -> None:
-    reprs: List[str] = []
+    reprs: list[str] = []
 
     def sample_repr(v: Any, info: core_schema.ValidationInfo) -> Any:
         reprs.append(repr(info))
diff --git a/tests/validators/test_int.py b/tests/validators/test_int.py
index a07be2994..c69d6bb9a 100644
--- a/tests/validators/test_int.py
+++ b/tests/validators/test_int.py
@@ -1,7 +1,7 @@
 import json
 import re
 from decimal import Decimal
-from typing import Any, Dict
+from typing import Any
 
 import pytest
 from dirty_equals import IsStr
@@ -325,7 +325,7 @@ def test_int_strict(py_and_json: PyAndJson, input_value, expected):
     ],
     ids=repr,
 )
-def test_int_kwargs(py_and_json: PyAndJson, kwargs: Dict[str, Any], input_value, expected):
+def test_int_kwargs(py_and_json: PyAndJson, kwargs: dict[str, Any], input_value, expected):
     v = py_and_json({'type': 'int', **kwargs})
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)) as exc_info:
diff --git a/tests/validators/test_list.py b/tests/validators/test_list.py
index 6914529f9..ac5c5c051 100644
--- a/tests/validators/test_list.py
+++ b/tests/validators/test_list.py
@@ -1,8 +1,9 @@
 import collections.abc
 import re
 from collections import deque
+from collections.abc import Iterator
 from dataclasses import dataclass
-from typing import Any, Dict, Iterator, List, Union
+from typing import Any, Union
 
 import pytest
 from dirty_equals import Contains, HasRepr, IsInstance, IsList, IsStr
@@ -169,7 +170,7 @@ def test_list_error(input_value, index):
         ),
     ],
 )
-def test_list_length_constraints(kwargs: Dict[str, Any], input_value, expected):
+def test_list_length_constraints(kwargs: dict[str, Any], input_value, expected):
     v = SchemaValidator({'type': 'list', **kwargs})
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
@@ -443,7 +444,7 @@ def test_list_fail_fast(fail_fast, expected):
 
 
 class MySequence(collections.abc.Sequence):
-    def __init__(self, data: List[Any]):
+    def __init__(self, data: list[Any]):
         self._data = data
 
     def __getitem__(self, index: int) -> Any:
@@ -457,7 +458,7 @@ def __repr__(self) -> str:
 
 
 class MyMapping(collections.abc.Mapping):
-    def __init__(self, data: Dict[Any, Any]) -> None:
+    def __init__(self, data: dict[Any, Any]) -> None:
         self._data = data
 
     def __getitem__(self, key: Any) -> Any:
@@ -480,7 +481,7 @@ class ListInputTestCase:
     strict: Union[bool, None] = None
 
 
-LAX_MODE_INPUTS: List[Any] = [
+LAX_MODE_INPUTS: list[Any] = [
     (1, 2, 3),
     frozenset((1, 2, 3)),
     {1, 2, 3},
diff --git a/tests/validators/test_literal.py b/tests/validators/test_literal.py
index d0d1af279..2b3f88a4e 100644
--- a/tests/validators/test_literal.py
+++ b/tests/validators/test_literal.py
@@ -1,6 +1,6 @@
 import re
 from enum import Enum
-from typing import Any, Callable, List
+from typing import Any, Callable
 
 import pytest
 
@@ -317,7 +317,7 @@ class Foo(int, Enum):
         ),
     ],
 )
-def test_mix_int_enum_with_int(reverse: Callable[[List[Any]], List[Any]], err: Any):
+def test_mix_int_enum_with_int(reverse: Callable[[list[Any]], list[Any]], err: Any):
     class Foo(int, Enum):
         foo = 1
 
@@ -363,7 +363,7 @@ class Foo(int, Enum):
         ),
     ],
 )
-def test_mix_str_enum_with_str(reverse: Callable[[List[Any]], List[Any]], err: Any):
+def test_mix_str_enum_with_str(reverse: Callable[[list[Any]], list[Any]], err: Any):
     class Foo(str, Enum):
         foo = 'foo_val'
 
diff --git a/tests/validators/test_model.py b/tests/validators/test_model.py
index 8814a5e65..1d6ab7f47 100644
--- a/tests/validators/test_model.py
+++ b/tests/validators/test_model.py
@@ -2,7 +2,7 @@
 import sys
 from copy import deepcopy
 from decimal import Decimal
-from typing import Any, Callable, Dict, List, Set, Tuple
+from typing import Any, Callable
 
 import pytest
 from dirty_equals import HasRepr, IsInstance
@@ -206,8 +206,8 @@ def __init__(self, **kwargs: Any) -> None:
             self.__dict__.update(kwargs)
 
     def f(
-        input_value: Dict[str, Any],
-        validator: Callable[[Dict[str, Any]], Dict[str, Any]],
+        input_value: dict[str, Any],
+        validator: Callable[[dict[str, Any]], dict[str, Any]],
         info: core_schema.ValidationInfo,
     ):
         assert input_value['field_a'] == 123
@@ -244,7 +244,7 @@ class MyModel:
         def __init__(self, **kwargs: Any) -> None:
             self.__dict__.update(kwargs)
 
-    def f(input_value: Dict[str, Any], info: core_schema.ValidationInfo):
+    def f(input_value: dict[str, Any], info: core_schema.ValidationInfo):
         assert input_value['field_a'] == 123
         return input_value
 
@@ -278,7 +278,7 @@ class MyModel:
         def __init__(self, **kwargs: Any) -> None:
             self.__dict__.update(kwargs)
 
-    def f(input_value_and_fields_set: Tuple[Dict[str, Any], Set[str]]):
+    def f(input_value_and_fields_set: tuple[dict[str, Any], set[str]]):
         input_value, _, _ = input_value_and_fields_set
         assert input_value['field_a'] == 123
         return input_value_and_fields_set
@@ -1078,7 +1078,7 @@ class MyModel:
         field_b: int
         field_c: int
 
-    calls: List[Any] = []
+    calls: list[Any] = []
 
     def func(x, info):
         calls.append(str(info))
@@ -1214,7 +1214,7 @@ def test_validate_assignment_model_validator_function(function_schema: Any, call
     class Model:
         __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__'
 
-    calls: List[Any] = []
+    calls: list[Any] = []
 
     def f(values_or_values_and_fields_set: Any, *args: Any) -> Any:
         if len(args) == 2:
diff --git a/tests/validators/test_model_fields.py b/tests/validators/test_model_fields.py
index 8a22d96c3..491a3baf8 100644
--- a/tests/validators/test_model_fields.py
+++ b/tests/validators/test_model_fields.py
@@ -1,9 +1,10 @@
 import math
 import re
 import sys
+from collections.abc import Mapping
 from dataclasses import dataclass
 from datetime import datetime
-from typing import Any, Dict, List, Mapping, Union
+from typing import Any, Union
 
 import pytest
 from dirty_equals import FunctionCheck, HasRepr, IsStr
@@ -1182,7 +1183,7 @@ def test_from_attributes_extra_ignore_no_attributes_accessed() -> None:
         }
     )
 
-    accessed: List[str] = []
+    accessed: list[str] = []
 
     class Source:
         a = 1
@@ -1667,8 +1668,8 @@ def test_frozen_field():
 )
 def test_extra_behavior_allow(
     config: Union[core_schema.CoreConfig, None],
-    schema_extra_behavior_kw: Dict[str, Any],
-    extras_schema_kw: Dict[str, Any],
+    schema_extra_behavior_kw: dict[str, Any],
+    extras_schema_kw: dict[str, Any],
     expected_extra_value: Any,
 ):
     v = SchemaValidator(
@@ -1702,7 +1703,7 @@ def test_extra_behavior_allow(
         (core_schema.CoreConfig(extra_fields_behavior='allow'), {'extra_behavior': 'forbid'}),
     ],
 )
-def test_extra_behavior_forbid(config: Union[core_schema.CoreConfig, None], schema_extra_behavior_kw: Dict[str, Any]):
+def test_extra_behavior_forbid(config: Union[core_schema.CoreConfig, None], schema_extra_behavior_kw: dict[str, Any]):
     v = SchemaValidator(
         core_schema.model_fields_schema(
             {'f': core_schema.model_field(core_schema.str_schema())}, **schema_extra_behavior_kw
@@ -1749,7 +1750,7 @@ def test_extra_behavior_forbid(config: Union[core_schema.CoreConfig, None], sche
         (None, {'extra_behavior': None}),
     ],
 )
-def test_extra_behavior_ignore(config: Union[core_schema.CoreConfig, None], schema_extra_behavior_kw: Dict[str, Any]):
+def test_extra_behavior_ignore(config: Union[core_schema.CoreConfig, None], schema_extra_behavior_kw: dict[str, Any]):
     v = SchemaValidator(
         core_schema.model_fields_schema(
             {'f': core_schema.model_field(core_schema.str_schema())}, **schema_extra_behavior_kw
diff --git a/tests/validators/test_model_root.py b/tests/validators/test_model_root.py
index 8daa326ea..4e0a55048 100644
--- a/tests/validators/test_model_root.py
+++ b/tests/validators/test_model_root.py
@@ -1,5 +1,3 @@
-from typing import List
-
 import pytest
 
 from pydantic_core import PydanticUndefined, SchemaValidator, ValidationError, core_schema
@@ -8,7 +6,7 @@
 def test_model_root():
     class RootModel:
         __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__'
-        root: List[int]
+        root: list[int]
 
     v = SchemaValidator(
         core_schema.model_schema(RootModel, core_schema.list_schema(core_schema.int_schema()), root_model=True)
@@ -36,7 +34,7 @@ class RootModel:
 def test_revalidate():
     class RootModel:
         __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__'
-        root: List[int]
+        root: list[int]
 
     v = SchemaValidator(
         core_schema.model_schema(
diff --git a/tests/validators/test_set.py b/tests/validators/test_set.py
index 3c044658c..b5d35abf3 100644
--- a/tests/validators/test_set.py
+++ b/tests/validators/test_set.py
@@ -1,6 +1,6 @@
 import re
 from collections import deque
-from typing import Any, Dict
+from typing import Any
 
 import pytest
 
@@ -146,7 +146,7 @@ def generate_repeats():
     ],
     ids=repr,
 )
-def test_set_kwargs(kwargs: Dict[str, Any], input_value, expected):
+def test_set_kwargs(kwargs: dict[str, Any], input_value, expected):
     v = SchemaValidator({'type': 'set', **kwargs})
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
diff --git a/tests/validators/test_string.py b/tests/validators/test_string.py
index d7ae3e5ab..864125a47 100644
--- a/tests/validators/test_string.py
+++ b/tests/validators/test_string.py
@@ -2,7 +2,7 @@
 import sys
 from decimal import Decimal
 from numbers import Number
-from typing import Any, Dict, Union
+from typing import Any, Union
 
 import pytest
 
@@ -90,7 +90,7 @@ def test_str_not_json(input_value, expected):
         ({'min_length': 1}, '🐈 Hello', '🐈 Hello'),
     ],
 )
-def test_constrained_str(py_and_json: PyAndJson, kwargs: Dict[str, Any], input_value, expected):
+def test_constrained_str(py_and_json: PyAndJson, kwargs: dict[str, Any], input_value, expected):
     v = py_and_json({'type': 'str', **kwargs})
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
@@ -111,7 +111,7 @@ def test_constrained_str(py_and_json: PyAndJson, kwargs: Dict[str, Any], input_v
         ),
     ],
 )
-def test_constrained_str_py_only(kwargs: Dict[str, Any], input_value, expected):
+def test_constrained_str_py_only(kwargs: dict[str, Any], input_value, expected):
     v = SchemaValidator({'type': 'str', **kwargs})
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
diff --git a/tests/validators/test_time.py b/tests/validators/test_time.py
index 360cda644..1061cd063 100644
--- a/tests/validators/test_time.py
+++ b/tests/validators/test_time.py
@@ -1,7 +1,7 @@
 import re
 from datetime import date, datetime, time, timedelta, timezone
 from decimal import Decimal
-from typing import Any, Dict
+from typing import Any
 
 import pytest
 
@@ -158,7 +158,7 @@ def test_time_strict_json(input_value, expected):
         ({'gt': time(12, 13, 14, 123_456)}, '12:13:14.123456', Err('Input should be greater than 12:13:14.123456')),
     ],
 )
-def test_time_kwargs(kwargs: Dict[str, Any], input_value, expected):
+def test_time_kwargs(kwargs: dict[str, Any], input_value, expected):
     v = SchemaValidator({'type': 'time', **kwargs})
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)) as exc_info:
diff --git a/tests/validators/test_timedelta.py b/tests/validators/test_timedelta.py
index 7ef45eaa0..6f9f9133f 100644
--- a/tests/validators/test_timedelta.py
+++ b/tests/validators/test_timedelta.py
@@ -1,7 +1,7 @@
 import re
 from datetime import timedelta
 from decimal import Decimal
-from typing import Any, Dict
+from typing import Any
 
 import pytest
 
@@ -178,7 +178,7 @@ def test_timedelta_strict_json(input_value, expected):
     ],
     ids=repr,
 )
-def test_timedelta_kwargs(kwargs: Dict[str, Any], input_value, expected):
+def test_timedelta_kwargs(kwargs: dict[str, Any], input_value, expected):
     v = SchemaValidator({'type': 'timedelta', **kwargs})
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
diff --git a/tests/validators/test_tuple.py b/tests/validators/test_tuple.py
index d25ef9547..986b7fcd0 100644
--- a/tests/validators/test_tuple.py
+++ b/tests/validators/test_tuple.py
@@ -1,6 +1,6 @@
 import re
 from collections import deque
-from typing import Any, Dict, Type
+from typing import Any
 
 import pytest
 from dirty_equals import IsNonNegative, IsTuple
@@ -82,7 +82,7 @@ def test_empty_positional_tuple(fail_fast):
     'variadic_item_index,items', [(0, [{'type': 'int'}]), (None, [{'type': 'int'}, {'type': 'int'}, {'type': 'int'}])]
 )
 @pytest.mark.parametrize('wrong_coll_type', [list, set, frozenset])
-def test_tuple_strict_fails_without_tuple(wrong_coll_type: Type[Any], variadic_item_index, items):
+def test_tuple_strict_fails_without_tuple(wrong_coll_type: type[Any], variadic_item_index, items):
     v = SchemaValidator(
         core_schema.tuple_schema(variadic_item_index=variadic_item_index, items_schema=items, strict=True)
     )
@@ -123,7 +123,7 @@ def test_tuple_strict_fails_without_tuple(wrong_coll_type: Type[Any], variadic_i
     ],
     ids=repr,
 )
-def test_tuple_var_len_kwargs(kwargs: Dict[str, Any], input_value, expected):
+def test_tuple_var_len_kwargs(kwargs: dict[str, Any], input_value, expected):
     v = SchemaValidator({'type': 'tuple', 'items_schema': [{'type': 'any'}], 'variadic_item_index': 0, **kwargs})
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
diff --git a/tests/validators/test_typed_dict.py b/tests/validators/test_typed_dict.py
index dc18cd86e..9d543ea4f 100644
--- a/tests/validators/test_typed_dict.py
+++ b/tests/validators/test_typed_dict.py
@@ -3,7 +3,8 @@
 import platform
 import re
 import weakref
-from typing import Any, Dict, Mapping, Union
+from collections.abc import Mapping
+from typing import Any, Union
 
 import pytest
 from dirty_equals import FunctionCheck
@@ -1097,8 +1098,8 @@ def wrap_function(input_value, validator, info):
 )
 def test_extra_behavior_allow(
     config: Union[core_schema.CoreConfig, None],
-    schema_extra_behavior_kw: Dict[str, Any],
-    extras_schema_kw: Dict[str, Any],
+    schema_extra_behavior_kw: dict[str, Any],
+    extras_schema_kw: dict[str, Any],
     expected_extra_value: Any,
 ):
     v = SchemaValidator(
@@ -1110,7 +1111,7 @@ def test_extra_behavior_allow(
         )
     )
 
-    m: Dict[str, Any] = v.validate_python({'f': 'x', 'extra_field': '123'})
+    m: dict[str, Any] = v.validate_python({'f': 'x', 'extra_field': '123'})
     assert m == {'f': 'x', 'extra_field': expected_extra_value}
 
 
@@ -1124,14 +1125,14 @@ def test_extra_behavior_allow(
         (core_schema.CoreConfig(extra_fields_behavior='allow'), {'extra_behavior': 'forbid'}),
     ],
 )
-def test_extra_behavior_forbid(config: Union[core_schema.CoreConfig, None], schema_extra_behavior_kw: Dict[str, Any]):
+def test_extra_behavior_forbid(config: Union[core_schema.CoreConfig, None], schema_extra_behavior_kw: dict[str, Any]):
     v = SchemaValidator(
         core_schema.typed_dict_schema(
             {'f': core_schema.typed_dict_field(core_schema.str_schema())}, **schema_extra_behavior_kw, config=config
         )
     )
 
-    m: Dict[str, Any] = v.validate_python({'f': 'x'})
+    m: dict[str, Any] = v.validate_python({'f': 'x'})
     assert m == {'f': 'x'}
 
     with pytest.raises(ValidationError) as exc_info:
@@ -1153,7 +1154,7 @@ def test_extra_behavior_forbid(config: Union[core_schema.CoreConfig, None], sche
         (None, {'extra_behavior': None}),
     ],
 )
-def test_extra_behavior_ignore(config: Union[core_schema.CoreConfig, None], schema_extra_behavior_kw: Dict[str, Any]):
+def test_extra_behavior_ignore(config: Union[core_schema.CoreConfig, None], schema_extra_behavior_kw: dict[str, Any]):
     v = SchemaValidator(
         core_schema.typed_dict_schema(
             {'f': core_schema.typed_dict_field(core_schema.str_schema())}, **schema_extra_behavior_kw
@@ -1161,7 +1162,7 @@ def test_extra_behavior_ignore(config: Union[core_schema.CoreConfig, None], sche
         config=config,
     )
 
-    m: Dict[str, Any] = v.validate_python({'f': 'x', 'extra_field': 123})
+    m: dict[str, Any] = v.validate_python({'f': 'x', 'extra_field': 123})
     assert m == {'f': 'x'}
 
 
diff --git a/tests/validators/test_union.py b/tests/validators/test_union.py
index 7f9b4b424..1951fb3de 100644
--- a/tests/validators/test_union.py
+++ b/tests/validators/test_union.py
@@ -2,7 +2,7 @@
 from datetime import date, time
 from enum import Enum, IntEnum
 from itertools import permutations
-from typing import Any, List, Optional, Union
+from typing import Any, Optional, Union
 from uuid import UUID
 
 import pytest
@@ -808,7 +808,7 @@ class ModelA:
     assert validator.validate_python(True) is True
 
 
-def permute_choices(choices: List[core_schema.CoreSchema]) -> List[List[core_schema.CoreSchema]]:
+def permute_choices(choices: list[core_schema.CoreSchema]) -> list[list[core_schema.CoreSchema]]:
     return [list(p) for p in permutations(choices)]
 
 
diff --git a/tests/validators/test_url.py b/tests/validators/test_url.py
index 59489dd00..e8534a26a 100644
--- a/tests/validators/test_url.py
+++ b/tests/validators/test_url.py
@@ -1,6 +1,6 @@
 import re
 from copy import deepcopy
-from typing import Dict, Optional, Union
+from typing import Optional, Union
 
 import pytest
 from dirty_equals import HasRepr, IsInstance
@@ -1169,7 +1169,7 @@ def test_multi_host_url_bool() -> None:
 
 
 def test_multi_host_url_hash() -> None:
-    data: Dict[MultiHostUrl, int] = {}
+    data: dict[MultiHostUrl, int] = {}
 
     data[MultiHostUrl('http://example.com,www.example.com')] = 1
     assert data == {MultiHostUrl('http://example.com,www.example.com/'): 1}
@@ -1208,7 +1208,7 @@ def test_url_bool() -> None:
 
 
 def test_url_hash() -> None:
-    data: Dict[Url, int] = {}
+    data: dict[Url, int] = {}
 
     data[Url('http://example.com')] = 1
     assert data == {Url('http://example.com/'): 1}
diff --git a/tests/validators/test_with_default.py b/tests/validators/test_with_default.py
index 105241140..a27b80268 100644
--- a/tests/validators/test_with_default.py
+++ b/tests/validators/test_with_default.py
@@ -3,7 +3,7 @@
 import sys
 import weakref
 from collections import deque
-from typing import Any, Callable, Dict, List, Union, cast
+from typing import Any, Callable, Union, cast
 
 import pytest
 
@@ -437,8 +437,8 @@ def test_deepcopy_mutable_defaults():
     stored_empty_dict = {}
 
     class Model:
-        int_list_with_default: List[int] = stored_empty_list
-        str_dict_with_default: Dict[str, str] = stored_empty_dict
+        int_list_with_default: list[int] = stored_empty_list
+        str_dict_with_default: dict[str, str] = stored_empty_dict
 
     v = SchemaValidator(
         {
diff --git a/uv.lock b/uv.lock
index 17e350df9..ee00fd9c9 100644
--- a/uv.lock
+++ b/uv.lock
@@ -1,64 +1,34 @@
 version = 1
-requires-python = ">=3.8"
+requires-python = ">=3.9"
 resolution-markers = [
-    "python_full_version < '3.9' or (python_full_version < '3.12' and implementation_name != 'cpython') or (python_full_version < '3.12' and platform_machine != 'x86_64')",
-    "(python_full_version == '3.12.*' and implementation_name != 'cpython') or (python_full_version == '3.12.*' and platform_machine != 'x86_64') or (python_full_version == '3.13.*' and implementation_name != 'cpython') or python_full_version >= '3.14'",
     "python_full_version == '3.13.*' and implementation_name == 'cpython'",
-    "python_full_version >= '3.9' and python_full_version < '3.11' and implementation_name == 'cpython' and platform_machine == 'x86_64'",
-    "python_full_version == '3.11.*' and implementation_name == 'cpython' and platform_machine == 'x86_64'",
-    "python_full_version == '3.12.*' and implementation_name == 'cpython' and platform_machine == 'x86_64'",
+    "(python_full_version >= '3.12' and implementation_name != 'cpython') or (python_full_version == '3.12.*' and implementation_name == 'cpython') or (python_full_version >= '3.14' and implementation_name == 'cpython')",
+    "python_full_version == '3.11.*'",
+    "python_full_version == '3.10.*'",
+    "python_full_version < '3.10'",
 ]
 
 [[package]]
 name = "asttokens"
-version = "2.4.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "six" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/45/1d/f03bcb60c4a3212e15f99a56085d93093a497718adf828d050b9d675da81/asttokens-2.4.1.tar.gz", hash = "sha256:b03869718ba9a6eb027e134bfdf69f38a236d681c83c160d510768af11254ba0", size = 62284 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/45/86/4736ac618d82a20d87d2f92ae19441ebc7ac9e7a581d7e58bbe79233b24a/asttokens-2.4.1-py2.py3-none-any.whl", hash = "sha256:051ed49c3dcae8913ea7cd08e46a606dba30b79993209636c4875bc1d637bc24", size = 27764 },
-]
-
-[[package]]
-name = "astunparse"
-version = "1.6.3"
+version = "3.0.0"
 source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "six", marker = "python_full_version < '3.9' or (python_full_version < '3.12' and implementation_name != 'cpython') or (python_full_version < '3.12' and platform_machine != 'x86_64')" },
-    { name = "wheel", marker = "python_full_version < '3.9' or (python_full_version < '3.12' and implementation_name != 'cpython') or (python_full_version < '3.12' and platform_machine != 'x86_64')" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/f3/af/4182184d3c338792894f34a62672919db7ca008c89abee9b564dd34d8029/astunparse-1.6.3.tar.gz", hash = "sha256:5ad93a8456f0d084c3456d059fd9a92cce667963232cbf763eac3bc5b7940872", size = 18290 }
+sdist = { url = "https://files.pythonhosted.org/packages/4a/e7/82da0a03e7ba5141f05cce0d302e6eed121ae055e0456ca228bf693984bc/asttokens-3.0.0.tar.gz", hash = "sha256:0dcd8baa8d62b0c1d118b399b2ddba3c4aff271d0d7a9e0d4c1681c79035bbc7", size = 61978 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2b/03/13dde6512ad7b4557eb792fbcf0c653af6076b81e5941d36ec61f7ce6028/astunparse-1.6.3-py2.py3-none-any.whl", hash = "sha256:c2652417f2c8b5bb325c885ae329bdf3f86424075c4fd1a128674bc6fba4b8e8", size = 12732 },
+    { url = "https://files.pythonhosted.org/packages/25/8a/c46dcc25341b5bce5472c718902eb3d38600a903b14fa6aeecef3f21a46f/asttokens-3.0.0-py3-none-any.whl", hash = "sha256:e3078351a059199dd5138cb1c706e6430c05eff2ff136af5eb4790f9d28932e2", size = 26918 },
 ]
 
 [[package]]
 name = "attrs"
-version = "24.2.0"
+version = "24.3.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/fc/0f/aafca9af9315aee06a89ffde799a10a582fe8de76c563ee80bbcdc08b3fb/attrs-24.2.0.tar.gz", hash = "sha256:5cfb1b9148b5b086569baec03f20d7b6bf3bcacc9a42bebf87ffaaca362f6346", size = 792678 }
+sdist = { url = "https://files.pythonhosted.org/packages/48/c8/6260f8ccc11f0917360fc0da435c5c9c7504e3db174d5a12a1494887b045/attrs-24.3.0.tar.gz", hash = "sha256:8f5c07333d543103541ba7be0e2ce16eeee8130cb0b3f9238ab904ce1e85baff", size = 805984 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/6a/21/5b6702a7f963e95456c0de2d495f67bf5fd62840ac655dc451586d23d39a/attrs-24.2.0-py3-none-any.whl", hash = "sha256:81921eb96de3191c8258c199618104dd27ac608d9366f5e35d011eae1867ede2", size = 63001 },
-]
-
-[[package]]
-name = "backports-zoneinfo"
-version = "0.2.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/ad/85/475e514c3140937cf435954f78dedea1861aeab7662d11de232bdaa90655/backports.zoneinfo-0.2.1.tar.gz", hash = "sha256:fadbfe37f74051d024037f223b8e001611eac868b5c5b06144ef4d8b799862f2", size = 74098 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/4a/6d/eca004eeadcbf8bd64cc96feb9e355536147f0577420b44d80c7cac70767/backports.zoneinfo-0.2.1-cp38-cp38-macosx_10_14_x86_64.whl", hash = "sha256:8961c0f32cd0336fb8e8ead11a1f8cd99ec07145ec2931122faaac1c8f7fd987", size = 35816 },
-    { url = "https://files.pythonhosted.org/packages/c1/8f/9b1b920a6a95652463143943fa3b8c000cb0b932ab463764a6f2a2416560/backports.zoneinfo-0.2.1-cp38-cp38-manylinux1_i686.whl", hash = "sha256:e81b76cace8eda1fca50e345242ba977f9be6ae3945af8d46326d776b4cf78d1", size = 72147 },
-    { url = "https://files.pythonhosted.org/packages/1a/ab/3e941e3fcf1b7d3ab3d0233194d99d6a0ed6b24f8f956fc81e47edc8c079/backports.zoneinfo-0.2.1-cp38-cp38-manylinux1_x86_64.whl", hash = "sha256:7b0a64cda4145548fed9efc10322770f929b944ce5cee6c0dfe0c87bf4c0c8c9", size = 74033 },
-    { url = "https://files.pythonhosted.org/packages/c0/34/5fdb0a3a28841d215c255be8fc60b8666257bb6632193c86fd04b63d4a31/backports.zoneinfo-0.2.1-cp38-cp38-win32.whl", hash = "sha256:1b13e654a55cd45672cb54ed12148cd33628f672548f373963b0bff67b217328", size = 36803 },
-    { url = "https://files.pythonhosted.org/packages/78/cc/e27fd6493bbce8dbea7e6c1bc861fe3d3bc22c4f7c81f4c3befb8ff5bfaf/backports.zoneinfo-0.2.1-cp38-cp38-win_amd64.whl", hash = "sha256:4a0f800587060bf8880f954dbef70de6c11bbe59c673c3d818921f042f9954a6", size = 38967 },
+    { url = "https://files.pythonhosted.org/packages/89/aa/ab0f7891a01eeb2d2e338ae8fecbe57fcebea1a24dbb64d45801bfab481d/attrs-24.3.0-py3-none-any.whl", hash = "sha256:ac96cd038792094f438ad1f6ff80837353805ac950cd2aa0e0625ef19850c308", size = 63397 },
 ]
 
 [[package]]
 name = "black"
-version = "24.8.0"
+version = "24.10.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "click" },
@@ -69,29 +39,24 @@ dependencies = [
     { name = "tomli", marker = "python_full_version < '3.11'" },
     { name = "typing-extensions", marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/04/b0/46fb0d4e00372f4a86a6f8efa3cb193c9f64863615e39010b1477e010578/black-24.8.0.tar.gz", hash = "sha256:2500945420b6784c38b9ee885af039f5e7471ef284ab03fa35ecdde4688cd83f", size = 644810 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/47/6e/74e29edf1fba3887ed7066930a87f698ffdcd52c5dbc263eabb06061672d/black-24.8.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:09cdeb74d494ec023ded657f7092ba518e8cf78fa8386155e4a03fdcc44679e6", size = 1632092 },
-    { url = "https://files.pythonhosted.org/packages/ab/49/575cb6c3faee690b05c9d11ee2e8dba8fbd6d6c134496e644c1feb1b47da/black-24.8.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:81c6742da39f33b08e791da38410f32e27d632260e599df7245cccee2064afeb", size = 1457529 },
-    { url = "https://files.pythonhosted.org/packages/7a/b4/d34099e95c437b53d01c4aa37cf93944b233066eb034ccf7897fa4e5f286/black-24.8.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:707a1ca89221bc8a1a64fb5e15ef39cd755633daa672a9db7498d1c19de66a42", size = 1757443 },
-    { url = "https://files.pythonhosted.org/packages/87/a0/6d2e4175ef364b8c4b64f8441ba041ed65c63ea1db2720d61494ac711c15/black-24.8.0-cp310-cp310-win_amd64.whl", hash = "sha256:d6417535d99c37cee4091a2f24eb2b6d5ec42b144d50f1f2e436d9fe1916fe1a", size = 1418012 },
-    { url = "https://files.pythonhosted.org/packages/08/a6/0a3aa89de9c283556146dc6dbda20cd63a9c94160a6fbdebaf0918e4a3e1/black-24.8.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:fb6e2c0b86bbd43dee042e48059c9ad7830abd5c94b0bc518c0eeec57c3eddc1", size = 1615080 },
-    { url = "https://files.pythonhosted.org/packages/db/94/b803d810e14588bb297e565821a947c108390a079e21dbdcb9ab6956cd7a/black-24.8.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:837fd281f1908d0076844bc2b801ad2d369c78c45cf800cad7b61686051041af", size = 1438143 },
-    { url = "https://files.pythonhosted.org/packages/a5/b5/f485e1bbe31f768e2e5210f52ea3f432256201289fd1a3c0afda693776b0/black-24.8.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:62e8730977f0b77998029da7971fa896ceefa2c4c4933fcd593fa599ecbf97a4", size = 1738774 },
-    { url = "https://files.pythonhosted.org/packages/a8/69/a000fc3736f89d1bdc7f4a879f8aaf516fb03613bb51a0154070383d95d9/black-24.8.0-cp311-cp311-win_amd64.whl", hash = "sha256:72901b4913cbac8972ad911dc4098d5753704d1f3c56e44ae8dce99eecb0e3af", size = 1427503 },
-    { url = "https://files.pythonhosted.org/packages/a2/a8/05fb14195cfef32b7c8d4585a44b7499c2a4b205e1662c427b941ed87054/black-24.8.0-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:7c046c1d1eeb7aea9335da62472481d3bbf3fd986e093cffd35f4385c94ae368", size = 1646132 },
-    { url = "https://files.pythonhosted.org/packages/41/77/8d9ce42673e5cb9988f6df73c1c5c1d4e9e788053cccd7f5fb14ef100982/black-24.8.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:649f6d84ccbae73ab767e206772cc2d7a393a001070a4c814a546afd0d423aed", size = 1448665 },
-    { url = "https://files.pythonhosted.org/packages/cc/94/eff1ddad2ce1d3cc26c162b3693043c6b6b575f538f602f26fe846dfdc75/black-24.8.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2b59b250fdba5f9a9cd9d0ece6e6d993d91ce877d121d161e4698af3eb9c1018", size = 1762458 },
-    { url = "https://files.pythonhosted.org/packages/28/ea/18b8d86a9ca19a6942e4e16759b2fa5fc02bbc0eb33c1b866fcd387640ab/black-24.8.0-cp312-cp312-win_amd64.whl", hash = "sha256:6e55d30d44bed36593c3163b9bc63bf58b3b30e4611e4d88a0c3c239930ed5b2", size = 1436109 },
-    { url = "https://files.pythonhosted.org/packages/9f/d4/ae03761ddecc1a37d7e743b89cccbcf3317479ff4b88cfd8818079f890d0/black-24.8.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:505289f17ceda596658ae81b61ebbe2d9b25aa78067035184ed0a9d855d18afd", size = 1617322 },
-    { url = "https://files.pythonhosted.org/packages/14/4b/4dfe67eed7f9b1ddca2ec8e4418ea74f0d1dc84d36ea874d618ffa1af7d4/black-24.8.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:b19c9ad992c7883ad84c9b22aaa73562a16b819c1d8db7a1a1a49fb7ec13c7d2", size = 1442108 },
-    { url = "https://files.pythonhosted.org/packages/97/14/95b3f91f857034686cae0e73006b8391d76a8142d339b42970eaaf0416ea/black-24.8.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:1f13f7f386f86f8121d76599114bb8c17b69d962137fc70efe56137727c7047e", size = 1745786 },
-    { url = "https://files.pythonhosted.org/packages/95/54/68b8883c8aa258a6dde958cd5bdfada8382bec47c5162f4a01e66d839af1/black-24.8.0-cp38-cp38-win_amd64.whl", hash = "sha256:f490dbd59680d809ca31efdae20e634f3fae27fba3ce0ba3208333b713bc3920", size = 1426754 },
-    { url = "https://files.pythonhosted.org/packages/13/b2/b3f24fdbb46f0e7ef6238e131f13572ee8279b70f237f221dd168a9dba1a/black-24.8.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:eab4dd44ce80dea27dc69db40dab62d4ca96112f87996bca68cd75639aeb2e4c", size = 1631706 },
-    { url = "https://files.pythonhosted.org/packages/d9/35/31010981e4a05202a84a3116423970fd1a59d2eda4ac0b3570fbb7029ddc/black-24.8.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:3c4285573d4897a7610054af5a890bde7c65cb466040c5f0c8b732812d7f0e5e", size = 1457429 },
-    { url = "https://files.pythonhosted.org/packages/27/25/3f706b4f044dd569a20a4835c3b733dedea38d83d2ee0beb8178a6d44945/black-24.8.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9e84e33b37be070ba135176c123ae52a51f82306def9f7d063ee302ecab2cf47", size = 1756488 },
-    { url = "https://files.pythonhosted.org/packages/63/72/79375cd8277cbf1c5670914e6bd4c1b15dea2c8f8e906dc21c448d0535f0/black-24.8.0-cp39-cp39-win_amd64.whl", hash = "sha256:73bbf84ed136e45d451a260c6b73ed674652f90a2b3211d6a35e78054563a9bb", size = 1417721 },
-    { url = "https://files.pythonhosted.org/packages/27/1e/83fa8a787180e1632c3d831f7e58994d7aaf23a0961320d21e84f922f919/black-24.8.0-py3-none-any.whl", hash = "sha256:972085c618ee94f402da1af548a4f218c754ea7e5dc70acb168bfaca4c2542ed", size = 206504 },
+sdist = { url = "https://files.pythonhosted.org/packages/d8/0d/cc2fb42b8c50d80143221515dd7e4766995bd07c56c9a3ed30baf080b6dc/black-24.10.0.tar.gz", hash = "sha256:846ea64c97afe3bc677b761787993be4991810ecc7a4a937816dd6bddedc4875", size = 645813 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/a3/f3/465c0eb5cddf7dbbfe1fecd9b875d1dcf51b88923cd2c1d7e9ab95c6336b/black-24.10.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e6668650ea4b685440857138e5fe40cde4d652633b1bdffc62933d0db4ed9812", size = 1623211 },
+    { url = "https://files.pythonhosted.org/packages/6e/c5/9023b7673904a5188f9be81f5e129fff69f51f5515655fbd1d5a4e80a47b/black-24.10.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:649fff99a20bd06c6f727d2a27f401331dc0cc861fb69cde910fe95b01b5928f", size = 1753774 },
+    { url = "https://files.pythonhosted.org/packages/e1/32/df7f18bd0e724e0d9748829765455d6643ec847b3f87e77456fc99d0edab/black-24.10.0-cp310-cp310-win_amd64.whl", hash = "sha256:fe4d6476887de70546212c99ac9bd803d90b42fc4767f058a0baa895013fbb3e", size = 1414209 },
+    { url = "https://files.pythonhosted.org/packages/c2/cc/7496bb63a9b06a954d3d0ac9fe7a73f3bf1cd92d7a58877c27f4ad1e9d41/black-24.10.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5a2221696a8224e335c28816a9d331a6c2ae15a2ee34ec857dcf3e45dbfa99ad", size = 1607468 },
+    { url = "https://files.pythonhosted.org/packages/c9/9b/2db8045b45844665c720dcfe292fdaf2e49825810c0103e1191515fc101a/black-24.10.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4007b1393d902b48b36958a216c20c4482f601569d19ed1df294a496eb366392", size = 1737061 },
+    { url = "https://files.pythonhosted.org/packages/a3/95/17d4a09a5be5f8c65aa4a361444d95edc45def0de887810f508d3f65db7a/black-24.10.0-cp311-cp311-win_amd64.whl", hash = "sha256:394d4ddc64782e51153eadcaaca95144ac4c35e27ef9b0a42e121ae7e57a9175", size = 1423293 },
+    { url = "https://files.pythonhosted.org/packages/90/04/bf74c71f592bcd761610bbf67e23e6a3cff824780761f536512437f1e655/black-24.10.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b5e39e0fae001df40f95bd8cc36b9165c5e2ea88900167bddf258bacef9bbdc3", size = 1644256 },
+    { url = "https://files.pythonhosted.org/packages/4e/3e/443ef8bc1fbda78e61f79157f303893f3fddf19ca3c8989b163eb3469a12/black-24.10.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:14b3502784f09ce2443830e3133dacf2c0110d45191ed470ecb04d0f5f6fcb0f", size = 1761892 },
+    { url = "https://files.pythonhosted.org/packages/52/93/eac95ff229049a6901bc84fec6908a5124b8a0b7c26ea766b3b8a5debd22/black-24.10.0-cp312-cp312-win_amd64.whl", hash = "sha256:30d2c30dc5139211dda799758559d1b049f7f14c580c409d6ad925b74a4208a8", size = 1434796 },
+    { url = "https://files.pythonhosted.org/packages/d0/a0/a993f58d4ecfba035e61fca4e9f64a2ecae838fc9f33ab798c62173ed75c/black-24.10.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1cbacacb19e922a1d75ef2b6ccaefcd6e93a2c05ede32f06a21386a04cedb981", size = 1643986 },
+    { url = "https://files.pythonhosted.org/packages/47/6d/a3a239e938960df1a662b93d6230d4f3e9b4a22982d060fc38c42f45a56b/black-24.10.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ddacb691cdcdf77b96f549cf9591701d8db36b2f19519373d60d31746068dbf2", size = 1760928 },
+    { url = "https://files.pythonhosted.org/packages/dd/cf/af018e13b0eddfb434df4d9cd1b2b7892bab119f7a20123e93f6910982e8/black-24.10.0-cp313-cp313-win_amd64.whl", hash = "sha256:680359d932801c76d2e9c9068d05c6b107f2584b2a5b88831c83962eb9984c1b", size = 1436875 },
+    { url = "https://files.pythonhosted.org/packages/fe/02/f408c804e0ee78c367dcea0a01aedde4f1712af93b8b6e60df981e0228c7/black-24.10.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:17374989640fbca88b6a448129cd1745c5eb8d9547b464f281b251dd00155ccd", size = 1622516 },
+    { url = "https://files.pythonhosted.org/packages/0a/1c/314d7f17434a5375682ad097f6f4cc0e3f414f3c95a9b1bb4df14a0f11f9/black-24.10.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfa1d0cb6200857f1923b602f978386a3a2758a65b52e0950299ea014be6800", size = 1752801 },
+    { url = "https://files.pythonhosted.org/packages/39/a7/20e5cd9237d28ad0b31438de5d9f01c8b99814576f4c0cda1edd62caf4b0/black-24.10.0-cp39-cp39-win_amd64.whl", hash = "sha256:2cd9c95431d94adc56600710f8813ee27eea544dd118d45896bb734e9d7a0dc7", size = 1413626 },
+    { url = "https://files.pythonhosted.org/packages/8d/a7/4b27c50537ebca8bec139b872861f9d2bf501c5ec51fcf897cb924d9e264/black-24.10.0-py3-none-any.whl", hash = "sha256:3bb2b7a1f7b685f85b11fed1ef10f8a9148bceb49853e47a294a3dd963c1dd7d", size = 206898 },
 ]
 
 [[package]]
@@ -149,14 +114,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/f1/47/d7145bf2dc04684935d57d67dff9d6d795b2ba2796806bb109864be3a151/cffi-1.17.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:72e72408cad3d5419375fc87d289076ee319835bdfa2caad331e377589aebba9", size = 488469 },
     { url = "https://files.pythonhosted.org/packages/bf/ee/f94057fa6426481d663b88637a9a10e859e492c73d0384514a17d78ee205/cffi-1.17.1-cp313-cp313-win32.whl", hash = "sha256:e03eab0a8677fa80d646b5ddece1cbeaf556c313dcfac435ba11f107ba117b5d", size = 172475 },
     { url = "https://files.pythonhosted.org/packages/7c/fc/6a8cb64e5f0324877d503c854da15d76c1e50eb722e320b15345c4d0c6de/cffi-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:f6a16c31041f09ead72d69f583767292f750d24913dadacf5756b966aacb3f1a", size = 182009 },
-    { url = "https://files.pythonhosted.org/packages/48/08/15bf6b43ae9bd06f6b00ad8a91f5a8fe1069d4c9fab550a866755402724e/cffi-1.17.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:636062ea65bd0195bc012fea9321aca499c0504409f413dc88af450b57ffd03b", size = 182457 },
-    { url = "https://files.pythonhosted.org/packages/c2/5b/f1523dd545f92f7df468e5f653ffa4df30ac222f3c884e51e139878f1cb5/cffi-1.17.1-cp38-cp38-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c7eac2ef9b63c79431bc4b25f1cd649d7f061a28808cbc6c47b534bd789ef964", size = 425932 },
-    { url = "https://files.pythonhosted.org/packages/53/93/7e547ab4105969cc8c93b38a667b82a835dd2cc78f3a7dad6130cfd41e1d/cffi-1.17.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e221cf152cff04059d011ee126477f0d9588303eb57e88923578ace7baad17f9", size = 448585 },
-    { url = "https://files.pythonhosted.org/packages/56/c4/a308f2c332006206bb511de219efeff090e9d63529ba0a77aae72e82248b/cffi-1.17.1-cp38-cp38-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:31000ec67d4221a71bd3f67df918b1f88f676f1c3b535a7eb473255fdc0b83fc", size = 456268 },
-    { url = "https://files.pythonhosted.org/packages/ca/5b/b63681518265f2f4060d2b60755c1c77ec89e5e045fc3773b72735ddaad5/cffi-1.17.1-cp38-cp38-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:6f17be4345073b0a7b8ea599688f692ac3ef23ce28e5df79c04de519dbc4912c", size = 436592 },
-    { url = "https://files.pythonhosted.org/packages/bb/19/b51af9f4a4faa4a8ac5a0e5d5c2522dcd9703d07fac69da34a36c4d960d3/cffi-1.17.1-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0e2b1fac190ae3ebfe37b979cc1ce69c81f4e4fe5746bb401dca63a9062cdaf1", size = 446512 },
-    { url = "https://files.pythonhosted.org/packages/e2/63/2bed8323890cb613bbecda807688a31ed11a7fe7afe31f8faaae0206a9a3/cffi-1.17.1-cp38-cp38-win32.whl", hash = "sha256:7596d6620d3fa590f677e9ee430df2958d2d6d6de2feeae5b20e82c00b76fbf8", size = 171576 },
-    { url = "https://files.pythonhosted.org/packages/2f/70/80c33b044ebc79527447fd4fbc5455d514c3bb840dede4455de97da39b4d/cffi-1.17.1-cp38-cp38-win_amd64.whl", hash = "sha256:78122be759c3f8a014ce010908ae03364d00a1f81ab5c7f4a7a5120607ea56e1", size = 181229 },
     { url = "https://files.pythonhosted.org/packages/b9/ea/8bb50596b8ffbc49ddd7a1ad305035daa770202a6b782fc164647c2673ad/cffi-1.17.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:b2ab587605f4ba0bf81dc0cb08a41bd1c0a5906bd59243d56bad7668a6fc6c16", size = 182220 },
     { url = "https://files.pythonhosted.org/packages/ae/11/e77c8cd24f58285a82c23af484cf5b124a376b32644e445960d1a4654c3a/cffi-1.17.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:28b16024becceed8c6dfbc75629e27788d8a3f9030691a1dbf9821a128b22c36", size = 178605 },
     { url = "https://files.pythonhosted.org/packages/ed/65/25a8dc32c53bf5b7b6c2686b42ae2ad58743f7ff644844af7cdb29b49361/cffi-1.17.1-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1d599671f396c4723d016dbddb72fe8e0397082b0a77a4fab8028923bec050e8", size = 424910 },
@@ -173,14 +130,14 @@ wheels = [
 
 [[package]]
 name = "click"
-version = "8.1.7"
+version = "8.1.8"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "colorama", marker = "platform_system == 'Windows'" },
+    { name = "colorama", marker = "sys_platform == 'win32'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/96/d3/f04c7bfcf5c1862a2a5b845c6b2b360488cf47af55dfa79c98f6a6bf98b5/click-8.1.7.tar.gz", hash = "sha256:ca9853ad459e787e2192211578cc907e7594e294c7ccc834310722b41b9ca6de", size = 336121 }
+sdist = { url = "https://files.pythonhosted.org/packages/b9/2e/0090cbf739cee7d23781ad4b89a9894a41538e4fcf4c31dcdd705b78eb8b/click-8.1.8.tar.gz", hash = "sha256:ed53c9d8990d83c2a27deae68e4ee337473f6330c040a31d4225c9574d16096a", size = 226593 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/00/2e/d53fa4befbf2cfa713304affc7ca780ce4fc1fd8710527771b58311a3229/click-8.1.7-py3-none-any.whl", hash = "sha256:ae74fb96c20a0277a1d615f1e4d73c8414f5a98db8b799a7931d1582f3390c28", size = 97941 },
+    { url = "https://files.pythonhosted.org/packages/7e/d4/7ebdbd03970677812aac39c869717059dbb71a4cfc033ca6e5221787892c/click-8.1.8-py3-none-any.whl", hash = "sha256:63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2", size = 98188 },
 ]
 
 [[package]]
@@ -194,93 +151,80 @@ wheels = [
 
 [[package]]
 name = "coverage"
-version = "7.6.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/f7/08/7e37f82e4d1aead42a7443ff06a1e406aabf7302c4f00a546e4b320b994c/coverage-7.6.1.tar.gz", hash = "sha256:953510dfb7b12ab69d20135a0662397f077c59b1e6379a768e97c59d852ee51d", size = 798791 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/7e/61/eb7ce5ed62bacf21beca4937a90fe32545c91a3c8a42a30c6616d48fc70d/coverage-7.6.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:b06079abebbc0e89e6163b8e8f0e16270124c154dc6e4a47b413dd538859af16", size = 206690 },
-    { url = "https://files.pythonhosted.org/packages/7d/73/041928e434442bd3afde5584bdc3f932fb4562b1597629f537387cec6f3d/coverage-7.6.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:cf4b19715bccd7ee27b6b120e7e9dd56037b9c0681dcc1adc9ba9db3d417fa36", size = 207127 },
-    { url = "https://files.pythonhosted.org/packages/c7/c8/6ca52b5147828e45ad0242388477fdb90df2c6cbb9a441701a12b3c71bc8/coverage-7.6.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:e61c0abb4c85b095a784ef23fdd4aede7a2628478e7baba7c5e3deba61070a02", size = 235654 },
-    { url = "https://files.pythonhosted.org/packages/d5/da/9ac2b62557f4340270942011d6efeab9833648380109e897d48ab7c1035d/coverage-7.6.1-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:fd21f6ae3f08b41004dfb433fa895d858f3f5979e7762d052b12aef444e29afc", size = 233598 },
-    { url = "https://files.pythonhosted.org/packages/53/23/9e2c114d0178abc42b6d8d5281f651a8e6519abfa0ef460a00a91f80879d/coverage-7.6.1-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8f59d57baca39b32db42b83b2a7ba6f47ad9c394ec2076b084c3f029b7afca23", size = 234732 },
-    { url = "https://files.pythonhosted.org/packages/0f/7e/a0230756fb133343a52716e8b855045f13342b70e48e8ad41d8a0d60ab98/coverage-7.6.1-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:a1ac0ae2b8bd743b88ed0502544847c3053d7171a3cff9228af618a068ed9c34", size = 233816 },
-    { url = "https://files.pythonhosted.org/packages/28/7c/3753c8b40d232b1e5eeaed798c875537cf3cb183fb5041017c1fdb7ec14e/coverage-7.6.1-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:e6a08c0be454c3b3beb105c0596ebdc2371fab6bb90c0c0297f4e58fd7e1012c", size = 232325 },
-    { url = "https://files.pythonhosted.org/packages/57/e3/818a2b2af5b7573b4b82cf3e9f137ab158c90ea750a8f053716a32f20f06/coverage-7.6.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:f5796e664fe802da4f57a168c85359a8fbf3eab5e55cd4e4569fbacecc903959", size = 233418 },
-    { url = "https://files.pythonhosted.org/packages/c8/fb/4532b0b0cefb3f06d201648715e03b0feb822907edab3935112b61b885e2/coverage-7.6.1-cp310-cp310-win32.whl", hash = "sha256:7bb65125fcbef8d989fa1dd0e8a060999497629ca5b0efbca209588a73356232", size = 209343 },
-    { url = "https://files.pythonhosted.org/packages/5a/25/af337cc7421eca1c187cc9c315f0a755d48e755d2853715bfe8c418a45fa/coverage-7.6.1-cp310-cp310-win_amd64.whl", hash = "sha256:3115a95daa9bdba70aea750db7b96b37259a81a709223c8448fa97727d546fe0", size = 210136 },
-    { url = "https://files.pythonhosted.org/packages/ad/5f/67af7d60d7e8ce61a4e2ddcd1bd5fb787180c8d0ae0fbd073f903b3dd95d/coverage-7.6.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:7dea0889685db8550f839fa202744652e87c60015029ce3f60e006f8c4462c93", size = 206796 },
-    { url = "https://files.pythonhosted.org/packages/e1/0e/e52332389e057daa2e03be1fbfef25bb4d626b37d12ed42ae6281d0a274c/coverage-7.6.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:ed37bd3c3b063412f7620464a9ac1314d33100329f39799255fb8d3027da50d3", size = 207244 },
-    { url = "https://files.pythonhosted.org/packages/aa/cd/766b45fb6e090f20f8927d9c7cb34237d41c73a939358bc881883fd3a40d/coverage-7.6.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d85f5e9a5f8b73e2350097c3756ef7e785f55bd71205defa0bfdaf96c31616ff", size = 239279 },
-    { url = "https://files.pythonhosted.org/packages/70/6c/a9ccd6fe50ddaf13442a1e2dd519ca805cbe0f1fcd377fba6d8339b98ccb/coverage-7.6.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9bc572be474cafb617672c43fe989d6e48d3c83af02ce8de73fff1c6bb3c198d", size = 236859 },
-    { url = "https://files.pythonhosted.org/packages/14/6f/8351b465febb4dbc1ca9929505202db909c5a635c6fdf33e089bbc3d7d85/coverage-7.6.1-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0c0420b573964c760df9e9e86d1a9a622d0d27f417e1a949a8a66dd7bcee7bc6", size = 238549 },
-    { url = "https://files.pythonhosted.org/packages/68/3c/289b81fa18ad72138e6d78c4c11a82b5378a312c0e467e2f6b495c260907/coverage-7.6.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:1f4aa8219db826ce6be7099d559f8ec311549bfc4046f7f9fe9b5cea5c581c56", size = 237477 },
-    { url = "https://files.pythonhosted.org/packages/ed/1c/aa1efa6459d822bd72c4abc0b9418cf268de3f60eeccd65dc4988553bd8d/coverage-7.6.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:fc5a77d0c516700ebad189b587de289a20a78324bc54baee03dd486f0855d234", size = 236134 },
-    { url = "https://files.pythonhosted.org/packages/fb/c8/521c698f2d2796565fe9c789c2ee1ccdae610b3aa20b9b2ef980cc253640/coverage-7.6.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:b48f312cca9621272ae49008c7f613337c53fadca647d6384cc129d2996d1133", size = 236910 },
-    { url = "https://files.pythonhosted.org/packages/7d/30/033e663399ff17dca90d793ee8a2ea2890e7fdf085da58d82468b4220bf7/coverage-7.6.1-cp311-cp311-win32.whl", hash = "sha256:1125ca0e5fd475cbbba3bb67ae20bd2c23a98fac4e32412883f9bcbaa81c314c", size = 209348 },
-    { url = "https://files.pythonhosted.org/packages/20/05/0d1ccbb52727ccdadaa3ff37e4d2dc1cd4d47f0c3df9eb58d9ec8508ca88/coverage-7.6.1-cp311-cp311-win_amd64.whl", hash = "sha256:8ae539519c4c040c5ffd0632784e21b2f03fc1340752af711f33e5be83a9d6c6", size = 210230 },
-    { url = "https://files.pythonhosted.org/packages/7e/d4/300fc921dff243cd518c7db3a4c614b7e4b2431b0d1145c1e274fd99bd70/coverage-7.6.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:95cae0efeb032af8458fc27d191f85d1717b1d4e49f7cb226cf526ff28179778", size = 206983 },
-    { url = "https://files.pythonhosted.org/packages/e1/ab/6bf00de5327ecb8db205f9ae596885417a31535eeda6e7b99463108782e1/coverage-7.6.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:5621a9175cf9d0b0c84c2ef2b12e9f5f5071357c4d2ea6ca1cf01814f45d2391", size = 207221 },
-    { url = "https://files.pythonhosted.org/packages/92/8f/2ead05e735022d1a7f3a0a683ac7f737de14850395a826192f0288703472/coverage-7.6.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:260933720fdcd75340e7dbe9060655aff3af1f0c5d20f46b57f262ab6c86a5e8", size = 240342 },
-    { url = "https://files.pythonhosted.org/packages/0f/ef/94043e478201ffa85b8ae2d2c79b4081e5a1b73438aafafccf3e9bafb6b5/coverage-7.6.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:07e2ca0ad381b91350c0ed49d52699b625aab2b44b65e1b4e02fa9df0e92ad2d", size = 237371 },
-    { url = "https://files.pythonhosted.org/packages/1f/0f/c890339dd605f3ebc269543247bdd43b703cce6825b5ed42ff5f2d6122c7/coverage-7.6.1-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c44fee9975f04b33331cb8eb272827111efc8930cfd582e0320613263ca849ca", size = 239455 },
-    { url = "https://files.pythonhosted.org/packages/d1/04/7fd7b39ec7372a04efb0f70c70e35857a99b6a9188b5205efb4c77d6a57a/coverage-7.6.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:877abb17e6339d96bf08e7a622d05095e72b71f8afd8a9fefc82cf30ed944163", size = 238924 },
-    { url = "https://files.pythonhosted.org/packages/ed/bf/73ce346a9d32a09cf369f14d2a06651329c984e106f5992c89579d25b27e/coverage-7.6.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:3e0cadcf6733c09154b461f1ca72d5416635e5e4ec4e536192180d34ec160f8a", size = 237252 },
-    { url = "https://files.pythonhosted.org/packages/86/74/1dc7a20969725e917b1e07fe71a955eb34bc606b938316bcc799f228374b/coverage-7.6.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:c3c02d12f837d9683e5ab2f3d9844dc57655b92c74e286c262e0fc54213c216d", size = 238897 },
-    { url = "https://files.pythonhosted.org/packages/b6/e9/d9cc3deceb361c491b81005c668578b0dfa51eed02cd081620e9a62f24ec/coverage-7.6.1-cp312-cp312-win32.whl", hash = "sha256:e05882b70b87a18d937ca6768ff33cc3f72847cbc4de4491c8e73880766718e5", size = 209606 },
-    { url = "https://files.pythonhosted.org/packages/47/c8/5a2e41922ea6740f77d555c4d47544acd7dc3f251fe14199c09c0f5958d3/coverage-7.6.1-cp312-cp312-win_amd64.whl", hash = "sha256:b5d7b556859dd85f3a541db6a4e0167b86e7273e1cdc973e5b175166bb634fdb", size = 210373 },
-    { url = "https://files.pythonhosted.org/packages/8c/f9/9aa4dfb751cb01c949c990d136a0f92027fbcc5781c6e921df1cb1563f20/coverage-7.6.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a4acd025ecc06185ba2b801f2de85546e0b8ac787cf9d3b06e7e2a69f925b106", size = 207007 },
-    { url = "https://files.pythonhosted.org/packages/b9/67/e1413d5a8591622a46dd04ff80873b04c849268831ed5c304c16433e7e30/coverage-7.6.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:a6d3adcf24b624a7b778533480e32434a39ad8fa30c315208f6d3e5542aeb6e9", size = 207269 },
-    { url = "https://files.pythonhosted.org/packages/14/5b/9dec847b305e44a5634d0fb8498d135ab1d88330482b74065fcec0622224/coverage-7.6.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d0c212c49b6c10e6951362f7c6df3329f04c2b1c28499563d4035d964ab8e08c", size = 239886 },
-    { url = "https://files.pythonhosted.org/packages/7b/b7/35760a67c168e29f454928f51f970342d23cf75a2bb0323e0f07334c85f3/coverage-7.6.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:6e81d7a3e58882450ec4186ca59a3f20a5d4440f25b1cff6f0902ad890e6748a", size = 237037 },
-    { url = "https://files.pythonhosted.org/packages/f7/95/d2fd31f1d638df806cae59d7daea5abf2b15b5234016a5ebb502c2f3f7ee/coverage-7.6.1-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:78b260de9790fd81e69401c2dc8b17da47c8038176a79092a89cb2b7d945d060", size = 239038 },
-    { url = "https://files.pythonhosted.org/packages/6e/bd/110689ff5752b67924efd5e2aedf5190cbbe245fc81b8dec1abaffba619d/coverage-7.6.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:a78d169acd38300060b28d600344a803628c3fd585c912cacc9ea8790fe96862", size = 238690 },
-    { url = "https://files.pythonhosted.org/packages/d3/a8/08d7b38e6ff8df52331c83130d0ab92d9c9a8b5462f9e99c9f051a4ae206/coverage-7.6.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:2c09f4ce52cb99dd7505cd0fc8e0e37c77b87f46bc9c1eb03fe3bc9991085388", size = 236765 },
-    { url = "https://files.pythonhosted.org/packages/d6/6a/9cf96839d3147d55ae713eb2d877f4d777e7dc5ba2bce227167d0118dfe8/coverage-7.6.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6878ef48d4227aace338d88c48738a4258213cd7b74fd9a3d4d7582bb1d8a155", size = 238611 },
-    { url = "https://files.pythonhosted.org/packages/74/e4/7ff20d6a0b59eeaab40b3140a71e38cf52547ba21dbcf1d79c5a32bba61b/coverage-7.6.1-cp313-cp313-win32.whl", hash = "sha256:44df346d5215a8c0e360307d46ffaabe0f5d3502c8a1cefd700b34baf31d411a", size = 209671 },
-    { url = "https://files.pythonhosted.org/packages/35/59/1812f08a85b57c9fdb6d0b383d779e47b6f643bc278ed682859512517e83/coverage-7.6.1-cp313-cp313-win_amd64.whl", hash = "sha256:8284cf8c0dd272a247bc154eb6c95548722dce90d098c17a883ed36e67cdb129", size = 210368 },
-    { url = "https://files.pythonhosted.org/packages/9c/15/08913be1c59d7562a3e39fce20661a98c0a3f59d5754312899acc6cb8a2d/coverage-7.6.1-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:d3296782ca4eab572a1a4eca686d8bfb00226300dcefdf43faa25b5242ab8a3e", size = 207758 },
-    { url = "https://files.pythonhosted.org/packages/c4/ae/b5d58dff26cade02ada6ca612a76447acd69dccdbb3a478e9e088eb3d4b9/coverage-7.6.1-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:502753043567491d3ff6d08629270127e0c31d4184c4c8d98f92c26f65019962", size = 208035 },
-    { url = "https://files.pythonhosted.org/packages/b8/d7/62095e355ec0613b08dfb19206ce3033a0eedb6f4a67af5ed267a8800642/coverage-7.6.1-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:6a89ecca80709d4076b95f89f308544ec8f7b4727e8a547913a35f16717856cb", size = 250839 },
-    { url = "https://files.pythonhosted.org/packages/7c/1e/c2967cb7991b112ba3766df0d9c21de46b476d103e32bb401b1b2adf3380/coverage-7.6.1-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a318d68e92e80af8b00fa99609796fdbcdfef3629c77c6283566c6f02c6d6704", size = 246569 },
-    { url = "https://files.pythonhosted.org/packages/8b/61/a7a6a55dd266007ed3b1df7a3386a0d760d014542d72f7c2c6938483b7bd/coverage-7.6.1-cp313-cp313t-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:13b0a73a0896988f053e4fbb7de6d93388e6dd292b0d87ee51d106f2c11b465b", size = 248927 },
-    { url = "https://files.pythonhosted.org/packages/c8/fa/13a6f56d72b429f56ef612eb3bc5ce1b75b7ee12864b3bd12526ab794847/coverage-7.6.1-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:4421712dbfc5562150f7554f13dde997a2e932a6b5f352edcce948a815efee6f", size = 248401 },
-    { url = "https://files.pythonhosted.org/packages/75/06/0429c652aa0fb761fc60e8c6b291338c9173c6aa0f4e40e1902345b42830/coverage-7.6.1-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:166811d20dfea725e2e4baa71fffd6c968a958577848d2131f39b60043400223", size = 246301 },
-    { url = "https://files.pythonhosted.org/packages/52/76/1766bb8b803a88f93c3a2d07e30ffa359467810e5cbc68e375ebe6906efb/coverage-7.6.1-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:225667980479a17db1048cb2bf8bfb39b8e5be8f164b8f6628b64f78a72cf9d3", size = 247598 },
-    { url = "https://files.pythonhosted.org/packages/66/8b/f54f8db2ae17188be9566e8166ac6df105c1c611e25da755738025708d54/coverage-7.6.1-cp313-cp313t-win32.whl", hash = "sha256:170d444ab405852903b7d04ea9ae9b98f98ab6d7e63e1115e82620807519797f", size = 210307 },
-    { url = "https://files.pythonhosted.org/packages/9f/b0/e0dca6da9170aefc07515cce067b97178cefafb512d00a87a1c717d2efd5/coverage-7.6.1-cp313-cp313t-win_amd64.whl", hash = "sha256:b9f222de8cded79c49bf184bdbc06630d4c58eec9459b939b4a690c82ed05657", size = 211453 },
-    { url = "https://files.pythonhosted.org/packages/81/d0/d9e3d554e38beea5a2e22178ddb16587dbcbe9a1ef3211f55733924bf7fa/coverage-7.6.1-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:6db04803b6c7291985a761004e9060b2bca08da6d04f26a7f2294b8623a0c1a0", size = 206674 },
-    { url = "https://files.pythonhosted.org/packages/38/ea/cab2dc248d9f45b2b7f9f1f596a4d75a435cb364437c61b51d2eb33ceb0e/coverage-7.6.1-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:f1adfc8ac319e1a348af294106bc6a8458a0f1633cc62a1446aebc30c5fa186a", size = 207101 },
-    { url = "https://files.pythonhosted.org/packages/ca/6f/f82f9a500c7c5722368978a5390c418d2a4d083ef955309a8748ecaa8920/coverage-7.6.1-cp38-cp38-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a95324a9de9650a729239daea117df21f4b9868ce32e63f8b650ebe6cef5595b", size = 236554 },
-    { url = "https://files.pythonhosted.org/packages/a6/94/d3055aa33d4e7e733d8fa309d9adf147b4b06a82c1346366fc15a2b1d5fa/coverage-7.6.1-cp38-cp38-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:b43c03669dc4618ec25270b06ecd3ee4fa94c7f9b3c14bae6571ca00ef98b0d3", size = 234440 },
-    { url = "https://files.pythonhosted.org/packages/e4/6e/885bcd787d9dd674de4a7d8ec83faf729534c63d05d51d45d4fa168f7102/coverage-7.6.1-cp38-cp38-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:8929543a7192c13d177b770008bc4e8119f2e1f881d563fc6b6305d2d0ebe9de", size = 235889 },
-    { url = "https://files.pythonhosted.org/packages/f4/63/df50120a7744492710854860783d6819ff23e482dee15462c9a833cc428a/coverage-7.6.1-cp38-cp38-musllinux_1_2_aarch64.whl", hash = "sha256:a09ece4a69cf399510c8ab25e0950d9cf2b42f7b3cb0374f95d2e2ff594478a6", size = 235142 },
-    { url = "https://files.pythonhosted.org/packages/3a/5d/9d0acfcded2b3e9ce1c7923ca52ccc00c78a74e112fc2aee661125b7843b/coverage-7.6.1-cp38-cp38-musllinux_1_2_i686.whl", hash = "sha256:9054a0754de38d9dbd01a46621636689124d666bad1936d76c0341f7d71bf569", size = 233805 },
-    { url = "https://files.pythonhosted.org/packages/c4/56/50abf070cb3cd9b1dd32f2c88f083aab561ecbffbcd783275cb51c17f11d/coverage-7.6.1-cp38-cp38-musllinux_1_2_x86_64.whl", hash = "sha256:0dbde0f4aa9a16fa4d754356a8f2e36296ff4d83994b2c9d8398aa32f222f989", size = 234655 },
-    { url = "https://files.pythonhosted.org/packages/25/ee/b4c246048b8485f85a2426ef4abab88e48c6e80c74e964bea5cd4cd4b115/coverage-7.6.1-cp38-cp38-win32.whl", hash = "sha256:da511e6ad4f7323ee5702e6633085fb76c2f893aaf8ce4c51a0ba4fc07580ea7", size = 209296 },
-    { url = "https://files.pythonhosted.org/packages/5c/1c/96cf86b70b69ea2b12924cdf7cabb8ad10e6130eab8d767a1099fbd2a44f/coverage-7.6.1-cp38-cp38-win_amd64.whl", hash = "sha256:3f1156e3e8f2872197af3840d8ad307a9dd18e615dc64d9ee41696f287c57ad8", size = 210137 },
-    { url = "https://files.pythonhosted.org/packages/19/d3/d54c5aa83268779d54c86deb39c1c4566e5d45c155369ca152765f8db413/coverage-7.6.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:abd5fd0db5f4dc9289408aaf34908072f805ff7792632250dcb36dc591d24255", size = 206688 },
-    { url = "https://files.pythonhosted.org/packages/a5/fe/137d5dca72e4a258b1bc17bb04f2e0196898fe495843402ce826a7419fe3/coverage-7.6.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:547f45fa1a93154bd82050a7f3cddbc1a7a4dd2a9bf5cb7d06f4ae29fe94eaf8", size = 207120 },
-    { url = "https://files.pythonhosted.org/packages/78/5b/a0a796983f3201ff5485323b225d7c8b74ce30c11f456017e23d8e8d1945/coverage-7.6.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:645786266c8f18a931b65bfcefdbf6952dd0dea98feee39bd188607a9d307ed2", size = 235249 },
-    { url = "https://files.pythonhosted.org/packages/4e/e1/76089d6a5ef9d68f018f65411fcdaaeb0141b504587b901d74e8587606ad/coverage-7.6.1-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9e0b2df163b8ed01d515807af24f63de04bebcecbd6c3bfeff88385789fdf75a", size = 233237 },
-    { url = "https://files.pythonhosted.org/packages/9a/6f/eef79b779a540326fee9520e5542a8b428cc3bfa8b7c8f1022c1ee4fc66c/coverage-7.6.1-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:609b06f178fe8e9f89ef676532760ec0b4deea15e9969bf754b37f7c40326dbc", size = 234311 },
-    { url = "https://files.pythonhosted.org/packages/75/e1/656d65fb126c29a494ef964005702b012f3498db1a30dd562958e85a4049/coverage-7.6.1-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:702855feff378050ae4f741045e19a32d57d19f3e0676d589df0575008ea5004", size = 233453 },
-    { url = "https://files.pythonhosted.org/packages/68/6a/45f108f137941a4a1238c85f28fd9d048cc46b5466d6b8dda3aba1bb9d4f/coverage-7.6.1-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:2bdb062ea438f22d99cba0d7829c2ef0af1d768d1e4a4f528087224c90b132cb", size = 231958 },
-    { url = "https://files.pythonhosted.org/packages/9b/e7/47b809099168b8b8c72ae311efc3e88c8d8a1162b3ba4b8da3cfcdb85743/coverage-7.6.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:9c56863d44bd1c4fe2abb8a4d6f5371d197f1ac0ebdee542f07f35895fc07f36", size = 232938 },
-    { url = "https://files.pythonhosted.org/packages/52/80/052222ba7058071f905435bad0ba392cc12006380731c37afaf3fe749b88/coverage-7.6.1-cp39-cp39-win32.whl", hash = "sha256:6e2cd258d7d927d09493c8df1ce9174ad01b381d4729a9d8d4e38670ca24774c", size = 209352 },
-    { url = "https://files.pythonhosted.org/packages/b8/d8/1b92e0b3adcf384e98770a00ca095da1b5f7b483e6563ae4eb5e935d24a1/coverage-7.6.1-cp39-cp39-win_amd64.whl", hash = "sha256:06a737c882bd26d0d6ee7269b20b12f14a8704807a01056c80bb881a4b2ce6ca", size = 210153 },
-    { url = "https://files.pythonhosted.org/packages/a5/2b/0354ed096bca64dc8e32a7cbcae28b34cb5ad0b1fe2125d6d99583313ac0/coverage-7.6.1-pp38.pp39.pp310-none-any.whl", hash = "sha256:e9a6e0eb86070e8ccaedfbd9d38fec54864f3125ab95419970575b42af7541df", size = 198926 },
+version = "7.6.10"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/84/ba/ac14d281f80aab516275012e8875991bb06203957aa1e19950139238d658/coverage-7.6.10.tar.gz", hash = "sha256:7fb105327c8f8f0682e29843e2ff96af9dcbe5bab8eeb4b398c6a33a16d80a23", size = 803868 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c5/12/2a2a923edf4ddabdffed7ad6da50d96a5c126dae7b80a33df7310e329a1e/coverage-7.6.10-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:5c912978f7fbf47ef99cec50c4401340436d200d41d714c7a4766f377c5b7b78", size = 207982 },
+    { url = "https://files.pythonhosted.org/packages/ca/49/6985dbca9c7be3f3cb62a2e6e492a0c88b65bf40579e16c71ae9c33c6b23/coverage-7.6.10-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a01ec4af7dfeb96ff0078ad9a48810bb0cc8abcb0115180c6013a6b26237626c", size = 208414 },
+    { url = "https://files.pythonhosted.org/packages/35/93/287e8f1d1ed2646f4e0b2605d14616c9a8a2697d0d1b453815eb5c6cebdb/coverage-7.6.10-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a3b204c11e2b2d883946fe1d97f89403aa1811df28ce0447439178cc7463448a", size = 236860 },
+    { url = "https://files.pythonhosted.org/packages/de/e1/cfdb5627a03567a10031acc629b75d45a4ca1616e54f7133ca1fa366050a/coverage-7.6.10-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:32ee6d8491fcfc82652a37109f69dee9a830e9379166cb73c16d8dc5c2915165", size = 234758 },
+    { url = "https://files.pythonhosted.org/packages/6d/85/fc0de2bcda3f97c2ee9fe8568f7d48f7279e91068958e5b2cc19e0e5f600/coverage-7.6.10-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:675cefc4c06e3b4c876b85bfb7c59c5e2218167bbd4da5075cbe3b5790a28988", size = 235920 },
+    { url = "https://files.pythonhosted.org/packages/79/73/ef4ea0105531506a6f4cf4ba571a214b14a884630b567ed65b3d9c1975e1/coverage-7.6.10-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:f4f620668dbc6f5e909a0946a877310fb3d57aea8198bde792aae369ee1c23b5", size = 234986 },
+    { url = "https://files.pythonhosted.org/packages/c6/4d/75afcfe4432e2ad0405c6f27adeb109ff8976c5e636af8604f94f29fa3fc/coverage-7.6.10-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:4eea95ef275de7abaef630c9b2c002ffbc01918b726a39f5a4353916ec72d2f3", size = 233446 },
+    { url = "https://files.pythonhosted.org/packages/86/5b/efee56a89c16171288cafff022e8af44f8f94075c2d8da563c3935212871/coverage-7.6.10-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:e2f0280519e42b0a17550072861e0bc8a80a0870de260f9796157d3fca2733c5", size = 234566 },
+    { url = "https://files.pythonhosted.org/packages/f2/db/67770cceb4a64d3198bf2aa49946f411b85ec6b0a9b489e61c8467a4253b/coverage-7.6.10-cp310-cp310-win32.whl", hash = "sha256:bc67deb76bc3717f22e765ab3e07ee9c7a5e26b9019ca19a3b063d9f4b874244", size = 210675 },
+    { url = "https://files.pythonhosted.org/packages/8d/27/e8bfc43f5345ec2c27bc8a1fa77cdc5ce9dcf954445e11f14bb70b889d14/coverage-7.6.10-cp310-cp310-win_amd64.whl", hash = "sha256:0f460286cb94036455e703c66988851d970fdfd8acc2a1122ab7f4f904e4029e", size = 211518 },
+    { url = "https://files.pythonhosted.org/packages/85/d2/5e175fcf6766cf7501a8541d81778fd2f52f4870100e791f5327fd23270b/coverage-7.6.10-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ea3c8f04b3e4af80e17bab607c386a830ffc2fb88a5484e1df756478cf70d1d3", size = 208088 },
+    { url = "https://files.pythonhosted.org/packages/4b/6f/06db4dc8fca33c13b673986e20e466fd936235a6ec1f0045c3853ac1b593/coverage-7.6.10-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:507a20fc863cae1d5720797761b42d2d87a04b3e5aeb682ef3b7332e90598f43", size = 208536 },
+    { url = "https://files.pythonhosted.org/packages/0d/62/c6a0cf80318c1c1af376d52df444da3608eafc913b82c84a4600d8349472/coverage-7.6.10-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d37a84878285b903c0fe21ac8794c6dab58150e9359f1aaebbeddd6412d53132", size = 240474 },
+    { url = "https://files.pythonhosted.org/packages/a3/59/750adafc2e57786d2e8739a46b680d4fb0fbc2d57fbcb161290a9f1ecf23/coverage-7.6.10-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a534738b47b0de1995f85f582d983d94031dffb48ab86c95bdf88dc62212142f", size = 237880 },
+    { url = "https://files.pythonhosted.org/packages/2c/f8/ef009b3b98e9f7033c19deb40d629354aab1d8b2d7f9cfec284dbedf5096/coverage-7.6.10-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0d7a2bf79378d8fb8afaa994f91bfd8215134f8631d27eba3e0e2c13546ce994", size = 239750 },
+    { url = "https://files.pythonhosted.org/packages/a6/e2/6622f3b70f5f5b59f705e680dae6db64421af05a5d1e389afd24dae62e5b/coverage-7.6.10-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6713ba4b4ebc330f3def51df1d5d38fad60b66720948112f114968feb52d3f99", size = 238642 },
+    { url = "https://files.pythonhosted.org/packages/2d/10/57ac3f191a3c95c67844099514ff44e6e19b2915cd1c22269fb27f9b17b6/coverage-7.6.10-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:ab32947f481f7e8c763fa2c92fd9f44eeb143e7610c4ca9ecd6a36adab4081bd", size = 237266 },
+    { url = "https://files.pythonhosted.org/packages/ee/2d/7016f4ad9d553cabcb7333ed78ff9d27248ec4eba8dd21fa488254dff894/coverage-7.6.10-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:7bbd8c8f1b115b892e34ba66a097b915d3871db7ce0e6b9901f462ff3a975377", size = 238045 },
+    { url = "https://files.pythonhosted.org/packages/a7/fe/45af5c82389a71e0cae4546413266d2195c3744849669b0bab4b5f2c75da/coverage-7.6.10-cp311-cp311-win32.whl", hash = "sha256:299e91b274c5c9cdb64cbdf1b3e4a8fe538a7a86acdd08fae52301b28ba297f8", size = 210647 },
+    { url = "https://files.pythonhosted.org/packages/db/11/3f8e803a43b79bc534c6a506674da9d614e990e37118b4506faf70d46ed6/coverage-7.6.10-cp311-cp311-win_amd64.whl", hash = "sha256:489a01f94aa581dbd961f306e37d75d4ba16104bbfa2b0edb21d29b73be83609", size = 211508 },
+    { url = "https://files.pythonhosted.org/packages/86/77/19d09ea06f92fdf0487499283b1b7af06bc422ea94534c8fe3a4cd023641/coverage-7.6.10-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:27c6e64726b307782fa5cbe531e7647aee385a29b2107cd87ba7c0105a5d3853", size = 208281 },
+    { url = "https://files.pythonhosted.org/packages/b6/67/5479b9f2f99fcfb49c0d5cf61912a5255ef80b6e80a3cddba39c38146cf4/coverage-7.6.10-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c56e097019e72c373bae32d946ecf9858fda841e48d82df7e81c63ac25554078", size = 208514 },
+    { url = "https://files.pythonhosted.org/packages/15/d1/febf59030ce1c83b7331c3546d7317e5120c5966471727aa7ac157729c4b/coverage-7.6.10-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c7827a5bc7bdb197b9e066cdf650b2887597ad124dd99777332776f7b7c7d0d0", size = 241537 },
+    { url = "https://files.pythonhosted.org/packages/4b/7e/5ac4c90192130e7cf8b63153fe620c8bfd9068f89a6d9b5f26f1550f7a26/coverage-7.6.10-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:204a8238afe787323a8b47d8be4df89772d5c1e4651b9ffa808552bdf20e1d50", size = 238572 },
+    { url = "https://files.pythonhosted.org/packages/dc/03/0334a79b26ecf59958f2fe9dd1f5ab3e2f88db876f5071933de39af09647/coverage-7.6.10-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e67926f51821b8e9deb6426ff3164870976fe414d033ad90ea75e7ed0c2e5022", size = 240639 },
+    { url = "https://files.pythonhosted.org/packages/d7/45/8a707f23c202208d7b286d78ad6233f50dcf929319b664b6cc18a03c1aae/coverage-7.6.10-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e78b270eadb5702938c3dbe9367f878249b5ef9a2fcc5360ac7bff694310d17b", size = 240072 },
+    { url = "https://files.pythonhosted.org/packages/66/02/603ce0ac2d02bc7b393279ef618940b4a0535b0868ee791140bda9ecfa40/coverage-7.6.10-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:714f942b9c15c3a7a5fe6876ce30af831c2ad4ce902410b7466b662358c852c0", size = 238386 },
+    { url = "https://files.pythonhosted.org/packages/04/62/4e6887e9be060f5d18f1dd58c2838b2d9646faf353232dec4e2d4b1c8644/coverage-7.6.10-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:abb02e2f5a3187b2ac4cd46b8ced85a0858230b577ccb2c62c81482ca7d18852", size = 240054 },
+    { url = "https://files.pythonhosted.org/packages/5c/74/83ae4151c170d8bd071924f212add22a0e62a7fe2b149edf016aeecad17c/coverage-7.6.10-cp312-cp312-win32.whl", hash = "sha256:55b201b97286cf61f5e76063f9e2a1d8d2972fc2fcfd2c1272530172fd28c359", size = 210904 },
+    { url = "https://files.pythonhosted.org/packages/c3/54/de0893186a221478f5880283119fc40483bc460b27c4c71d1b8bba3474b9/coverage-7.6.10-cp312-cp312-win_amd64.whl", hash = "sha256:e4ae5ac5e0d1e4edfc9b4b57b4cbecd5bc266a6915c500f358817a8496739247", size = 211692 },
+    { url = "https://files.pythonhosted.org/packages/25/6d/31883d78865529257bf847df5789e2ae80e99de8a460c3453dbfbe0db069/coverage-7.6.10-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:05fca8ba6a87aabdd2d30d0b6c838b50510b56cdcfc604d40760dae7153b73d9", size = 208308 },
+    { url = "https://files.pythonhosted.org/packages/70/22/3f2b129cc08de00c83b0ad6252e034320946abfc3e4235c009e57cfeee05/coverage-7.6.10-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:9e80eba8801c386f72e0712a0453431259c45c3249f0009aff537a517b52942b", size = 208565 },
+    { url = "https://files.pythonhosted.org/packages/97/0a/d89bc2d1cc61d3a8dfe9e9d75217b2be85f6c73ebf1b9e3c2f4e797f4531/coverage-7.6.10-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a372c89c939d57abe09e08c0578c1d212e7a678135d53aa16eec4430adc5e690", size = 241083 },
+    { url = "https://files.pythonhosted.org/packages/4c/81/6d64b88a00c7a7aaed3a657b8eaa0931f37a6395fcef61e53ff742b49c97/coverage-7.6.10-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ec22b5e7fe7a0fa8509181c4aac1db48f3dd4d3a566131b313d1efc102892c18", size = 238235 },
+    { url = "https://files.pythonhosted.org/packages/9a/0b/7797d4193f5adb4b837207ed87fecf5fc38f7cc612b369a8e8e12d9fa114/coverage-7.6.10-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:26bcf5c4df41cad1b19c84af71c22cbc9ea9a547fc973f1f2cc9a290002c8b3c", size = 240220 },
+    { url = "https://files.pythonhosted.org/packages/65/4d/6f83ca1bddcf8e51bf8ff71572f39a1c73c34cf50e752a952c34f24d0a60/coverage-7.6.10-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4e4630c26b6084c9b3cb53b15bd488f30ceb50b73c35c5ad7871b869cb7365fd", size = 239847 },
+    { url = "https://files.pythonhosted.org/packages/30/9d/2470df6aa146aff4c65fee0f87f58d2164a67533c771c9cc12ffcdb865d5/coverage-7.6.10-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:2396e8116db77789f819d2bc8a7e200232b7a282c66e0ae2d2cd84581a89757e", size = 237922 },
+    { url = "https://files.pythonhosted.org/packages/08/dd/723fef5d901e6a89f2507094db66c091449c8ba03272861eaefa773ad95c/coverage-7.6.10-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:79109c70cc0882e4d2d002fe69a24aa504dec0cc17169b3c7f41a1d341a73694", size = 239783 },
+    { url = "https://files.pythonhosted.org/packages/3d/f7/64d3298b2baf261cb35466000628706ce20a82d42faf9b771af447cd2b76/coverage-7.6.10-cp313-cp313-win32.whl", hash = "sha256:9e1747bab246d6ff2c4f28b4d186b205adced9f7bd9dc362051cc37c4a0c7bd6", size = 210965 },
+    { url = "https://files.pythonhosted.org/packages/d5/58/ec43499a7fc681212fe7742fe90b2bc361cdb72e3181ace1604247a5b24d/coverage-7.6.10-cp313-cp313-win_amd64.whl", hash = "sha256:254f1a3b1eef5f7ed23ef265eaa89c65c8c5b6b257327c149db1ca9d4a35f25e", size = 211719 },
+    { url = "https://files.pythonhosted.org/packages/ab/c9/f2857a135bcff4330c1e90e7d03446b036b2363d4ad37eb5e3a47bbac8a6/coverage-7.6.10-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:2ccf240eb719789cedbb9fd1338055de2761088202a9a0b73032857e53f612fe", size = 209050 },
+    { url = "https://files.pythonhosted.org/packages/aa/b3/f840e5bd777d8433caa9e4a1eb20503495709f697341ac1a8ee6a3c906ad/coverage-7.6.10-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:0c807ca74d5a5e64427c8805de15b9ca140bba13572d6d74e262f46f50b13273", size = 209321 },
+    { url = "https://files.pythonhosted.org/packages/85/7d/125a5362180fcc1c03d91850fc020f3831d5cda09319522bcfa6b2b70be7/coverage-7.6.10-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2bcfa46d7709b5a7ffe089075799b902020b62e7ee56ebaed2f4bdac04c508d8", size = 252039 },
+    { url = "https://files.pythonhosted.org/packages/a9/9c/4358bf3c74baf1f9bddd2baf3756b54c07f2cfd2535f0a47f1e7757e54b3/coverage-7.6.10-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4e0de1e902669dccbf80b0415fb6b43d27edca2fbd48c74da378923b05316098", size = 247758 },
+    { url = "https://files.pythonhosted.org/packages/cf/c7/de3eb6fc5263b26fab5cda3de7a0f80e317597a4bad4781859f72885f300/coverage-7.6.10-cp313-cp313t-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3f7b444c42bbc533aaae6b5a2166fd1a797cdb5eb58ee51a92bee1eb94a1e1cb", size = 250119 },
+    { url = "https://files.pythonhosted.org/packages/3e/e6/43de91f8ba2ec9140c6a4af1102141712949903dc732cf739167cfa7a3bc/coverage-7.6.10-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:b330368cb99ef72fcd2dc3ed260adf67b31499584dc8a20225e85bfe6f6cfed0", size = 249597 },
+    { url = "https://files.pythonhosted.org/packages/08/40/61158b5499aa2adf9e37bc6d0117e8f6788625b283d51e7e0c53cf340530/coverage-7.6.10-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:9a7cfb50515f87f7ed30bc882f68812fd98bc2852957df69f3003d22a2aa0abf", size = 247473 },
+    { url = "https://files.pythonhosted.org/packages/50/69/b3f2416725621e9f112e74e8470793d5b5995f146f596f133678a633b77e/coverage-7.6.10-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6f93531882a5f68c28090f901b1d135de61b56331bba82028489bc51bdd818d2", size = 248737 },
+    { url = "https://files.pythonhosted.org/packages/3c/6e/fe899fb937657db6df31cc3e61c6968cb56d36d7326361847440a430152e/coverage-7.6.10-cp313-cp313t-win32.whl", hash = "sha256:89d76815a26197c858f53c7f6a656686ec392b25991f9e409bcef020cd532312", size = 211611 },
+    { url = "https://files.pythonhosted.org/packages/1c/55/52f5e66142a9d7bc93a15192eba7a78513d2abf6b3558d77b4ca32f5f424/coverage-7.6.10-cp313-cp313t-win_amd64.whl", hash = "sha256:54a5f0f43950a36312155dae55c505a76cd7f2b12d26abeebbe7a0b36dbc868d", size = 212781 },
+    { url = "https://files.pythonhosted.org/packages/40/41/473617aadf9a1c15bc2d56be65d90d7c29bfa50a957a67ef96462f7ebf8e/coverage-7.6.10-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:656c82b8a0ead8bba147de9a89bda95064874c91a3ed43a00e687f23cc19d53a", size = 207978 },
+    { url = "https://files.pythonhosted.org/packages/10/f6/480586607768b39a30e6910a3c4522139094ac0f1677028e1f4823688957/coverage-7.6.10-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:ccc2b70a7ed475c68ceb548bf69cec1e27305c1c2606a5eb7c3afff56a1b3b27", size = 208415 },
+    { url = "https://files.pythonhosted.org/packages/f1/af/439bb760f817deff6f4d38fe7da08d9dd7874a560241f1945bc3b4446550/coverage-7.6.10-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a5e37dc41d57ceba70956fa2fc5b63c26dba863c946ace9705f8eca99daecdc4", size = 236452 },
+    { url = "https://files.pythonhosted.org/packages/d0/13/481f4ceffcabe29ee2332e60efb52e4694f54a402f3ada2bcec10bb32e43/coverage-7.6.10-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0aa9692b4fdd83a4647eeb7db46410ea1322b5ed94cd1715ef09d1d5922ba87f", size = 234374 },
+    { url = "https://files.pythonhosted.org/packages/c5/59/4607ea9d6b1b73e905c7656da08d0b00cdf6e59f2293ec259e8914160025/coverage-7.6.10-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aa744da1820678b475e4ba3dfd994c321c5b13381d1041fe9c608620e6676e25", size = 235505 },
+    { url = "https://files.pythonhosted.org/packages/85/60/d66365723b9b7f29464b11d024248ed3523ce5aab958e4ad8c43f3f4148b/coverage-7.6.10-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:c0b1818063dc9e9d838c09e3a473c1422f517889436dd980f5d721899e66f315", size = 234616 },
+    { url = "https://files.pythonhosted.org/packages/74/f8/2cf7a38e7d81b266f47dfcf137fecd8fa66c7bdbd4228d611628d8ca3437/coverage-7.6.10-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:59af35558ba08b758aec4d56182b222976330ef8d2feacbb93964f576a7e7a90", size = 233099 },
+    { url = "https://files.pythonhosted.org/packages/50/2b/bff6c1c6b63c4396ea7ecdbf8db1788b46046c681b8fcc6ec77db9f4ea49/coverage-7.6.10-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:7ed2f37cfce1ce101e6dffdfd1c99e729dd2ffc291d02d3e2d0af8b53d13840d", size = 234089 },
+    { url = "https://files.pythonhosted.org/packages/bf/b5/baace1c754d546a67779358341aa8d2f7118baf58cac235db457e1001d1b/coverage-7.6.10-cp39-cp39-win32.whl", hash = "sha256:4bcc276261505d82f0ad426870c3b12cb177752834a633e737ec5ee79bbdff18", size = 210701 },
+    { url = "https://files.pythonhosted.org/packages/b1/bf/9e1e95b8b20817398ecc5a1e8d3e05ff404e1b9fb2185cd71561698fe2a2/coverage-7.6.10-cp39-cp39-win_amd64.whl", hash = "sha256:457574f4599d2b00f7f637a0700a6422243b3565509457b2dbd3f50703e11f59", size = 211482 },
+    { url = "https://files.pythonhosted.org/packages/a1/70/de81bfec9ed38a64fc44a77c7665e20ca507fc3265597c28b0d989e4082e/coverage-7.6.10-pp39.pp310-none-any.whl", hash = "sha256:fd34e7b3405f0cc7ab03d54a334c17a9e802897580d964bd8c2001f4b9fd488f", size = 200223 },
 ]
 
 [[package]]
 name = "dirty-equals"
-version = "0.8.0"
+version = "0.9.0"
 source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "pytz", marker = "python_full_version < '3.9'" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/17/4c/39c428b7c900b21c8116d89a56b73f6dc14a2455767961b54adfe7c224fe/dirty_equals-0.8.0.tar.gz", hash = "sha256:798db3b9481b9a5024c0e520946507676ed2f0c65317d3e95bdce1a01657cf60", size = 50294 }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/99/133892f401ced5a27e641a473c547d5fbdb39af8f85dac8a9d633ea3e7a7/dirty_equals-0.9.0.tar.gz", hash = "sha256:17f515970b04ed7900b733c95fd8091f4f85e52f1fb5f268757f25c858eb1f7b", size = 50412 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f3/cd/8c3ce82cc6b18e149bff3cf8dd50a75316ca093ae706f0c1c4df87f2b88f/dirty_equals-0.8.0-py3-none-any.whl", hash = "sha256:0ef998ba3c395e03cf5eb3cd1c13c26a9a992efa18c0d59c22ba27344519cee1", size = 28217 },
+    { url = "https://files.pythonhosted.org/packages/77/0c/03cc99bf3b6328604b10829de3460f2b2ad3373200c45665c38508e550c6/dirty_equals-0.9.0-py3-none-any.whl", hash = "sha256:ff4d027f5cfa1b69573af00f7ba9043ea652dbdce3fe5cbe828e478c7346db9c", size = 28226 },
 ]
 
 [[package]]
@@ -294,47 +238,37 @@ wheels = [
 
 [[package]]
 name = "executing"
-version = "2.1.0"
+version = "2.2.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/8c/e3/7d45f492c2c4a0e8e0fad57d081a7c8a0286cdd86372b070cca1ec0caa1e/executing-2.1.0.tar.gz", hash = "sha256:8ea27ddd260da8150fa5a708269c4a10e76161e2496ec3e587da9e3c0fe4b9ab", size = 977485 }
+sdist = { url = "https://files.pythonhosted.org/packages/91/50/a9d80c47ff289c611ff12e63f7c5d13942c65d68125160cefd768c73e6e4/executing-2.2.0.tar.gz", hash = "sha256:5d108c028108fe2551d1a7b2e8b713341e2cb4fc0aa7dcf966fa4327a5226755", size = 978693 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b5/fd/afcd0496feca3276f509df3dbd5dae726fcc756f1a08d9e25abe1733f962/executing-2.1.0-py2.py3-none-any.whl", hash = "sha256:8d63781349375b5ebccc3142f4b30350c0cd9c79f921cde38be2be4637e98eaf", size = 25805 },
-]
-
-[[package]]
-name = "filelock"
-version = "3.16.1"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/9d/db/3ef5bb276dae18d6ec2124224403d1d67bccdbefc17af4cc8f553e341ab1/filelock-3.16.1.tar.gz", hash = "sha256:c249fbfcd5db47e5e2d6d62198e565475ee65e4831e2561c8e313fa7eb961435", size = 18037 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/b9/f8/feced7779d755758a52d1f6635d990b8d98dc0a29fa568bbe0625f18fdf3/filelock-3.16.1-py3-none-any.whl", hash = "sha256:2082e5703d51fbf98ea75855d9d5527e33d8ff23099bec374a134febee6946b0", size = 16163 },
+    { url = "https://files.pythonhosted.org/packages/7b/8f/c4d9bafc34ad7ad5d8dc16dd1347ee0e507a52c3adb6bfa8887e1c6a26ba/executing-2.2.0-py2.py3-none-any.whl", hash = "sha256:11387150cad388d62750327a53d3339fad4888b39a6fe233c3afbb54ecffd3aa", size = 26702 },
 ]
 
 [[package]]
 name = "griffe"
-version = "1.4.0"
+version = "1.5.5"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "astunparse", marker = "python_full_version < '3.9'" },
     { name = "colorama" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/05/e9/b2c86ad9d69053e497a24ceb25d661094fb321ab4ed39a8b71793dcbae82/griffe-1.4.0.tar.gz", hash = "sha256:8fccc585896d13f1221035d32c50dec65830c87d23f9adb9b1e6f3d63574f7f5", size = 381028 }
+sdist = { url = "https://files.pythonhosted.org/packages/5c/74/cd35a98cb11f79de0581e8e1e6fbd738aeeed1f2d90e9b5106728b63f5f7/griffe-1.5.5.tar.gz", hash = "sha256:35ee5b38b93d6a839098aad0f92207e6ad6b70c3e8866c08ca669275b8cba585", size = 391124 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/22/7c/e9e66869c2e4c9b378474e49c993128ec0131ef4721038b6d06e50538caf/griffe-1.4.0-py3-none-any.whl", hash = "sha256:e589de8b8c137e99a46ec45f9598fc0ac5b6868ce824b24db09c02d117b89bc5", size = 127015 },
+    { url = "https://files.pythonhosted.org/packages/1f/88/52c9422bc853cd7c2b6122090e887d17b5fad29b67f930e4277c9c557357/griffe-1.5.5-py3-none-any.whl", hash = "sha256:2761b1e8876c6f1f9ab1af274df93ea6bbadd65090de5f38f4cb5cc84897c7dd", size = 128221 },
 ]
 
 [[package]]
 name = "hypothesis"
-version = "6.113.0"
+version = "6.124.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "attrs" },
     { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
     { name = "sortedcontainers" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/28/32/6513cd7256f38c19a6c8a1d5ce9792bcd35c7f11651989994731f0e97672/hypothesis-6.113.0.tar.gz", hash = "sha256:5556ac66fdf72a4ccd5d237810f7cf6bdcd00534a4485015ef881af26e20f7c7", size = 408897 }
+sdist = { url = "https://files.pythonhosted.org/packages/e6/3b/3a7cf8973b0424c6af0b2b5fe30f89ab738616bad2a16aafcc49ff069ed4/hypothesis-6.124.2.tar.gz", hash = "sha256:c98823fc1323f23399e5f2251982fd1f38259f84cf627aaaea1b3f0a0d4d2b03", size = 419462 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/14/fa/4acb477b86a94571958bd337eae5baf334d21b8c98a04b594d0dad381ba8/hypothesis-6.113.0-py3-none-any.whl", hash = "sha256:d539180eb2bb71ed28a23dfe94e67c851f9b09f3ccc4125afad43f17e32e2bad", size = 469790 },
+    { url = "https://files.pythonhosted.org/packages/a3/e1/80f1819e65a9a0b1b744b453cd26803764fc192cff8eaea202e76f6f5a65/hypothesis-6.124.2-py3-none-any.whl", hash = "sha256:fef7709a404929a9cd3e785f60a6e026089aab986e288b1fdced13091574d474", size = 482180 },
 ]
 
 [[package]]
@@ -348,20 +282,17 @@ wheels = [
 
 [[package]]
 name = "inline-snapshot"
-version = "0.14.0"
+version = "0.19.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "asttokens" },
-    { name = "black" },
-    { name = "click" },
     { name = "executing" },
     { name = "rich" },
     { name = "tomli", marker = "python_full_version < '3.11'" },
-    { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/45/a9/b6b9db4f2ef1e3261460701a429f8248e517cb8d18e27ff05f4690ac0a73/inline_snapshot-0.14.0.tar.gz", hash = "sha256:54fdf7831055d06a2423054875d640102865a164cc8291a8086e44dd9b4fd316", size = 209662 }
+sdist = { url = "https://files.pythonhosted.org/packages/42/bc/bbba2efb2ab0c8cf3d43fb0a7a1d3dfd8533d3bf18df9662ee4c09af7cac/inline_snapshot-0.19.3.tar.gz", hash = "sha256:1e40f34da64fe2406c6bba3f473905e22386da43e16c85060610692325aa94d7", size = 88636 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/5e/a3/8ca14974625632d56d7e9f899d76d15dc4acd94ec15c179ca528beadeb4a/inline_snapshot-0.14.0-py3-none-any.whl", hash = "sha256:dc246d28b720f6050404b72cc1d171b0671e1494249197753d23771ff228748c", size = 31807 },
+    { url = "https://files.pythonhosted.org/packages/fd/fc/d99b8983af46c0adbe10ad369ab929eb35cb32635526a9de4fe06ffd612f/inline_snapshot-0.19.3-py3-none-any.whl", hash = "sha256:81ed10eedb593aee630d2fc0cfe5d10a843c4bd507c2d96ea058c28413985452", size = 43627 },
 ]
 
 [[package]]
@@ -378,25 +309,25 @@ wheels = [
 
 [[package]]
 name = "maturin"
-version = "1.7.4"
+version = "1.8.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "tomli", marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/51/28/31a650d9209d873b6aec759c944bd284155154d7a01f7f541786d7c435ca/maturin-1.7.4.tar.gz", hash = "sha256:2b349d742a07527d236f0b4b6cab26f53ebecad0ceabfc09ec4c6a396e3176f9", size = 191145 }
+sdist = { url = "https://files.pythonhosted.org/packages/9a/08/ccb0f917722a35ab0d758be9bb5edaf645c3a3d6170061f10d396ecd273f/maturin-1.8.1.tar.gz", hash = "sha256:49cd964aabf59f8b0a6969f9860d2cdf194ac331529caae14c884f5659568857", size = 197397 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/85/19/b5be36f3cb30ba72aa2232492d4462409955da134ea25083f0e625618082/maturin-1.7.4-py3-none-linux_armv6l.whl", hash = "sha256:eb7b7753b733ae302c08f80bca7b0c3fda1eea665c2b1922c58795f35a54c833", size = 8215481 },
-    { url = "https://files.pythonhosted.org/packages/4f/0a/1b2a2fda3f338dedd219de358d77b01f1138bc4bc6b4c73b6ea01d8ddd9e/maturin-1.7.4-py3-none-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:0182a9638399c8835afd39d2aeacf56908e37cba3f7abb15816b9df6774fab81", size = 15930801 },
-    { url = "https://files.pythonhosted.org/packages/21/df/f75dcd8472f3be5b528942b11444eb4a82aa1aced7d105a8ba39bb85ece8/maturin-1.7.4-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:41a29c5b23f3ebdfe7633637e3de256579a1b2700c04cd68c16ed46934440c5a", size = 8166643 },
-    { url = "https://files.pythonhosted.org/packages/87/43/52baa75e6dae9848ea22ae6bd405e7f7da091ba63409b07912048fde2083/maturin-1.7.4-py3-none-manylinux_2_12_i686.manylinux2010_i686.musllinux_1_1_i686.whl", hash = "sha256:23fae44e345a2da5cb391ae878726fb793394826e2f97febe41710bd4099460e", size = 8560688 },
-    { url = "https://files.pythonhosted.org/packages/84/97/5e2bfbcf42725ba5f64310423edcf00d90e684a61d55dd0a26b2313a44b6/maturin-1.7.4-py3-none-manylinux_2_12_x86_64.manylinux2010_x86_64.musllinux_1_1_x86_64.whl", hash = "sha256:8b441521c151f0dbe70ed06fb1feb29b855d787bda038ff4330ca962e5d56641", size = 8939107 },
-    { url = "https://files.pythonhosted.org/packages/34/59/e0d58ce67a8a6245dcb74ffb81cb12f0cda8b622c8d902f2371de742ae04/maturin-1.7.4-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64.whl", hash = "sha256:7ccb66d0c5297cf06652c5f72cb398f447d3a332eccf5d1e73b3fe14dbc9498c", size = 8425431 },
-    { url = "https://files.pythonhosted.org/packages/53/20/4b79324b14a1f39b2c66eb1ad681cf8b0fff1f905374b0cca59fc9c8ef7a/maturin-1.7.4-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.musllinux_1_1_armv7l.whl", hash = "sha256:71f668f19e719048605dbca6a1f4d0dc03b987c922ad9c4bf5be03b9b278e4c3", size = 8104459 },
-    { url = "https://files.pythonhosted.org/packages/7f/fa/8d9497c62451fc19f52cda1ad652c5dca4e9646ff93be35250070afbc2af/maturin-1.7.4-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.musllinux_1_1_ppc64le.whl", hash = "sha256:c179fcb2b494f19186781b667320e43d95b3e71fcb1c98fffad9ef6bd6e276b3", size = 8729663 },
-    { url = "https://files.pythonhosted.org/packages/a4/e9/15a24263de981928303ca64465d5d9d5062f248b9ceaab3de5857ee0ba83/maturin-1.7.4-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:fd5b4b95286f2f376437340f8a4908f4761587212170263084455be8099099a7", size = 10142511 },
-    { url = "https://files.pythonhosted.org/packages/a5/5d/59765561ea1a5f993141a403eb4ae85b7a8bd118971de0ed14048e3faf7f/maturin-1.7.4-py3-none-win32.whl", hash = "sha256:35487a424467d1fda4567cbb02d21f09febb10eda22f5fd647b130bc0767dc61", size = 6578873 },
-    { url = "https://files.pythonhosted.org/packages/72/50/a9b402aa506bad6c066c7775b1cb3036b7b1c74b9de708ed537ee804ea4a/maturin-1.7.4-py3-none-win_amd64.whl", hash = "sha256:f70c1c8ec9bd4749a53c0f3ae8fdbb326ce45be4f1c5551985ee25a6d7150328", size = 7442039 },
-    { url = "https://files.pythonhosted.org/packages/30/38/8e27282ab6ff94291f04e3eb11ba960dfb487605d73cec75177d3a29879a/maturin-1.7.4-py3-none-win_arm64.whl", hash = "sha256:f3d38a6d0c7fd7b04bec30dd470b2173cf9bd184ab6220c1acaf49df6b48faf5", size = 6388008 },
+    { url = "https://files.pythonhosted.org/packages/4c/00/f34077315f34db8ad2ccf6bfe11b864ca27baab3a1320634da8e3cf89a48/maturin-1.8.1-py3-none-linux_armv6l.whl", hash = "sha256:7e590a23d9076b8a994f2e67bc63dc9a2d1c9a41b1e7b45ac354ba8275254e89", size = 7568415 },
+    { url = "https://files.pythonhosted.org/packages/5c/07/9219976135ce0cb32d2fa6ea5c6d0ad709013d9a17967312e149b98153a6/maturin-1.8.1-py3-none-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:8d8251a95682c83ea60988c804b620c181911cd824aa107b4a49ac5333c92968", size = 14527816 },
+    { url = "https://files.pythonhosted.org/packages/e6/04/fa009a00903acdd1785d58322193140bfe358595347c39f315112dabdf9e/maturin-1.8.1-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:b9fc1a4354cac5e32c190410208039812ea88c4a36bd2b6499268ec49ef5de00", size = 7580446 },
+    { url = "https://files.pythonhosted.org/packages/9b/d4/414b2aab9bbfe88182b734d3aa1b4fef7d7701e50f6be48500378b8c8721/maturin-1.8.1-py3-none-manylinux_2_12_i686.manylinux2010_i686.musllinux_1_1_i686.whl", hash = "sha256:621e171c6b39f95f1d0df69a118416034fbd59c0f89dcaea8c2ea62019deecba", size = 7650535 },
+    { url = "https://files.pythonhosted.org/packages/f0/64/879418a8a0196013ec1fb19eada0781c04a30e8d6d9227e80f91275a4f5b/maturin-1.8.1-py3-none-manylinux_2_12_x86_64.manylinux2010_x86_64.musllinux_1_1_x86_64.whl", hash = "sha256:98f638739a5132962347871b85c91f525c9246ef4d99796ae98a2031e3df029f", size = 8006702 },
+    { url = "https://files.pythonhosted.org/packages/39/c2/605829324f8371294f70303aca130682df75318958efed246873d3d604ab/maturin-1.8.1-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64.whl", hash = "sha256:f9f5c47521924b6e515cbc652a042fe5f17f8747445be9d931048e5d8ddb50a4", size = 7368164 },
+    { url = "https://files.pythonhosted.org/packages/be/6c/30e136d397bb146b94b628c0ef7f17708281611b97849e2cf37847025ac7/maturin-1.8.1-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.musllinux_1_1_armv7l.whl", hash = "sha256:0f4407c7353c31bfbb8cdeb82bc2170e474cbfb97b5ba27568f440c9d6c1fdd4", size = 7450889 },
+    { url = "https://files.pythonhosted.org/packages/1b/50/e1f5023512696d4e56096f702e2f68d6d9a30afe0a4eec82b0e27b8eb4e4/maturin-1.8.1-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.musllinux_1_1_ppc64le.whl", hash = "sha256:ec49cd70cad3c389946c6e2bc0bd50772a7fcb463040dd800720345897eec9bf", size = 9585819 },
+    { url = "https://files.pythonhosted.org/packages/b7/80/b24b5248d89d2e5982553900237a337ea098ca9297b8369ca2aa95549e0f/maturin-1.8.1-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c08767d794de8f8a11c5c8b1b47a4ff9fb6ae2d2d97679e27030f2f509c8c2a0", size = 10920801 },
+    { url = "https://files.pythonhosted.org/packages/6e/f4/8ede7a662fabf93456b44390a5ad22630e25fb5ddaecf787251071b2e143/maturin-1.8.1-py3-none-win32.whl", hash = "sha256:d678407713f3e10df33c5b3d7a343ec0551eb7f14d8ad9ba6febeb96f4e4c75c", size = 6873556 },
+    { url = "https://files.pythonhosted.org/packages/9c/22/757f093ed0e319e9648155b8c9d716765442bea5bc98ebc58ad4ad5b0524/maturin-1.8.1-py3-none-win_amd64.whl", hash = "sha256:a526f90fe0e5cb59ffb81f4ff547ddc42e823bbdeae4a31012c0893ca6dcaf46", size = 7823153 },
+    { url = "https://files.pythonhosted.org/packages/a4/f5/051413e04f6da25069db5e76759ecdb8cd2a8ab4a94045b5a3bf548c66fa/maturin-1.8.1-py3-none-win_arm64.whl", hash = "sha256:e95f077fd2ddd2f048182880eed458c308571a534be3eb2add4d3dac55bf57f4", size = 6552131 },
 ]
 
 [[package]]
@@ -410,46 +341,46 @@ wheels = [
 
 [[package]]
 name = "mypy"
-version = "1.13.0"
+version = "1.14.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "mypy-extensions" },
     { name = "tomli", marker = "python_full_version < '3.11'" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/e8/21/7e9e523537991d145ab8a0a2fd98548d67646dc2aaaf6091c31ad883e7c1/mypy-1.13.0.tar.gz", hash = "sha256:0291a61b6fbf3e6673e3405cfcc0e7650bebc7939659fdca2702958038bd835e", size = 3152532 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/5e/8c/206de95a27722b5b5a8c85ba3100467bd86299d92a4f71c6b9aa448bfa2f/mypy-1.13.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:6607e0f1dd1fb7f0aca14d936d13fd19eba5e17e1cd2a14f808fa5f8f6d8f60a", size = 11020731 },
-    { url = "https://files.pythonhosted.org/packages/ab/bb/b31695a29eea76b1569fd28b4ab141a1adc9842edde080d1e8e1776862c7/mypy-1.13.0-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8a21be69bd26fa81b1f80a61ee7ab05b076c674d9b18fb56239d72e21d9f4c80", size = 10184276 },
-    { url = "https://files.pythonhosted.org/packages/a5/2d/4a23849729bb27934a0e079c9c1aad912167d875c7b070382a408d459651/mypy-1.13.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7b2353a44d2179846a096e25691d54d59904559f4232519d420d64da6828a3a7", size = 12587706 },
-    { url = "https://files.pythonhosted.org/packages/5c/c3/d318e38ada50255e22e23353a469c791379825240e71b0ad03e76ca07ae6/mypy-1.13.0-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:0730d1c6a2739d4511dc4253f8274cdd140c55c32dfb0a4cf8b7a43f40abfa6f", size = 13105586 },
-    { url = "https://files.pythonhosted.org/packages/4a/25/3918bc64952370c3dbdbd8c82c363804678127815febd2925b7273d9482c/mypy-1.13.0-cp310-cp310-win_amd64.whl", hash = "sha256:c5fc54dbb712ff5e5a0fca797e6e0aa25726c7e72c6a5850cfd2adbc1eb0a372", size = 9632318 },
-    { url = "https://files.pythonhosted.org/packages/d0/19/de0822609e5b93d02579075248c7aa6ceaddcea92f00bf4ea8e4c22e3598/mypy-1.13.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:581665e6f3a8a9078f28d5502f4c334c0c8d802ef55ea0e7276a6e409bc0d82d", size = 10939027 },
-    { url = "https://files.pythonhosted.org/packages/c8/71/6950fcc6ca84179137e4cbf7cf41e6b68b4a339a1f5d3e954f8c34e02d66/mypy-1.13.0-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:3ddb5b9bf82e05cc9a627e84707b528e5c7caaa1c55c69e175abb15a761cec2d", size = 10108699 },
-    { url = "https://files.pythonhosted.org/packages/26/50/29d3e7dd166e74dc13d46050b23f7d6d7533acf48f5217663a3719db024e/mypy-1.13.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:20c7ee0bc0d5a9595c46f38beb04201f2620065a93755704e141fcac9f59db2b", size = 12506263 },
-    { url = "https://files.pythonhosted.org/packages/3f/1d/676e76f07f7d5ddcd4227af3938a9c9640f293b7d8a44dd4ff41d4db25c1/mypy-1.13.0-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:3790ded76f0b34bc9c8ba4def8f919dd6a46db0f5a6610fb994fe8efdd447f73", size = 12984688 },
-    { url = "https://files.pythonhosted.org/packages/9c/03/5a85a30ae5407b1d28fab51bd3e2103e52ad0918d1e68f02a7778669a307/mypy-1.13.0-cp311-cp311-win_amd64.whl", hash = "sha256:51f869f4b6b538229c1d1bcc1dd7d119817206e2bc54e8e374b3dfa202defcca", size = 9626811 },
-    { url = "https://files.pythonhosted.org/packages/fb/31/c526a7bd2e5c710ae47717c7a5f53f616db6d9097caf48ad650581e81748/mypy-1.13.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:5c7051a3461ae84dfb5dd15eff5094640c61c5f22257c8b766794e6dd85e72d5", size = 11077900 },
-    { url = "https://files.pythonhosted.org/packages/83/67/b7419c6b503679d10bd26fc67529bc6a1f7a5f220bbb9f292dc10d33352f/mypy-1.13.0-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:39bb21c69a5d6342f4ce526e4584bc5c197fd20a60d14a8624d8743fffb9472e", size = 10074818 },
-    { url = "https://files.pythonhosted.org/packages/ba/07/37d67048786ae84e6612575e173d713c9a05d0ae495dde1e68d972207d98/mypy-1.13.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:164f28cb9d6367439031f4c81e84d3ccaa1e19232d9d05d37cb0bd880d3f93c2", size = 12589275 },
-    { url = "https://files.pythonhosted.org/packages/1f/17/b1018c6bb3e9f1ce3956722b3bf91bff86c1cefccca71cec05eae49d6d41/mypy-1.13.0-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:a4c1bfcdbce96ff5d96fc9b08e3831acb30dc44ab02671eca5953eadad07d6d0", size = 13037783 },
-    { url = "https://files.pythonhosted.org/packages/cb/32/cd540755579e54a88099aee0287086d996f5a24281a673f78a0e14dba150/mypy-1.13.0-cp312-cp312-win_amd64.whl", hash = "sha256:a0affb3a79a256b4183ba09811e3577c5163ed06685e4d4b46429a271ba174d2", size = 9726197 },
-    { url = "https://files.pythonhosted.org/packages/11/bb/ab4cfdc562cad80418f077d8be9b4491ee4fb257440da951b85cbb0a639e/mypy-1.13.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:a7b44178c9760ce1a43f544e595d35ed61ac2c3de306599fa59b38a6048e1aa7", size = 11069721 },
-    { url = "https://files.pythonhosted.org/packages/59/3b/a393b1607cb749ea2c621def5ba8c58308ff05e30d9dbdc7c15028bca111/mypy-1.13.0-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:5d5092efb8516d08440e36626f0153b5006d4088c1d663d88bf79625af3d1d62", size = 10063996 },
-    { url = "https://files.pythonhosted.org/packages/d1/1f/6b76be289a5a521bb1caedc1f08e76ff17ab59061007f201a8a18cc514d1/mypy-1.13.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:de2904956dac40ced10931ac967ae63c5089bd498542194b436eb097a9f77bc8", size = 12584043 },
-    { url = "https://files.pythonhosted.org/packages/a6/83/5a85c9a5976c6f96e3a5a7591aa28b4a6ca3a07e9e5ba0cec090c8b596d6/mypy-1.13.0-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:7bfd8836970d33c2105562650656b6846149374dc8ed77d98424b40b09340ba7", size = 13036996 },
-    { url = "https://files.pythonhosted.org/packages/b4/59/c39a6f752f1f893fccbcf1bdd2aca67c79c842402b5283563d006a67cf76/mypy-1.13.0-cp313-cp313-win_amd64.whl", hash = "sha256:9f73dba9ec77acb86457a8fc04b5239822df0c14a082564737833d2963677dbc", size = 9737709 },
-    { url = "https://files.pythonhosted.org/packages/5e/2a/13e9ad339131c0fba5c70584f639005a47088f5eed77081a3d00479df0ca/mypy-1.13.0-cp38-cp38-macosx_10_9_x86_64.whl", hash = "sha256:100fac22ce82925f676a734af0db922ecfea991e1d7ec0ceb1e115ebe501301a", size = 10955147 },
-    { url = "https://files.pythonhosted.org/packages/94/39/02929067dc16b72d78109195cfed349ac4ec85f3d52517ac62b9a5263685/mypy-1.13.0-cp38-cp38-macosx_11_0_arm64.whl", hash = "sha256:7bcb0bb7f42a978bb323a7c88f1081d1b5dee77ca86f4100735a6f541299d8fb", size = 10138373 },
-    { url = "https://files.pythonhosted.org/packages/4a/cc/066709bb01734e3dbbd1375749f8789bf9693f8b842344fc0cf52109694f/mypy-1.13.0-cp38-cp38-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:bde31fc887c213e223bbfc34328070996061b0833b0a4cfec53745ed61f3519b", size = 12543621 },
-    { url = "https://files.pythonhosted.org/packages/f5/a2/124df839025348c7b9877d0ce134832a9249968e3ab36bb826bab0e9a1cf/mypy-1.13.0-cp38-cp38-musllinux_1_1_x86_64.whl", hash = "sha256:07de989f89786f62b937851295ed62e51774722e5444a27cecca993fc3f9cd74", size = 13050348 },
-    { url = "https://files.pythonhosted.org/packages/45/86/cc94b1e7f7e756a63043cf425c24fb7470013ee1c032180282db75b1b335/mypy-1.13.0-cp38-cp38-win_amd64.whl", hash = "sha256:4bde84334fbe19bad704b3f5b78c4abd35ff1026f8ba72b29de70dda0916beb6", size = 9615311 },
-    { url = "https://files.pythonhosted.org/packages/5f/d4/b33ddd40dad230efb317898a2d1c267c04edba73bc5086bf77edeb410fb2/mypy-1.13.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:0246bcb1b5de7f08f2826451abd947bf656945209b140d16ed317f65a17dc7dc", size = 11013906 },
-    { url = "https://files.pythonhosted.org/packages/f4/e6/f414bca465b44d01cd5f4a82761e15044bedd1bf8025c5af3cc64518fac5/mypy-1.13.0-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:7f5b7deae912cf8b77e990b9280f170381fdfbddf61b4ef80927edd813163732", size = 10180657 },
-    { url = "https://files.pythonhosted.org/packages/38/e9/fc3865e417722f98d58409770be01afb961e2c1f99930659ff4ae7ca8b7e/mypy-1.13.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:7029881ec6ffb8bc233a4fa364736789582c738217b133f1b55967115288a2bc", size = 12586394 },
-    { url = "https://files.pythonhosted.org/packages/2e/35/f4d8b6d2cb0b3dad63e96caf159419dda023f45a358c6c9ac582ccaee354/mypy-1.13.0-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:3e38b980e5681f28f033f3be86b099a247b13c491f14bb8b1e1e134d23bb599d", size = 13103591 },
-    { url = "https://files.pythonhosted.org/packages/22/1d/80594aef135f921dd52e142fa0acd19df197690bd0cde42cea7b88cf5aa2/mypy-1.13.0-cp39-cp39-win_amd64.whl", hash = "sha256:a6789be98a2017c912ae6ccb77ea553bbaf13d27605d2ca20a76dfbced631b24", size = 9634690 },
-    { url = "https://files.pythonhosted.org/packages/3b/86/72ce7f57431d87a7ff17d442f521146a6585019eb8f4f31b7c02801f78ad/mypy-1.13.0-py3-none-any.whl", hash = "sha256:9c250883f9fd81d212e0952c92dbfcc96fc237f4b7c92f56ac81fd48460b3e5a", size = 2647043 },
+sdist = { url = "https://files.pythonhosted.org/packages/b9/eb/2c92d8ea1e684440f54fa49ac5d9a5f19967b7b472a281f419e69a8d228e/mypy-1.14.1.tar.gz", hash = "sha256:7ec88144fe9b510e8475ec2f5f251992690fcf89ccb4500b214b4226abcd32d6", size = 3216051 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9b/7a/87ae2adb31d68402da6da1e5f30c07ea6063e9f09b5e7cfc9dfa44075e74/mypy-1.14.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:52686e37cf13d559f668aa398dd7ddf1f92c5d613e4f8cb262be2fb4fedb0fcb", size = 11211002 },
+    { url = "https://files.pythonhosted.org/packages/e1/23/eada4c38608b444618a132be0d199b280049ded278b24cbb9d3fc59658e4/mypy-1.14.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1fb545ca340537d4b45d3eecdb3def05e913299ca72c290326be19b3804b39c0", size = 10358400 },
+    { url = "https://files.pythonhosted.org/packages/43/c9/d6785c6f66241c62fd2992b05057f404237deaad1566545e9f144ced07f5/mypy-1.14.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:90716d8b2d1f4cd503309788e51366f07c56635a3309b0f6a32547eaaa36a64d", size = 12095172 },
+    { url = "https://files.pythonhosted.org/packages/c3/62/daa7e787770c83c52ce2aaf1a111eae5893de9e004743f51bfcad9e487ec/mypy-1.14.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2ae753f5c9fef278bcf12e1a564351764f2a6da579d4a81347e1d5a15819997b", size = 12828732 },
+    { url = "https://files.pythonhosted.org/packages/1b/a2/5fb18318a3637f29f16f4e41340b795da14f4751ef4f51c99ff39ab62e52/mypy-1.14.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:e0fe0f5feaafcb04505bcf439e991c6d8f1bf8b15f12b05feeed96e9e7bf1427", size = 13012197 },
+    { url = "https://files.pythonhosted.org/packages/28/99/e153ce39105d164b5f02c06c35c7ba958aaff50a2babba7d080988b03fe7/mypy-1.14.1-cp310-cp310-win_amd64.whl", hash = "sha256:7d54bd85b925e501c555a3227f3ec0cfc54ee8b6930bd6141ec872d1c572f81f", size = 9780836 },
+    { url = "https://files.pythonhosted.org/packages/da/11/a9422850fd506edbcdc7f6090682ecceaf1f87b9dd847f9df79942da8506/mypy-1.14.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f995e511de847791c3b11ed90084a7a0aafdc074ab88c5a9711622fe4751138c", size = 11120432 },
+    { url = "https://files.pythonhosted.org/packages/b6/9e/47e450fd39078d9c02d620545b2cb37993a8a8bdf7db3652ace2f80521ca/mypy-1.14.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d64169ec3b8461311f8ce2fd2eb5d33e2d0f2c7b49116259c51d0d96edee48d1", size = 10279515 },
+    { url = "https://files.pythonhosted.org/packages/01/b5/6c8d33bd0f851a7692a8bfe4ee75eb82b6983a3cf39e5e32a5d2a723f0c1/mypy-1.14.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ba24549de7b89b6381b91fbc068d798192b1b5201987070319889e93038967a8", size = 12025791 },
+    { url = "https://files.pythonhosted.org/packages/f0/4c/e10e2c46ea37cab5c471d0ddaaa9a434dc1d28650078ac1b56c2d7b9b2e4/mypy-1.14.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:183cf0a45457d28ff9d758730cd0210419ac27d4d3f285beda038c9083363b1f", size = 12749203 },
+    { url = "https://files.pythonhosted.org/packages/88/55/beacb0c69beab2153a0f57671ec07861d27d735a0faff135a494cd4f5020/mypy-1.14.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f2a0ecc86378f45347f586e4163d1769dd81c5a223d577fe351f26b179e148b1", size = 12885900 },
+    { url = "https://files.pythonhosted.org/packages/a2/75/8c93ff7f315c4d086a2dfcde02f713004357d70a163eddb6c56a6a5eff40/mypy-1.14.1-cp311-cp311-win_amd64.whl", hash = "sha256:ad3301ebebec9e8ee7135d8e3109ca76c23752bac1e717bc84cd3836b4bf3eae", size = 9777869 },
+    { url = "https://files.pythonhosted.org/packages/43/1b/b38c079609bb4627905b74fc6a49849835acf68547ac33d8ceb707de5f52/mypy-1.14.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:30ff5ef8519bbc2e18b3b54521ec319513a26f1bba19a7582e7b1f58a6e69f14", size = 11266668 },
+    { url = "https://files.pythonhosted.org/packages/6b/75/2ed0d2964c1ffc9971c729f7a544e9cd34b2cdabbe2d11afd148d7838aa2/mypy-1.14.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:cb9f255c18052343c70234907e2e532bc7e55a62565d64536dbc7706a20b78b9", size = 10254060 },
+    { url = "https://files.pythonhosted.org/packages/a1/5f/7b8051552d4da3c51bbe8fcafffd76a6823779101a2b198d80886cd8f08e/mypy-1.14.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b4e3413e0bddea671012b063e27591b953d653209e7a4fa5e48759cda77ca11", size = 11933167 },
+    { url = "https://files.pythonhosted.org/packages/04/90/f53971d3ac39d8b68bbaab9a4c6c58c8caa4d5fd3d587d16f5927eeeabe1/mypy-1.14.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:553c293b1fbdebb6c3c4030589dab9fafb6dfa768995a453d8a5d3b23784af2e", size = 12864341 },
+    { url = "https://files.pythonhosted.org/packages/03/d2/8bc0aeaaf2e88c977db41583559319f1821c069e943ada2701e86d0430b7/mypy-1.14.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fad79bfe3b65fe6a1efaed97b445c3d37f7be9fdc348bdb2d7cac75579607c89", size = 12972991 },
+    { url = "https://files.pythonhosted.org/packages/6f/17/07815114b903b49b0f2cf7499f1c130e5aa459411596668267535fe9243c/mypy-1.14.1-cp312-cp312-win_amd64.whl", hash = "sha256:8fa2220e54d2946e94ab6dbb3ba0a992795bd68b16dc852db33028df2b00191b", size = 9879016 },
+    { url = "https://files.pythonhosted.org/packages/9e/15/bb6a686901f59222275ab228453de741185f9d54fecbaacec041679496c6/mypy-1.14.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:92c3ed5afb06c3a8e188cb5da4984cab9ec9a77ba956ee419c68a388b4595255", size = 11252097 },
+    { url = "https://files.pythonhosted.org/packages/f8/b3/8b0f74dfd072c802b7fa368829defdf3ee1566ba74c32a2cb2403f68024c/mypy-1.14.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:dbec574648b3e25f43d23577309b16534431db4ddc09fda50841f1e34e64ed34", size = 10239728 },
+    { url = "https://files.pythonhosted.org/packages/c5/9b/4fd95ab20c52bb5b8c03cc49169be5905d931de17edfe4d9d2986800b52e/mypy-1.14.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8c6d94b16d62eb3e947281aa7347d78236688e21081f11de976376cf010eb31a", size = 11924965 },
+    { url = "https://files.pythonhosted.org/packages/56/9d/4a236b9c57f5d8f08ed346914b3f091a62dd7e19336b2b2a0d85485f82ff/mypy-1.14.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d4b19b03fdf54f3c5b2fa474c56b4c13c9dbfb9a2db4370ede7ec11a2c5927d9", size = 12867660 },
+    { url = "https://files.pythonhosted.org/packages/40/88/a61a5497e2f68d9027de2bb139c7bb9abaeb1be1584649fa9d807f80a338/mypy-1.14.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0c911fde686394753fff899c409fd4e16e9b294c24bfd5e1ea4675deae1ac6fd", size = 12969198 },
+    { url = "https://files.pythonhosted.org/packages/54/da/3d6fc5d92d324701b0c23fb413c853892bfe0e1dbe06c9138037d459756b/mypy-1.14.1-cp313-cp313-win_amd64.whl", hash = "sha256:8b21525cb51671219f5307be85f7e646a153e5acc656e5cebf64bfa076c50107", size = 9885276 },
+    { url = "https://files.pythonhosted.org/packages/ca/1f/186d133ae2514633f8558e78cd658070ba686c0e9275c5a5c24a1e1f0d67/mypy-1.14.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:3888a1816d69f7ab92092f785a462944b3ca16d7c470d564165fe703b0970c35", size = 11200493 },
+    { url = "https://files.pythonhosted.org/packages/af/fc/4842485d034e38a4646cccd1369f6b1ccd7bc86989c52770d75d719a9941/mypy-1.14.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:46c756a444117c43ee984bd055db99e498bc613a70bbbc120272bd13ca579fbc", size = 10357702 },
+    { url = "https://files.pythonhosted.org/packages/b4/e6/457b83f2d701e23869cfec013a48a12638f75b9d37612a9ddf99072c1051/mypy-1.14.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:27fc248022907e72abfd8e22ab1f10e903915ff69961174784a3900a8cba9ad9", size = 12091104 },
+    { url = "https://files.pythonhosted.org/packages/f1/bf/76a569158db678fee59f4fd30b8e7a0d75bcbaeef49edd882a0d63af6d66/mypy-1.14.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:499d6a72fb7e5de92218db961f1a66d5f11783f9ae549d214617edab5d4dbdbb", size = 12830167 },
+    { url = "https://files.pythonhosted.org/packages/43/bc/0bc6b694b3103de9fed61867f1c8bd33336b913d16831431e7cb48ef1c92/mypy-1.14.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:57961db9795eb566dc1d1b4e9139ebc4c6b0cb6e7254ecde69d1552bf7613f60", size = 13013834 },
+    { url = "https://files.pythonhosted.org/packages/b0/79/5f5ec47849b6df1e6943d5fd8e6632fbfc04b4fd4acfa5a5a9535d11b4e2/mypy-1.14.1-cp39-cp39-win_amd64.whl", hash = "sha256:07ba89fdcc9451f2ebb02853deb6aaaa3d2239a236669a63ab3801bbf923ef5c", size = 9781231 },
+    { url = "https://files.pythonhosted.org/packages/a0/b5/32dd67b69a16d088e533962e5044e51004176a9952419de0370cdaead0f8/mypy-1.14.1-py3-none-any.whl", hash = "sha256:b66a60cc4073aeb8ae00057f9c1f64d49e90f918fbcef9a977eb121da8b8f1d1", size = 2752905 },
 ]
 
 [[package]]
@@ -474,47 +405,30 @@ wheels = [
 name = "numpy"
 version = "2.0.2"
 source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "python_full_version < '3.10'",
+]
 sdist = { url = "https://files.pythonhosted.org/packages/a9/75/10dd1f8116a8b796cb2c737b674e02d02e80454bda953fa7e65d8c12b016/numpy-2.0.2.tar.gz", hash = "sha256:883c987dee1880e2a864ab0dc9892292582510604156762362d9326444636e78", size = 18902015 }
 wheels = [
     { url = "https://files.pythonhosted.org/packages/21/91/3495b3237510f79f5d81f2508f9f13fea78ebfdf07538fc7444badda173d/numpy-2.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:51129a29dbe56f9ca83438b706e2e69a39892b5eda6cedcb6b0c9fdc9b0d3ece", size = 21165245 },
-    { url = "https://files.pythonhosted.org/packages/05/33/26178c7d437a87082d11019292dce6d3fe6f0e9026b7b2309cbf3e489b1d/numpy-2.0.2-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:f15975dfec0cf2239224d80e32c3170b1d168335eaedee69da84fbe9f1f9cd04", size = 13738540 },
-    { url = "https://files.pythonhosted.org/packages/ec/31/cc46e13bf07644efc7a4bf68df2df5fb2a1a88d0cd0da9ddc84dc0033e51/numpy-2.0.2-cp310-cp310-macosx_14_0_arm64.whl", hash = "sha256:8c5713284ce4e282544c68d1c3b2c7161d38c256d2eefc93c1d683cf47683e66", size = 5300623 },
     { url = "https://files.pythonhosted.org/packages/6e/16/7bfcebf27bb4f9d7ec67332ffebee4d1bf085c84246552d52dbb548600e7/numpy-2.0.2-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:becfae3ddd30736fe1889a37f1f580e245ba79a5855bff5f2a29cb3ccc22dd7b", size = 6901774 },
-    { url = "https://files.pythonhosted.org/packages/f9/a3/561c531c0e8bf082c5bef509d00d56f82e0ea7e1e3e3a7fc8fa78742a6e5/numpy-2.0.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2da5960c3cf0df7eafefd806d4e612c5e19358de82cb3c343631188991566ccd", size = 13907081 },
     { url = "https://files.pythonhosted.org/packages/fa/66/f7177ab331876200ac7563a580140643d1179c8b4b6a6b0fc9838de2a9b8/numpy-2.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:496f71341824ed9f3d2fd36cf3ac57ae2e0165c143b55c3a035ee219413f3318", size = 19523451 },
     { url = "https://files.pythonhosted.org/packages/25/7f/0b209498009ad6453e4efc2c65bcdf0ae08a182b2b7877d7ab38a92dc542/numpy-2.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:a61ec659f68ae254e4d237816e33171497e978140353c0c2038d46e63282d0c8", size = 19927572 },
-    { url = "https://files.pythonhosted.org/packages/3e/df/2619393b1e1b565cd2d4c4403bdd979621e2c4dea1f8532754b2598ed63b/numpy-2.0.2-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:d731a1c6116ba289c1e9ee714b08a8ff882944d4ad631fd411106a30f083c326", size = 14400722 },
-    { url = "https://files.pythonhosted.org/packages/22/ad/77e921b9f256d5da36424ffb711ae79ca3f451ff8489eeca544d0701d74a/numpy-2.0.2-cp310-cp310-win32.whl", hash = "sha256:984d96121c9f9616cd33fbd0618b7f08e0cfc9600a7ee1d6fd9b239186d19d97", size = 6472170 },
     { url = "https://files.pythonhosted.org/packages/10/05/3442317535028bc29cf0c0dd4c191a4481e8376e9f0db6bcf29703cadae6/numpy-2.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:c7b0be4ef08607dd04da4092faee0b86607f111d5ae68036f16cc787e250a131", size = 15905558 },
     { url = "https://files.pythonhosted.org/packages/8b/cf/034500fb83041aa0286e0fb16e7c76e5c8b67c0711bb6e9e9737a717d5fe/numpy-2.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:49ca4decb342d66018b01932139c0961a8f9ddc7589611158cb3c27cbcf76448", size = 21169137 },
-    { url = "https://files.pythonhosted.org/packages/4a/d9/32de45561811a4b87fbdee23b5797394e3d1504b4a7cf40c10199848893e/numpy-2.0.2-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:11a76c372d1d37437857280aa142086476136a8c0f373b2e648ab2c8f18fb195", size = 13703552 },
-    { url = "https://files.pythonhosted.org/packages/c1/ca/2f384720020c7b244d22508cb7ab23d95f179fcfff33c31a6eeba8d6c512/numpy-2.0.2-cp311-cp311-macosx_14_0_arm64.whl", hash = "sha256:807ec44583fd708a21d4a11d94aedf2f4f3c3719035c76a2bbe1fe8e217bdc57", size = 5298957 },
     { url = "https://files.pythonhosted.org/packages/0e/78/a3e4f9fb6aa4e6fdca0c5428e8ba039408514388cf62d89651aade838269/numpy-2.0.2-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:8cafab480740e22f8d833acefed5cc87ce276f4ece12fdaa2e8903db2f82897a", size = 6905573 },
-    { url = "https://files.pythonhosted.org/packages/a0/72/cfc3a1beb2caf4efc9d0b38a15fe34025230da27e1c08cc2eb9bfb1c7231/numpy-2.0.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a15f476a45e6e5a3a79d8a14e62161d27ad897381fecfa4a09ed5322f2085669", size = 13914330 },
     { url = "https://files.pythonhosted.org/packages/ba/a8/c17acf65a931ce551fee11b72e8de63bf7e8a6f0e21add4c937c83563538/numpy-2.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:13e689d772146140a252c3a28501da66dfecd77490b498b168b501835041f951", size = 19534895 },
     { url = "https://files.pythonhosted.org/packages/ba/86/8767f3d54f6ae0165749f84648da9dcc8cd78ab65d415494962c86fac80f/numpy-2.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:9ea91dfb7c3d1c56a0e55657c0afb38cf1eeae4544c208dc465c3c9f3a7c09f9", size = 19937253 },
-    { url = "https://files.pythonhosted.org/packages/df/87/f76450e6e1c14e5bb1eae6836478b1028e096fd02e85c1c37674606ab752/numpy-2.0.2-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:c1c9307701fec8f3f7a1e6711f9089c06e6284b3afbbcd259f7791282d660a15", size = 14414074 },
-    { url = "https://files.pythonhosted.org/packages/5c/ca/0f0f328e1e59f73754f06e1adfb909de43726d4f24c6a3f8805f34f2b0fa/numpy-2.0.2-cp311-cp311-win32.whl", hash = "sha256:a392a68bd329eafac5817e5aefeb39038c48b671afd242710b451e76090e81f4", size = 6470640 },
     { url = "https://files.pythonhosted.org/packages/eb/57/3a3f14d3a759dcf9bf6e9eda905794726b758819df4663f217d658a58695/numpy-2.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:286cd40ce2b7d652a6f22efdfc6d1edf879440e53e76a75955bc0c826c7e64dc", size = 15910230 },
     { url = "https://files.pythonhosted.org/packages/45/40/2e117be60ec50d98fa08c2f8c48e09b3edea93cfcabd5a9ff6925d54b1c2/numpy-2.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:df55d490dea7934f330006d0f81e8551ba6010a5bf035a249ef61a94f21c500b", size = 20895803 },
-    { url = "https://files.pythonhosted.org/packages/46/92/1b8b8dee833f53cef3e0a3f69b2374467789e0bb7399689582314df02651/numpy-2.0.2-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8df823f570d9adf0978347d1f926b2a867d5608f434a7cff7f7908c6570dcf5e", size = 13471835 },
-    { url = "https://files.pythonhosted.org/packages/7f/19/e2793bde475f1edaea6945be141aef6c8b4c669b90c90a300a8954d08f0a/numpy-2.0.2-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:9a92ae5c14811e390f3767053ff54eaee3bf84576d99a2456391401323f4ec2c", size = 5038499 },
     { url = "https://files.pythonhosted.org/packages/e3/ff/ddf6dac2ff0dd50a7327bcdba45cb0264d0e96bb44d33324853f781a8f3c/numpy-2.0.2-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:a842d573724391493a97a62ebbb8e731f8a5dcc5d285dfc99141ca15a3302d0c", size = 6633497 },
-    { url = "https://files.pythonhosted.org/packages/72/21/67f36eac8e2d2cd652a2e69595a54128297cdcb1ff3931cfc87838874bd4/numpy-2.0.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c05e238064fc0610c840d1cf6a13bf63d7e391717d247f1bf0318172e759e692", size = 13621158 },
     { url = "https://files.pythonhosted.org/packages/39/68/e9f1126d757653496dbc096cb429014347a36b228f5a991dae2c6b6cfd40/numpy-2.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0123ffdaa88fa4ab64835dcbde75dcdf89c453c922f18dced6e27c90d1d0ec5a", size = 19236173 },
     { url = "https://files.pythonhosted.org/packages/d1/e9/1f5333281e4ebf483ba1c888b1d61ba7e78d7e910fdd8e6499667041cc35/numpy-2.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:96a55f64139912d61de9137f11bf39a55ec8faec288c75a54f93dfd39f7eb40c", size = 19634174 },
-    { url = "https://files.pythonhosted.org/packages/71/af/a469674070c8d8408384e3012e064299f7a2de540738a8e414dcfd639996/numpy-2.0.2-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:ec9852fb39354b5a45a80bdab5ac02dd02b15f44b3804e9f00c556bf24b4bded", size = 14099701 },
-    { url = "https://files.pythonhosted.org/packages/d0/3d/08ea9f239d0e0e939b6ca52ad403c84a2bce1bde301a8eb4888c1c1543f1/numpy-2.0.2-cp312-cp312-win32.whl", hash = "sha256:671bec6496f83202ed2d3c8fdc486a8fc86942f2e69ff0e986140339a63bcbe5", size = 6174313 },
     { url = "https://files.pythonhosted.org/packages/b2/b5/4ac39baebf1fdb2e72585c8352c56d063b6126be9fc95bd2bb5ef5770c20/numpy-2.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:cfd41e13fdc257aa5778496b8caa5e856dc4896d4ccf01841daee1d96465467a", size = 15606179 },
     { url = "https://files.pythonhosted.org/packages/43/c1/41c8f6df3162b0c6ffd4437d729115704bd43363de0090c7f913cfbc2d89/numpy-2.0.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:9059e10581ce4093f735ed23f3b9d283b9d517ff46009ddd485f1747eb22653c", size = 21169942 },
-    { url = "https://files.pythonhosted.org/packages/39/bc/fd298f308dcd232b56a4031fd6ddf11c43f9917fbc937e53762f7b5a3bb1/numpy-2.0.2-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:423e89b23490805d2a5a96fe40ec507407b8ee786d66f7328be214f9679df6dd", size = 13711512 },
-    { url = "https://files.pythonhosted.org/packages/96/ff/06d1aa3eeb1c614eda245c1ba4fb88c483bee6520d361641331872ac4b82/numpy-2.0.2-cp39-cp39-macosx_14_0_arm64.whl", hash = "sha256:2b2955fa6f11907cf7a70dab0d0755159bca87755e831e47932367fc8f2f2d0b", size = 5306976 },
     { url = "https://files.pythonhosted.org/packages/2d/98/121996dcfb10a6087a05e54453e28e58694a7db62c5a5a29cee14c6e047b/numpy-2.0.2-cp39-cp39-macosx_14_0_x86_64.whl", hash = "sha256:97032a27bd9d8988b9a97a8c4d2c9f2c15a81f61e2f21404d7e8ef00cb5be729", size = 6906494 },
-    { url = "https://files.pythonhosted.org/packages/15/31/9dffc70da6b9bbf7968f6551967fc21156207366272c2a40b4ed6008dc9b/numpy-2.0.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:1e795a8be3ddbac43274f18588329c72939870a16cae810c2b73461c40718ab1", size = 13912596 },
     { url = "https://files.pythonhosted.org/packages/b9/14/78635daab4b07c0930c919d451b8bf8c164774e6a3413aed04a6d95758ce/numpy-2.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f26b258c385842546006213344c50655ff1555a9338e2e5e02a0756dc3e803dd", size = 19526099 },
     { url = "https://files.pythonhosted.org/packages/26/4c/0eeca4614003077f68bfe7aac8b7496f04221865b3a5e7cb230c9d055afd/numpy-2.0.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5fec9451a7789926bcf7c2b8d187292c9f93ea30284802a0ab3f5be8ab36865d", size = 19932823 },
-    { url = "https://files.pythonhosted.org/packages/f1/46/ea25b98b13dccaebddf1a803f8c748680d972e00507cd9bc6dcdb5aa2ac1/numpy-2.0.2-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:9189427407d88ff25ecf8f12469d4d39d35bee1db5d39fc5c168c6f088a6956d", size = 14404424 },
-    { url = "https://files.pythonhosted.org/packages/c8/a6/177dd88d95ecf07e722d21008b1b40e681a929eb9e329684d449c36586b2/numpy-2.0.2-cp39-cp39-win32.whl", hash = "sha256:905d16e0c60200656500c95b6b8dca5d109e23cb24abc701d41c02d74c6b3afa", size = 6476809 },
     { url = "https://files.pythonhosted.org/packages/ea/2b/7fc9f4e7ae5b507c1a3a21f0f15ed03e794c1242ea8a242ac158beb56034/numpy-2.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:a3f4ab0caa7f053f6797fcd4e1e25caee367db3112ef2b6ef82d749530768c73", size = 15911314 },
     { url = "https://files.pythonhosted.org/packages/8f/3b/df5a870ac6a3be3a86856ce195ef42eec7ae50d2a202be1f5a4b3b340e14/numpy-2.0.2-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:7f0a0c6f12e07fa94133c8a67404322845220c06a9e80e85999afe727f7438b8", size = 21025288 },
     { url = "https://files.pythonhosted.org/packages/2c/97/51af92f18d6f6f2d9ad8b482a99fb74e142d71372da5d834b3a2747a446e/numpy-2.0.2-pp39-pypy39_pp73-macosx_14_0_x86_64.whl", hash = "sha256:312950fdd060354350ed123c0e25a71327d3711584beaef30cdaa93320c392d4", size = 6762793 },
@@ -522,6 +436,48 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/cc/dc/d330a6faefd92b446ec0f0dfea4c3207bb1fef3c4771d19cf4543efd2c78/numpy-2.0.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:a46288ec55ebbd58947d31d72be2c63cbf839f0a63b49cb755022310792a3385", size = 15828784 },
 ]
 
+[[package]]
+name = "numpy"
+version = "2.2.2"
+source = { registry = "https://pypi.org/simple" }
+resolution-markers = [
+    "(python_full_version >= '3.12' and implementation_name != 'cpython') or (python_full_version == '3.12.*' and implementation_name == 'cpython') or (python_full_version >= '3.14' and implementation_name == 'cpython')",
+    "python_full_version == '3.11.*'",
+    "python_full_version == '3.10.*'",
+]
+sdist = { url = "https://files.pythonhosted.org/packages/ec/d0/c12ddfd3a02274be06ffc71f3efc6d0e457b0409c4481596881e748cb264/numpy-2.2.2.tar.gz", hash = "sha256:ed6906f61834d687738d25988ae117683705636936cc605be0bb208b23df4d8f", size = 20233295 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/70/2a/69033dc22d981ad21325314f8357438078f5c28310a6d89fb3833030ec8a/numpy-2.2.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:7079129b64cb78bdc8d611d1fd7e8002c0a2565da6a47c4df8062349fee90e3e", size = 21215825 },
+    { url = "https://files.pythonhosted.org/packages/7f/f4/3d8a5a0da297034106c5de92be881aca7079cde6058934215a1de91334f6/numpy-2.2.2-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:995f9e8181723852ca458e22de5d9b7d3ba4da3f11cc1cb113f093b271d7965a", size = 6928931 },
+    { url = "https://files.pythonhosted.org/packages/e3/d7/11fc594838d35c43519763310c316d4fd56f8600d3fc80a8e13e325b5c5c/numpy-2.2.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3fbe72d347fbc59f94124125e73fc4976a06927ebc503ec5afbfb35f193cd957", size = 16381794 },
+    { url = "https://files.pythonhosted.org/packages/30/97/ab96b7650f27f684a9b1e46757a7294ecc50cab27701d05f146e9f779627/numpy-2.2.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:09d6a2032faf25e8d0cadde7fd6145118ac55d2740132c1d845f98721b5ebcfd", size = 18170896 },
+    { url = "https://files.pythonhosted.org/packages/92/9b/95678092febd14070cfb7906ea7932e71e9dd5a6ab3ee948f9ed975e905d/numpy-2.2.2-cp310-cp310-win_amd64.whl", hash = "sha256:64bd6e1762cd7f0986a740fee4dff927b9ec2c5e4d9a28d056eb17d332158014", size = 12915812 },
+    { url = "https://files.pythonhosted.org/packages/21/67/32c68756eed84df181c06528ff57e09138f893c4653448c4967311e0f992/numpy-2.2.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:642199e98af1bd2b6aeb8ecf726972d238c9877b0f6e8221ee5ab945ec8a2189", size = 21220002 },
+    { url = "https://files.pythonhosted.org/packages/47/e2/fccf89d64d9b47ffb242823d4e851fc9d36fa751908c9aac2807924d9b4e/numpy-2.2.2-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:451e854cfae0febe723077bd0cf0a4302a5d84ff25f0bfece8f29206c7bed02e", size = 6933133 },
+    { url = "https://files.pythonhosted.org/packages/5b/86/caec78829311f62afa6fa334c8dfcd79cffb4d24bcf96ee02ae4840d462b/numpy-2.2.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:02935e2c3c0c6cbe9c7955a8efa8908dd4221d7755644c59d1bba28b94fd334f", size = 16393429 },
+    { url = "https://files.pythonhosted.org/packages/d4/bd/d557f10fa50dc4d5871fb9606af563249b66af2fc6f99041a10e8757c6f1/numpy-2.2.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d6d6a0910c3b4368d89dde073e630882cdb266755565155bc33520283b2d9df8", size = 18182967 },
+    { url = "https://files.pythonhosted.org/packages/66/a3/4139296b481ae7304a43581046b8f0a20da6a0dfe0ee47a044cade796603/numpy-2.2.2-cp311-cp311-win_amd64.whl", hash = "sha256:da1eeb460ecce8d5b8608826595c777728cdf28ce7b5a5a8c8ac8d949beadcf2", size = 12919805 },
+    { url = "https://files.pythonhosted.org/packages/0c/e6/847d15770ab7a01e807bdfcd4ead5bdae57c0092b7dc83878171b6af97bb/numpy-2.2.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ac9bea18d6d58a995fac1b2cb4488e17eceeac413af014b1dd26170b766d8467", size = 20912636 },
+    { url = "https://files.pythonhosted.org/packages/7a/1b/50985edb6f1ec495a1c36452e860476f5b7ecdc3fc59ea89ccad3c4926c5/numpy-2.2.2-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:8ec0636d3f7d68520afc6ac2dc4b8341ddb725039de042faf0e311599f54eb37", size = 6661937 },
+    { url = "https://files.pythonhosted.org/packages/5b/73/65d2f0b698df1731e851e3295eb29a5ab8aa06f763f7e4188647a809578d/numpy-2.2.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0349b025e15ea9d05c3d63f9657707a4e1d471128a3b1d876c095f328f8ff7f0", size = 16099146 },
+    { url = "https://files.pythonhosted.org/packages/f0/d8/d8d333ad0d8518d077a21aeea7b7c826eff766a2b1ce1194dea95ca0bacf/numpy-2.2.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:9dd47ff0cb2a656ad69c38da850df3454da88ee9a6fde0ba79acceee0e79daba", size = 17863507 },
+    { url = "https://files.pythonhosted.org/packages/fc/84/7f801a42a67b9772a883223a0a1e12069a14626c81a732bd70aac57aebc1/numpy-2.2.2-cp312-cp312-win_amd64.whl", hash = "sha256:5acea83b801e98541619af398cc0109ff48016955cc0818f478ee9ef1c5c3dcb", size = 12616372 },
+    { url = "https://files.pythonhosted.org/packages/e1/fe/df5624001f4f5c3e0b78e9017bfab7fdc18a8d3b3d3161da3d64924dd659/numpy-2.2.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b208cfd4f5fe34e1535c08983a1a6803fdbc7a1e86cf13dd0c61de0b51a0aadc", size = 20899188 },
+    { url = "https://files.pythonhosted.org/packages/8d/f3/399c15629d5a0c68ef2aa7621d430b2be22034f01dd7f3c65a9c9666c445/numpy-2.2.2-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:128c41c085cab8a85dc29e66ed88c05613dccf6bc28b3866cd16050a2f5448be", size = 6648426 },
+    { url = "https://files.pythonhosted.org/packages/83/9c/96a9ab62274ffafb023f8ee08c88d3d31ee74ca58869f859db6845494fa6/numpy-2.2.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e0c8854b09bc4de7b041148d8550d3bd712b5c21ff6a8ed308085f190235d7ff", size = 16096614 },
+    { url = "https://files.pythonhosted.org/packages/5e/6d/541717a554a8f56fa75e91886d9b79ade2e595918690eb5d0d3dbd3accb9/numpy-2.2.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:57b4012e04cc12b78590a334907e01b3a85efb2107df2b8733ff1ed05fce71de", size = 17859160 },
+    { url = "https://files.pythonhosted.org/packages/56/e5/01106b9291ef1d680f82bc47d0c5b5e26dfed15b0754928e8f856c82c881/numpy-2.2.2-cp313-cp313-win_amd64.whl", hash = "sha256:5a8c863ceacae696aff37d1fd636121f1a512117652e5dfb86031c8d84836369", size = 12609010 },
+    { url = "https://files.pythonhosted.org/packages/9f/30/f23d9876de0f08dceb707c4dcf7f8dd7588266745029debb12a3cdd40be6/numpy-2.2.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:b3482cb7b3325faa5f6bc179649406058253d91ceda359c104dac0ad320e1391", size = 20924451 },
+    { url = "https://files.pythonhosted.org/packages/f7/ec/fe2e91b2642b9d6544518388a441bcd65c904cea38d9ff998e2e8ebf808e/numpy-2.2.2-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:7dca87ca328f5ea7dafc907c5ec100d187911f94825f8700caac0b3f4c384b49", size = 6671958 },
+    { url = "https://files.pythonhosted.org/packages/e1/fb/13c58591d0b6294a08cc40fcc6b9552d239d773d520858ae27f39997f2ae/numpy-2.2.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9fad446ad0bc886855ddf5909cbf8cb5d0faa637aaa6277fb4b19ade134ab3c7", size = 16079759 },
+    { url = "https://files.pythonhosted.org/packages/aa/29/14a177f1a90b8ad8a592ca32124ac06af5eff32889874e53a308f850290f/numpy-2.2.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:106397dbbb1896f99e044efc90360d098b3335060375c26aa89c0d8a97c5f648", size = 17856316 },
+    { url = "https://files.pythonhosted.org/packages/80/94/cd9e9b04012c015cb6320ab3bf43bc615e248dddfeb163728e800a5d96f0/numpy-2.2.2-cp313-cp313t-win_amd64.whl", hash = "sha256:97b974d3ba0fb4612b77ed35d7627490e8e3dff56ab41454d9e8b23448940576", size = 12696208 },
+    { url = "https://files.pythonhosted.org/packages/96/7e/1dd770ee68916ed358991ab62c2cc353ffd98d0b75b901d52183ca28e8bb/numpy-2.2.2-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:b0531f0b0e07643eb089df4c509d30d72c9ef40defa53e41363eca8a8cc61495", size = 21047291 },
+    { url = "https://files.pythonhosted.org/packages/d1/3c/ccd08578dc532a8e6927952339d4a02682b776d5e85be49ed0760308433e/numpy-2.2.2-pp310-pypy310_pp73-macosx_14_0_x86_64.whl", hash = "sha256:e9e82dcb3f2ebbc8cb5ce1102d5f1c5ed236bf8a11730fb45ba82e2841ec21df", size = 6792494 },
+    { url = "https://files.pythonhosted.org/packages/7c/28/8754b9aee4f97199f9a047f73bb644b5a2014994a6d7b061ba67134a42de/numpy-2.2.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e0d4142eb40ca6f94539e4db929410f2a46052a0fe7a2c1c59f6179c39938d2a", size = 16197312 },
+    { url = "https://files.pythonhosted.org/packages/26/96/deb93f871f401045a684ca08a009382b247d14996d7a94fea6aa43c67b94/numpy-2.2.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:356ca982c188acbfa6af0d694284d8cf20e95b1c3d0aefa8929376fea9146f60", size = 12822674 },
+]
+
 [[package]]
 name = "packaging"
 version = "24.2"
@@ -536,52 +492,35 @@ name = "pandas"
 version = "2.2.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "numpy", marker = "python_full_version >= '3.9' and python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
-    { name = "python-dateutil", marker = "python_full_version >= '3.9' and python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
-    { name = "pytz", marker = "python_full_version >= '3.9' and python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
-    { name = "tzdata", marker = "python_full_version >= '3.9' and python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
+    { name = "numpy", version = "2.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" },
+    { name = "numpy", version = "2.2.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" },
+    { name = "python-dateutil" },
+    { name = "pytz" },
+    { name = "tzdata" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/9c/d6/9f8431bacc2e19dca897724cd097b1bb224a6ad5433784a44b587c7c13af/pandas-2.2.3.tar.gz", hash = "sha256:4f18ba62b61d7e192368b84517265a99b4d7ee8912f8708660fb4a366cc82667", size = 4399213 }
 wheels = [
     { url = "https://files.pythonhosted.org/packages/aa/70/c853aec59839bceed032d52010ff5f1b8d87dc3114b762e4ba2727661a3b/pandas-2.2.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:1948ddde24197a0f7add2bdc4ca83bf2b1ef84a1bc8ccffd95eda17fd836ecb5", size = 12580827 },
-    { url = "https://files.pythonhosted.org/packages/99/f2/c4527768739ffa4469b2b4fff05aa3768a478aed89a2f271a79a40eee984/pandas-2.2.3-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:381175499d3802cde0eabbaf6324cce0c4f5d52ca6f8c377c29ad442f50f6348", size = 11303897 },
-    { url = "https://files.pythonhosted.org/packages/ed/12/86c1747ea27989d7a4064f806ce2bae2c6d575b950be087837bdfcabacc9/pandas-2.2.3-cp310-cp310-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:d9c45366def9a3dd85a6454c0e7908f2b3b8e9c138f5dc38fed7ce720d8453ed", size = 66480908 },
     { url = "https://files.pythonhosted.org/packages/44/50/7db2cd5e6373ae796f0ddad3675268c8d59fb6076e66f0c339d61cea886b/pandas-2.2.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:86976a1c5b25ae3f8ccae3a5306e443569ee3c3faf444dfd0f41cda24667ad57", size = 13064210 },
-    { url = "https://files.pythonhosted.org/packages/61/61/a89015a6d5536cb0d6c3ba02cebed51a95538cf83472975275e28ebf7d0c/pandas-2.2.3-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:b8661b0238a69d7aafe156b7fa86c44b881387509653fdf857bebc5e4008ad42", size = 16754292 },
     { url = "https://files.pythonhosted.org/packages/ce/0d/4cc7b69ce37fac07645a94e1d4b0880b15999494372c1523508511b09e40/pandas-2.2.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:37e0aced3e8f539eccf2e099f65cdb9c8aa85109b0be6e93e2baff94264bdc6f", size = 14416379 },
     { url = "https://files.pythonhosted.org/packages/31/9e/6ebb433de864a6cd45716af52a4d7a8c3c9aaf3a98368e61db9e69e69a9c/pandas-2.2.3-cp310-cp310-win_amd64.whl", hash = "sha256:56534ce0746a58afaf7942ba4863e0ef81c9c50d3f0ae93e9497d6a41a057645", size = 11598471 },
     { url = "https://files.pythonhosted.org/packages/a8/44/d9502bf0ed197ba9bf1103c9867d5904ddcaf869e52329787fc54ed70cc8/pandas-2.2.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:66108071e1b935240e74525006034333f98bcdb87ea116de573a6a0dccb6c039", size = 12602222 },
-    { url = "https://files.pythonhosted.org/packages/52/11/9eac327a38834f162b8250aab32a6781339c69afe7574368fffe46387edf/pandas-2.2.3-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:7c2875855b0ff77b2a64a0365e24455d9990730d6431b9e0ee18ad8acee13dbd", size = 11321274 },
-    { url = "https://files.pythonhosted.org/packages/45/fb/c4beeb084718598ba19aa9f5abbc8aed8b42f90930da861fcb1acdb54c3a/pandas-2.2.3-cp311-cp311-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:cd8d0c3be0515c12fed0bdbae072551c8b54b7192c7b1fda0ba56059a0179698", size = 15579836 },
     { url = "https://files.pythonhosted.org/packages/cd/5f/4dba1d39bb9c38d574a9a22548c540177f78ea47b32f99c0ff2ec499fac5/pandas-2.2.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c124333816c3a9b03fbeef3a9f230ba9a737e9e5bb4060aa2107a86cc0a497fc", size = 13058505 },
-    { url = "https://files.pythonhosted.org/packages/b9/57/708135b90391995361636634df1f1130d03ba456e95bcf576fada459115a/pandas-2.2.3-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:63cc132e40a2e084cf01adf0775b15ac515ba905d7dcca47e9a251819c575ef3", size = 16744420 },
     { url = "https://files.pythonhosted.org/packages/86/4a/03ed6b7ee323cf30404265c284cee9c65c56a212e0a08d9ee06984ba2240/pandas-2.2.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:29401dbfa9ad77319367d36940cd8a0b3a11aba16063e39632d98b0e931ddf32", size = 14440457 },
     { url = "https://files.pythonhosted.org/packages/ed/8c/87ddf1fcb55d11f9f847e3c69bb1c6f8e46e2f40ab1a2d2abadb2401b007/pandas-2.2.3-cp311-cp311-win_amd64.whl", hash = "sha256:3fc6873a41186404dad67245896a6e440baacc92f5b716ccd1bc9ed2995ab2c5", size = 11617166 },
     { url = "https://files.pythonhosted.org/packages/17/a3/fb2734118db0af37ea7433f57f722c0a56687e14b14690edff0cdb4b7e58/pandas-2.2.3-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:b1d432e8d08679a40e2a6d8b2f9770a5c21793a6f9f47fdd52c5ce1948a5a8a9", size = 12529893 },
-    { url = "https://files.pythonhosted.org/packages/e1/0c/ad295fd74bfac85358fd579e271cded3ac969de81f62dd0142c426b9da91/pandas-2.2.3-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:a5a1595fe639f5988ba6a8e5bc9649af3baf26df3998a0abe56c02609392e0a4", size = 11363475 },
-    { url = "https://files.pythonhosted.org/packages/c6/2a/4bba3f03f7d07207481fed47f5b35f556c7441acddc368ec43d6643c5777/pandas-2.2.3-cp312-cp312-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:5de54125a92bb4d1c051c0659e6fcb75256bf799a732a87184e5ea503965bce3", size = 15188645 },
     { url = "https://files.pythonhosted.org/packages/38/f8/d8fddee9ed0d0c0f4a2132c1dfcf0e3e53265055da8df952a53e7eaf178c/pandas-2.2.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fffb8ae78d8af97f849404f21411c95062db1496aeb3e56f146f0355c9989319", size = 12739445 },
-    { url = "https://files.pythonhosted.org/packages/20/e8/45a05d9c39d2cea61ab175dbe6a2de1d05b679e8de2011da4ee190d7e748/pandas-2.2.3-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:6dfcb5ee8d4d50c06a51c2fffa6cff6272098ad6540aed1a76d15fb9318194d8", size = 16359235 },
     { url = "https://files.pythonhosted.org/packages/1d/99/617d07a6a5e429ff90c90da64d428516605a1ec7d7bea494235e1c3882de/pandas-2.2.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:062309c1b9ea12a50e8ce661145c6aab431b1e99530d3cd60640e255778bd43a", size = 14056756 },
     { url = "https://files.pythonhosted.org/packages/29/d4/1244ab8edf173a10fd601f7e13b9566c1b525c4f365d6bee918e68381889/pandas-2.2.3-cp312-cp312-win_amd64.whl", hash = "sha256:59ef3764d0fe818125a5097d2ae867ca3fa64df032331b7e0917cf5d7bf66b13", size = 11504248 },
     { url = "https://files.pythonhosted.org/packages/64/22/3b8f4e0ed70644e85cfdcd57454686b9057c6c38d2f74fe4b8bc2527214a/pandas-2.2.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f00d1345d84d8c86a63e476bb4955e46458b304b9575dcf71102b5c705320015", size = 12477643 },
-    { url = "https://files.pythonhosted.org/packages/e4/93/b3f5d1838500e22c8d793625da672f3eec046b1a99257666c94446969282/pandas-2.2.3-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:3508d914817e153ad359d7e069d752cdd736a247c322d932eb89e6bc84217f28", size = 11281573 },
-    { url = "https://files.pythonhosted.org/packages/f5/94/6c79b07f0e5aab1dcfa35a75f4817f5c4f677931d4234afcd75f0e6a66ca/pandas-2.2.3-cp313-cp313-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:22a9d949bfc9a502d320aa04e5d02feab689d61da4e7764b62c30b991c42c5f0", size = 15196085 },
     { url = "https://files.pythonhosted.org/packages/e8/31/aa8da88ca0eadbabd0a639788a6da13bb2ff6edbbb9f29aa786450a30a91/pandas-2.2.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f3a255b2c19987fbbe62a9dfd6cff7ff2aa9ccab3fc75218fd4b7530f01efa24", size = 12711809 },
-    { url = "https://files.pythonhosted.org/packages/ee/7c/c6dbdb0cb2a4344cacfb8de1c5808ca885b2e4dcfde8008266608f9372af/pandas-2.2.3-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:800250ecdadb6d9c78eae4990da62743b857b470883fa27f652db8bdde7f6659", size = 16356316 },
     { url = "https://files.pythonhosted.org/packages/57/b7/8b757e7d92023b832869fa8881a992696a0bfe2e26f72c9ae9f255988d42/pandas-2.2.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6374c452ff3ec675a8f46fd9ab25c4ad0ba590b71cf0656f8b6daa5202bca3fb", size = 14022055 },
     { url = "https://files.pythonhosted.org/packages/3b/bc/4b18e2b8c002572c5a441a64826252ce5da2aa738855747247a971988043/pandas-2.2.3-cp313-cp313-win_amd64.whl", hash = "sha256:61c5ad4043f791b61dd4752191d9f07f0ae412515d59ba8f005832a532f8736d", size = 11481175 },
     { url = "https://files.pythonhosted.org/packages/76/a3/a5d88146815e972d40d19247b2c162e88213ef51c7c25993942c39dbf41d/pandas-2.2.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:3b71f27954685ee685317063bf13c7709a7ba74fc996b84fc6821c59b0f06468", size = 12615650 },
-    { url = "https://files.pythonhosted.org/packages/9c/8c/f0fd18f6140ddafc0c24122c8a964e48294acc579d47def376fef12bcb4a/pandas-2.2.3-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:38cf8125c40dae9d5acc10fa66af8ea6fdf760b2714ee482ca691fc66e6fcb18", size = 11290177 },
-    { url = "https://files.pythonhosted.org/packages/ed/f9/e995754eab9c0f14c6777401f7eece0943840b7a9fc932221c19d1abee9f/pandas-2.2.3-cp313-cp313t-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:ba96630bc17c875161df3818780af30e43be9b166ce51c9a18c1feae342906c2", size = 14651526 },
     { url = "https://files.pythonhosted.org/packages/25/b0/98d6ae2e1abac4f35230aa756005e8654649d305df9a28b16b9ae4353bff/pandas-2.2.3-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1db71525a1538b30142094edb9adc10be3f3e176748cd7acc2240c2f2e5aa3a4", size = 11871013 },
-    { url = "https://files.pythonhosted.org/packages/cc/57/0f72a10f9db6a4628744c8e8f0df4e6e21de01212c7c981d31e50ffc8328/pandas-2.2.3-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:15c0e1e02e93116177d29ff83e8b1619c93ddc9c49083f237d4312337a61165d", size = 15711620 },
     { url = "https://files.pythonhosted.org/packages/ab/5f/b38085618b950b79d2d9164a711c52b10aefc0ae6833b96f626b7021b2ed/pandas-2.2.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:ad5b65698ab28ed8d7f18790a0dc58005c7629f227be9ecc1072aa74c0c1d43a", size = 13098436 },
     { url = "https://files.pythonhosted.org/packages/ca/8c/8848a4c9b8fdf5a534fe2077af948bf53cd713d77ffbcd7bd15710348fd7/pandas-2.2.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:bc6b93f9b966093cb0fd62ff1a7e4c09e6d546ad7c1de191767baffc57628f39", size = 12595535 },
-    { url = "https://files.pythonhosted.org/packages/9c/b9/5cead4f63b6d31bdefeb21a679bc5a7f4aaf262ca7e07e2bc1c341b68470/pandas-2.2.3-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:5dbca4c1acd72e8eeef4753eeca07de9b1db4f398669d5994086f788a5d7cc30", size = 11319822 },
-    { url = "https://files.pythonhosted.org/packages/31/af/89e35619fb573366fa68dc26dad6ad2c08c17b8004aad6d98f1a31ce4bb3/pandas-2.2.3-cp39-cp39-manylinux2014_aarch64.manylinux_2_17_aarch64.whl", hash = "sha256:8cd6d7cc958a3910f934ea8dbdf17b2364827bb4dafc38ce6eef6bb3d65ff09c", size = 15625439 },
     { url = "https://files.pythonhosted.org/packages/3d/dd/bed19c2974296661493d7acc4407b1d2db4e2a482197df100f8f965b6225/pandas-2.2.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:99df71520d25fade9db7c1076ac94eb994f4d2673ef2aa2e86ee039b6746d20c", size = 13068928 },
-    { url = "https://files.pythonhosted.org/packages/31/a3/18508e10a31ea108d746c848b5a05c0711e0278fa0d6f1c52a8ec52b80a5/pandas-2.2.3-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:31d0ced62d4ea3e231a9f228366919a5ea0b07440d9d4dac345376fd8e1477ea", size = 16783266 },
     { url = "https://files.pythonhosted.org/packages/c4/a5/3429bd13d82bebc78f4d78c3945efedef63a7cd0c15c17b2eeb838d1121f/pandas-2.2.3-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:7eee9e7cea6adf3e3d24e304ac6b8300646e2a5d1cd3a3c2abed9101b0846761", size = 14450871 },
     { url = "https://files.pythonhosted.org/packages/2f/49/5c30646e96c684570925b772eac4eb0a8cb0ca590fa978f56c5d3ae73ea1/pandas-2.2.3-cp39-cp39-win_amd64.whl", hash = "sha256:4850ba03528b6dd51d6c5d273c46f183f39a9baf3f0143e566b89450965b105e", size = 11618011 },
 ]
@@ -624,7 +563,6 @@ wheels = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.27.2"
 source = { virtual = "." }
 dependencies = [
     { name = "typing-extensions" },
@@ -632,7 +570,6 @@ dependencies = [
 
 [package.dev-dependencies]
 all = [
-    { name = "backports-zoneinfo", marker = "python_full_version < '3.9'" },
     { name = "coverage" },
     { name = "dirty-equals" },
     { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
@@ -641,8 +578,9 @@ all = [
     { name = "inline-snapshot" },
     { name = "maturin" },
     { name = "mypy" },
-    { name = "numpy", marker = "python_full_version >= '3.9' and python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
-    { name = "pandas", marker = "python_full_version >= '3.9' and python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
+    { name = "numpy", version = "2.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
+    { name = "numpy", version = "2.2.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10' and python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
+    { name = "pandas", marker = "python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
     { name = "pyright" },
     { name = "pytest" },
     { name = "pytest-examples", marker = "implementation_name == 'cpython' and platform_machine == 'x86_64'" },
@@ -651,6 +589,7 @@ all = [
     { name = "pytest-speed" },
     { name = "pytest-timeout" },
     { name = "python-dateutil" },
+    { name = "pyupgrade" },
     { name = "ruff" },
     { name = "typing-extensions" },
     { name = "tzdata" },
@@ -662,17 +601,18 @@ linting = [
     { name = "griffe" },
     { name = "mypy" },
     { name = "pyright" },
+    { name = "pyupgrade" },
     { name = "ruff" },
 ]
 testing = [
-    { name = "backports-zoneinfo", marker = "python_full_version < '3.9'" },
     { name = "coverage" },
     { name = "dirty-equals" },
     { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
     { name = "hypothesis" },
     { name = "inline-snapshot" },
-    { name = "numpy", marker = "python_full_version >= '3.9' and python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
-    { name = "pandas", marker = "python_full_version >= '3.9' and python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
+    { name = "numpy", version = "2.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
+    { name = "numpy", version = "2.2.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10' and python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
+    { name = "pandas", marker = "python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
     { name = "pytest" },
     { name = "pytest-examples", marker = "implementation_name == 'cpython' and platform_machine == 'x86_64'" },
     { name = "pytest-mock" },
@@ -713,6 +653,7 @@ all = [
     { name = "pytest-speed" },
     { name = "pytest-timeout" },
     { name = "python-dateutil" },
+    { name = "pyupgrade" },
     { name = "ruff" },
     { name = "typing-extensions" },
     { name = "tzdata" },
@@ -722,6 +663,7 @@ linting = [
     { name = "griffe" },
     { name = "mypy" },
     { name = "pyright" },
+    { name = "pyupgrade" },
     { name = "ruff" },
 ]
 testing = [
@@ -751,29 +693,29 @@ wasm = [
 
 [[package]]
 name = "pygments"
-version = "2.18.0"
+version = "2.19.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/8e/62/8336eff65bcbc8e4cb5d05b55faf041285951b6e80f33e2bff2024788f31/pygments-2.18.0.tar.gz", hash = "sha256:786ff802f32e91311bff3889f6e9a86e81505fe99f2735bb6d60ae0c5004f199", size = 4891905 }
+sdist = { url = "https://files.pythonhosted.org/packages/7c/2d/c3338d48ea6cc0feb8446d8e6937e1408088a72a39937982cc6111d17f84/pygments-2.19.1.tar.gz", hash = "sha256:61c16d2a8576dc0649d9f39e089b5f02bcd27fba10d8fb4dcc28173f7a45151f", size = 4968581 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f7/3f/01c8b82017c199075f8f788d0d906b9ffbbc5a47dc9918a945e13d5a2bda/pygments-2.18.0-py3-none-any.whl", hash = "sha256:b8e6aca0523f3ab76fee51799c488e38782ac06eafcf95e7ba832985c8e7b13a", size = 1205513 },
+    { url = "https://files.pythonhosted.org/packages/8a/0b/9fcc47d19c48b59121088dd6da2488a49d5f72dacf8262e2790a1d2c7d15/pygments-2.19.1-py3-none-any.whl", hash = "sha256:9ea1544ad55cecf4b8242fab6dd35a93bbce657034b0611ee383099054ab6d8c", size = 1225293 },
 ]
 
 [[package]]
 name = "pyright"
-version = "1.1.389"
+version = "1.1.392.post0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "nodeenv" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/72/4e/9a5ab8745e7606b88c2c7ca223449ac9d82a71fd5e31df47b453f2cb39a1/pyright-1.1.389.tar.gz", hash = "sha256:716bf8cc174ab8b4dcf6828c3298cac05c5ed775dda9910106a5dcfe4c7fe220", size = 21940 }
+sdist = { url = "https://files.pythonhosted.org/packages/66/df/3c6f6b08fba7ccf49b114dfc4bb33e25c299883fd763f93fad47ef8bc58d/pyright-1.1.392.post0.tar.gz", hash = "sha256:3b7f88de74a28dcfa90c7d90c782b6569a48c2be5f9d4add38472bdaac247ebd", size = 3789911 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/1b/26/c288cabf8cfc5a27e1aa9e5029b7682c0f920b8074f45d22bf844314d66a/pyright-1.1.389-py3-none-any.whl", hash = "sha256:41e9620bba9254406dc1f621a88ceab5a88af4c826feb4f614d95691ed243a60", size = 18581 },
+    { url = "https://files.pythonhosted.org/packages/e7/b1/a18de17f40e4f61ca58856b9ef9b0febf74ff88978c3f7776f910071f567/pyright-1.1.392.post0-py3-none-any.whl", hash = "sha256:252f84458a46fa2f0fd4e2f91fc74f50b9ca52c757062e93f6c250c0d8329eb2", size = 5595487 },
 ]
 
 [[package]]
 name = "pytest"
-version = "8.3.3"
+version = "8.3.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "colorama", marker = "sys_platform == 'win32'" },
@@ -783,39 +725,47 @@ dependencies = [
     { name = "pluggy" },
     { name = "tomli", marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/8b/6c/62bbd536103af674e227c41a8f3dcd022d591f6eed5facb5a0f31ee33bbc/pytest-8.3.3.tar.gz", hash = "sha256:70b98107bd648308a7952b06e6ca9a50bc660be218d53c257cc1fc94fda10181", size = 1442487 }
+sdist = { url = "https://files.pythonhosted.org/packages/05/35/30e0d83068951d90a01852cb1cef56e5d8a09d20c7f511634cc2f7e0372a/pytest-8.3.4.tar.gz", hash = "sha256:965370d062bce11e73868e0335abac31b4d3de0e82f4007408d242b4f8610761", size = 1445919 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/6b/77/7440a06a8ead44c7757a64362dd22df5760f9b12dc5f11b6188cd2fc27a0/pytest-8.3.3-py3-none-any.whl", hash = "sha256:a6853c7375b2663155079443d2e45de913a911a11d669df02a50814944db57b2", size = 342341 },
+    { url = "https://files.pythonhosted.org/packages/11/92/76a1c94d3afee238333bc0a42b82935dd8f9cf8ce9e336ff87ee14d9e1cf/pytest-8.3.4-py3-none-any.whl", hash = "sha256:50e16d954148559c9a74109af1eaf0c945ba2d8f30f0a3d3335edde19788b6f6", size = 343083 },
 ]
 
 [[package]]
 name = "pytest-codspeed"
-version = "3.0.0"
+version = "3.1.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "cffi", marker = "python_full_version == '3.13.*' and implementation_name == 'cpython'" },
-    { name = "filelock", marker = "python_full_version == '3.13.*' and implementation_name == 'cpython'" },
     { name = "pytest", marker = "python_full_version == '3.13.*' and implementation_name == 'cpython'" },
     { name = "rich", marker = "python_full_version == '3.13.*' and implementation_name == 'cpython'" },
-    { name = "setuptools", marker = "python_full_version == '3.13.*' and implementation_name == 'cpython'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ba/78/40e613268cce75b11cd35ea9fdc280fb648e2233fc4187c76112377b1869/pytest_codspeed-3.0.0.tar.gz", hash = "sha256:c5b80100ea32dd44079bb2db298288763eb8fe859eafa1650a8711bd2c32fd06", size = 12540 }
+sdist = { url = "https://files.pythonhosted.org/packages/36/39/4a94b61e981f993d52d0fbff259c3de08a2fb884a77464f35522031125d5/pytest_codspeed-3.1.2.tar.gz", hash = "sha256:09c1733af3aab35e94a621aa510f2d2114f65591e6f644c42ca3f67547edad4b", size = 18277 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a6/79/fa067436033410ac16e5d14b61b1a5f355688930ca8c6a8c61a52b2cbe0a/pytest_codspeed-3.0.0-py3-none-any.whl", hash = "sha256:ab1b8cb9da72e0d394718333d1abc7bea38524e09fd4854bc70a91abbcdcb20e", size = 15640 },
+    { url = "https://files.pythonhosted.org/packages/a5/ca/8fbcf065e10fcde0d766fa40452e1e348ad17456b87584fb3136c8b53809/pytest_codspeed-3.1.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aed496f873670ce0ea8f980a7c1a2c6a08f415e0ebdf207bf651b2d922103374", size = 26734 },
+    { url = "https://files.pythonhosted.org/packages/f6/b9/852971f76d8e4aa73ef4dcc028c07d2d8f2ca7add8eb8bc94f9e6053c879/pytest_codspeed-3.1.2-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ee45b0b763f6b5fa5d74c7b91d694a9615561c428b320383660672f4471756e3", size = 25373 },
+    { url = "https://files.pythonhosted.org/packages/44/9f/5d2c0879256ca824c720baf5fac61d51179dd16111c609abab4f84e8ddcb/pytest_codspeed-3.1.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c84e591a7a0f67d45e2dc9fd05b276971a3aabcab7478fe43363ebefec1358f4", size = 26742 },
+    { url = "https://files.pythonhosted.org/packages/5b/ff/862657f1a5a5dc9682dc7c23849fdabb0501df8da44eb307b1a9c3017254/pytest_codspeed-3.1.2-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c6ae6d094247156407770e6b517af70b98862dd59a3c31034aede11d5f71c32c", size = 25375 },
+    { url = "https://files.pythonhosted.org/packages/1b/bb/42fa7de046ddd0cefb1987d72e7ed4ee5ae4d962c8e6c62c29a8d6334e90/pytest_codspeed-3.1.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d0f264991de5b5cdc118b96fc671386cca3f0f34e411482939bf2459dc599097", size = 27114 },
+    { url = "https://files.pythonhosted.org/packages/0a/8e/bc84e8f94637ef31323961e25ce83508edb630e05a5956ce585fa96b57f2/pytest_codspeed-3.1.2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c0695a4bcd5ff04e8379124dba5d9795ea5e0cadf38be7a0406432fc1467b555", size = 25870 },
+    { url = "https://files.pythonhosted.org/packages/d6/a1/b85a880916d8c8992a18ce2ee41b179e867af1b5d9ea1c27a68190780d3d/pytest_codspeed-3.1.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6dc356c8dcaaa883af83310f397ac06c96fac9b8a1146e303d4b374b2cb46a18", size = 27112 },
+    { url = "https://files.pythonhosted.org/packages/23/44/2ba137983072cad2c853687fa737138b790cc0f71dc1842f3672488c61fc/pytest_codspeed-3.1.2-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cc8a5d0366322a75cf562f7d8d672d28c1cf6948695c4dddca50331e08f6b3d5", size = 25859 },
+    { url = "https://files.pythonhosted.org/packages/ea/f4/8deca488c04d993eb8b9a7c30408bdffcd84b87eda8f83759718a8f82efb/pytest_codspeed-3.1.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6c5fe7a19b72f54f217480b3b527102579547b1de9fe3acd9e66cb4629ff46c8", size = 26725 },
+    { url = "https://files.pythonhosted.org/packages/c1/8f/0433514dd85f136057b31c27264bab08a3b96c91f3870912a9a1cb362572/pytest_codspeed-3.1.2-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b67205755a665593f6521a98317d02a9d07d6fdc593f6634de2c94dea47a3055", size = 25364 },
+    { url = "https://files.pythonhosted.org/packages/a0/9f/7833be9ce5ceed7284955e1c1602a19552c397861a5b3c1eab3d6b26fca7/pytest_codspeed-3.1.2-py3-none-any.whl", hash = "sha256:5e7ed0315e33496c5c07dba262b50303b8d0bc4c3d10bf1d422a41e70783f1cb", size = 14938 },
 ]
 
 [[package]]
 name = "pytest-examples"
-version = "0.0.14"
+version = "0.0.15"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "black" },
     { name = "pytest" },
     { name = "ruff" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/d2/a7/b81d5cf26e9713a2d4c8e6863ee009360c5c07a0cfb880456ec8b09adab7/pytest_examples-0.0.14.tar.gz", hash = "sha256:776d1910709c0c5ce01b29bfe3651c5312d5cfe5c063e23ca6f65aed9af23f09", size = 20767 }
+sdist = { url = "https://files.pythonhosted.org/packages/c3/82/fa4fb866d52934de97b90c84c89896faebfb984436804fc3baa55d48d511/pytest_examples-0.0.15.tar.gz", hash = "sha256:2d6ced2d1f0d59863f81a4d2f193737464b8004a7670907c3bedef6306a5d660", size = 20771 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2b/99/f418071551ff2b5e8c06bd8b82b1f4fd472b5e4162f018773ba4ef52b6e8/pytest_examples-0.0.14-py3-none-any.whl", hash = "sha256:867a7ea105635d395df712a4b8d0df3bda4c3d78ae97a57b4f115721952b5e25", size = 17919 },
+    { url = "https://files.pythonhosted.org/packages/ba/81/3f727a7d2f9c1ff36f581453949a4af314629108642d5140298476e90902/pytest_examples-0.0.15-py3-none-any.whl", hash = "sha256:6e4adc522bf2e3f93cae3b37a4add76fcc2c1ada29d8988b2ea15b236233ec0f", size = 17922 },
 ]
 
 [[package]]
@@ -890,6 +840,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/11/c3/005fcca25ce078d2cc29fd559379817424e94885510568bc1bc53d7d5846/pytz-2024.2-py2.py3-none-any.whl", hash = "sha256:31c7c1817eb7fae7ca4b8c7ee50c72f93aa2dd863de768e1ef4245d426aa0725", size = 508002 },
 ]
 
+[[package]]
+name = "pyupgrade"
+version = "3.19.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "tokenize-rt" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/35/3a/efa8e75cf84d53f1b3f0113387ab120ef460396a4068e41b6cf18a3d216d/pyupgrade-3.19.1.tar.gz", hash = "sha256:d10e8c5f54b8327211828769e98d95d95e4715de632a3414f1eef3f51357b9e2", size = 45116 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/dd/43/c6c1ff945c7900613f6e6ef2a8688639a247d62eb0ffa9935c599f69c08e/pyupgrade-3.19.1-py2.py3-none-any.whl", hash = "sha256:8c5b0bfacae5ff30fa136a53eb7f22c34ba007450d4099e9da8089dabb9e67c9", size = 62412 },
+]
+
 [[package]]
 name = "rich"
 version = "13.9.4"
@@ -906,45 +868,36 @@ wheels = [
 
 [[package]]
 name = "ruff"
-version = "0.7.4"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/0b/8b/bc4e0dfa1245b07cf14300e10319b98e958a53ff074c1dd86b35253a8c2a/ruff-0.7.4.tar.gz", hash = "sha256:cd12e35031f5af6b9b93715d8c4f40360070b2041f81273d0527683d5708fce2", size = 3275547 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/e6/4b/f5094719e254829766b807dadb766841124daba75a37da83e292ae5ad12f/ruff-0.7.4-py3-none-linux_armv6l.whl", hash = "sha256:a4919925e7684a3f18e18243cd6bea7cfb8e968a6eaa8437971f681b7ec51478", size = 10447512 },
-    { url = "https://files.pythonhosted.org/packages/9e/1d/3d2d2c9f601cf6044799c5349ff5267467224cefed9b35edf5f1f36486e9/ruff-0.7.4-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:cfb365c135b830778dda8c04fb7d4280ed0b984e1aec27f574445231e20d6c63", size = 10235436 },
-    { url = "https://files.pythonhosted.org/packages/62/83/42a6ec6216ded30b354b13e0e9327ef75a3c147751aaf10443756cb690e9/ruff-0.7.4-py3-none-macosx_11_0_arm64.whl", hash = "sha256:63a569b36bc66fbadec5beaa539dd81e0527cb258b94e29e0531ce41bacc1f20", size = 9888936 },
-    { url = "https://files.pythonhosted.org/packages/4d/26/e1e54893b13046a6ad05ee9b89ee6f71542ba250f72b4c7a7d17c3dbf73d/ruff-0.7.4-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:0d06218747d361d06fd2fdac734e7fa92df36df93035db3dc2ad7aa9852cb109", size = 10697353 },
-    { url = "https://files.pythonhosted.org/packages/21/24/98d2e109c4efc02bfef144ec6ea2c3e1217e7ce0cfddda8361d268dfd499/ruff-0.7.4-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:e0cea28d0944f74ebc33e9f934238f15c758841f9f5edd180b5315c203293452", size = 10228078 },
-    { url = "https://files.pythonhosted.org/packages/ad/b7/964c75be9bc2945fc3172241b371197bb6d948cc69e28bc4518448c368f3/ruff-0.7.4-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:80094ecd4793c68b2571b128f91754d60f692d64bc0d7272ec9197fdd09bf9ea", size = 11264823 },
-    { url = "https://files.pythonhosted.org/packages/12/8d/20abdbf705969914ce40988fe71a554a918deaab62c38ec07483e77866f6/ruff-0.7.4-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:997512325c6620d1c4c2b15db49ef59543ef9cd0f4aa8065ec2ae5103cedc7e7", size = 11951855 },
-    { url = "https://files.pythonhosted.org/packages/b8/fc/6519ce58c57b4edafcdf40920b7273dfbba64fc6ebcaae7b88e4dc1bf0a8/ruff-0.7.4-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:00b4cf3a6b5fad6d1a66e7574d78956bbd09abfd6c8a997798f01f5da3d46a05", size = 11516580 },
-    { url = "https://files.pythonhosted.org/packages/37/1a/5ec1844e993e376a86eb2456496831ed91b4398c434d8244f89094758940/ruff-0.7.4-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:7dbdc7d8274e1422722933d1edddfdc65b4336abf0b16dfcb9dedd6e6a517d06", size = 12692057 },
-    { url = "https://files.pythonhosted.org/packages/50/90/76867152b0d3c05df29a74bb028413e90f704f0f6701c4801174ba47f959/ruff-0.7.4-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0e92dfb5f00eaedb1501b2f906ccabfd67b2355bdf117fea9719fc99ac2145bc", size = 11085137 },
-    { url = "https://files.pythonhosted.org/packages/c8/eb/0a7cb6059ac3555243bd026bb21785bbc812f7bbfa95a36c101bd72b47ae/ruff-0.7.4-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:3bd726099f277d735dc38900b6a8d6cf070f80828877941983a57bca1cd92172", size = 10681243 },
-    { url = "https://files.pythonhosted.org/packages/5e/76/2270719dbee0fd35780b05c08a07b7a726c3da9f67d9ae89ef21fc18e2e5/ruff-0.7.4-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:2e32829c429dd081ee5ba39aef436603e5b22335c3d3fff013cd585806a6486a", size = 10319187 },
-    { url = "https://files.pythonhosted.org/packages/9f/e5/39100f72f8ba70bec1bd329efc880dea8b6c1765ea1cb9d0c1c5f18b8d7f/ruff-0.7.4-py3-none-musllinux_1_2_i686.whl", hash = "sha256:662a63b4971807623f6f90c1fb664613f67cc182dc4d991471c23c541fee62dd", size = 10803715 },
-    { url = "https://files.pythonhosted.org/packages/a5/89/40e904784f305fb56850063f70a998a64ebba68796d823dde67e89a24691/ruff-0.7.4-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:876f5e09eaae3eb76814c1d3b68879891d6fde4824c015d48e7a7da4cf066a3a", size = 11162912 },
-    { url = "https://files.pythonhosted.org/packages/8d/1b/dd77503b3875c51e3dbc053fd8367b845ab8b01c9ca6d0c237082732856c/ruff-0.7.4-py3-none-win32.whl", hash = "sha256:75c53f54904be42dd52a548728a5b572344b50d9b2873d13a3f8c5e3b91f5cac", size = 8702767 },
-    { url = "https://files.pythonhosted.org/packages/63/76/253ddc3e89e70165bba952ecca424b980b8d3c2598ceb4fc47904f424953/ruff-0.7.4-py3-none-win_amd64.whl", hash = "sha256:745775c7b39f914238ed1f1b0bebed0b9155a17cd8bc0b08d3c87e4703b990d6", size = 9497534 },
-    { url = "https://files.pythonhosted.org/packages/aa/70/f8724f31abc0b329ca98b33d73c14020168babcf71b0cba3cded5d9d0e66/ruff-0.7.4-py3-none-win_arm64.whl", hash = "sha256:11bff065102c3ae9d3ea4dc9ecdfe5a5171349cdd0787c1fc64761212fc9cf1f", size = 8851590 },
-]
-
-[[package]]
-name = "setuptools"
-version = "75.6.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/43/54/292f26c208734e9a7f067aea4a7e282c080750c4546559b58e2e45413ca0/setuptools-75.6.0.tar.gz", hash = "sha256:8199222558df7c86216af4f84c30e9b34a61d8ba19366cc914424cdbd28252f6", size = 1337429 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/55/21/47d163f615df1d30c094f6c8bbb353619274edccf0327b185cc2493c2c33/setuptools-75.6.0-py3-none-any.whl", hash = "sha256:ce74b49e8f7110f9bf04883b730f4765b774ef3ef28f722cce7c273d253aaf7d", size = 1224032 },
+version = "0.9.2"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/80/63/77ecca9d21177600f551d1c58ab0e5a0b260940ea7312195bd2a4798f8a8/ruff-0.9.2.tar.gz", hash = "sha256:b5eceb334d55fae5f316f783437392642ae18e16dcf4f1858d55d3c2a0f8f5d0", size = 3553799 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/af/b9/0e168e4e7fb3af851f739e8f07889b91d1a33a30fca8c29fa3149d6b03ec/ruff-0.9.2-py3-none-linux_armv6l.whl", hash = "sha256:80605a039ba1454d002b32139e4970becf84b5fee3a3c3bf1c2af6f61a784347", size = 11652408 },
+    { url = "https://files.pythonhosted.org/packages/2c/22/08ede5db17cf701372a461d1cb8fdde037da1d4fa622b69ac21960e6237e/ruff-0.9.2-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:b9aab82bb20afd5f596527045c01e6ae25a718ff1784cb92947bff1f83068b00", size = 11587553 },
+    { url = "https://files.pythonhosted.org/packages/42/05/dedfc70f0bf010230229e33dec6e7b2235b2a1b8cbb2a991c710743e343f/ruff-0.9.2-py3-none-macosx_11_0_arm64.whl", hash = "sha256:fbd337bac1cfa96be615f6efcd4bc4d077edbc127ef30e2b8ba2a27e18c054d4", size = 11020755 },
+    { url = "https://files.pythonhosted.org/packages/df/9b/65d87ad9b2e3def67342830bd1af98803af731243da1255537ddb8f22209/ruff-0.9.2-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:82b35259b0cbf8daa22a498018e300b9bb0174c2bbb7bcba593935158a78054d", size = 11826502 },
+    { url = "https://files.pythonhosted.org/packages/93/02/f2239f56786479e1a89c3da9bc9391120057fc6f4a8266a5b091314e72ce/ruff-0.9.2-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8b6a9701d1e371bf41dca22015c3f89769da7576884d2add7317ec1ec8cb9c3c", size = 11390562 },
+    { url = "https://files.pythonhosted.org/packages/c9/37/d3a854dba9931f8cb1b2a19509bfe59e00875f48ade632e95aefcb7a0aee/ruff-0.9.2-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9cc53e68b3c5ae41e8faf83a3b89f4a5d7b2cb666dff4b366bb86ed2a85b481f", size = 12548968 },
+    { url = "https://files.pythonhosted.org/packages/fa/c3/c7b812bb256c7a1d5553433e95980934ffa85396d332401f6b391d3c4569/ruff-0.9.2-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:8efd9da7a1ee314b910da155ca7e8953094a7c10d0c0a39bfde3fcfd2a015684", size = 13187155 },
+    { url = "https://files.pythonhosted.org/packages/bd/5a/3c7f9696a7875522b66aa9bba9e326e4e5894b4366bd1dc32aa6791cb1ff/ruff-0.9.2-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3292c5a22ea9a5f9a185e2d131dc7f98f8534a32fb6d2ee7b9944569239c648d", size = 12704674 },
+    { url = "https://files.pythonhosted.org/packages/be/d6/d908762257a96ce5912187ae9ae86792e677ca4f3dc973b71e7508ff6282/ruff-0.9.2-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1a605fdcf6e8b2d39f9436d343d1f0ff70c365a1e681546de0104bef81ce88df", size = 14529328 },
+    { url = "https://files.pythonhosted.org/packages/2d/c2/049f1e6755d12d9cd8823242fa105968f34ee4c669d04cac8cea51a50407/ruff-0.9.2-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c547f7f256aa366834829a08375c297fa63386cbe5f1459efaf174086b564247", size = 12385955 },
+    { url = "https://files.pythonhosted.org/packages/91/5a/a9bdb50e39810bd9627074e42743b00e6dc4009d42ae9f9351bc3dbc28e7/ruff-0.9.2-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:d18bba3d3353ed916e882521bc3e0af403949dbada344c20c16ea78f47af965e", size = 11810149 },
+    { url = "https://files.pythonhosted.org/packages/e5/fd/57df1a0543182f79a1236e82a79c68ce210efb00e97c30657d5bdb12b478/ruff-0.9.2-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:b338edc4610142355ccf6b87bd356729b62bf1bc152a2fad5b0c7dc04af77bfe", size = 11479141 },
+    { url = "https://files.pythonhosted.org/packages/dc/16/bc3fd1d38974f6775fc152a0554f8c210ff80f2764b43777163c3c45d61b/ruff-0.9.2-py3-none-musllinux_1_2_i686.whl", hash = "sha256:492a5e44ad9b22a0ea98cf72e40305cbdaf27fac0d927f8bc9e1df316dcc96eb", size = 12014073 },
+    { url = "https://files.pythonhosted.org/packages/47/6b/e4ca048a8f2047eb652e1e8c755f384d1b7944f69ed69066a37acd4118b0/ruff-0.9.2-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:af1e9e9fe7b1f767264d26b1075ac4ad831c7db976911fa362d09b2d0356426a", size = 12435758 },
+    { url = "https://files.pythonhosted.org/packages/c2/40/4d3d6c979c67ba24cf183d29f706051a53c36d78358036a9cd21421582ab/ruff-0.9.2-py3-none-win32.whl", hash = "sha256:71cbe22e178c5da20e1514e1e01029c73dc09288a8028a5d3446e6bba87a5145", size = 9796916 },
+    { url = "https://files.pythonhosted.org/packages/c3/ef/7f548752bdb6867e6939489c87fe4da489ab36191525fadc5cede2a6e8e2/ruff-0.9.2-py3-none-win_amd64.whl", hash = "sha256:c5e1d6abc798419cf46eed03f54f2e0c3adb1ad4b801119dedf23fcaf69b55b5", size = 10773080 },
+    { url = "https://files.pythonhosted.org/packages/0e/4e/33df635528292bd2d18404e4daabcd74ca8a9853b2e1df85ed3d32d24362/ruff-0.9.2-py3-none-win_arm64.whl", hash = "sha256:a1b63fa24149918f8b37cef2ee6fff81f24f0d74b6f0bdc37bc3e1f2143e41c6", size = 10001738 },
 ]
 
 [[package]]
 name = "six"
-version = "1.16.0"
+version = "1.17.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/71/39/171f1c67cd00715f190ba0b100d606d440a28c93c7714febeca8b79af85e/six-1.16.0.tar.gz", hash = "sha256:1e61c37477a1626458e36f7b1d82aa5c9b094fa4802892072e49de9c60c4c926", size = 34041 }
+sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d9/5a/e7c31adbe875f2abbb91bd84cf2dc52d792b5a01506781dbcf25c91daf11/six-1.16.0-py2.py3-none-any.whl", hash = "sha256:8abb2f1d86890a2dfb989f9a77cfcfd3e47c2a354b01111771326f8aa26e0254", size = 11053 },
+    { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050 },
 ]
 
 [[package]]
@@ -957,12 +910,51 @@ wheels = [
 ]
 
 [[package]]
-name = "tomli"
-version = "2.1.0"
+name = "tokenize-rt"
+version = "6.1.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/1e/e4/1b6cbcc82d8832dd0ce34767d5c560df8a3547ad8cbc427f34601415930a/tomli-2.1.0.tar.gz", hash = "sha256:3f646cae2aec94e17d04973e4249548320197cfabdf130015d023de4b74d8ab8", size = 16622 }
+sdist = { url = "https://files.pythonhosted.org/packages/6b/0a/5854d8ced8c1e00193d1353d13db82d7f813f99bd5dcb776ce3e2a4c0d19/tokenize_rt-6.1.0.tar.gz", hash = "sha256:e8ee836616c0877ab7c7b54776d2fefcc3bde714449a206762425ae114b53c86", size = 5506 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/de/f7/4da0ffe1892122c9ea096c57f64c2753ae5dd3ce85488802d11b0992cc6d/tomli-2.1.0-py3-none-any.whl", hash = "sha256:a5c57c3d1c56f5ccdf89f6523458f60ef716e210fc47c4cfb188c5ba473e0391", size = 13750 },
+    { url = "https://files.pythonhosted.org/packages/87/ba/576aac29b10dfa49a6ce650001d1bb31f81e734660555eaf144bfe5b8995/tokenize_rt-6.1.0-py2.py3-none-any.whl", hash = "sha256:d706141cdec4aa5f358945abe36b911b8cbdc844545da99e811250c0cee9b6fc", size = 6015 },
+]
+
+[[package]]
+name = "tomli"
+version = "2.2.1"
+source = { registry = "https://pypi.org/simple" }
+sdist = { url = "https://files.pythonhosted.org/packages/18/87/302344fed471e44a87289cf4967697d07e532f2421fdaf868a303cbae4ff/tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff", size = 17175 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/43/ca/75707e6efa2b37c77dadb324ae7d9571cb424e61ea73fad7c56c2d14527f/tomli-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678e4fa69e4575eb77d103de3df8a895e1591b48e740211bd1067378c69e8249", size = 131077 },
+    { url = "https://files.pythonhosted.org/packages/c7/16/51ae563a8615d472fdbffc43a3f3d46588c264ac4f024f63f01283becfbb/tomli-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:023aa114dd824ade0100497eb2318602af309e5a55595f76b626d6d9f3b7b0a6", size = 123429 },
+    { url = "https://files.pythonhosted.org/packages/f1/dd/4f6cd1e7b160041db83c694abc78e100473c15d54620083dbd5aae7b990e/tomli-2.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece47d672db52ac607a3d9599a9d48dcb2f2f735c6c2d1f34130085bb12b112a", size = 226067 },
+    { url = "https://files.pythonhosted.org/packages/a9/6b/c54ede5dc70d648cc6361eaf429304b02f2871a345bbdd51e993d6cdf550/tomli-2.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6972ca9c9cc9f0acaa56a8ca1ff51e7af152a9f87fb64623e31d5c83700080ee", size = 236030 },
+    { url = "https://files.pythonhosted.org/packages/1f/47/999514fa49cfaf7a92c805a86c3c43f4215621855d151b61c602abb38091/tomli-2.2.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c954d2250168d28797dd4e3ac5cf812a406cd5a92674ee4c8f123c889786aa8e", size = 240898 },
+    { url = "https://files.pythonhosted.org/packages/73/41/0a01279a7ae09ee1573b423318e7934674ce06eb33f50936655071d81a24/tomli-2.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8dd28b3e155b80f4d54beb40a441d366adcfe740969820caf156c019fb5c7ec4", size = 229894 },
+    { url = "https://files.pythonhosted.org/packages/55/18/5d8bc5b0a0362311ce4d18830a5d28943667599a60d20118074ea1b01bb7/tomli-2.2.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e59e304978767a54663af13c07b3d1af22ddee3bb2fb0618ca1593e4f593a106", size = 245319 },
+    { url = "https://files.pythonhosted.org/packages/92/a3/7ade0576d17f3cdf5ff44d61390d4b3febb8a9fc2b480c75c47ea048c646/tomli-2.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:33580bccab0338d00994d7f16f4c4ec25b776af3ffaac1ed74e0b3fc95e885a8", size = 238273 },
+    { url = "https://files.pythonhosted.org/packages/72/6f/fa64ef058ac1446a1e51110c375339b3ec6be245af9d14c87c4a6412dd32/tomli-2.2.1-cp311-cp311-win32.whl", hash = "sha256:465af0e0875402f1d226519c9904f37254b3045fc5084697cefb9bdde1ff99ff", size = 98310 },
+    { url = "https://files.pythonhosted.org/packages/6a/1c/4a2dcde4a51b81be3530565e92eda625d94dafb46dbeb15069df4caffc34/tomli-2.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2d0f2fdd22b02c6d81637a3c95f8cd77f995846af7414c5c4b8d0545afa1bc4b", size = 108309 },
+    { url = "https://files.pythonhosted.org/packages/52/e1/f8af4c2fcde17500422858155aeb0d7e93477a0d59a98e56cbfe75070fd0/tomli-2.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4a8f6e44de52d5e6c657c9fe83b562f5f4256d8ebbfe4ff922c495620a7f6cea", size = 132762 },
+    { url = "https://files.pythonhosted.org/packages/03/b8/152c68bb84fc00396b83e7bbddd5ec0bd3dd409db4195e2a9b3e398ad2e3/tomli-2.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8d57ca8095a641b8237d5b079147646153d22552f1c637fd3ba7f4b0b29167a8", size = 123453 },
+    { url = "https://files.pythonhosted.org/packages/c8/d6/fc9267af9166f79ac528ff7e8c55c8181ded34eb4b0e93daa767b8841573/tomli-2.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e340144ad7ae1533cb897d406382b4b6fede8890a03738ff1683af800d54192", size = 233486 },
+    { url = "https://files.pythonhosted.org/packages/5c/51/51c3f2884d7bab89af25f678447ea7d297b53b5a3b5730a7cb2ef6069f07/tomli-2.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db2b95f9de79181805df90bedc5a5ab4c165e6ec3fe99f970d0e302f384ad222", size = 242349 },
+    { url = "https://files.pythonhosted.org/packages/ab/df/bfa89627d13a5cc22402e441e8a931ef2108403db390ff3345c05253935e/tomli-2.2.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:40741994320b232529c802f8bc86da4e1aa9f413db394617b9a256ae0f9a7f77", size = 252159 },
+    { url = "https://files.pythonhosted.org/packages/9e/6e/fa2b916dced65763a5168c6ccb91066f7639bdc88b48adda990db10c8c0b/tomli-2.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:400e720fe168c0f8521520190686ef8ef033fb19fc493da09779e592861b78c6", size = 237243 },
+    { url = "https://files.pythonhosted.org/packages/b4/04/885d3b1f650e1153cbb93a6a9782c58a972b94ea4483ae4ac5cedd5e4a09/tomli-2.2.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:02abe224de6ae62c19f090f68da4e27b10af2b93213d36cf44e6e1c5abd19fdd", size = 259645 },
+    { url = "https://files.pythonhosted.org/packages/9c/de/6b432d66e986e501586da298e28ebeefd3edc2c780f3ad73d22566034239/tomli-2.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b82ebccc8c8a36f2094e969560a1b836758481f3dc360ce9a3277c65f374285e", size = 244584 },
+    { url = "https://files.pythonhosted.org/packages/1c/9a/47c0449b98e6e7d1be6cbac02f93dd79003234ddc4aaab6ba07a9a7482e2/tomli-2.2.1-cp312-cp312-win32.whl", hash = "sha256:889f80ef92701b9dbb224e49ec87c645ce5df3fa2cc548664eb8a25e03127a98", size = 98875 },
+    { url = "https://files.pythonhosted.org/packages/ef/60/9b9638f081c6f1261e2688bd487625cd1e660d0a85bd469e91d8db969734/tomli-2.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:7fc04e92e1d624a4a63c76474610238576942d6b8950a2d7f908a340494e67e4", size = 109418 },
+    { url = "https://files.pythonhosted.org/packages/04/90/2ee5f2e0362cb8a0b6499dc44f4d7d48f8fff06d28ba46e6f1eaa61a1388/tomli-2.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f4039b9cbc3048b2416cc57ab3bda989a6fcf9b36cf8937f01a6e731b64f80d7", size = 132708 },
+    { url = "https://files.pythonhosted.org/packages/c0/ec/46b4108816de6b385141f082ba99e315501ccd0a2ea23db4a100dd3990ea/tomli-2.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:286f0ca2ffeeb5b9bd4fcc8d6c330534323ec51b2f52da063b11c502da16f30c", size = 123582 },
+    { url = "https://files.pythonhosted.org/packages/a0/bd/b470466d0137b37b68d24556c38a0cc819e8febe392d5b199dcd7f578365/tomli-2.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a92ef1a44547e894e2a17d24e7557a5e85a9e1d0048b0b5e7541f76c5032cb13", size = 232543 },
+    { url = "https://files.pythonhosted.org/packages/d9/e5/82e80ff3b751373f7cead2815bcbe2d51c895b3c990686741a8e56ec42ab/tomli-2.2.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9316dc65bed1684c9a98ee68759ceaed29d229e985297003e494aa825ebb0281", size = 241691 },
+    { url = "https://files.pythonhosted.org/packages/05/7e/2a110bc2713557d6a1bfb06af23dd01e7dde52b6ee7dadc589868f9abfac/tomli-2.2.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e85e99945e688e32d5a35c1ff38ed0b3f41f43fad8df0bdf79f72b2ba7bc5272", size = 251170 },
+    { url = "https://files.pythonhosted.org/packages/64/7b/22d713946efe00e0adbcdfd6d1aa119ae03fd0b60ebed51ebb3fa9f5a2e5/tomli-2.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ac065718db92ca818f8d6141b5f66369833d4a80a9d74435a268c52bdfa73140", size = 236530 },
+    { url = "https://files.pythonhosted.org/packages/38/31/3a76f67da4b0cf37b742ca76beaf819dca0ebef26d78fc794a576e08accf/tomli-2.2.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:d920f33822747519673ee656a4b6ac33e382eca9d331c87770faa3eef562aeb2", size = 258666 },
+    { url = "https://files.pythonhosted.org/packages/07/10/5af1293da642aded87e8a988753945d0cf7e00a9452d3911dd3bb354c9e2/tomli-2.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a198f10c4d1b1375d7687bc25294306e551bf1abfa4eace6650070a5c1ae2744", size = 243954 },
+    { url = "https://files.pythonhosted.org/packages/5b/b9/1ed31d167be802da0fc95020d04cd27b7d7065cc6fbefdd2f9186f60d7bd/tomli-2.2.1-cp313-cp313-win32.whl", hash = "sha256:d3f5614314d758649ab2ab3a62d4f2004c825922f9e370b29416484086b264ec", size = 98724 },
+    { url = "https://files.pythonhosted.org/packages/c7/32/b0963458706accd9afcfeb867c0f9175a741bf7b19cd424230714d722198/tomli-2.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:a38aa0308e754b0e3c67e344754dff64999ff9b513e691d0e786265c93583c69", size = 109383 },
+    { url = "https://files.pythonhosted.org/packages/6e/c2/61d3e0f47e2b74ef40a68b9e6ad5984f6241a942f7cd3bbfbdbd03861ea9/tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc", size = 14257 },
 ]
 
 [[package]]
@@ -976,18 +968,9 @@ wheels = [
 
 [[package]]
 name = "tzdata"
-version = "2024.2"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e1/34/943888654477a574a86a98e9896bae89c7aa15078ec29f490fef2f1e5384/tzdata-2024.2.tar.gz", hash = "sha256:7d85cc416e9382e69095b7bdf4afd9e3880418a2413feec7069d533d6b4e31cc", size = 193282 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/a6/ab/7e5f53c3b9d14972843a647d8d7a853969a58aecc7559cb3267302c94774/tzdata-2024.2-py2.py3-none-any.whl", hash = "sha256:a48093786cdcde33cad18c2555e8532f34422074448fbc874186f0abd79565cd", size = 346586 },
-]
-
-[[package]]
-name = "wheel"
-version = "0.45.0"
+version = "2025.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e7/52/fd4516fb8f7d11a08e3f9cd69eb1558f098ab67e79f32d920c4974ee550f/wheel-0.45.0.tar.gz", hash = "sha256:a57353941a3183b3d5365346b567a260a0602a0f8a635926a7dede41b94c674a", size = 107426 }
+sdist = { url = "https://files.pythonhosted.org/packages/43/0f/fa4723f22942480be4ca9527bbde8d43f6c3f2fe8412f00e7f5f6746bc8b/tzdata-2025.1.tar.gz", hash = "sha256:24894909e88cdb28bd1636c6887801df64cb485bd593f2fd83ef29075a81d694", size = 194950 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/92/81/65ae90d584a73ca976d8f1eb83e2f58447a4055a9fb3ae69b28721070bdf/wheel-0.45.0-py3-none-any.whl", hash = "sha256:52f0baa5e6522155090a09c6bd95718cc46956d1b51d537ea5454249edb671c7", size = 72497 },
+    { url = "https://files.pythonhosted.org/packages/0f/dd/84f10e23edd882c6f968c21c2434fe67bd4a528967067515feca9e611e5e/tzdata-2025.1-py2.py3-none-any.whl", hash = "sha256:7e127113816800496f027041c570f50bcd464a020098a3b6b199517772303639", size = 346762 },
 ]

From 82b7aa77dcfa66956a7b3164eee45bf31d62a507 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Thu, 23 Jan 2025 12:43:36 -0500
Subject: [PATCH 467/550] Remove `pyupgrade` as an explicit linting dependency
 (#1606)

---
 pyproject.toml |  1 -
 uv.lock        | 33 ++++-----------------------------
 2 files changed, 4 insertions(+), 30 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index ef6e4a9ce..521c110df 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -75,7 +75,6 @@ linting = [
     'pyright',
     'ruff',
     'mypy',
-    'pyupgrade',
 ]
 wasm = [
     'typing_extensions',
diff --git a/uv.lock b/uv.lock
index ee00fd9c9..c6b53ad7c 100644
--- a/uv.lock
+++ b/uv.lock
@@ -493,10 +493,10 @@ version = "2.2.3"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "numpy", version = "2.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10'" },
-    { name = "numpy", version = "2.2.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10'" },
-    { name = "python-dateutil" },
-    { name = "pytz" },
-    { name = "tzdata" },
+    { name = "numpy", version = "2.2.2", source = { registry = "https://pypi.org/simple" }, marker = "(python_full_version >= '3.10' and python_full_version < '3.13') or (python_full_version >= '3.10' and implementation_name != 'cpython') or (python_full_version >= '3.14' and implementation_name == 'cpython')" },
+    { name = "python-dateutil", marker = "python_full_version != '3.13.*' or implementation_name != 'cpython'" },
+    { name = "pytz", marker = "python_full_version != '3.13.*' or implementation_name != 'cpython'" },
+    { name = "tzdata", marker = "python_full_version != '3.13.*' or implementation_name != 'cpython'" },
 ]
 sdist = { url = "https://files.pythonhosted.org/packages/9c/d6/9f8431bacc2e19dca897724cd097b1bb224a6ad5433784a44b587c7c13af/pandas-2.2.3.tar.gz", hash = "sha256:4f18ba62b61d7e192368b84517265a99b4d7ee8912f8708660fb4a366cc82667", size = 4399213 }
 wheels = [
@@ -589,7 +589,6 @@ all = [
     { name = "pytest-speed" },
     { name = "pytest-timeout" },
     { name = "python-dateutil" },
-    { name = "pyupgrade" },
     { name = "ruff" },
     { name = "typing-extensions" },
     { name = "tzdata" },
@@ -601,7 +600,6 @@ linting = [
     { name = "griffe" },
     { name = "mypy" },
     { name = "pyright" },
-    { name = "pyupgrade" },
     { name = "ruff" },
 ]
 testing = [
@@ -653,7 +651,6 @@ all = [
     { name = "pytest-speed" },
     { name = "pytest-timeout" },
     { name = "python-dateutil" },
-    { name = "pyupgrade" },
     { name = "ruff" },
     { name = "typing-extensions" },
     { name = "tzdata" },
@@ -663,7 +660,6 @@ linting = [
     { name = "griffe" },
     { name = "mypy" },
     { name = "pyright" },
-    { name = "pyupgrade" },
     { name = "ruff" },
 ]
 testing = [
@@ -840,18 +836,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/11/c3/005fcca25ce078d2cc29fd559379817424e94885510568bc1bc53d7d5846/pytz-2024.2-py2.py3-none-any.whl", hash = "sha256:31c7c1817eb7fae7ca4b8c7ee50c72f93aa2dd863de768e1ef4245d426aa0725", size = 508002 },
 ]
 
-[[package]]
-name = "pyupgrade"
-version = "3.19.1"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "tokenize-rt" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/35/3a/efa8e75cf84d53f1b3f0113387ab120ef460396a4068e41b6cf18a3d216d/pyupgrade-3.19.1.tar.gz", hash = "sha256:d10e8c5f54b8327211828769e98d95d95e4715de632a3414f1eef3f51357b9e2", size = 45116 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/dd/43/c6c1ff945c7900613f6e6ef2a8688639a247d62eb0ffa9935c599f69c08e/pyupgrade-3.19.1-py2.py3-none-any.whl", hash = "sha256:8c5b0bfacae5ff30fa136a53eb7f22c34ba007450d4099e9da8089dabb9e67c9", size = 62412 },
-]
-
 [[package]]
 name = "rich"
 version = "13.9.4"
@@ -909,15 +893,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/32/46/9cb0e58b2deb7f82b84065f37f3bffeb12413f947f9388e4cac22c4621ce/sortedcontainers-2.4.0-py2.py3-none-any.whl", hash = "sha256:a163dcaede0f1c021485e957a39245190e74249897e2ae4b2aa38595db237ee0", size = 29575 },
 ]
 
-[[package]]
-name = "tokenize-rt"
-version = "6.1.0"
-source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/6b/0a/5854d8ced8c1e00193d1353d13db82d7f813f99bd5dcb776ce3e2a4c0d19/tokenize_rt-6.1.0.tar.gz", hash = "sha256:e8ee836616c0877ab7c7b54776d2fefcc3bde714449a206762425ae114b53c86", size = 5506 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/87/ba/576aac29b10dfa49a6ce650001d1bb31f81e734660555eaf144bfe5b8995/tokenize_rt-6.1.0-py2.py3-none-any.whl", hash = "sha256:d706141cdec4aa5f358945abe36b911b8cbdc844545da99e811250c0cee9b6fc", size = 6015 },
-]
-
 [[package]]
 name = "tomli"
 version = "2.2.1"

From 261c7ab39e4c654b9cc979e13934964dc01252e4 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Thu, 23 Jan 2025 14:06:37 -0500
Subject: [PATCH 468/550] Fix: `dataclass` `InitVar`s shouldn't be required on
 serialization (#1602)

---
 src/serializers/type_serializers/dataclass.rs | 20 +++++----
 tests/serializers/test_dataclasses.py         | 43 +++++++++++++++++++
 2 files changed, 54 insertions(+), 9 deletions(-)

diff --git a/src/serializers/type_serializers/dataclass.rs b/src/serializers/type_serializers/dataclass.rs
index e5cf15199..5b3c425df 100644
--- a/src/serializers/type_serializers/dataclass.rs
+++ b/src/serializers/type_serializers/dataclass.rs
@@ -43,15 +43,17 @@ impl BuildSerializer for DataclassArgsBuilder {
 
             let key_py: Py<PyString> = PyString::new(py, &name).into();
 
-            if field_info.get_as(intern!(py, "serialization_exclude"))? == Some(true) {
-                fields.insert(name, SerField::new(py, key_py, None, None, true));
-            } else {
-                let schema = field_info.get_as_req(intern!(py, "schema"))?;
-                let serializer = CombinedSerializer::build(&schema, config, definitions)
-                    .map_err(|e| py_schema_error_type!("Field `{}`:\n  {}", index, e))?;
-
-                let alias = field_info.get_as(intern!(py, "serialization_alias"))?;
-                fields.insert(name, SerField::new(py, key_py, alias, Some(serializer), true));
+            if !field_info.get_as(intern!(py, "init_only"))?.unwrap_or(false) {
+                if field_info.get_as(intern!(py, "serialization_exclude"))? == Some(true) {
+                    fields.insert(name, SerField::new(py, key_py, None, None, true));
+                } else {
+                    let schema = field_info.get_as_req(intern!(py, "schema"))?;
+                    let serializer = CombinedSerializer::build(&schema, config, definitions)
+                        .map_err(|e| py_schema_error_type!("Field `{}`:\n  {}", index, e))?;
+
+                    let alias = field_info.get_as(intern!(py, "serialization_alias"))?;
+                    fields.insert(name, SerField::new(py, key_py, alias, Some(serializer), true));
+                }
             }
         }
 
diff --git a/tests/serializers/test_dataclasses.py b/tests/serializers/test_dataclasses.py
index eb4bede97..d7fbcffaf 100644
--- a/tests/serializers/test_dataclasses.py
+++ b/tests/serializers/test_dataclasses.py
@@ -192,3 +192,46 @@ class Model:
     m = v.validate_python({'extra': 'extra'})
 
     assert s.to_python(m) == {'extra': 'extra bam!'}
+
+
+def test_dataclass_initvar_not_required_on_union_ser() -> None:
+    @dataclasses.dataclass
+    class Foo:
+        x: int
+        init_var: dataclasses.InitVar[int] = 1
+
+    @dataclasses.dataclass
+    class Bar:
+        x: int
+
+    schema = core_schema.union_schema(
+        [
+            core_schema.dataclass_schema(
+                Foo,
+                core_schema.dataclass_args_schema(
+                    'Foo',
+                    [
+                        core_schema.dataclass_field(name='x', schema=core_schema.int_schema()),
+                        core_schema.dataclass_field(
+                            name='init_var',
+                            init_only=True,
+                            schema=core_schema.with_default_schema(core_schema.int_schema(), default=1),
+                        ),
+                    ],
+                ),
+                ['x'],
+                post_init=True,
+            ),
+            core_schema.dataclass_schema(
+                Bar,
+                core_schema.dataclass_args_schema(
+                    'Bar', [core_schema.dataclass_field(name='x', schema=core_schema.int_schema())]
+                ),
+                ['x'],
+            ),
+        ]
+    )
+
+    s = SchemaSerializer(schema)
+    assert s.to_python(Foo(x=1), warnings='error') == {'x': 1}
+    assert s.to_python(Foo(x=1, init_var=2), warnings='error') == {'x': 1}

From 87585285615639f6d7eaf6d941c5b42787b1d9f1 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Thu, 23 Jan 2025 19:29:52 +0000
Subject: [PATCH 469/550] resolve remaining deprecation warnings from PyO3 0.23
 (#1584)

---
 src/build_tools.rs                           |  8 +++--
 src/common/union.rs                          |  2 +-
 src/errors/line_error.rs                     |  9 ------
 src/errors/location.rs                       | 28 +++++++---------
 src/errors/types.rs                          |  9 ++----
 src/errors/validation_exception.rs           | 34 +++++++++-----------
 src/input/input_abstract.rs                  | 28 ++++++++++------
 src/input/input_json.rs                      | 18 ++++++++---
 src/input/input_python.rs                    | 13 +++++---
 src/input/input_string.rs                    | 16 ++++-----
 src/input/return_enums.rs                    | 15 ++-------
 src/lib.rs                                   |  1 -
 src/serializers/extra.rs                     | 15 ++++++---
 src/serializers/infer.rs                     |  4 +--
 src/serializers/mod.rs                       | 11 +++----
 src/serializers/ob_type.rs                   | 17 ++++------
 src/serializers/type_serializers/float.rs    |  7 ++--
 src/serializers/type_serializers/function.rs |  8 ++---
 src/serializers/type_serializers/json.rs     |  3 +-
 src/serializers/type_serializers/literal.rs  |  9 +++---
 src/serializers/type_serializers/model.rs    |  4 +--
 src/serializers/type_serializers/simple.rs   |  6 ++--
 src/url.rs                                   |  8 +----
 src/validators/any.rs                        |  2 +-
 src/validators/arguments.rs                  |  9 ++++--
 src/validators/call.rs                       |  4 +--
 src/validators/callable.rs                   | 10 +++---
 src/validators/complex.rs                    |  2 +-
 src/validators/dataclass.rs                  | 15 +++++----
 src/validators/decimal.rs                    |  4 +--
 src/validators/enum_.rs                      |  6 ++--
 src/validators/function.rs                   | 18 +++++------
 src/validators/generator.rs                  | 12 +++----
 src/validators/literal.rs                    | 26 +++++++++------
 src/validators/mod.rs                        |  9 ++----
 src/validators/model.rs                      | 25 ++++++--------
 src/validators/model_fields.rs               | 15 +++++----
 src/validators/string.rs                     |  2 +-
 src/validators/typed_dict.rs                 |  4 +--
 src/validators/union.rs                      |  4 +--
 src/validators/uuid.rs                       |  2 +-
 src/validators/with_default.rs               |  2 +-
 42 files changed, 214 insertions(+), 230 deletions(-)

diff --git a/src/build_tools.rs b/src/build_tools.rs
index 9ada03e49..6c7e63455 100644
--- a/src/build_tools.rs
+++ b/src/build_tools.rs
@@ -93,8 +93,12 @@ impl SchemaError {
                     Ok(errors) => errors,
                     Err(err) => return err,
                 };
-                let validation_error =
-                    ValidationError::new(line_errors, "Schema".to_object(py), InputType::Python, false);
+                let validation_error = ValidationError::new(
+                    line_errors,
+                    PyString::new(py, "Schema").into(),
+                    InputType::Python,
+                    false,
+                );
                 let schema_error = SchemaError(SchemaErrorEnum::ValidationError(validation_error));
                 match Py::new(py, schema_error) {
                     Ok(err) => PyErr::from_value(err.into_bound(py).into_any()),
diff --git a/src/common/union.rs b/src/common/union.rs
index 17fe9ad90..5aeb4c926 100644
--- a/src/common/union.rs
+++ b/src/common/union.rs
@@ -15,7 +15,7 @@ pub enum Discriminator {
 impl Discriminator {
     pub fn new(py: Python, raw: &Bound<'_, PyAny>) -> PyResult<Self> {
         if raw.is_callable() {
-            return Ok(Self::Function(raw.to_object(py)));
+            return Ok(Self::Function(raw.clone().unbind()));
         }
 
         let lookup_key = LookupKey::from_py(py, raw, None)?;
diff --git a/src/errors/line_error.rs b/src/errors/line_error.rs
index ec8348556..86033214a 100644
--- a/src/errors/line_error.rs
+++ b/src/errors/line_error.rs
@@ -169,12 +169,3 @@ pub enum InputValue {
     Python(PyObject),
     Json(JsonValue<'static>),
 }
-
-impl ToPyObject for InputValue {
-    fn to_object(&self, py: Python) -> PyObject {
-        match self {
-            Self::Python(input) => input.clone_ref(py),
-            Self::Json(input) => input.to_object(py),
-        }
-    }
-}
diff --git a/src/errors/location.rs b/src/errors/location.rs
index e544eeb38..636ba6f1a 100644
--- a/src/errors/location.rs
+++ b/src/errors/location.rs
@@ -85,15 +85,6 @@ impl From<PathItem> for LocItem {
     }
 }
 
-impl ToPyObject for LocItem {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        match self {
-            Self::S(val) => val.to_object(py),
-            Self::I(val) => val.to_object(py),
-        }
-    }
-}
-
 impl Serialize for LocItem {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -128,15 +119,20 @@ impl Default for Location {
     }
 }
 
-static EMPTY_TUPLE: GILOnceCell<PyObject> = GILOnceCell::new();
+static EMPTY_TUPLE: GILOnceCell<Py<PyTuple>> = GILOnceCell::new();
+
+impl<'py> IntoPyObject<'py> for &'_ Location {
+    type Target = PyTuple;
+    type Output = Bound<'py, PyTuple>;
+    type Error = PyErr;
 
-impl ToPyObject for Location {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
+    fn into_pyobject(self, py: Python<'py>) -> PyResult<Bound<'py, PyTuple>> {
         match self {
-            Self::List(loc) => PyTuple::new(py, loc.iter().rev()).unwrap().to_object(py),
-            Self::Empty => EMPTY_TUPLE
-                .get_or_init(py, || PyTuple::empty(py).to_object(py))
-                .clone_ref(py),
+            Location::List(loc) => PyTuple::new(py, loc.iter().rev()),
+            Location::Empty => Ok(EMPTY_TUPLE
+                .get_or_init(py, || PyTuple::empty(py).unbind())
+                .bind(py)
+                .clone()),
         }
     }
 }
diff --git a/src/errors/types.rs b/src/errors/types.rs
index 54d4c9c8f..359f0c3de 100644
--- a/src/errors/types.rs
+++ b/src/errors/types.rs
@@ -3,9 +3,9 @@ use std::borrow::Cow;
 use std::fmt;
 
 use pyo3::exceptions::{PyKeyError, PyTypeError};
+use pyo3::prelude::*;
 use pyo3::sync::GILOnceCell;
 use pyo3::types::{PyDict, PyList};
-use pyo3::{prelude::*, IntoPyObjectExt};
 
 use ahash::AHashMap;
 use num_bigint::BigInt;
@@ -124,7 +124,7 @@ macro_rules! error_types {
                     $(
                         Self::$item { context, $($key,)* } => {
                             $(
-                                dict.set_item::<&str, Py<PyAny>>(stringify!($key), $key.to_object(py))?;
+                                dict.set_item(stringify!($key), $key)?;
                             )*
                             if let Some(ctx) = context {
                                 dict.update(ctx.bind(py).downcast::<PyMapping>()?)?;
@@ -824,8 +824,3 @@ impl fmt::Display for Number {
         }
     }
 }
-impl ToPyObject for Number {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        self.into_py_any(py).unwrap()
-    }
-}
diff --git a/src/errors/validation_exception.rs b/src/errors/validation_exception.rs
index 89e082d02..2ce752b42 100644
--- a/src/errors/validation_exception.rs
+++ b/src/errors/validation_exception.rs
@@ -1,3 +1,4 @@
+use std::borrow::Cow;
 use std::fmt;
 use std::fmt::{Display, Write};
 use std::str::from_utf8;
@@ -72,15 +73,15 @@ impl ValidationError {
                     Err(err) => return err,
                 };
                 let validation_error = Self::new(line_errors, title, input_type, hide_input);
-                match Py::new(py, validation_error) {
+                match Bound::new(py, validation_error) {
                     Ok(err) => {
                         if validation_error_cause {
                             // Will return an import error if the backport was needed and not installed:
-                            if let Some(cause_problem) = ValidationError::maybe_add_cause(err.borrow(py), py) {
+                            if let Some(cause_problem) = ValidationError::maybe_add_cause(err.borrow(), py) {
                                 return cause_problem;
                             }
                         }
-                        PyErr::from_value(err.into_bound(py).into_any())
+                        PyErr::from_value(err.into_any())
                     }
                     Err(err) => err,
                 }
@@ -125,16 +126,13 @@ impl ValidationError {
             } = &line_error.error_type
             {
                 let note = if let Location::Empty = &line_error.location {
-                    PyString::new(py, "Pydantic: cause of loc: root")
+                    Cow::Borrowed("Pydantic: cause of loc: root")
                 } else {
-                    PyString::new(
-                        py,
-                        &format!(
-                            "Pydantic: cause of loc: {}",
-                            // Location formats with a newline at the end, hence the trim()
-                            line_error.location.to_string().trim()
-                        ),
-                    )
+                    Cow::Owned(format!(
+                        "Pydantic: cause of loc: {}",
+                        // Location formats with a newline at the end, hence the trim()
+                        line_error.location.to_string().trim()
+                    ))
                 };
 
                 // Notes only support 3.11 upwards:
@@ -153,7 +151,7 @@ impl ValidationError {
                 {
                     use pyo3::exceptions::PyUserWarning;
 
-                    let wrapped = PyUserWarning::new_err((note.unbind(),));
+                    let wrapped = PyUserWarning::new_err((note,));
                     wrapped.set_cause(py, Some(PyErr::from_value(err.clone_ref(py).into_bound(py))));
                     user_py_errs.push(wrapped);
                 }
@@ -329,7 +327,7 @@ impl ValidationError {
         if let Some(err) = iteration_error {
             Err(err)
         } else {
-            Ok(list.into())
+            Ok(list.unbind())
         }
     }
 
@@ -396,12 +394,12 @@ impl ValidationError {
         let callable = slf.getattr("from_exception_data")?;
         let borrow = slf.try_borrow()?;
         let args = (
-            borrow.title.bind(py),
+            &borrow.title,
             borrow.errors(py, include_url_env(py), true, true)?,
-            borrow.input_type.into_pyobject(py)?,
+            borrow.input_type,
             borrow.hide_input,
         )
-            .into_pyobject(slf.py())?;
+            .into_pyobject(py)?;
         Ok((callable, args))
     }
 }
@@ -501,7 +499,7 @@ impl PyLineError {
     ) -> PyResult<Bound<'py, PyDict>> {
         let dict = PyDict::new(py);
         dict.set_item("type", self.error_type.type_string())?;
-        dict.set_item("loc", self.location.to_object(py))?;
+        dict.set_item("loc", &self.location)?;
         dict.set_item("msg", self.error_type.render_message(py, input_type)?)?;
         if include_input {
             dict.set_item("input", &self.input_value)?;
diff --git a/src/input/input_abstract.rs b/src/input/input_abstract.rs
index 6f5b9279e..aa9c6eb16 100644
--- a/src/input/input_abstract.rs
+++ b/src/input/input_abstract.rs
@@ -3,7 +3,7 @@ use std::fmt;
 
 use pyo3::exceptions::PyValueError;
 use pyo3::types::{PyDict, PyList, PyString};
-use pyo3::{intern, prelude::*};
+use pyo3::{intern, prelude::*, IntoPyObjectExt};
 
 use crate::errors::{ErrorTypeDefaults, InputValue, LocItem, ValError, ValResult};
 use crate::lookup_key::{LookupKey, LookupPath};
@@ -23,15 +23,16 @@ pub enum InputType {
 
 impl<'py> IntoPyObject<'py> for InputType {
     type Target = PyString;
-    type Output = Bound<'py, PyString>;
+    type Output = Borrowed<'py, 'py, PyString>;
     type Error = Infallible;
 
-    fn into_pyobject(self, py: Python<'_>) -> Result<Bound<'_, PyString>, Infallible> {
-        Ok(match self {
-            Self::Json => intern!(py, "json").clone(),
-            Self::Python => intern!(py, "python").clone(),
-            Self::String => intern!(py, "string").clone(),
-        })
+    fn into_pyobject(self, py: Python<'py>) -> Result<Borrowed<'py, 'py, PyString>, Infallible> {
+        let text = match self {
+            Self::Json => intern!(py, "json"),
+            Self::Python => intern!(py, "python"),
+            Self::String => intern!(py, "string"),
+        };
+        Ok(text.as_borrowed())
     }
 }
 
@@ -54,7 +55,14 @@ pub type ValMatch<T> = ValResult<ValidationMatch<T>>;
 /// the convention is to either implement:
 /// * `strict_*` & `lax_*` if they have different behavior
 /// * or, `validate_*` and `strict_*` to just call `validate_*` if the behavior for strict and lax is the same
-pub trait Input<'py>: fmt::Debug + ToPyObject {
+pub trait Input<'py>: fmt::Debug {
+    fn py_converter(&self) -> impl IntoPyObject<'py> + '_;
+
+    #[inline]
+    fn to_object<'a>(&'a self, py: Python<'py>) -> PyResult<Bound<'py, PyAny>> {
+        self.py_converter().into_bound_py_any(py)
+    }
+
     fn as_error_value(&self) -> InputValue;
 
     fn is_none(&self) -> bool {
@@ -208,7 +216,7 @@ pub trait KeywordArgs<'py> {
     type Key<'a>: BorrowInput<'py> + Clone + Into<LocItem>
     where
         Self: 'a;
-    type Item<'a>: BorrowInput<'py> + ToPyObject
+    type Item<'a>: BorrowInput<'py>
     where
         Self: 'a;
     fn len(&self) -> usize;
diff --git a/src/input/input_json.rs b/src/input/input_json.rs
index 58839318e..139c71a25 100644
--- a/src/input/input_json.rs
+++ b/src/input/input_json.rs
@@ -44,6 +44,11 @@ impl From<JsonValue<'_>> for LocItem {
 }
 
 impl<'py, 'data> Input<'py> for JsonValue<'data> {
+    #[inline]
+    fn py_converter(&self) -> impl IntoPyObject<'py> + '_ {
+        self
+    }
+
     fn as_error_value(&self) -> InputValue {
         // cloning JsonValue is cheap due to use of Arc
         InputValue::Json(self.to_static())
@@ -58,7 +63,7 @@ impl<'py, 'data> Input<'py> for JsonValue<'data> {
             JsonValue::Object(object) => {
                 let dict = PyDict::new(py);
                 for (k, v) in LazyIndexMap::iter(object) {
-                    dict.set_item(k, v.to_object(py)).unwrap();
+                    dict.set_item(k, v).unwrap();
                 }
                 Some(dict)
             }
@@ -174,7 +179,7 @@ impl<'py, 'data> Input<'py> for JsonValue<'data> {
                 create_decimal(&PyString::new(py, &f.to_string()), self).map(ValidationMatch::strict)
             }
             JsonValue::Str(..) | JsonValue::Int(..) | JsonValue::BigInt(..) => {
-                create_decimal(self.to_object(py).bind(py), self).map(ValidationMatch::strict)
+                create_decimal(&self.into_pyobject(py)?, self).map(ValidationMatch::strict)
             }
             _ => Err(ValError::new(ErrorTypeDefaults::DecimalType, self)),
         }
@@ -348,6 +353,11 @@ impl<'py, 'data> Input<'py> for JsonValue<'data> {
 
 /// Required for JSON Object keys so the string can behave like an Input
 impl<'py> Input<'py> for str {
+    #[inline]
+    fn py_converter(&self) -> impl IntoPyObject<'py> + '_ {
+        self
+    }
+
     fn as_error_value(&self) -> InputValue {
         // Justification for the clone: this is on the error pathway and we are generally ok
         // with errors having a performance penalty
@@ -414,7 +424,7 @@ impl<'py> Input<'py> for str {
     }
 
     fn validate_decimal(&self, _strict: bool, py: Python<'py>) -> ValMatch<Bound<'py, PyAny>> {
-        create_decimal(self.to_object(py).bind(py), self).map(ValidationMatch::lax)
+        create_decimal(self.into_pyobject(py)?.as_any(), self).map(ValidationMatch::lax)
     }
 
     type Dict<'a> = Never;
@@ -483,7 +493,7 @@ impl<'py> Input<'py> for str {
 
     fn validate_complex(&self, _strict: bool, py: Python<'py>) -> ValResult<ValidationMatch<EitherComplex<'py>>> {
         Ok(ValidationMatch::strict(EitherComplex::Py(string_to_complex(
-            self.to_object(py).downcast_bound::<PyString>(py)?,
+            &self.into_pyobject(py)?,
             self,
         )?)))
     }
diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index fa5cc3167..ea6eab054 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -75,6 +75,11 @@ impl From<Bound<'_, PyAny>> for LocItem {
 }
 
 impl<'py> Input<'py> for Bound<'py, PyAny> {
+    #[inline]
+    fn py_converter(&self) -> impl IntoPyObject<'py> + '_ {
+        self
+    }
+
     fn as_error_value(&self) -> InputValue {
         InputValue::Python(self.clone().into())
     }
@@ -472,7 +477,7 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
     }
 
     fn validate_iter(&self) -> ValResult<GenericIterator<'static>> {
-        if self.iter().is_ok() {
+        if self.try_iter().is_ok() {
             Ok(self.into())
         } else {
             Err(ValError::new(ErrorTypeDefaults::IterableType, self))
@@ -851,7 +856,7 @@ impl<'py> ValidatedDict<'py> for GenericPyMapping<'_, 'py> {
             Self::Mapping(mapping) => mapping
                 .call_method0(intern!(mapping.py(), "keys"))
                 .ok()?
-                .iter()
+                .try_iter()
                 .ok()?
                 .last()?
                 .ok(),
@@ -891,7 +896,7 @@ fn extract_sequence_iterable<'a, 'py>(obj: &'a Bound<'py, PyAny>) -> ValResult<P
             || obj.is_instance_of::<PyDict>()
             || obj.downcast::<PyMapping>().is_ok())
         {
-            if let Ok(iter) = obj.iter() {
+            if let Ok(iter) = obj.try_iter() {
                 return Ok(PySequenceIterable::Iterator(iter));
             }
         }
@@ -920,7 +925,7 @@ impl<'py> PySequenceIterable<'_, 'py> {
             PySequenceIterable::Tuple(iter) => Ok(consumer.consume_iterator(iter.iter().map(Ok))),
             PySequenceIterable::Set(iter) => Ok(consumer.consume_iterator(iter.iter().map(Ok))),
             PySequenceIterable::FrozenSet(iter) => Ok(consumer.consume_iterator(iter.iter().map(Ok))),
-            PySequenceIterable::Iterator(iter) => Ok(consumer.consume_iterator(iter.iter()?)),
+            PySequenceIterable::Iterator(iter) => Ok(consumer.consume_iterator(iter.try_iter()?)),
         }
     }
 }
diff --git a/src/input/input_string.rs b/src/input/input_string.rs
index d2e3137e4..a50b3cff2 100644
--- a/src/input/input_string.rs
+++ b/src/input/input_string.rs
@@ -22,21 +22,12 @@ use super::{
     KeywordArgs, ValidatedDict, ValidationMatch,
 };
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, IntoPyObject, IntoPyObjectRef)]
 pub enum StringMapping<'py> {
     String(Bound<'py, PyString>),
     Mapping(Bound<'py, PyDict>),
 }
 
-impl ToPyObject for StringMapping<'_> {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        match self {
-            Self::String(s) => s.to_object(py),
-            Self::Mapping(d) => d.to_object(py),
-        }
-    }
-}
-
 impl<'py> StringMapping<'py> {
     pub fn new_key(py_key: Bound<'py, PyAny>) -> ValResult<Self> {
         match py_key.downcast_into::<PyString>() {
@@ -72,6 +63,11 @@ impl From<StringMapping<'_>> for LocItem {
 }
 
 impl<'py> Input<'py> for StringMapping<'py> {
+    #[inline]
+    fn py_converter(&self) -> impl IntoPyObject<'py> + '_ {
+        self
+    }
+
     fn as_error_value(&self) -> InputValue {
         match self {
             Self::String(s) => s.as_error_value(),
diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index 5e31242b2..64f4f7c0f 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -185,7 +185,7 @@ impl BuildSet for Bound<'_, PyFrozenSet> {
         py_error_on_minusone(self.py(), unsafe {
             // Safety: self.as_ptr() the _only_ pointer to the `frozenset`, and it's allowed
             // to mutate this via the C API when nothing else can refer to it.
-            ffi::PySet_Add(self.as_ptr(), item.to_object(self.py()).as_ptr())
+            ffi::PySet_Add(self.as_ptr(), item.as_ptr())
         })
     }
 
@@ -266,7 +266,7 @@ pub(crate) fn no_validator_iter_to_vec<'py>(
         .map(|(index, result)| {
             let v = result.map_err(|e| any_next_error!(py, e, input, index))?;
             max_length_check.incr()?;
-            Ok(v.borrow_input().to_object(py))
+            Ok(v.borrow_input().to_object(py)?.unbind())
         })
         .collect()
 }
@@ -382,7 +382,7 @@ impl From<&Bound<'_, PyAny>> for GenericIterator<'_> {
     fn from(obj: &Bound<'_, PyAny>) -> Self {
         let py_iter = GenericPyIterator {
             obj: obj.clone().into(),
-            iter: obj.iter().unwrap().into(),
+            iter: obj.try_iter().unwrap().into(),
             index: 0,
         };
         Self::PyIterator(py_iter)
@@ -706,15 +706,6 @@ impl FromPyObject<'_> for Int {
     }
 }
 
-impl ToPyObject for Int {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
-        match self {
-            Self::I64(i) => i.to_object(py),
-            Self::Big(big_i) => big_i.to_object(py),
-        }
-    }
-}
-
 #[derive(Clone)]
 pub enum EitherComplex<'py> {
     Complex([f64; 2]),
diff --git a/src/lib.rs b/src/lib.rs
index 4a9effb48..7689f3988 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -1,5 +1,4 @@
 #![cfg_attr(has_coverage_attribute, feature(coverage_attribute))]
-#![allow(deprecated)] // FIXME: just used during upgrading PyO3 to 0.23
 
 extern crate core;
 
diff --git a/src/serializers/extra.rs b/src/serializers/extra.rs
index b0e26b826..295a2de18 100644
--- a/src/serializers/extra.rs
+++ b/src/serializers/extra.rs
@@ -1,3 +1,4 @@
+use std::convert::Infallible;
 use std::ffi::CString;
 use std::fmt;
 use std::sync::Mutex;
@@ -323,12 +324,16 @@ impl From<Option<&str>> for SerMode {
     }
 }
 
-impl ToPyObject for SerMode {
-    fn to_object(&self, py: Python<'_>) -> PyObject {
+impl<'py> IntoPyObject<'py> for &'_ SerMode {
+    type Target = PyString;
+    type Output = Bound<'py, PyString>;
+    type Error = Infallible;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
         match self {
-            SerMode::Python => intern!(py, "python").to_object(py),
-            SerMode::Json => intern!(py, "json").to_object(py),
-            SerMode::Other(s) => s.to_object(py),
+            SerMode::Python => Ok(intern!(py, "python").clone()),
+            SerMode::Json => Ok(intern!(py, "json").clone()),
+            SerMode::Other(s) => Ok(PyString::new(py, s)),
         }
     }
 }
diff --git a/src/serializers/infer.rs b/src/serializers/infer.rs
index 7c14a2a03..33f53b290 100644
--- a/src/serializers/infer.rs
+++ b/src/serializers/infer.rs
@@ -213,7 +213,7 @@ pub(crate) fn infer_to_python_known(
                 let mut items = Vec::new();
                 let filter = AnyFilter::new();
 
-                for (index, r) in py_seq.iter()?.enumerate() {
+                for (index, r) in py_seq.try_iter()?.enumerate() {
                     let element = r?;
                     let op_next = filter.index_filter(index, include, exclude, None)?;
                     if let Some((next_include, next_exclude)) = op_next {
@@ -518,7 +518,7 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
             let py_seq = value.downcast::<PyIterator>().map_err(py_err_se_err)?;
             let mut seq = serializer.serialize_seq(None)?;
             let filter = AnyFilter::new();
-            for (index, r) in py_seq.iter().map_err(py_err_se_err)?.enumerate() {
+            for (index, r) in py_seq.try_iter().map_err(py_err_se_err)?.enumerate() {
                 let element = r.map_err(py_err_se_err)?;
                 let op_next = filter
                     .index_filter(index, include, exclude, None)
diff --git a/src/serializers/mod.rs b/src/serializers/mod.rs
index 5e5e7b382..8fc1a4230 100644
--- a/src/serializers/mod.rs
+++ b/src/serializers/mod.rs
@@ -2,7 +2,7 @@ use std::fmt::Debug;
 use std::sync::atomic::{AtomicUsize, Ordering};
 
 use pyo3::prelude::*;
-use pyo3::types::{PyBytes, PyDict};
+use pyo3::types::{PyBytes, PyDict, PyTuple, PyType};
 use pyo3::{PyTraverseError, PyVisit};
 
 use crate::definitions::{Definitions, DefinitionsBuilder};
@@ -213,12 +213,9 @@ impl SchemaSerializer {
         Ok(py_bytes.into())
     }
 
-    pub fn __reduce__(slf: &Bound<Self>) -> PyResult<(PyObject, (PyObject, PyObject))> {
-        // Enables support for `pickle` serialization.
-        let py = slf.py();
-        let cls = slf.get_type().into();
-        let init_args = (slf.get().py_schema.to_object(py), slf.get().py_config.to_object(py));
-        Ok((cls, init_args))
+    pub fn __reduce__<'py>(slf: &Bound<'py, Self>) -> PyResult<(Bound<'py, PyType>, Bound<'py, PyTuple>)> {
+        let init_args = (&slf.get().py_schema, &slf.get().py_config).into_pyobject(slf.py())?;
+        Ok((slf.get_type(), init_args))
     }
 
     pub fn __repr__(&self) -> String {
diff --git a/src/serializers/ob_type.rs b/src/serializers/ob_type.rs
index fc44b32a9..e7460a37b 100644
--- a/src/serializers/ob_type.rs
+++ b/src/serializers/ob_type.rs
@@ -69,7 +69,7 @@ impl ObTypeLookup {
             float: PyFloat::type_object_raw(py) as usize,
             list: PyList::type_object_raw(py) as usize,
             dict: PyDict::type_object_raw(py) as usize,
-            decimal_object: py.import("decimal").unwrap().getattr("Decimal").unwrap().to_object(py),
+            decimal_object: py.import("decimal").unwrap().getattr("Decimal").unwrap().unbind(),
             string: PyString::type_object_raw(py) as usize,
             bytes: PyBytes::type_object_raw(py) as usize,
             bytearray: PyByteArray::type_object_raw(py) as usize,
@@ -82,16 +82,11 @@ impl ObTypeLookup {
             timedelta: PyDelta::type_object_raw(py) as usize,
             url: PyUrl::type_object_raw(py) as usize,
             multi_host_url: PyMultiHostUrl::type_object_raw(py) as usize,
-            enum_object: py.import("enum").unwrap().getattr("Enum").unwrap().to_object(py),
-            generator_object: py
-                .import("types")
-                .unwrap()
-                .getattr("GeneratorType")
-                .unwrap()
-                .to_object(py),
-            path_object: py.import("pathlib").unwrap().getattr("Path").unwrap().to_object(py),
-            pattern_object: py.import("re").unwrap().getattr("Pattern").unwrap().to_object(py),
-            uuid_object: py.import("uuid").unwrap().getattr("UUID").unwrap().to_object(py),
+            enum_object: py.import("enum").unwrap().getattr("Enum").unwrap().unbind(),
+            generator_object: py.import("types").unwrap().getattr("GeneratorType").unwrap().unbind(),
+            path_object: py.import("pathlib").unwrap().getattr("Path").unwrap().unbind(),
+            pattern_object: py.import("re").unwrap().getattr("Pattern").unwrap().unbind(),
+            uuid_object: py.import("uuid").unwrap().getattr("UUID").unwrap().unbind(),
             complex: PyComplex::type_object_raw(py) as usize,
         }
     }
diff --git a/src/serializers/type_serializers/float.rs b/src/serializers/type_serializers/float.rs
index 69626e5ef..fd79a88b5 100644
--- a/src/serializers/type_serializers/float.rs
+++ b/src/serializers/type_serializers/float.rs
@@ -1,5 +1,5 @@
 use pyo3::types::PyDict;
-use pyo3::{intern, prelude::*};
+use pyo3::{intern, prelude::*, IntoPyObjectExt};
 
 use std::borrow::Cow;
 
@@ -77,10 +77,7 @@ impl TypeSerializer for FloatSerializer {
             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))
-                    }
+                    SerMode::Json => value.extract::<f64>()?.into_py_any(py),
                     _ => infer_to_python(value, include, exclude, extra),
                 },
             },
diff --git a/src/serializers/type_serializers/function.rs b/src/serializers/type_serializers/function.rs
index 5916e60d7..3aac20d7c 100644
--- a/src/serializers/type_serializers/function.rs
+++ b/src/serializers/type_serializers/function.rs
@@ -544,6 +544,7 @@ struct SerializationInfo {
     exclude: Option<PyObject>,
     #[pyo3(get)]
     context: Option<PyObject>,
+    #[pyo3(get, name = "mode")]
     _mode: SerMode,
     #[pyo3(get)]
     by_alias: bool,
@@ -625,11 +626,6 @@ impl SerializationInfo {
 
 #[pymethods]
 impl SerializationInfo {
-    #[getter]
-    fn mode(&self, py: Python) -> PyObject {
-        self._mode.to_object(py)
-    }
-
     fn mode_is_json(&self) -> bool {
         self._mode.is_json()
     }
@@ -646,7 +642,7 @@ impl SerializationInfo {
         if let Some(ref context) = self.context {
             d.set_item("context", context)?;
         }
-        d.set_item("mode", self.mode(py))?;
+        d.set_item("mode", &self._mode)?;
         d.set_item("by_alias", self.by_alias)?;
         d.set_item("exclude_unset", self.exclude_unset)?;
         d.set_item("exclude_defaults", self.exclude_defaults)?;
diff --git a/src/serializers/type_serializers/json.rs b/src/serializers/type_serializers/json.rs
index 7f9b20492..6b8b4294f 100644
--- a/src/serializers/type_serializers/json.rs
+++ b/src/serializers/type_serializers/json.rs
@@ -5,6 +5,7 @@ use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
 
+use pyo3::types::PyString;
 use serde::ser::Error;
 
 use crate::definitions::DefinitionsBuilder;
@@ -56,7 +57,7 @@ impl TypeSerializer for JsonSerializer {
             let bytes = to_json_bytes(value, &self.serializer, include, exclude, extra, None, 0)?;
             let py = value.py();
             let s = from_utf8(&bytes).map_err(|e| utf8_py_error(py, e, &bytes))?;
-            Ok(s.to_object(py))
+            Ok(PyString::new(py, s).into())
         } else {
             self.serializer.to_python(value, include, exclude, extra)
         }
diff --git a/src/serializers/type_serializers/literal.rs b/src/serializers/type_serializers/literal.rs
index c9f7d6912..d5683d4a9 100644
--- a/src/serializers/type_serializers/literal.rs
+++ b/src/serializers/type_serializers/literal.rs
@@ -5,6 +5,7 @@ use pyo3::prelude::*;
 use pyo3::types::{PyBool, PyDict, PyList, PyString};
 
 use ahash::AHashSet;
+use pyo3::IntoPyObjectExt;
 use serde::Serialize;
 
 use crate::build_tools::py_schema_err;
@@ -119,12 +120,12 @@ impl TypeSerializer for LiteralSerializer {
         let py = value.py();
         match self.check(value, extra)? {
             OutputValue::OkInt(int) => match extra.mode {
-                SerMode::Json => Ok(int.to_object(py)),
-                _ => Ok(value.to_object(py)),
+                SerMode::Json => int.into_py_any(py),
+                _ => Ok(value.clone().unbind()),
             },
             OutputValue::OkStr(s) => match extra.mode {
-                SerMode::Json => Ok(s.to_object(py)),
-                _ => Ok(value.to_object(py)),
+                SerMode::Json => Ok(s.into()),
+                _ => Ok(value.clone().unbind()),
             },
             OutputValue::Ok => infer_to_python(value, include, exclude, extra),
             OutputValue::Fallback => {
diff --git a/src/serializers/type_serializers/model.rs b/src/serializers/type_serializers/model.rs
index 36ddaf69f..198032ed4 100644
--- a/src/serializers/type_serializers/model.rs
+++ b/src/serializers/type_serializers/model.rs
@@ -5,6 +5,7 @@ use pyo3::prelude::*;
 use pyo3::types::{PyDict, PySet, PyString, PyType};
 
 use ahash::AHashMap;
+use pyo3::IntoPyObjectExt;
 
 use super::{
     infer_json_key, infer_json_key_known, infer_serialize, infer_to_python, py_err_se_err, BuildSerializer,
@@ -147,8 +148,7 @@ impl ModelSerializer {
 
         if self.has_extra {
             let model_extra = model.getattr(intern!(py, "__pydantic_extra__"))?;
-            let py_tuple = (attrs, model_extra).to_object(py).into_bound(py);
-            Ok(py_tuple)
+            (attrs, model_extra).into_bound_py_any(py)
         } else {
             Ok(attrs.into_any())
         }
diff --git a/src/serializers/type_serializers/simple.rs b/src/serializers/type_serializers/simple.rs
index fa000e21f..2cbed2a58 100644
--- a/src/serializers/type_serializers/simple.rs
+++ b/src/serializers/type_serializers/simple.rs
@@ -1,5 +1,6 @@
 use pyo3::prelude::*;
 use pyo3::types::PyDict;
+use pyo3::IntoPyObjectExt;
 
 use std::borrow::Cow;
 
@@ -124,10 +125,7 @@ macro_rules! build_simple_serializer {
                     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::<$rust_type>()?;
-                                Ok(rust_value.to_object(py))
-                            }
+                            SerMode::Json => value.extract::<$rust_type>()?.into_py_any(py),
                             _ => infer_to_python(value, include, exclude, extra),
                         },
                     },
diff --git a/src/url.rs b/src/url.rs
index 05a13d518..816227bd4 100644
--- a/src/url.rs
+++ b/src/url.rs
@@ -469,13 +469,7 @@ impl fmt::Display for UrlHostParts {
 
 fn host_to_dict<'a>(py: Python<'a>, lib_url: &Url) -> PyResult<Bound<'a, PyDict>> {
     let dict = PyDict::new(py);
-    dict.set_item(
-        "username",
-        match lib_url.username() {
-            "" => py.None(),
-            user => user.to_object(py),
-        },
-    )?;
+    dict.set_item("username", Some(lib_url.username()).filter(|s| !s.is_empty()))?;
     dict.set_item("password", lib_url.password())?;
     dict.set_item("host", lib_url.host_str())?;
     dict.set_item("port", lib_url.port_or_known_default())?;
diff --git a/src/validators/any.rs b/src/validators/any.rs
index d254cb31b..c19092942 100644
--- a/src/validators/any.rs
+++ b/src/validators/any.rs
@@ -35,7 +35,7 @@ impl Validator for AnyValidator {
     ) -> ValResult<PyObject> {
         // in a union, Any should be preferred to doing lax coercions
         state.floor_exactness(Exactness::Strict);
-        Ok(input.to_object(py))
+        Ok(input.to_object(py)?.unbind())
     }
 
     fn get_name(&self) -> &str {
diff --git a/src/validators/arguments.rs b/src/validators/arguments.rs
index b7172af90..ef129610a 100644
--- a/src/validators/arguments.rs
+++ b/src/validators/arguments.rs
@@ -5,6 +5,7 @@ use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList, PyString, PyTuple};
 
 use ahash::AHashSet;
+use pyo3::IntoPyObjectExt;
 
 use crate::build_tools::py_schema_err;
 use crate::build_tools::{schema_or_config_same, ExtraBehavior};
@@ -347,8 +348,10 @@ impl Validator for ArgumentsValidator {
                             },
                             VarKwargsMode::UnpackedTypedDict => {
                                 // Save to the remaining kwargs, we will validate as a single dict:
-                                remaining_kwargs
-                                    .set_item(either_str.as_py_string(py, state.cache_str()), value.to_object(py))?;
+                                remaining_kwargs.set_item(
+                                    either_str.as_py_string(py, state.cache_str()),
+                                    value.borrow_input().to_object(py)?,
+                                )?;
                             }
                         }
                     }
@@ -377,7 +380,7 @@ impl Validator for ArgumentsValidator {
         if !errors.is_empty() {
             Err(ValError::LineErrors(errors))
         } else {
-            Ok((PyTuple::new(py, output_args)?, output_kwargs).to_object(py))
+            Ok((PyTuple::new(py, output_args)?, output_kwargs).into_py_any(py)?)
         }
     }
 
diff --git a/src/validators/call.rs b/src/validators/call.rs
index 5eff0c6d0..50f75dd75 100644
--- a/src/validators/call.rs
+++ b/src/validators/call.rs
@@ -59,7 +59,7 @@ impl BuildValidator for CallValidator {
         let name = format!("{}[{function_name}]", Self::EXPECTED_TYPE);
 
         Ok(Self {
-            function: function.to_object(py),
+            function: function.unbind(),
             arguments_validator,
             return_validator,
             name,
@@ -97,7 +97,7 @@ impl Validator for CallValidator {
                 .validate(py, return_value.bind(py), state)
                 .map_err(|e| e.with_outer_location("return"))
         } else {
-            Ok(return_value.to_object(py))
+            Ok(return_value)
         }
     }
 
diff --git a/src/validators/callable.rs b/src/validators/callable.rs
index 1019d5c1e..8c16a3b9a 100644
--- a/src/validators/callable.rs
+++ b/src/validators/callable.rs
@@ -27,15 +27,17 @@ impl_py_gc_traverse!(CallableValidator {});
 impl Validator for CallableValidator {
     fn validate<'py>(
         &self,
-        py: Python<'py>,
+        _py: Python<'py>,
         input: &(impl Input<'py> + ?Sized),
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         state.floor_exactness(Exactness::Lax);
-        match input.as_python().is_some_and(PyAnyMethods::is_callable) {
-            true => Ok(input.to_object(py)),
-            false => Err(ValError::new(ErrorTypeDefaults::CallableType, input)),
+        if let Some(py_input) = input.as_python() {
+            if py_input.is_callable() {
+                return Ok(py_input.clone().unbind());
+            }
         }
+        Err(ValError::new(ErrorTypeDefaults::CallableType, input))
     }
 
     fn get_name(&self) -> &str {
diff --git a/src/validators/complex.rs b/src/validators/complex.rs
index 161daf1b8..98ffc7dfe 100644
--- a/src/validators/complex.rs
+++ b/src/validators/complex.rs
@@ -13,7 +13,7 @@ static COMPLEX_TYPE: GILOnceCell<Py<PyType>> = GILOnceCell::new();
 
 pub fn get_complex_type(py: Python) -> &Bound<'_, PyType> {
     COMPLEX_TYPE
-        .get_or_init(py, || py.get_type_bound::<PyComplex>().into())
+        .get_or_init(py, || py.get_type::<PyComplex>().into())
         .bind(py)
 }
 
diff --git a/src/validators/dataclass.rs b/src/validators/dataclass.rs
index 07595baab..a774c6c9a 100644
--- a/src/validators/dataclass.rs
+++ b/src/validators/dataclass.rs
@@ -4,6 +4,7 @@ use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList, PyString, PyTuple, PyType};
 
 use ahash::AHashSet;
+use pyo3::IntoPyObjectExt;
 
 use crate::build_tools::py_schema_err;
 use crate::build_tools::{is_strict, schema_or_config_same, ExtraBehavior};
@@ -328,7 +329,7 @@ impl Validator for DataclassArgsValidator {
                                         } else {
                                             output_dict.set_item(
                                                 either_str.as_py_string(py, state.cache_str()),
-                                                value.to_object(py),
+                                                value.borrow_input().to_object(py)?,
                                             )?;
                                         }
                                     }
@@ -353,9 +354,9 @@ impl Validator for DataclassArgsValidator {
 
         if errors.is_empty() {
             if let Some(init_only_args) = init_only_args {
-                Ok((output_dict, PyTuple::new(py, init_only_args)?).to_object(py))
+                Ok((output_dict, PyTuple::new(py, init_only_args)?).into_py_any(py)?)
             } else {
-                Ok((output_dict, py.None()).to_object(py))
+                Ok((output_dict, py.None()).into_py_any(py)?)
             }
         } else {
             Err(ValError::LineErrors(errors))
@@ -378,7 +379,7 @@ impl Validator for DataclassArgsValidator {
             // which doesn't make much sense in this context but we need to put something there
             // so that function validators that sit between DataclassValidator and DataclassArgsValidator
             // always get called the same shape of data.
-            Ok(PyTuple::new(py, vec![dict.to_object(py), py.None()])?.into())
+            Ok(PyTuple::new(py, [Some(dict), None])?.into())
         };
 
         if let Some(field) = self.fields.iter().find(|f| f.name == field_name) {
@@ -420,7 +421,7 @@ impl Validator for DataclassArgsValidator {
             match self.extra_behavior {
                 // For dataclasses we allow assigning unknown fields
                 // to match stdlib dataclass behavior
-                ExtraBehavior::Allow => ok(field_value.to_object(py)),
+                ExtraBehavior::Allow => ok(field_value.clone().unbind()),
                 _ => Err(ValError::new_with_loc(
                     ErrorType::NoSuchAttribute {
                         attribute: field_name.to_string(),
@@ -552,7 +553,7 @@ impl Validator for DataclassValidator {
                 self.set_dict_call(py, &dc, val_output, input)?;
                 Ok(dc.into())
             } else {
-                Ok(input.to_object(py))
+                Ok(input.to_object(py)?.unbind())
             }
         } else if state.strict_or(self.strict) && state.extra().input_type == InputType::Python {
             Err(ValError::new(
@@ -602,7 +603,7 @@ impl Validator for DataclassValidator {
             force_setattr(py, obj, intern!(py, "__dict__"), dc_dict)?;
         }
 
-        Ok(obj.to_object(py))
+        Ok(obj.clone().unbind())
     }
 
     fn get_name(&self) -> &str {
diff --git a/src/validators/decimal.rs b/src/validators/decimal.rs
index a1ec26a5b..4f56f4bfd 100644
--- a/src/validators/decimal.rs
+++ b/src/validators/decimal.rs
@@ -184,10 +184,10 @@ impl Validator for DecimalValidator {
             // fraction = (decimal / multiple_of) % 1
             let fraction = unsafe {
                 let division = decimal.div(multiple_of)?;
-                let one = 1.to_object(py);
+                let one = 1u8.into_pyobject(py)?;
                 Bound::from_owned_ptr_or_err(py, pyo3::ffi::PyNumber_Remainder(division.as_ptr(), one.as_ptr()))?
             };
-            let zero = 0.to_object(py);
+            let zero = 0u8.into_pyobject(py)?;
             if !fraction.eq(&zero)? {
                 return Err(ValError::new(
                     ErrorType::MultipleOf {
diff --git a/src/validators/enum_.rs b/src/validators/enum_.rs
index 73589d806..03393829a 100644
--- a/src/validators/enum_.rs
+++ b/src/validators/enum_.rs
@@ -103,8 +103,8 @@ impl<T: EnumValidateValue> Validator for EnumValidator<T> {
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let class = self.class.bind(py);
-        if input.as_python().is_some_and(|any| any.is_exact_instance(class)) {
-            return Ok(input.to_object(py));
+        if let Some(exact_py_input) = input.as_python().filter(|any| any.is_exact_instance(class)) {
+            return Ok(exact_py_input.clone().unbind());
         }
         let strict = state.strict_or(self.strict);
         if strict && input.as_python().is_some() {
@@ -125,7 +125,7 @@ impl<T: EnumValidateValue> Validator for EnumValidator<T> {
         } else if let Ok(res) = class.as_unbound().call1(py, (input.as_python(),)) {
             return Ok(res);
         } else if let Some(ref missing) = self.missing {
-            let enum_value = missing.bind(py).call1((input.to_object(py),)).map_err(|_| {
+            let enum_value = missing.bind(py).call1((input.to_object(py)?,)).map_err(|_| {
                 ValError::new(
                     ErrorType::Enum {
                         expected: self.expected_repr.clone(),
diff --git a/src/validators/function.rs b/src/validators/function.rs
index 512d4dcc2..6f0eea7f4 100644
--- a/src/validators/function.rs
+++ b/src/validators/function.rs
@@ -101,9 +101,9 @@ impl FunctionBeforeValidator {
     ) -> ValResult<PyObject> {
         let r = if self.info_arg {
             let info = ValidationInfo::new(py, state.extra(), &self.config, self.field_name.clone());
-            self.func.call1(py, (input.to_object(py), info))
+            self.func.call1(py, (input.to_object(py)?, info))
         } else {
-            self.func.call1(py, (input.to_object(py),))
+            self.func.call1(py, (input.to_object(py)?,))
         };
         let value = r.map_err(|e| convert_err(py, e, input))?;
         call(value.into_bound(py), state)
@@ -170,9 +170,9 @@ impl FunctionAfterValidator {
         let v = call(input, state)?;
         let r = if self.info_arg {
             let info = ValidationInfo::new(py, state.extra(), &self.config, self.field_name.clone());
-            self.func.call1(py, (v.to_object(py), info))
+            self.func.call1(py, (v, info))
         } else {
-            self.func.call1(py, (v.to_object(py),))
+            self.func.call1(py, (v,))
         };
         r.map_err(|e| convert_err(py, e, input))
     }
@@ -259,9 +259,9 @@ impl Validator for FunctionPlainValidator {
     ) -> ValResult<PyObject> {
         let r = if self.info_arg {
             let info = ValidationInfo::new(py, state.extra(), &self.config, self.field_name.clone());
-            self.func.call1(py, (input.to_object(py), info))
+            self.func.call1(py, (input.to_object(py)?, info))
         } else {
-            self.func.call1(py, (input.to_object(py),))
+            self.func.call1(py, (input.to_object(py)?,))
         };
         r.map_err(|e| convert_err(py, e, input))
     }
@@ -323,9 +323,9 @@ impl FunctionWrapValidator {
     ) -> ValResult<PyObject> {
         let r = if self.info_arg {
             let info = ValidationInfo::new(py, state.extra(), &self.config, self.field_name.clone());
-            self.func.call1(py, (input.to_object(py), handler, info))
+            self.func.call1(py, (input.to_object(py)?, handler, info))
         } else {
-            self.func.call1(py, (input.to_object(py), handler))
+            self.func.call1(py, (input.to_object(py)?, handler))
         };
         r.map_err(|e| convert_err(py, e, input))
     }
@@ -377,7 +377,7 @@ impl Validator for FunctionWrapValidator {
                 self.validation_error_cause,
             ),
             updated_field_name: field_name.to_string(),
-            updated_field_value: field_value.to_object(py),
+            updated_field_value: field_value.clone().into(),
         };
         #[allow(clippy::used_underscore_items)]
         self._validate(Bound::new(py, handler)?.as_any(), py, obj, state)
diff --git a/src/validators/generator.rs b/src/validators/generator.rs
index ba83e6d91..5e1b21c80 100644
--- a/src/validators/generator.rs
+++ b/src/validators/generator.rs
@@ -1,7 +1,7 @@
 use std::fmt;
 use std::sync::Arc;
 
-use pyo3::types::PyDict;
+use pyo3::types::{PyDict, PyString};
 use pyo3::{prelude::*, IntoPyObjectExt, PyTraverseError, PyVisit};
 
 use crate::errors::{ErrorType, LocItem, ValError, ValResult};
@@ -139,7 +139,7 @@ impl ValidatorIterator {
                                     );
                                     return Err(ValidationError::from_val_error(
                                         py,
-                                        "ValidatorIterator".to_object(py),
+                                        "ValidatorIterator".into_pyobject(py)?.into(),
                                         InputType::Python,
                                         val_error,
                                         None,
@@ -152,7 +152,7 @@ impl ValidatorIterator {
                                 .validate(py, next.borrow_input(), Some(index.into()))
                                 .map(Some)
                         }
-                        None => Ok(Some(next.to_object(py))),
+                        None => Ok(Some(next.into_pyobject(py)?.unbind())),
                     },
                     None => {
                         if let Some(min_length) = min_length {
@@ -168,7 +168,7 @@ impl ValidatorIterator {
                                 );
                                 return Err(ValidationError::from_val_error(
                                     py,
-                                    "ValidatorIterator".to_object(py),
+                                    "ValidatorIterator".into_pyobject(py)?.into(),
                                     InputType::Python,
                                     val_error,
                                     None,
@@ -288,7 +288,7 @@ impl InternalValidator {
             .map_err(|e| {
                 ValidationError::from_val_error(
                     py,
-                    self.name.to_object(py),
+                    PyString::new(py, &self.name).into(),
                     InputType::Python,
                     e,
                     outer_location,
@@ -320,7 +320,7 @@ impl InternalValidator {
         let result = self.validator.validate(py, input, &mut state).map_err(|e| {
             ValidationError::from_val_error(
                 py,
-                self.name.to_object(py),
+                PyString::new(py, &self.name).into(),
                 InputType::Python,
                 e,
                 outer_location,
diff --git a/src/validators/literal.rs b/src/validators/literal.rs
index 755e8fccb..ffe615fe3 100644
--- a/src/validators/literal.rs
+++ b/src/validators/literal.rs
@@ -1,6 +1,7 @@
 // Validator for things inside of a typing.Literal[]
 // which can be an int, a string, bytes or an Enum value (including `class Foo(str, Enum)` type enums)
 use core::fmt::Debug;
+use std::cell::OnceCell;
 
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyInt, PyList};
@@ -139,21 +140,29 @@ impl<T: Debug> LiteralLookup<T> {
             }
         }
         // cache py_input if needed, since we might need it for multiple lookups
-        let mut py_input = None;
+        let py_input = OnceCell::new();
+        let get_py_input = || match py_input.get() {
+            Some(py_input) => PyResult::<_>::Ok(py_input),
+            None => {
+                let _ = py_input.set(input.to_object(py)?);
+                Ok(py_input.get().unwrap())
+            }
+        };
+
         if let Some(expected_py_dict) = &self.expected_py_dict {
-            let py_input = py_input.get_or_insert_with(|| input.to_object(py));
+            let py_input = get_py_input()?;
             // We don't use ? to unpack the result of `get_item` in the next line because unhashable
             // inputs will produce a TypeError, which in this case we just want to treat equivalently
             // to a failed lookup
-            if let Ok(Some(v)) = expected_py_dict.bind(py).get_item(&*py_input) {
+            if let Ok(Some(v)) = expected_py_dict.bind(py).get_item(py_input) {
                 let id: usize = v.extract().unwrap();
                 return Ok(Some((input, &self.values[id])));
             }
         };
         if let Some(expected_py_values) = &self.expected_py_values {
-            let py_input = py_input.get_or_insert_with(|| input.to_object(py));
+            let py_input = get_py_input()?;
             for (k, id) in expected_py_values {
-                if k.bind(py).eq(&*py_input).unwrap_or(false) {
+                if k.bind(py).eq(py_input).unwrap_or(false) {
                     return Ok(Some((input, &self.values[*id])));
                 }
             }
@@ -162,11 +171,11 @@ impl<T: Debug> LiteralLookup<T> {
         // this one must be last to avoid conflicts with the other lookups, think of this
         // almost as a lax fallback
         if let Some(expected_py_primitives) = &self.expected_py_primitives {
-            let py_input = py_input.get_or_insert_with(|| input.to_object(py));
+            let py_input = get_py_input()?;
             // We don't use ? to unpack the result of `get_item` in the next line because unhashable
             // inputs will produce a TypeError, which in this case we just want to treat equivalently
             // to a failed lookup
-            if let Ok(Some(v)) = expected_py_primitives.bind(py).get_item(&*py_input) {
+            if let Ok(Some(v)) = expected_py_primitives.bind(py).get_item(py_input) {
                 let id: usize = v.extract().unwrap();
                 return Ok(Some((input, &self.values[id])));
             }
@@ -215,8 +224,7 @@ impl<T: Debug> LiteralLookup<T> {
         if let Some(expected_py) = &self.expected_py_dict {
             if let Ok(either_float) = input.validate_float(strict) {
                 let f = either_float.into_inner().as_f64();
-                let py_float = f.to_object(py);
-                if let Ok(Some(v)) = expected_py.bind(py).get_item(py_float.bind(py)) {
+                if let Ok(Some(v)) = expected_py.bind(py).get_item(f) {
                     let id: usize = v.extract().unwrap();
                     return Ok(Some(&self.values[id]));
                 }
diff --git a/src/validators/mod.rs b/src/validators/mod.rs
index 9bf568731..bc1851ac5 100644
--- a/src/validators/mod.rs
+++ b/src/validators/mod.rs
@@ -157,12 +157,9 @@ impl SchemaValidator {
         })
     }
 
-    pub fn __reduce__(slf: &Bound<Self>) -> PyResult<(PyObject, (PyObject, PyObject))> {
-        // Enables support for `pickle` serialization.
-        let py = slf.py();
-        let cls = slf.get_type().into();
-        let init_args = (slf.get().py_schema.to_object(py), slf.get().py_config.to_object(py));
-        Ok((cls, init_args))
+    pub fn __reduce__<'py>(slf: &Bound<'py, Self>) -> PyResult<(Bound<'py, PyType>, Bound<'py, PyTuple>)> {
+        let init_args = (&slf.get().py_schema, &slf.get().py_config).into_pyobject(slf.py())?;
+        Ok((slf.get_type(), init_args))
     }
 
     #[allow(clippy::too_many_arguments)]
diff --git a/src/validators/model.rs b/src/validators/model.rs
index 7dfb3b7cc..6c93c209c 100644
--- a/src/validators/model.rs
+++ b/src/validators/model.rs
@@ -2,7 +2,7 @@ use std::ptr::null_mut;
 
 use pyo3::exceptions::PyTypeError;
 use pyo3::types::{PyDict, PySet, PyString, PyTuple, PyType};
-use pyo3::{ffi, IntoPyObjectExt};
+use pyo3::{ffi, BoundObject, IntoPyObjectExt};
 use pyo3::{intern, prelude::*};
 
 use super::function::convert_err;
@@ -100,7 +100,7 @@ impl BuildValidator for ModelValidator {
             frozen: schema.get_as(intern!(py, "frozen"))?.unwrap_or(false),
             custom_init: schema.get_as(intern!(py, "custom_init"))?.unwrap_or(false),
             root_model: schema.get_as(intern!(py, "root_model"))?.unwrap_or(false),
-            undefined: PydanticUndefinedType::new(py).to_object(py),
+            undefined: PydanticUndefinedType::new(py).into_any(),
             // Get the class's `__name__`, not using `class.qualname()`
             name,
         }
@@ -172,7 +172,7 @@ impl Validator for ModelValidator {
                     self.validate_construct(py, &inner_input, Some(&fields_set), state)
                 }
             } else {
-                Ok(input.to_object(py))
+                Ok(input.to_object(py)?.unbind())
             }
         } else {
             // Having to construct a new model is not an exact match
@@ -233,13 +233,8 @@ impl Validator for ModelValidator {
             }
         }
 
-        force_setattr(py, model, intern!(py, DUNDER_DICT), validated_dict.to_object(py))?;
-        force_setattr(
-            py,
-            model,
-            intern!(py, DUNDER_MODEL_EXTRA_KEY),
-            validated_extra.to_object(py),
-        )?;
+        force_setattr(py, model, intern!(py, DUNDER_DICT), validated_dict)?;
+        force_setattr(py, model, intern!(py, DUNDER_MODEL_EXTRA_KEY), validated_extra)?;
         Ok(model.into_py_any(py)?)
     }
 
@@ -371,13 +366,13 @@ fn set_model_attrs(
     Ok(())
 }
 
-pub(super) fn force_setattr<N, V>(py: Python<'_>, obj: &Bound<'_, PyAny>, attr_name: N, value: V) -> PyResult<()>
+pub(super) fn force_setattr<'py, N, V>(py: Python<'py>, obj: &Bound<'py, PyAny>, attr_name: N, value: V) -> PyResult<()>
 where
-    N: ToPyObject,
-    V: ToPyObject,
+    N: IntoPyObject<'py>,
+    V: IntoPyObject<'py>,
 {
-    let attr_name = attr_name.to_object(py);
-    let value = value.to_object(py);
+    let attr_name = attr_name.into_pyobject_or_pyerr(py)?;
+    let value = value.into_pyobject_or_pyerr(py)?;
     unsafe {
         py_error_on_minusone(
             py,
diff --git a/src/validators/model_fields.rs b/src/validators/model_fields.rs
index d2e1afe70..392760964 100644
--- a/src/validators/model_fields.rs
+++ b/src/validators/model_fields.rs
@@ -4,6 +4,7 @@ use pyo3::prelude::*;
 use pyo3::types::{PyDict, PySet, PyString, PyType};
 
 use ahash::AHashSet;
+use pyo3::IntoPyObjectExt;
 
 use crate::build_tools::py_schema_err;
 use crate::build_tools::{is_strict, schema_or_config_same, ExtraBehavior};
@@ -303,7 +304,7 @@ impl Validator for ModelFieldsValidator {
                                         Err(err) => return Err(err),
                                     }
                                 } else {
-                                    model_extra_dict.set_item(&py_key, value.to_object(self.py))?;
+                                    model_extra_dict.set_item(&py_key, value.to_object(self.py)?)?;
                                     self.fields_set_vec.push(py_key.into());
                                 };
                             }
@@ -340,7 +341,7 @@ impl Validator for ModelFieldsValidator {
                 model_extra_dict_op = Some(PyDict::new(py));
             };
 
-            Ok((model_dict, model_extra_dict_op, fields_set).to_object(py))
+            Ok((model_dict, model_extra_dict_op, fields_set).into_py_any(py)?)
         }
     }
 
@@ -354,13 +355,13 @@ impl Validator for ModelFieldsValidator {
     ) -> ValResult<PyObject> {
         let dict = obj.downcast::<PyDict>()?;
 
-        let get_updated_dict = |output: PyObject| {
+        let get_updated_dict = |output: &Bound<'py, PyAny>| {
             dict.set_item(field_name, output)?;
             Ok(dict)
         };
 
         let prepare_result = |result: ValResult<PyObject>| match result {
-            Ok(output) => get_updated_dict(output),
+            Ok(output) => get_updated_dict(&output.into_bound(py)),
             Err(ValError::LineErrors(line_errors)) => {
                 let errors = line_errors
                     .into_iter()
@@ -402,7 +403,7 @@ impl Validator for ModelFieldsValidator {
                 match self.extra_behavior {
                     ExtraBehavior::Allow => match self.extras_validator {
                         Some(ref validator) => prepare_result(validator.validate(py, field_value, state))?,
-                        None => get_updated_dict(field_value.to_object(py))?,
+                        None => get_updated_dict(field_value)?,
                     },
                     ExtraBehavior::Forbid | ExtraBehavior::Ignore => {
                         return Err(ValError::new_with_loc(
@@ -434,13 +435,13 @@ impl Validator for ModelFieldsValidator {
                 let new_extra = new_data.copy()?;
                 new_data.clear();
                 new_data.update(non_extra_data.as_mapping())?;
-                new_extra.to_object(py)
+                new_extra.into()
             }
             _ => py.None(),
         };
 
         let fields_set = PySet::new(py, &[field_name.to_string()])?;
-        Ok((new_data.to_object(py), new_extra, fields_set.to_object(py)).to_object(py))
+        Ok((new_data, new_extra, fields_set).into_py_any(py)?)
     }
 
     fn get_name(&self) -> &str {
diff --git a/src/validators/string.rs b/src/validators/string.rs
index 69d126c8f..a6ab8325e 100644
--- a/src/validators/string.rs
+++ b/src/validators/string.rs
@@ -260,7 +260,7 @@ impl Pattern {
             // so that any flags, etc. are preserved
             Ok(Self {
                 pattern: pattern_str,
-                engine: RegexEngine::PythonRe(pattern.to_object(py)),
+                engine: RegexEngine::PythonRe(pattern.unbind()),
             })
         } else {
             let engine = match engine {
diff --git a/src/validators/typed_dict.rs b/src/validators/typed_dict.rs
index 4dc72a9e1..3365c0169 100644
--- a/src/validators/typed_dict.rs
+++ b/src/validators/typed_dict.rs
@@ -331,7 +331,7 @@ impl Validator for TypedDictValidator {
                                         Err(err) => return Err(err),
                                     }
                                 } else {
-                                    self.output_dict.set_item(py_key, value.to_object(self.py))?;
+                                    self.output_dict.set_item(py_key, value.to_object(self.py)?)?;
                                 };
                             }
                         }
@@ -355,7 +355,7 @@ impl Validator for TypedDictValidator {
         }
 
         if errors.is_empty() {
-            Ok(output_dict.to_object(py))
+            Ok(output_dict.into())
         } else {
             Err(ValError::LineErrors(errors))
         }
diff --git a/src/validators/union.rs b/src/validators/union.rs
index ad14d421f..bfe744212 100644
--- a/src/validators/union.rs
+++ b/src/validators/union.rs
@@ -378,10 +378,10 @@ impl Validator for TaggedUnionValidator {
                     Some((_, value)) => value,
                     None => return Err(self.tag_not_found(input)),
                 };
-                self.find_call_validator(py, tag.borrow_input().to_object(py).bind(py), input, state)
+                self.find_call_validator(py, &tag.borrow_input().to_object(py)?, input, state)
             }
             Discriminator::Function(func) => {
-                let tag: Py<PyAny> = func.call1(py, (input.to_object(py),))?;
+                let tag: Py<PyAny> = func.call1(py, (input.to_object(py)?,))?;
                 if tag.is_none(py) {
                     Err(self.tag_not_found(input))
                 } else {
diff --git a/src/validators/uuid.rs b/src/validators/uuid.rs
index d1cab32a4..cd7dc580a 100644
--- a/src/validators/uuid.rs
+++ b/src/validators/uuid.rs
@@ -113,7 +113,7 @@ impl Validator for UuidValidator {
                     ));
                 }
             }
-            Ok(py_input.to_object(py))
+            Ok(py_input.clone().unbind())
         } else if state.strict_or(self.strict) && state.extra().input_type == InputType::Python {
             Err(ValError::new(
                 ErrorType::IsInstanceOf {
diff --git a/src/validators/with_default.rs b/src/validators/with_default.rs
index 55fbc6ce5..810008373 100644
--- a/src/validators/with_default.rs
+++ b/src/validators/with_default.rs
@@ -142,7 +142,7 @@ impl BuildValidator for WithDefaultValidator {
             validate_default: schema_or_config_same(schema, config, intern!(py, "validate_default"))?.unwrap_or(false),
             copy_default,
             name,
-            undefined: PydanticUndefinedType::new(py).to_object(py),
+            undefined: PydanticUndefinedType::new(py).into_any(),
         }
         .into())
     }

From 0ede4d11f7ec675b73013f0e2d6a9e9e92bf1408 Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Tue, 28 Jan 2025 16:25:28 +0100
Subject: [PATCH 470/550] Add back `stubtest` check (#1610)

---
 Makefile | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/Makefile b/Makefile
index 496f19ced..f37856789 100644
--- a/Makefile
+++ b/Makefile
@@ -1,6 +1,8 @@
 .DEFAULT_GOAL := all
 sources = python/pydantic_core tests generate_self_schema.py wasm-preview/run_tests.py
 
+mypy-stubtest = uv run python -m mypy.stubtest pydantic_core._pydantic_core --allowlist .mypy-stubtest-allowlist
+
 # using pip install cargo (via maturin via pip) doesn't get the tty handle
 # so doesn't render color without some help
 export CARGO_TERM_COLOR=$(shell (test -t 0 && echo "always") || echo "auto")
@@ -108,6 +110,7 @@ lint-python:
 	uv run ruff check $(sources)
 	uv run ruff format --check $(sources)
 	uv run griffe dump -f -d google -LWARNING -o/dev/null python/pydantic_core
+	$(mypy-stubtest)
 
 .PHONY: lint-rust
 lint-rust:

From 009b94853947d338f29612b88a807bf1ba2eb823 Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Thu, 30 Jan 2025 18:09:12 +0100
Subject: [PATCH 471/550] Bump version to v2.28.0 (#1615)

Also bump pyo3 to 0.23.4.
---
 Cargo.lock | 26 +++++++++++++-------------
 Cargo.toml |  4 ++--
 2 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 2c68dcac2..cdcc7a609 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -434,7 +434,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.27.2"
+version = "2.28.0"
 dependencies = [
  "ahash",
  "base64",
@@ -459,9 +459,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.23.3"
+version = "0.23.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e484fd2c8b4cb67ab05a318f1fd6fa8f199fcc30819f08f07d200809dba26c15"
+checksum = "57fe09249128b3173d092de9523eaa75136bf7ba85e0d69eca241c7939c933cc"
 dependencies = [
  "cfg-if",
  "indoc",
@@ -478,9 +478,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.23.3"
+version = "0.23.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dc0e0469a84f208e20044b98965e1561028180219e35352a2afaf2b942beff3b"
+checksum = "1cd3927b5a78757a0d71aa9dff669f903b1eb64b54142a9bd9f757f8fde65fd7"
 dependencies = [
  "once_cell",
  "python3-dll-a",
@@ -489,9 +489,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.23.3"
+version = "0.23.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "eb1547a7f9966f6f1a0f0227564a9945fe36b90da5a93b3933fc3dc03fae372d"
+checksum = "dab6bb2102bd8f991e7749f130a70d05dd557613e39ed2deeee8e9ca0c4d548d"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -499,9 +499,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.23.3"
+version = "0.23.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fdb6da8ec6fa5cedd1626c886fc8749bdcbb09424a86461eb8cdf096b7c33257"
+checksum = "91871864b353fd5ffcb3f91f2f703a22a9797c91b9ab497b1acac7b07ae509c7"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -511,9 +511,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.23.3"
+version = "0.23.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "38a385202ff5a92791168b1136afae5059d3ac118457bb7bc304c197c2d33e7d"
+checksum = "43abc3b80bc20f3facd86cd3c60beed58c3e2aa26213f3cda368de39c60a27e4"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -524,9 +524,9 @@ dependencies = [
 
 [[package]]
 name = "python3-dll-a"
-version = "0.2.11"
+version = "0.2.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b9e268ee1be609e93a13eb06839f68f67e5fe0fb4049834d261c2d5091c1b6d"
+checksum = "9b66f9171950e674e64bad3456e11bb3cca108e5c34844383cfe277f45c8a7a8"
 dependencies = [
  "cc",
 ]
diff --git a/Cargo.toml b/Cargo.toml
index efa05db7f..bda27781c 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.27.2"
+version = "2.28.0"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"
@@ -29,7 +29,7 @@ rust-version = "1.75"
 [dependencies]
 # TODO it would be very nice to remove the "py-clone" feature as it can panic,
 # but needs a bit of work to make sure it's not used in the codebase
-pyo3 = { version = "0.23.3", features = ["generate-import-lib", "num-bigint", "py-clone"] }
+pyo3 = { version = "0.23.4", features = ["generate-import-lib", "num-bigint", "py-clone"] }
 regex = "1.11.1"
 strum = { version = "0.26.3", features = ["derive"] }
 strum_macros = "0.26.4"

From e5b249edf5018e77aac3e10ce780e0bca66e2620 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 4 Feb 2025 19:43:06 +0000
Subject: [PATCH 472/550] Bump uuid from 1.11.0 to 1.12.1 (#1618)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index cdcc7a609..e373c4c36 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -781,9 +781,9 @@ checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
 
 [[package]]
 name = "uuid"
-version = "1.11.0"
+version = "1.12.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f8c5f0a0af699448548ad1a2fbf920fb4bee257eae39953ba95cb84891a0446a"
+checksum = "b3758f5e68192bb96cc8f9b7e2c2cfdabb435499a28499a42f8f984092adad4b"
 
 [[package]]
 name = "version_check"
diff --git a/Cargo.toml b/Cargo.toml
index bda27781c..18ba8e542 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -44,7 +44,7 @@ url = "2.5.0"
 idna = "1.0.3"
 base64 = "0.22.1"
 num-bigint = "0.4.6"
-uuid = "1.11.0"
+uuid = "1.12.1"
 jiter = { version = "0.8.2", features = ["python"] }
 hex = "0.4.3"
 

From e89bd8cf73b1d1737857845f57a0c94713cddf66 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Tue, 4 Feb 2025 19:43:24 +0000
Subject: [PATCH 473/550] Bump serde_json from 1.0.134 to 1.0.138 (#1617)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index e373c4c36..d08b98ac4 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -609,9 +609,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.134"
+version = "1.0.138"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d00f4175c42ee48b15416f6193a959ba3a0d67fc699a0db9ad12df9f83991c7d"
+checksum = "d434192e7da787e94a6ea7e9670b26a036d0ca41e0b7efb2676dd32bae872949"
 dependencies = [
  "indexmap",
  "itoa",
diff --git a/Cargo.toml b/Cargo.toml
index 18ba8e542..285805054 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -33,7 +33,7 @@ pyo3 = { version = "0.23.4", features = ["generate-import-lib", "num-bigint", "p
 regex = "1.11.1"
 strum = { version = "0.26.3", features = ["derive"] }
 strum_macros = "0.26.4"
-serde_json = {version = "1.0.134", features = ["arbitrary_precision", "preserve_order"]}
+serde_json = {version = "1.0.138", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.13"
 serde = { version = "1.0.217", features = ["derive"] }
 speedate = "0.15.0"

From ed15f6cae1f7073868372e3ac8f54f67c974ca6e Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=F0=9D=95=82?= <51281148+K-dash@users.noreply.github.com>
Date: Wed, 5 Feb 2025 22:42:14 +0900
Subject: [PATCH 474/550] Fix float `multiple_of` validation for negative
 numbers (#1373)

---
 src/validators/float.rs          |  7 +++---
 tests/validators/test_decimal.py | 40 ++++++++++++++++++++++++--------
 tests/validators/test_float.py   | 40 ++++++++++++++++++++++++--------
 3 files changed, 64 insertions(+), 23 deletions(-)

diff --git a/src/validators/float.rs b/src/validators/float.rs
index 30d3f3aa9..c2120d96b 100644
--- a/src/validators/float.rs
+++ b/src/validators/float.rs
@@ -109,9 +109,10 @@ impl Validator for ConstrainedFloatValidator {
             return Err(ValError::new(ErrorTypeDefaults::FiniteNumber, input));
         }
         if let Some(multiple_of) = self.multiple_of {
-            let rem = float % multiple_of;
-            let threshold = float.abs() / 1e9;
-            if rem.abs() > threshold && (rem - multiple_of).abs() > threshold {
+            let tolerance = 1e-9;
+            let rounded_div = (float / multiple_of).round();
+            let diff = (float - (rounded_div * multiple_of)).abs();
+            if diff > tolerance {
                 return Err(ValError::new(
                     ErrorType::MultipleOf {
                         multiple_of: multiple_of.into(),
diff --git a/tests/validators/test_decimal.py b/tests/validators/test_decimal.py
index fa1c0270d..0f165d5a8 100644
--- a/tests/validators/test_decimal.py
+++ b/tests/validators/test_decimal.py
@@ -171,24 +171,44 @@ def test_decimal_kwargs(py_and_json: PyAndJson, kwargs: dict[str, Any], input_va
 @pytest.mark.parametrize(
     'multiple_of,input_value,error',
     [
-        (0.5, 0.5, None),
-        (0.5, 1, None),
+        # Test cases for multiples of 0.5
+        *[(0.5, round(i * 0.5, 1), None) for i in range(-4, 5)],
+        (0.5, 0.49, Err('Input should be a multiple of 0.5')),
         (0.5, 0.6, Err('Input should be a multiple of 0.5')),
-        (0.5, 0.51, Err('Input should be a multiple of 0.5')),
+        (0.5, -0.75, Err('Input should be a multiple of 0.5')),
         (0.5, 0.501, Err('Input should be a multiple of 0.5')),
         (0.5, 1_000_000.5, None),
         (0.5, 1_000_000.49, Err('Input should be a multiple of 0.5')),
+        (0.5, int(5e10), None),
+        # Test cases for multiples of 0.1
+        *[(0.1, round(i * 0.1, 1), None) for i in range(-10, 11)],
         (0.1, 0, None),
-        (0.1, 0.0, None),
-        (0.1, 0.2, None),
-        (0.1, 0.3, None),
-        (0.1, 0.4, None),
-        (0.1, 0.5, None),
         (0.1, 0.5001, Err('Input should be a multiple of 0.1')),
+        (0.1, 0.05, Err('Input should be a multiple of 0.1')),
+        (0.1, -0.15, Err('Input should be a multiple of 0.1')),
+        (0.1, 1_000_000.1, None),
+        (0.1, 1_000_000.05, Err('Input should be a multiple of 0.1')),
         (0.1, 1, None),
-        (0.1, 1.0, None),
         (0.1, int(5e10), None),
-        (2.0, -2.0, None),
+        # Test cases for multiples of 2.0
+        *[(2.0, i * 2.0, None) for i in range(-5, 6)],
+        (2.0, -2.1, Err('Input should be a multiple of 2')),
+        (2.0, -3.0, Err('Input should be a multiple of 2')),
+        (2.0, 1_000_002.0, None),
+        (2.0, 1_000_001.0, Err('Input should be a multiple of 2')),
+        (2.0, int(5e10), None),
+        # Test cases for multiples of 0.01
+        *[(0.01, round(i * 0.01, 2), None) for i in range(-10, 11)],
+        (0.01, 0.005, Err('Input should be a multiple of 0.01')),
+        (0.01, -0.015, Err('Input should be a multiple of 0.01')),
+        (0.01, 1_000_000.01, None),
+        (0.01, 1_000_000.005, Err('Input should be a multiple of 0.01')),
+        (0.01, int(5e10), None),
+        # Test cases for values very close to zero
+        (0.1, 0.00001, Err('Input should be a multiple of 0.1')),
+        (0.1, -0.00001, Err('Input should be a multiple of 0.1')),
+        (0.01, 0.00001, Err('Input should be a multiple of 0.01')),
+        (0.01, -0.00001, Err('Input should be a multiple of 0.01')),
     ],
     ids=repr,
 )
diff --git a/tests/validators/test_float.py b/tests/validators/test_float.py
index c572fc68b..1269a6d51 100644
--- a/tests/validators/test_float.py
+++ b/tests/validators/test_float.py
@@ -105,24 +105,44 @@ def test_float_kwargs(py_and_json: PyAndJson, kwargs: dict[str, Any], input_valu
 @pytest.mark.parametrize(
     'multiple_of,input_value,error',
     [
-        (0.5, 0.5, None),
-        (0.5, 1, None),
+        # Test cases for multiples of 0.5
+        *[(0.5, round(i * 0.5, 1), None) for i in range(-4, 5)],
+        (0.5, 0.49, Err('Input should be a multiple of 0.5')),
         (0.5, 0.6, Err('Input should be a multiple of 0.5')),
-        (0.5, 0.51, Err('Input should be a multiple of 0.5')),
+        (0.5, -0.75, Err('Input should be a multiple of 0.5')),
         (0.5, 0.501, Err('Input should be a multiple of 0.5')),
         (0.5, 1_000_000.5, None),
         (0.5, 1_000_000.49, Err('Input should be a multiple of 0.5')),
+        (0.5, int(5e10), None),
+        # Test cases for multiples of 0.1
+        *[(0.1, round(i * 0.1, 1), None) for i in range(-10, 11)],
         (0.1, 0, None),
-        (0.1, 0.0, None),
-        (0.1, 0.2, None),
-        (0.1, 0.3, None),
-        (0.1, 0.4, None),
-        (0.1, 0.5, None),
         (0.1, 0.5001, Err('Input should be a multiple of 0.1')),
+        (0.1, 0.05, Err('Input should be a multiple of 0.1')),
+        (0.1, -0.15, Err('Input should be a multiple of 0.1')),
+        (0.1, 1_000_000.1, None),
+        (0.1, 1_000_000.05, Err('Input should be a multiple of 0.1')),
         (0.1, 1, None),
-        (0.1, 1.0, None),
         (0.1, int(5e10), None),
-        (2.0, -2.0, None),
+        # Test cases for multiples of 2.0
+        *[(2.0, i * 2.0, None) for i in range(-5, 6)],
+        (2.0, -2.1, Err('Input should be a multiple of 2')),
+        (2.0, -3.0, Err('Input should be a multiple of 2')),
+        (2.0, 1_000_002.0, None),
+        (2.0, 1_000_001.0, Err('Input should be a multiple of 2')),
+        (2.0, int(5e10), None),
+        # Test cases for multiples of 0.01
+        *[(0.01, round(i * 0.01, 2), None) for i in range(-10, 11)],
+        (0.01, 0.005, Err('Input should be a multiple of 0.01')),
+        (0.01, -0.015, Err('Input should be a multiple of 0.01')),
+        (0.01, 1_000_000.01, None),
+        (0.01, 1_000_000.005, Err('Input should be a multiple of 0.01')),
+        (0.01, int(5e10), None),
+        # Test cases for values very close to zero
+        (0.1, 0.00001, Err('Input should be a multiple of 0.1')),
+        (0.1, -0.00001, Err('Input should be a multiple of 0.1')),
+        (0.01, 0.00001, Err('Input should be a multiple of 0.01')),
+        (0.01, -0.00001, Err('Input should be a multiple of 0.01')),
     ],
     ids=repr,
 )

From fdccecd3d69d1b2aaf5ad5e9ff928b842ebe9143 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Wed, 5 Feb 2025 15:52:52 +0000
Subject: [PATCH 475/550] always use maturin for the uv commands in Makefile
 (#1622)

---
 Makefile       | 24 ---------------------
 pyproject.toml | 57 +++++++++++++++++++-------------------------------
 uv.lock        | 10 +++++++--
 3 files changed, 29 insertions(+), 62 deletions(-)

diff --git a/Makefile b/Makefile
index f37856789..b52e097d6 100644
--- a/Makefile
+++ b/Makefile
@@ -40,56 +40,32 @@ install-rust-coverage:
 .PHONY: build-dev
 build-dev:
 	@rm -f python/pydantic_core/*.so
-ifneq ($(USE_MATURIN),)
 	uv run maturin develop --uv
-else
-	uv pip install --force-reinstall -v -e . --config-settings=build-args='--profile dev'
-endif
 
 .PHONY: build-prod
 build-prod:
 	@rm -f python/pydantic_core/*.so
-ifneq ($(USE_MATURIN),)
 	uv run maturin develop --uv --release
-else
-	uv pip install -v -e .
-endif
 
 .PHONY: build-profiling
 build-profiling:
 	@rm -f python/pydantic_core/*.so
-ifneq ($(USE_MATURIN),)
 	uv run maturin develop --uv --profile profiling
-else
-	uv pip install --force-reinstall -v -e . --config-settings=build-args='--profile profiling'
-endif
 
 .PHONY: build-coverage
 build-coverage:
 	@rm -f python/pydantic_core/*.so
-ifneq ($(USE_MATURIN),)
 	RUSTFLAGS='-C instrument-coverage' uv run maturin develop --uv --release
-else
-	RUSTFLAGS='-C instrument-coverage' uv pip install -v -e .
-endif
 
 .PHONY: build-pgo
 build-pgo:
 	@rm -f python/pydantic_core/*.so
 	$(eval PROFDATA := $(shell mktemp -d))
-ifneq ($(USE_MATURIN),)
 	RUSTFLAGS='-Cprofile-generate=$(PROFDATA)' uv run maturin develop --uv --release
-else
-	RUSTFLAGS='-Cprofile-generate=$(PROFDATA)' uv pip install --force-reinstall -v -e .
-endif
 	pytest tests/benchmarks
 	$(eval LLVM_PROFDATA := $(shell rustup run stable bash -c 'echo $$RUSTUP_HOME/toolchains/$$RUSTUP_TOOLCHAIN/lib/rustlib/$$(rustc -Vv | grep host | cut -d " " -f 2)/bin/llvm-profdata'))
 	$(LLVM_PROFDATA) merge -o $(PROFDATA)/merged.profdata $(PROFDATA)
-ifneq ($(USE_MATURIN),)
 	RUSTFLAGS='-Cprofile-use=$(PROFDATA)/merged.profdata' uv run maturin develop --uv --release
-else
-	RUSTFLAGS='-Cprofile-use=$(PROFDATA)/merged.profdata' uv pip install --force-reinstall -v -e .
-endif
 	@rm -rf $(PROFDATA)
 
 
diff --git a/pyproject.toml b/pyproject.toml
index 521c110df..aa1f29011 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,17 +1,12 @@
 [build-system]
-requires = [
-    'maturin>=1,<2',
-    'typing-extensions >=4.6.0,!=4.7.0'
-]
+requires = ['maturin>=1,<2', 'typing-extensions >=4.6.0,!=4.7.0']
 build-backend = 'maturin'
 
 [project]
 name = 'pydantic_core'
 description = "Core functionality for Pydantic validation and serialization"
 requires-python = '>=3.9'
-authors = [
-    {name = 'Samuel Colvin', email = 's@muelcolvin.com'}
-]
+authors = [{ name = 'Samuel Colvin', email = 's@muelcolvin.com' }]
 classifiers = [
     'Development Status :: 3 - Alpha',
     'Programming Language :: Python',
@@ -32,15 +27,8 @@ classifiers = [
     'Operating System :: MacOS',
     'Typing :: Typed',
 ]
-dependencies = [
-    'typing-extensions >=4.6.0,!=4.7.0'
-]
-dynamic = [
-    'description',
-    'license',
-    'readme',
-    'version'
-]
+dependencies = ['typing-extensions >=4.6.0,!=4.7.0']
+dynamic = ['description', 'license', 'readme', 'version']
 
 [project.urls]
 Homepage = 'https://github.com/pydantic/pydantic-core'
@@ -48,7 +36,9 @@ Funding = 'https://github.com/sponsors/samuelcolvin'
 Source = 'https://github.com/pydantic/pydantic-core'
 
 [dependency-groups]
+dev = ["maturin"]
 testing = [
+    { include-group = "dev" },
     'backports.zoneinfo; python_version < "3.9"',
     'coverage',
     'dirty-equals',
@@ -70,26 +60,18 @@ testing = [
     'tzdata',
     'typing_extensions',
 ]
-linting = [
-    'griffe',
-    'pyright',
-    'ruff',
-    'mypy',
-]
-wasm = [
-    'typing_extensions',
-    'maturin>=1,<2',
-    'ruff',
-]
+linting = [{ include-group = "dev" }, 'griffe', 'pyright', 'ruff', 'mypy']
+wasm = [{ include-group = "dev" }, 'typing_extensions', 'ruff']
 codspeed = [
     # codspeed is only run on CI, with latest version of CPython
     'pytest-codspeed; python_version == "3.13" and implementation_name == "cpython"',
 ]
 
 all = [
-  { include-group = 'testing' },
-  { include-group = 'linting' },
-  { include-group = 'wasm' },
+    { include-group = "dev" },
+    { include-group = 'testing' },
+    { include-group = 'linting' },
+    { include-group = 'wasm' },
 ]
 
 [tool.maturin]
@@ -105,9 +87,9 @@ target-version = 'py39'
 [tool.ruff.lint]
 extend-select = ['Q', 'RUF100', 'C90', 'I', 'UP']
 extend-ignore = [
-    'E721',  # using type() instead of isinstance() - we use this in tests
+    'E721', # using type() instead of isinstance() - we use this in tests
 ]
-flake8-quotes = {inline-quotes = 'single', multiline-quotes = 'double'}
+flake8-quotes = { inline-quotes = 'single', multiline-quotes = 'double' }
 mccabe = { max-complexity = 13 }
 isort = { known-first-party = ['pydantic_core', 'tests'] }
 
@@ -130,10 +112,13 @@ timeout = 30
 xfail_strict = true
 # min, max, mean, stddev, median, iqr, outliers, ops, rounds, iterations
 addopts = [
-    '--benchmark-columns', 'min,mean,stddev,outliers,rounds,iterations',
-    '--benchmark-group-by', 'group',
-    '--benchmark-warmup', 'on',
-    '--benchmark-disable',  # this is enable by `make benchmark` when you actually want to run benchmarks
+    '--benchmark-columns',
+    'min,mean,stddev,outliers,rounds,iterations',
+    '--benchmark-group-by',
+    'group',
+    '--benchmark-warmup',
+    'on',
+    '--benchmark-disable',                        # this is enable by `make benchmark` when you actually want to run benchmarks
 ]
 
 [tool.coverage.run]
diff --git a/uv.lock b/uv.lock
index c6b53ad7c..3e936fef1 100644
--- a/uv.lock
+++ b/uv.lock
@@ -596,6 +596,9 @@ all = [
 codspeed = [
     { name = "pytest-codspeed", marker = "python_full_version == '3.13.*' and implementation_name == 'cpython'" },
 ]
+dev = [
+    { name = "maturin" },
+]
 linting = [
     { name = "griffe" },
     { name = "mypy" },
@@ -608,6 +611,7 @@ testing = [
     { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
     { name = "hypothesis" },
     { name = "inline-snapshot" },
+    { name = "maturin" },
     { name = "numpy", version = "2.0.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version < '3.10' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
     { name = "numpy", version = "2.2.2", source = { registry = "https://pypi.org/simple" }, marker = "python_full_version >= '3.10' and python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
     { name = "pandas", marker = "python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
@@ -639,7 +643,7 @@ all = [
     { name = "griffe" },
     { name = "hypothesis" },
     { name = "inline-snapshot" },
-    { name = "maturin", specifier = ">=1,<2" },
+    { name = "maturin" },
     { name = "mypy" },
     { name = "numpy", marker = "python_full_version >= '3.9' and python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
     { name = "pandas", marker = "python_full_version >= '3.9' and python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
@@ -656,6 +660,7 @@ all = [
     { name = "tzdata" },
 ]
 codspeed = [{ name = "pytest-codspeed", marker = "python_full_version == '3.13.*' and implementation_name == 'cpython'" }]
+dev = [{ name = "maturin" }]
 linting = [
     { name = "griffe" },
     { name = "mypy" },
@@ -669,6 +674,7 @@ testing = [
     { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
     { name = "hypothesis" },
     { name = "inline-snapshot" },
+    { name = "maturin" },
     { name = "numpy", marker = "python_full_version >= '3.9' and python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
     { name = "pandas", marker = "python_full_version >= '3.9' and python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
     { name = "pytest" },
@@ -682,7 +688,7 @@ testing = [
     { name = "tzdata" },
 ]
 wasm = [
-    { name = "maturin", specifier = ">=1,<2" },
+    { name = "maturin" },
     { name = "ruff" },
     { name = "typing-extensions" },
 ]

From 3707dcdd2135608b1fb515d66437ae07f84b6131 Mon Sep 17 00:00:00 2001
From: Samuel Colvin <s@muelcolvin.com>
Date: Wed, 5 Feb 2025 18:14:18 +0000
Subject: [PATCH 476/550] fix wasm preview (#1621)

---
 pyproject.toml            | 2 +-
 wasm-preview/run_tests.py | 4 +++-
 wasm-preview/worker.js    | 2 +-
 3 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index aa1f29011..27b54938d 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -27,7 +27,7 @@ classifiers = [
     'Operating System :: MacOS',
     'Typing :: Typed',
 ]
-dependencies = ['typing-extensions >=4.6.0,!=4.7.0']
+dependencies = ['typing-extensions>=4.6.0,!=4.7.0']
 dynamic = ['description', 'license', 'readme', 'version']
 
 [project.urls]
diff --git a/wasm-preview/run_tests.py b/wasm-preview/run_tests.py
index 03a26e088..806e01164 100644
--- a/wasm-preview/run_tests.py
+++ b/wasm-preview/run_tests.py
@@ -37,7 +37,9 @@ async def main(tests_zip: str, tag_name: str):
 
     print(f'Mounted {count} test files, installing dependencies...')
 
-    await micropip.install(['dirty-equals', 'hypothesis', 'pytest-speed', 'pytest-mock', pydantic_core_wheel, 'tzdata'])
+    await micropip.install(
+        ['dirty-equals', 'hypothesis', 'pytest-speed', 'pytest-mock', 'tzdata', 'inline-snapshot', pydantic_core_wheel]
+    )
     importlib.invalidate_caches()
 
     # print('installed packages:')
diff --git a/wasm-preview/worker.js b/wasm-preview/worker.js
index 93508f1c2..13414cdb5 100644
--- a/wasm-preview/worker.js
+++ b/wasm-preview/worker.js
@@ -97,7 +97,7 @@ async function main() {
     setupStreams(FS, pyodide._module.TTY);
     FS.mkdir('/test_dir');
     FS.chdir('/test_dir');
-    await pyodide.loadPackage(['micropip', 'pytest', 'numpy']);
+    await pyodide.loadPackage(['micropip', 'pytest', 'numpy', 'pygments']);
     if (pydantic_core_version < '2.0.0') await pyodide.loadPackage(['typing-extensions']);
     await pyodide.runPythonAsync(python_code, {globals: pyodide.toPy({pydantic_core_version, tests_zip})});
     post();

From 164b9ff9e3860c9cfce73abb8db8205ac61e8b08 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Wed, 5 Feb 2025 16:24:35 -0500
Subject: [PATCH 477/550] Memory usage optimization via reuse of
 `SchemaValidator` and `SchemaSerializer` (#1616)

---
 src/common/mod.rs           |  1 +
 src/common/prebuilt.rs      | 43 +++++++++++++++++++++++
 src/serializers/mod.rs      |  1 +
 src/serializers/prebuilt.rs | 68 +++++++++++++++++++++++++++++++++++++
 src/serializers/shared.rs   | 12 ++++++-
 src/validators/mod.rs       | 12 ++++++-
 src/validators/prebuilt.rs  | 41 ++++++++++++++++++++++
 tests/test_prebuilt.py      | 48 ++++++++++++++++++++++++++
 8 files changed, 224 insertions(+), 2 deletions(-)
 create mode 100644 src/common/prebuilt.rs
 create mode 100644 src/serializers/prebuilt.rs
 create mode 100644 src/validators/prebuilt.rs
 create mode 100644 tests/test_prebuilt.py

diff --git a/src/common/mod.rs b/src/common/mod.rs
index 11f2e1ece..47c0a0349 100644
--- a/src/common/mod.rs
+++ b/src/common/mod.rs
@@ -1 +1,2 @@
+pub(crate) mod prebuilt;
 pub(crate) mod union;
diff --git a/src/common/prebuilt.rs b/src/common/prebuilt.rs
new file mode 100644
index 000000000..961123691
--- /dev/null
+++ b/src/common/prebuilt.rs
@@ -0,0 +1,43 @@
+use pyo3::intern;
+use pyo3::prelude::*;
+use pyo3::types::{PyAny, PyDict, PyType};
+
+use crate::tools::SchemaDict;
+
+pub fn get_prebuilt<T>(
+    type_: &str,
+    schema: &Bound<'_, PyDict>,
+    prebuilt_attr_name: &str,
+    extractor: impl FnOnce(Bound<'_, PyAny>) -> PyResult<T>,
+) -> PyResult<Option<T>> {
+    let py = schema.py();
+
+    // we can only use prebuilt validators / serializers from models, typed dicts, and dataclasses
+    // however, we don't want to use a prebuilt structure from dataclasses if we have a generic_origin
+    // because the validator / serializer is cached on the unparametrized dataclass
+    if !matches!(type_, "model" | "typed-dict")
+        || matches!(type_, "dataclass") && schema.contains(intern!(py, "generic_origin"))?
+    {
+        return Ok(None);
+    }
+
+    let class: Bound<'_, PyType> = schema.get_as_req(intern!(py, "cls"))?;
+
+    // Note: we NEED to use the __dict__ here (and perform get_item calls rather than getattr)
+    // because we don't want to fetch prebuilt validators from parent classes.
+    // We don't downcast here because __dict__ on a class is a readonly mappingproxy,
+    // so we can just leave it as is and do get_item checks.
+    let class_dict = class.getattr(intern!(py, "__dict__"))?;
+
+    let is_complete: bool = class_dict
+        .get_item(intern!(py, "__pydantic_complete__"))
+        .is_ok_and(|b| b.extract().unwrap_or(false));
+
+    if !is_complete {
+        return Ok(None);
+    }
+
+    // Retrieve the prebuilt validator / serializer if available
+    let prebuilt: Bound<'_, PyAny> = class_dict.get_item(prebuilt_attr_name)?;
+    extractor(prebuilt).map(Some)
+}
diff --git a/src/serializers/mod.rs b/src/serializers/mod.rs
index 8fc1a4230..e652a75de 100644
--- a/src/serializers/mod.rs
+++ b/src/serializers/mod.rs
@@ -24,6 +24,7 @@ mod fields;
 mod filter;
 mod infer;
 mod ob_type;
+mod prebuilt;
 pub mod ser;
 mod shared;
 mod type_serializers;
diff --git a/src/serializers/prebuilt.rs b/src/serializers/prebuilt.rs
new file mode 100644
index 000000000..33d197d9b
--- /dev/null
+++ b/src/serializers/prebuilt.rs
@@ -0,0 +1,68 @@
+use std::borrow::Cow;
+
+use pyo3::prelude::*;
+use pyo3::types::PyDict;
+
+use crate::common::prebuilt::get_prebuilt;
+use crate::SchemaSerializer;
+
+use super::extra::Extra;
+use super::shared::{CombinedSerializer, TypeSerializer};
+
+#[derive(Debug)]
+pub struct PrebuiltSerializer {
+    schema_serializer: Py<SchemaSerializer>,
+}
+
+impl PrebuiltSerializer {
+    pub fn try_get_from_schema(type_: &str, schema: &Bound<'_, PyDict>) -> PyResult<Option<CombinedSerializer>> {
+        get_prebuilt(type_, schema, "__pydantic_serializer__", |py_any| {
+            py_any
+                .extract::<Py<SchemaSerializer>>()
+                .map(|schema_serializer| Self { schema_serializer }.into())
+        })
+    }
+}
+
+impl_py_gc_traverse!(PrebuiltSerializer { schema_serializer });
+
+impl TypeSerializer for PrebuiltSerializer {
+    fn to_python(
+        &self,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
+        extra: &Extra,
+    ) -> PyResult<PyObject> {
+        self.schema_serializer
+            .get()
+            .serializer
+            .to_python(value, include, exclude, extra)
+    }
+
+    fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
+        self.schema_serializer.get().serializer.json_key(key, extra)
+    }
+
+    fn serde_serialize<S: serde::ser::Serializer>(
+        &self,
+        value: &Bound<'_, PyAny>,
+        serializer: S,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
+        extra: &Extra,
+    ) -> Result<S::Ok, S::Error> {
+        self.schema_serializer
+            .get()
+            .serializer
+            .serde_serialize(value, serializer, include, exclude, extra)
+    }
+
+    fn get_name(&self) -> &str {
+        self.schema_serializer.get().serializer.get_name()
+    }
+
+    fn retry_with_lax_check(&self) -> bool {
+        self.schema_serializer.get().serializer.retry_with_lax_check()
+    }
+}
diff --git a/src/serializers/shared.rs b/src/serializers/shared.rs
index f37810657..f7a018749 100644
--- a/src/serializers/shared.rs
+++ b/src/serializers/shared.rs
@@ -84,6 +84,8 @@ combined_serializer! {
         Function: super::type_serializers::function::FunctionPlainSerializer;
         FunctionWrap: super::type_serializers::function::FunctionWrapSerializer;
         Fields: super::fields::GeneralFieldsSerializer;
+        // prebuilt serializers are manually constructed, and thus manually added to the `CombinedSerializer` enum
+        Prebuilt: super::prebuilt::PrebuiltSerializer;
     }
     // `find_only` is for type_serializers which are built directly via the `type` key and `find_serializer`
     // but aren't actually used for serialization, e.g. their `build` method must return another serializer
@@ -195,7 +197,14 @@ impl CombinedSerializer {
         }
 
         let type_: Bound<'_, PyString> = schema.get_as_req(type_key)?;
-        Self::find_serializer(type_.to_str()?, schema, config, definitions)
+        let type_ = type_.to_str()?;
+
+        // if we have a SchemaValidator on the type already, use it
+        if let Ok(Some(prebuilt_serializer)) = super::prebuilt::PrebuiltSerializer::try_get_from_schema(type_, schema) {
+            return Ok(prebuilt_serializer);
+        }
+
+        Self::find_serializer(type_, schema, config, definitions)
     }
 }
 
@@ -219,6 +228,7 @@ impl PyGcTraverse for CombinedSerializer {
             CombinedSerializer::Function(inner) => inner.py_gc_traverse(visit),
             CombinedSerializer::FunctionWrap(inner) => inner.py_gc_traverse(visit),
             CombinedSerializer::Fields(inner) => inner.py_gc_traverse(visit),
+            CombinedSerializer::Prebuilt(inner) => inner.py_gc_traverse(visit),
             CombinedSerializer::None(inner) => inner.py_gc_traverse(visit),
             CombinedSerializer::Nullable(inner) => inner.py_gc_traverse(visit),
             CombinedSerializer::Int(inner) => inner.py_gc_traverse(visit),
diff --git a/src/validators/mod.rs b/src/validators/mod.rs
index bc1851ac5..75f39df29 100644
--- a/src/validators/mod.rs
+++ b/src/validators/mod.rs
@@ -52,6 +52,7 @@ mod model;
 mod model_fields;
 mod none;
 mod nullable;
+mod prebuilt;
 mod set;
 mod string;
 mod time;
@@ -515,8 +516,15 @@ pub fn build_validator(
     definitions: &mut DefinitionsBuilder<CombinedValidator>,
 ) -> PyResult<CombinedValidator> {
     let dict = schema.downcast::<PyDict>()?;
-    let type_: Bound<'_, PyString> = dict.get_as_req(intern!(schema.py(), "type"))?;
+    let py = schema.py();
+    let type_: Bound<'_, PyString> = dict.get_as_req(intern!(py, "type"))?;
     let type_ = type_.to_str()?;
+
+    // if we have a SchemaValidator on the type already, use it
+    if let Ok(Some(prebuilt_validator)) = prebuilt::PrebuiltValidator::try_get_from_schema(type_, dict) {
+        return Ok(prebuilt_validator);
+    }
+
     validator_match!(
         type_,
         dict,
@@ -763,6 +771,8 @@ pub enum CombinedValidator {
     // input dependent
     JsonOrPython(json_or_python::JsonOrPython),
     Complex(complex::ComplexValidator),
+    // uses a reference to an existing SchemaValidator to reduce memory usage
+    Prebuilt(prebuilt::PrebuiltValidator),
 }
 
 /// This trait must be implemented by all validators, it allows various validators to be accessed consistently,
diff --git a/src/validators/prebuilt.rs b/src/validators/prebuilt.rs
new file mode 100644
index 000000000..c17acb9f9
--- /dev/null
+++ b/src/validators/prebuilt.rs
@@ -0,0 +1,41 @@
+use pyo3::prelude::*;
+use pyo3::types::PyDict;
+
+use crate::common::prebuilt::get_prebuilt;
+use crate::errors::ValResult;
+use crate::input::Input;
+
+use super::ValidationState;
+use super::{CombinedValidator, SchemaValidator, Validator};
+
+#[derive(Debug)]
+pub struct PrebuiltValidator {
+    schema_validator: Py<SchemaValidator>,
+}
+
+impl PrebuiltValidator {
+    pub fn try_get_from_schema(type_: &str, schema: &Bound<'_, PyDict>) -> PyResult<Option<CombinedValidator>> {
+        get_prebuilt(type_, schema, "__pydantic_validator__", |py_any| {
+            py_any
+                .extract::<Py<SchemaValidator>>()
+                .map(|schema_validator| Self { schema_validator }.into())
+        })
+    }
+}
+
+impl_py_gc_traverse!(PrebuiltValidator { schema_validator });
+
+impl Validator for PrebuiltValidator {
+    fn validate<'py>(
+        &self,
+        py: Python<'py>,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
+    ) -> ValResult<PyObject> {
+        self.schema_validator.get().validator.validate(py, input, state)
+    }
+
+    fn get_name(&self) -> &str {
+        self.schema_validator.get().validator.get_name()
+    }
+}
diff --git a/tests/test_prebuilt.py b/tests/test_prebuilt.py
new file mode 100644
index 000000000..9cd5aa325
--- /dev/null
+++ b/tests/test_prebuilt.py
@@ -0,0 +1,48 @@
+from pydantic_core import SchemaSerializer, SchemaValidator, core_schema
+
+
+def test_prebuilt_val_and_ser_used() -> None:
+    class InnerModel:
+        x: int
+
+    inner_schema = core_schema.model_schema(
+        InnerModel,
+        schema=core_schema.model_fields_schema(
+            {'x': core_schema.model_field(schema=core_schema.int_schema())},
+        ),
+    )
+
+    inner_schema_validator = SchemaValidator(inner_schema)
+    inner_schema_serializer = SchemaSerializer(inner_schema)
+    InnerModel.__pydantic_complete__ = True  # pyright: ignore[reportAttributeAccessIssue]
+    InnerModel.__pydantic_validator__ = inner_schema_validator  # pyright: ignore[reportAttributeAccessIssue]
+    InnerModel.__pydantic_serializer__ = inner_schema_serializer  # pyright: ignore[reportAttributeAccessIssue]
+
+    class OuterModel:
+        inner: InnerModel
+
+    outer_schema = core_schema.model_schema(
+        OuterModel,
+        schema=core_schema.model_fields_schema(
+            {
+                'inner': core_schema.model_field(
+                    schema=core_schema.model_schema(
+                        InnerModel,
+                        schema=core_schema.model_fields_schema(
+                            # note, we use str schema here even though that's incorrect
+                            # in order to verify that the prebuilt validator is used
+                            # off of InnerModel with the correct int schema, not this str schema
+                            {'x': core_schema.model_field(schema=core_schema.str_schema())},
+                        ),
+                    )
+                )
+            }
+        ),
+    )
+
+    outer_validator = SchemaValidator(outer_schema)
+    outer_serializer = SchemaSerializer(outer_schema)
+
+    result = outer_validator.validate_python({'inner': {'x': 1}})
+    assert result.inner.x == 1
+    assert outer_serializer.to_python(result) == {'inner': {'x': 1}}

From 0862ea5dabb0bc783649d6f068378c2582ff2ead Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Thu, 6 Feb 2025 11:46:06 +0000
Subject: [PATCH 478/550] build PGO wheels on `macos-latest` runners (#1624)

---
 .github/workflows/ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index c23f784eb..e65597b6f 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -506,7 +506,7 @@ jobs:
             ls: dir
             runs-on: windows-latest
           - os: macos
-            runs-on: macos-latest-xlarge
+            runs-on: macos-latest
         exclude:
           # macos arm only supported from 3.10 and up
           - os: macos

From f7fb50bdc7b88af69e9d776b991c16758e8f924d Mon Sep 17 00:00:00 2001
From: Michael Jones <mike.ed.jones@gmail.com>
Date: Thu, 6 Feb 2025 14:00:51 +0100
Subject: [PATCH 479/550] Raise validation error when unhashable items added to
 a set (#1619)

Co-authored-by: JONEMI21 <michael.jones2@kingfisher.com>
---
 python/pydantic_core/core_schema.py |  1 +
 src/errors/types.rs                 |  2 ++
 src/input/return_enums.rs           | 24 +++++++++++++++++++++---
 tests/test_errors.py                |  1 +
 tests/validators/test_set.py        | 16 ++++++++++++++++
 5 files changed, 41 insertions(+), 3 deletions(-)

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index 65e4a7a1f..c477bae1d 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -4037,6 +4037,7 @@ def definition_reference_schema(
     'list_type',
     'tuple_type',
     'set_type',
+    'set_item_not_hashable',
     'bool_type',
     'bool_parsing',
     'int_type',
diff --git a/src/errors/types.rs b/src/errors/types.rs
index 359f0c3de..0c75e1e24 100644
--- a/src/errors/types.rs
+++ b/src/errors/types.rs
@@ -268,6 +268,7 @@ error_types! {
     // ---------------------
     // set errors
     SetType {},
+    SetItemNotHashable {},
     // ---------------------
     // bool errors
     BoolType {},
@@ -513,6 +514,7 @@ impl ErrorType {
             Self::ListType {..} => "Input should be a valid list",
             Self::TupleType {..} => "Input should be a valid tuple",
             Self::SetType {..} => "Input should be a valid set",
+            Self::SetItemNotHashable {..} => "Set items should be hashable",
             Self::BoolType {..} => "Input should be a valid boolean",
             Self::BoolParsing {..} => "Input should be a valid boolean, unable to interpret input",
             Self::IntType {..} => "Input should be a valid integer",
diff --git a/src/input/return_enums.rs b/src/input/return_enums.rs
index 64f4f7c0f..6ac382430 100644
--- a/src/input/return_enums.rs
+++ b/src/input/return_enums.rs
@@ -194,6 +194,25 @@ impl BuildSet for Bound<'_, PyFrozenSet> {
     }
 }
 
+fn validate_add<'py>(
+    py: Python<'py>,
+    set: &impl BuildSet,
+    item: impl BorrowInput<'py>,
+    state: &mut ValidationState<'_, 'py>,
+    validator: &CombinedValidator,
+) -> ValResult<()> {
+    let validated_item = validator.validate(py, item.borrow_input(), state)?;
+    match set.build_add(validated_item) {
+        Ok(()) => Ok(()),
+        Err(err) => {
+            if err.matches(py, py.get_type::<PyTypeError>())? {
+                return Err(ValError::new(ErrorTypeDefaults::SetItemNotHashable, item));
+            }
+            Err(err)?
+        }
+    }
+}
+
 #[allow(clippy::too_many_arguments)]
 pub(crate) fn validate_iter_to_set<'py>(
     py: Python<'py>,
@@ -216,9 +235,8 @@ pub(crate) fn validate_iter_to_set<'py>(
             false => PartialMode::Off,
         };
         let item = item_result.map_err(|e| any_next_error!(py, e, input, index))?;
-        match validator.validate(py, item.borrow_input(), state) {
-            Ok(item) => {
-                set.build_add(item)?;
+        match validate_add(py, set, item, state, validator) {
+            Ok(()) => {
                 if let Some(max_length) = max_length {
                     if set.build_len() > max_length {
                         return Err(ValError::new(
diff --git a/tests/test_errors.py b/tests/test_errors.py
index 4760baad7..550f94e3d 100644
--- a/tests/test_errors.py
+++ b/tests/test_errors.py
@@ -306,6 +306,7 @@ def f(input_value, info):
     ('iteration_error', 'Error iterating over object, error: foobar', {'error': 'foobar'}),
     ('list_type', 'Input should be a valid list', None),
     ('tuple_type', 'Input should be a valid tuple', None),
+    ('set_item_not_hashable', 'Set items should be hashable', None),
     ('set_type', 'Input should be a valid set', None),
     ('bool_type', 'Input should be a valid boolean', None),
     ('bool_parsing', 'Input should be a valid boolean, unable to interpret input', None),
diff --git a/tests/validators/test_set.py b/tests/validators/test_set.py
index b5d35abf3..1bda3db70 100644
--- a/tests/validators/test_set.py
+++ b/tests/validators/test_set.py
@@ -104,6 +104,22 @@ def test_set_multiple_errors():
     ]
 
 
+def test_list_with_unhashable_items():
+    v = SchemaValidator({'type': 'set'})
+
+    class Unhashable:
+        __hash__ = None
+
+    unhashable = Unhashable()
+
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_python([{'a': 'b'}, unhashable])
+    assert exc_info.value.errors(include_url=False) == [
+        {'type': 'set_item_not_hashable', 'loc': (0,), 'msg': 'Set items should be hashable', 'input': {'a': 'b'}},
+        {'type': 'set_item_not_hashable', 'loc': (1,), 'msg': 'Set items should be hashable', 'input': unhashable},
+    ]
+
+
 def generate_repeats():
     for i in 1, 2, 3:
         yield i

From 4e824dff52918292d41a68c27c319d809fc3b03b Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Thu, 6 Feb 2025 14:48:16 +0000
Subject: [PATCH 480/550] add test run for 3.13t (#1626)

---
 .github/workflows/ci.yml              |  9 +++++++++
 pyproject.toml                        |  1 +
 src/argument_markers.rs               |  7 ++++++-
 tests/conftest.py                     | 21 ++++++++++++++++++++-
 tests/test_docstrings.py              |  2 ++
 tests/test_garbage_collection.py      | 21 +++++----------------
 tests/test_hypothesis.py              |  9 +++++++++
 tests/validators/test_dataclasses.py  |  9 ++-------
 tests/validators/test_frozenset.py    |  2 ++
 tests/validators/test_list.py         |  3 +++
 tests/validators/test_model_init.py   |  9 +++------
 tests/validators/test_nullable.py     |  9 +++------
 tests/validators/test_set.py          |  2 ++
 tests/validators/test_typed_dict.py   |  9 ++-------
 tests/validators/test_with_default.py | 10 ++--------
 uv.lock                               | 18 ++++++++++++++++++
 16 files changed, 89 insertions(+), 52 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index e65597b6f..2da8f98b3 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -68,11 +68,15 @@ jobs:
           - '3.11'
           - '3.12'
           - '3.13'
+          - '3.13t'
           - 'pypy3.9'
           - 'pypy3.10'
 
     runs-on: ubuntu-latest
 
+    # TODO: get test suite stable with free-threaded python
+    continue-on-error: ${{ endsWith(matrix.python-version, 't') }}
+
     steps:
       - uses: actions/checkout@v4
 
@@ -101,6 +105,11 @@ jobs:
       - run: uv run pytest
         env:
           HYPOTHESIS_PROFILE: slow
+          # TODO: remove -x when test suite is more stable; we use it so that first error (hopefully) gets
+          # reported without the interpreter crashing
+          PYTEST_ADDOPTS: ${{ endsWith(matrix.python-version, 't') && '--parallel-threads=2 -x' || '' }}
+          # TODO: add `gil_used = false` to the PyO3 `#[pymodule]` when test suite is ok
+          PYTHON_GIL: ${{ endsWith(matrix.python-version, 't') && '0' || '1' }}
 
   test-os:
     name: test on ${{ matrix.os }}
diff --git a/pyproject.toml b/pyproject.toml
index 27b54938d..db64e0d7a 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -52,6 +52,7 @@ testing = [
     'pytest-speed',
     'pytest-mock',
     'pytest-pretty',
+    'pytest-run-parallel',
     'pytest-timeout',
     'python-dateutil',
     # numpy doesn't offer prebuilt wheels for all versions and platforms we test in CI e.g. aarch64 musllinux
diff --git a/src/argument_markers.rs b/src/argument_markers.rs
index f22a32c78..1b74a62f1 100644
--- a/src/argument_markers.rs
+++ b/src/argument_markers.rs
@@ -5,7 +5,12 @@ use pyo3::types::{PyDict, PyTuple};
 
 use crate::tools::safe_repr;
 
-#[pyclass(module = "pydantic_core._pydantic_core", get_all, frozen, freelist = 100)]
+// see https://github.com/PyO3/pyo3/issues/4894 - freelist is currently unsound with GIL disabled
+#[cfg_attr(
+    not(Py_GIL_DISABLED),
+    pyclass(module = "pydantic_core._pydantic_core", get_all, frozen, freelist = 100)
+)]
+#[cfg_attr(Py_GIL_DISABLED, pyclass(module = "pydantic_core._pydantic_core", get_all, frozen))]
 #[derive(Debug, Clone)]
 pub struct ArgsKwargs {
     pub(crate) args: Py<PyTuple>,
diff --git a/tests/conftest.py b/tests/conftest.py
index f41d36b88..56d94a0c1 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -1,13 +1,15 @@
 from __future__ import annotations as _annotations
 
 import functools
+import gc
 import importlib.util
 import json
 import os
 import re
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Literal
+from time import sleep, time
+from typing import Any, Callable, Literal
 
 import hypothesis
 import pytest
@@ -160,3 +162,20 @@ def infinite_generator():
     while True:
         yield i
         i += 1
+
+
+def assert_gc(test: Callable[[], bool], timeout: float = 10) -> None:
+    """Helper to retry garbage collection until the test passes or timeout is
+    reached.
+
+    This is useful on free-threading where the GC collect call finishes before
+    all cleanup is done.
+    """
+    start = now = time()
+    while now - start < timeout:
+        if test():
+            return
+        gc.collect()
+        sleep(0.1)
+        now = time()
+    raise AssertionError('Timeout waiting for GC')
diff --git a/tests/test_docstrings.py b/tests/test_docstrings.py
index 25f5bf1e4..b3703067b 100644
--- a/tests/test_docstrings.py
+++ b/tests/test_docstrings.py
@@ -14,6 +14,7 @@ def find_examples(*_directories):
 
 @pytest.mark.skipif(CodeExample is None or sys.platform not in {'linux', 'darwin'}, reason='Only on linux and macos')
 @pytest.mark.parametrize('example', find_examples('python/pydantic_core/core_schema.py'), ids=str)
+@pytest.mark.thread_unsafe  # TODO investigate why pytest_examples seems to be thread unsafe here
 def test_docstrings(example: CodeExample, eval_example: EvalExample):
     eval_example.set_config(quotes='single')
 
@@ -27,6 +28,7 @@ def test_docstrings(example: CodeExample, eval_example: EvalExample):
 
 @pytest.mark.skipif(CodeExample is None or sys.platform not in {'linux', 'darwin'}, reason='Only on linux and macos')
 @pytest.mark.parametrize('example', find_examples('README.md'), ids=str)
+@pytest.mark.thread_unsafe  # TODO investigate why pytest_examples seems to be thread unsafe here
 def test_readme(example: CodeExample, eval_example: EvalExample):
     eval_example.set_config(line_length=100, quotes='single')
     if eval_example.update_examples:
diff --git a/tests/test_garbage_collection.py b/tests/test_garbage_collection.py
index 2b26bf008..512e480c5 100644
--- a/tests/test_garbage_collection.py
+++ b/tests/test_garbage_collection.py
@@ -1,4 +1,3 @@
-import gc
 import platform
 from collections.abc import Iterable
 from typing import Any
@@ -8,6 +7,8 @@
 
 from pydantic_core import SchemaSerializer, SchemaValidator, core_schema
 
+from .conftest import assert_gc
+
 GC_TEST_SCHEMA_INNER = core_schema.definitions_schema(
     core_schema.definition_reference_schema(schema_ref='model'),
     [
@@ -43,11 +44,7 @@ class MyModel(BaseModel):
 
         del MyModel
 
-    gc.collect(0)
-    gc.collect(1)
-    gc.collect(2)
-
-    assert len(cache) == 0
+    assert_gc(lambda: len(cache) == 0)
 
 
 @pytest.mark.xfail(
@@ -75,11 +72,7 @@ class MyModel(BaseModel):
 
         del MyModel
 
-    gc.collect(0)
-    gc.collect(1)
-    gc.collect(2)
-
-    assert len(cache) == 0
+    assert_gc(lambda: len(cache) == 0)
 
 
 @pytest.mark.xfail(
@@ -114,8 +107,4 @@ def __next__(self):
         v.validate_python({'iter': iterable})
         del iterable
 
-    gc.collect(0)
-    gc.collect(1)
-    gc.collect(2)
-
-    assert len(cache) == 0
+    assert_gc(lambda: len(cache) == 0)
diff --git a/tests/test_hypothesis.py b/tests/test_hypothesis.py
index f02d1b3a9..51674f620 100644
--- a/tests/test_hypothesis.py
+++ b/tests/test_hypothesis.py
@@ -19,12 +19,14 @@ def datetime_schema():
 
 
 @given(strategies.datetimes())
+@pytest.mark.thread_unsafe  # https://github.com/Quansight-Labs/pytest-run-parallel/issues/20
 def test_datetime_datetime(datetime_schema, data):
     assert datetime_schema.validate_python(data) == data
 
 
 @pytest.mark.skipif(sys.platform == 'win32', reason='Can fail on windows, I guess due to 64-bit issue')
 @given(strategies.integers(min_value=-11_676_096_000, max_value=253_402_300_799_000))
+@pytest.mark.thread_unsafe  # https://github.com/Quansight-Labs/pytest-run-parallel/issues/20
 def test_datetime_int(datetime_schema, data):
     try:
         if abs(data) > 20_000_000_000:
@@ -41,6 +43,7 @@ def test_datetime_int(datetime_schema, data):
 
 
 @given(strategies.binary())
+@pytest.mark.thread_unsafe  # https://github.com/Quansight-Labs/pytest-run-parallel/issues/20
 def test_datetime_binary(datetime_schema, data):
     try:
         datetime_schema.validate_python(data)
@@ -89,6 +92,7 @@ class BranchModel(TypedDict):
 
 @pytest.mark.skipif(sys.platform == 'emscripten', reason='Seems to fail sometimes on pyodide no idea why')
 @given(strategies.from_type(BranchModel))
+@pytest.mark.thread_unsafe  # https://github.com/Quansight-Labs/pytest-run-parallel/issues/20
 def test_recursive(definition_schema, data):
     assert definition_schema.validate_python(data) == data
 
@@ -108,6 +112,7 @@ def branch_models_with_cycles(draw, existing=None):
 
 
 @given(branch_models_with_cycles())
+@pytest.mark.thread_unsafe  # https://github.com/Quansight-Labs/pytest-run-parallel/issues/20
 def test_definition_cycles(definition_schema, data):
     try:
         assert definition_schema.validate_python(data) == data
@@ -130,6 +135,7 @@ def test_definition_broken(definition_schema):
 
 
 @given(strategies.timedeltas())
+@pytest.mark.thread_unsafe  # https://github.com/Quansight-Labs/pytest-run-parallel/issues/20
 def test_pytimedelta_as_timedelta(dt):
     v = SchemaValidator({'type': 'timedelta', 'gt': dt})
     # simplest way to check `pytimedelta_as_timedelta` is correct is to extract duration from repr of the validator
@@ -150,6 +156,7 @@ def url_validator():
 
 
 @given(strategies.text())
+@pytest.mark.thread_unsafe  # https://github.com/Quansight-Labs/pytest-run-parallel/issues/20
 def test_urls_text(url_validator, text):
     try:
         url_validator.validate_python(text)
@@ -166,6 +173,7 @@ def multi_host_url_validator():
 
 
 @given(strategies.text())
+@pytest.mark.thread_unsafe  # https://github.com/Quansight-Labs/pytest-run-parallel/issues/20
 def test_multi_host_urls_text(multi_host_url_validator, text):
     try:
         multi_host_url_validator.validate_python(text)
@@ -182,6 +190,7 @@ def str_serializer():
 
 
 @given(strategies.text())
+@pytest.mark.thread_unsafe  # https://github.com/Quansight-Labs/pytest-run-parallel/issues/20
 def test_serialize_string(str_serializer: SchemaSerializer, data):
     assert str_serializer.to_python(data) == data
     assert json.loads(str_serializer.to_json(data)) == data
diff --git a/tests/validators/test_dataclasses.py b/tests/validators/test_dataclasses.py
index 2555c733d..09bd4e762 100644
--- a/tests/validators/test_dataclasses.py
+++ b/tests/validators/test_dataclasses.py
@@ -1,5 +1,4 @@
 import dataclasses
-import gc
 import platform
 import re
 import sys
@@ -11,7 +10,7 @@
 
 from pydantic_core import ArgsKwargs, SchemaValidator, ValidationError, core_schema
 
-from ..conftest import Err, PyAndJson
+from ..conftest import Err, PyAndJson, assert_gc
 
 
 @pytest.mark.parametrize(
@@ -1586,12 +1585,8 @@ def _wrap_validator(cls, v, validator, info):
     assert ref() is not None
 
     del klass
-    gc.collect(0)
-    gc.collect(1)
-    gc.collect(2)
-    gc.collect()
 
-    assert ref() is None
+    assert_gc(lambda: ref() is None)
 
 
 init_test_cases = [
diff --git a/tests/validators/test_frozenset.py b/tests/validators/test_frozenset.py
index b17feb95a..c75175766 100644
--- a/tests/validators/test_frozenset.py
+++ b/tests/validators/test_frozenset.py
@@ -82,6 +82,7 @@ def test_frozenset_no_validators_both(py_and_json: PyAndJson, input_value, expec
         ('abc', Err('Input should be a valid frozenset')),
     ],
 )
+@pytest.mark.thread_unsafe  # generators in parameters not compatible with pytest-run-parallel, https://github.com/Quansight-Labs/pytest-run-parallel/issues/14
 def test_frozenset_ints_python(input_value, expected):
     v = SchemaValidator({'type': 'frozenset', 'items_schema': {'type': 'int'}})
     if isinstance(expected, Err):
@@ -165,6 +166,7 @@ def generate_repeats():
         ),
     ],
 )
+@pytest.mark.thread_unsafe  # generators in parameters not compatible with pytest-run-parallel, https://github.com/Quansight-Labs/pytest-run-parallel/issues/14
 def test_frozenset_kwargs_python(kwargs: dict[str, Any], input_value, expected):
     v = SchemaValidator({'type': 'frozenset', **kwargs})
     if isinstance(expected, Err):
diff --git a/tests/validators/test_list.py b/tests/validators/test_list.py
index ac5c5c051..991a90cbc 100644
--- a/tests/validators/test_list.py
+++ b/tests/validators/test_list.py
@@ -71,6 +71,7 @@ def gen_ints():
     ],
     ids=repr,
 )
+@pytest.mark.thread_unsafe  # generators in parameters not compatible with pytest-run-parallel, https://github.com/Quansight-Labs/pytest-run-parallel/issues/14
 def test_list_int(input_value, expected):
     v = SchemaValidator({'type': 'list', 'items_schema': {'type': 'int'}})
     if isinstance(expected, Err):
@@ -170,6 +171,7 @@ def test_list_error(input_value, index):
         ),
     ],
 )
+@pytest.mark.thread_unsafe  # generators in parameters not compatible with pytest-run-parallel, https://github.com/Quansight-Labs/pytest-run-parallel/issues/14
 def test_list_length_constraints(kwargs: dict[str, Any], input_value, expected):
     v = SchemaValidator({'type': 'list', **kwargs})
     if isinstance(expected, Err):
@@ -511,6 +513,7 @@ class ListInputTestCase:
     ],
     ids=repr,
 )
+@pytest.mark.thread_unsafe  # generators in parameters not compatible with pytest-run-parallel, https://github.com/Quansight-Labs/pytest-run-parallel/issues/14
 def test_list_allowed_inputs_python(testcase: ListInputTestCase):
     v = SchemaValidator(core_schema.list_schema(core_schema.int_schema(), strict=testcase.strict))
     if isinstance(testcase.output, Err):
diff --git a/tests/validators/test_model_init.py b/tests/validators/test_model_init.py
index b0c28dc86..f1226265a 100644
--- a/tests/validators/test_model_init.py
+++ b/tests/validators/test_model_init.py
@@ -1,4 +1,3 @@
-import gc
 import platform
 import weakref
 
@@ -7,6 +6,8 @@
 
 from pydantic_core import CoreConfig, SchemaValidator, core_schema
 
+from ..conftest import assert_gc
+
 
 class MyModel:
     # this is not required, but it avoids `__pydantic_fields_set__` being included in `__dict__`
@@ -473,12 +474,8 @@ def _wrap_validator(cls, v, validator, info):
     assert ref() is not None
 
     del klass
-    gc.collect(0)
-    gc.collect(1)
-    gc.collect(2)
-    gc.collect()
 
-    assert ref() is None
+    assert_gc(lambda: ref() is None)
 
 
 def test_model_custom_init_with_union() -> None:
diff --git a/tests/validators/test_nullable.py b/tests/validators/test_nullable.py
index a74d56138..451559c76 100644
--- a/tests/validators/test_nullable.py
+++ b/tests/validators/test_nullable.py
@@ -1,4 +1,3 @@
-import gc
 import platform
 import weakref
 
@@ -6,6 +5,8 @@
 
 from pydantic_core import SchemaValidator, ValidationError, core_schema
 
+from ..conftest import assert_gc
+
 
 def test_nullable():
     v = SchemaValidator({'type': 'nullable', 'schema': {'type': 'int'}})
@@ -62,9 +63,5 @@ def validate(v, info):
     assert ref() is not None
 
     del cycle
-    gc.collect(0)
-    gc.collect(1)
-    gc.collect(2)
-    gc.collect()
 
-    assert ref() is None
+    assert_gc(lambda: ref() is None)
diff --git a/tests/validators/test_set.py b/tests/validators/test_set.py
index 1bda3db70..df94a8e31 100644
--- a/tests/validators/test_set.py
+++ b/tests/validators/test_set.py
@@ -73,6 +73,7 @@ def test_frozenset_no_validators_both(py_and_json: PyAndJson, input_value, expec
         ('abc', Err('Input should be a valid set')),
     ],
 )
+@pytest.mark.thread_unsafe  # generators in parameters not compatible with pytest-run-parallel, https://github.com/Quansight-Labs/pytest-run-parallel/issues/14
 def test_set_ints_python(input_value, expected):
     v = SchemaValidator({'type': 'set', 'items_schema': {'type': 'int'}})
     if isinstance(expected, Err):
@@ -162,6 +163,7 @@ def generate_repeats():
     ],
     ids=repr,
 )
+@pytest.mark.thread_unsafe  # generators in parameters not compatible with pytest-run-parallel, https://github.com/Quansight-Labs/pytest-run-parallel/issues/14
 def test_set_kwargs(kwargs: dict[str, Any], input_value, expected):
     v = SchemaValidator({'type': 'set', **kwargs})
     if isinstance(expected, Err):
diff --git a/tests/validators/test_typed_dict.py b/tests/validators/test_typed_dict.py
index 9d543ea4f..b41a1188f 100644
--- a/tests/validators/test_typed_dict.py
+++ b/tests/validators/test_typed_dict.py
@@ -1,4 +1,3 @@
-import gc
 import math
 import platform
 import re
@@ -11,7 +10,7 @@
 
 from pydantic_core import CoreConfig, SchemaError, SchemaValidator, ValidationError, core_schema, validate_core_schema
 
-from ..conftest import Err, PyAndJson
+from ..conftest import Err, PyAndJson, assert_gc
 
 
 class Cls:
@@ -1191,9 +1190,5 @@ def validate(v, info):
     assert ref() is not None
 
     del cycle
-    gc.collect(0)
-    gc.collect(1)
-    gc.collect(2)
-    gc.collect()
 
-    assert ref() is None
+    assert_gc(lambda: ref() is None)
diff --git a/tests/validators/test_with_default.py b/tests/validators/test_with_default.py
index a27b80268..7c5972c5a 100644
--- a/tests/validators/test_with_default.py
+++ b/tests/validators/test_with_default.py
@@ -1,4 +1,3 @@
-import gc
 import platform
 import sys
 import weakref
@@ -17,7 +16,7 @@
     core_schema,
 )
 
-from ..conftest import PyAndJson
+from ..conftest import PyAndJson, assert_gc
 
 
 def test_typed_dict_default():
@@ -662,12 +661,7 @@ def _validator(cls, v, info):
     assert ref() is not None
 
     del klass
-    gc.collect(0)
-    gc.collect(1)
-    gc.collect(2)
-    gc.collect()
-
-    assert ref() is None
+    assert_gc(lambda: ref() is None)
 
 
 validate_default_raises_examples = [
diff --git a/uv.lock b/uv.lock
index 3e936fef1..7ad8e1c5a 100644
--- a/uv.lock
+++ b/uv.lock
@@ -586,6 +586,7 @@ all = [
     { name = "pytest-examples", marker = "implementation_name == 'cpython' and platform_machine == 'x86_64'" },
     { name = "pytest-mock" },
     { name = "pytest-pretty" },
+    { name = "pytest-run-parallel" },
     { name = "pytest-speed" },
     { name = "pytest-timeout" },
     { name = "python-dateutil" },
@@ -601,6 +602,7 @@ dev = [
 ]
 linting = [
     { name = "griffe" },
+    { name = "maturin" },
     { name = "mypy" },
     { name = "pyright" },
     { name = "ruff" },
@@ -619,6 +621,7 @@ testing = [
     { name = "pytest-examples", marker = "implementation_name == 'cpython' and platform_machine == 'x86_64'" },
     { name = "pytest-mock" },
     { name = "pytest-pretty" },
+    { name = "pytest-run-parallel" },
     { name = "pytest-speed" },
     { name = "pytest-timeout" },
     { name = "python-dateutil" },
@@ -652,6 +655,7 @@ all = [
     { name = "pytest-examples", marker = "implementation_name == 'cpython' and platform_machine == 'x86_64'" },
     { name = "pytest-mock" },
     { name = "pytest-pretty" },
+    { name = "pytest-run-parallel" },
     { name = "pytest-speed" },
     { name = "pytest-timeout" },
     { name = "python-dateutil" },
@@ -663,6 +667,7 @@ codspeed = [{ name = "pytest-codspeed", marker = "python_full_version == '3.13.*
 dev = [{ name = "maturin" }]
 linting = [
     { name = "griffe" },
+    { name = "maturin" },
     { name = "mypy" },
     { name = "pyright" },
     { name = "ruff" },
@@ -681,6 +686,7 @@ testing = [
     { name = "pytest-examples", marker = "implementation_name == 'cpython' and platform_machine == 'x86_64'" },
     { name = "pytest-mock" },
     { name = "pytest-pretty" },
+    { name = "pytest-run-parallel" },
     { name = "pytest-speed" },
     { name = "pytest-timeout" },
     { name = "python-dateutil" },
@@ -795,6 +801,18 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/bf/fe/d44d391312c1b8abee2af58ee70fabb1c00b6577ac4e0bdf25b70c1caffb/pytest_pretty-1.2.0-py3-none-any.whl", hash = "sha256:6f79122bf53864ae2951b6c9e94d7a06a87ef753476acd4588aeac018f062036", size = 6180 },
 ]
 
+[[package]]
+name = "pytest-run-parallel"
+version = "0.3.1"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "pytest" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/fe/13/d3bcb2c52f63b774be612cbee51f33a5cf2fa97d2f60fe26264f6720477b/pytest_run_parallel-0.3.1.tar.gz", hash = "sha256:636306d3ed6838898d8d42b3cd379dac7b327ce6d68df1bcc30d55a208d5081e", size = 14142 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/4d/67/4943178bb5dacb2e0b745b4db4ab126112dafab66266f2262896e791dbbe/pytest_run_parallel-0.3.1-py3-none-any.whl", hash = "sha256:0675c9e4c8e843085333c66bc0ce6b8091e3509dc8e6df3429f05c28f5345b17", size = 9468 },
+]
+
 [[package]]
 name = "pytest-speed"
 version = "0.3.5"

From 944658816aa8c08b6e23d41b59fd2df05cb9fdb9 Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Thu, 6 Feb 2025 16:45:44 +0100
Subject: [PATCH 481/550] Fix condition before using prebuilt
 validator/serializer (#1625)

Typed dictionaries don't have cached validators/serializers, and the condition wasn't actually ignoring parametrized dataclasses.
---
 src/common/prebuilt.rs | 11 ++++++-----
 1 file changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/common/prebuilt.rs b/src/common/prebuilt.rs
index 961123691..f4307064f 100644
--- a/src/common/prebuilt.rs
+++ b/src/common/prebuilt.rs
@@ -12,11 +12,12 @@ pub fn get_prebuilt<T>(
 ) -> PyResult<Option<T>> {
     let py = schema.py();
 
-    // we can only use prebuilt validators / serializers from models, typed dicts, and dataclasses
-    // however, we don't want to use a prebuilt structure from dataclasses if we have a generic_origin
-    // because the validator / serializer is cached on the unparametrized dataclass
-    if !matches!(type_, "model" | "typed-dict")
-        || matches!(type_, "dataclass") && schema.contains(intern!(py, "generic_origin"))?
+    // we can only use prebuilt validators/serializers from models and Pydantic dataclasses.
+    // However, we don't want to use a prebuilt structure from dataclasses if we have a `generic_origin`
+    // as this means the dataclass was parametrized (so a generic alias instance), and `cls` in the
+    // core schema is still the (unparametrized) class, meaning we would fetch the wrong validator/serializer.
+    if !matches!(type_, "model" | "dataclass")
+        || (type_ == "dataclass" && schema.contains(intern!(py, "generic_origin"))?)
     {
         return Ok(None);
     }

From db63fecda71c6815aec7a316a17d5b8174c6659a Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Thu, 6 Feb 2025 19:54:22 +0000
Subject: [PATCH 482/550] disable `inline-snapshot` on 3.13t test run (#1627)

---
 .github/workflows/ci.yml | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 2da8f98b3..ed52c387f 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -105,9 +105,8 @@ jobs:
       - run: uv run pytest
         env:
           HYPOTHESIS_PROFILE: slow
-          # TODO: remove -x when test suite is more stable; we use it so that first error (hopefully) gets
-          # reported without the interpreter crashing
-          PYTEST_ADDOPTS: ${{ endsWith(matrix.python-version, 't') && '--parallel-threads=2 -x' || '' }}
+          # TODO: remove --inline-snapshot=disable after https://github.com/15r10nk/inline-snapshot/issues/192
+          PYTEST_ADDOPTS: ${{ endsWith(matrix.python-version, 't') && '--parallel-threads=2 --inline-snapshot=disable' || '' }}
           # TODO: add `gil_used = false` to the PyO3 `#[pymodule]` when test suite is ok
           PYTHON_GIL: ${{ endsWith(matrix.python-version, 't') && '0' || '1' }}
 

From ce467563cb2a83f78a6582ac5310f2d691b29551 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Fri, 7 Feb 2025 14:42:47 +0000
Subject: [PATCH 483/550] support free-threaded Python 3.13t (#1628)

---
 .github/workflows/ci.yml  |  4 +--
 src/lib.rs                | 51 +++++++++++++++++----------------------
 src/validators/decimal.rs |  6 +----
 3 files changed, 24 insertions(+), 37 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index ed52c387f..74200993d 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -107,8 +107,6 @@ jobs:
           HYPOTHESIS_PROFILE: slow
           # TODO: remove --inline-snapshot=disable after https://github.com/15r10nk/inline-snapshot/issues/192
           PYTEST_ADDOPTS: ${{ endsWith(matrix.python-version, 't') && '--parallel-threads=2 --inline-snapshot=disable' || '' }}
-          # TODO: add `gil_used = false` to the PyO3 `#[pymodule]` when test suite is ok
-          PYTHON_GIL: ${{ endsWith(matrix.python-version, 't') && '0' || '1' }}
 
   test-os:
     name: test on ${{ matrix.os }}
@@ -505,7 +503,7 @@ jobs:
       fail-fast: false
       matrix:
         os: [linux, windows, macos]
-        interpreter: ['3.9', '3.10', '3.11', '3.12', '3.13']
+        interpreter: ['3.9', '3.10', '3.11', '3.12', '3.13', '3.13t']
         include:
           # standard runners with override for macos arm
           - os: linux
diff --git a/src/lib.rs b/src/lib.rs
index 7689f3988..2404ebdfb 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -106,33 +106,26 @@ pub fn build_info() -> String {
     )
 }
 
-#[pymodule]
-fn _pydantic_core(py: Python, m: &Bound<'_, PyModule>) -> PyResult<()> {
-    m.add("__version__", get_pydantic_core_version())?;
-    m.add("build_profile", env!("PROFILE"))?;
-    m.add("build_info", build_info())?;
-    m.add("_recursion_limit", recursion_guard::RECURSION_GUARD_LIMIT)?;
-    m.add("PydanticUndefined", PydanticUndefinedType::new(py))?;
-    m.add_class::<PydanticUndefinedType>()?;
-    m.add_class::<PySome>()?;
-    m.add_class::<SchemaValidator>()?;
-    m.add_class::<ValidationError>()?;
-    m.add_class::<SchemaError>()?;
-    m.add_class::<PydanticCustomError>()?;
-    m.add_class::<PydanticKnownError>()?;
-    m.add_class::<PydanticOmit>()?;
-    m.add_class::<PydanticUseDefault>()?;
-    m.add_class::<PydanticSerializationError>()?;
-    m.add_class::<PydanticSerializationUnexpectedValue>()?;
-    m.add_class::<PyUrl>()?;
-    m.add_class::<PyMultiHostUrl>()?;
-    m.add_class::<ArgsKwargs>()?;
-    m.add_class::<SchemaSerializer>()?;
-    m.add_class::<TzInfo>()?;
-    m.add_function(wrap_pyfunction!(to_json, m)?)?;
-    m.add_function(wrap_pyfunction!(from_json, m)?)?;
-    m.add_function(wrap_pyfunction!(to_jsonable_python, m)?)?;
-    m.add_function(wrap_pyfunction!(list_all_errors, m)?)?;
-    m.add_function(wrap_pyfunction!(validate_core_schema, m)?)?;
-    Ok(())
+#[pymodule(gil_used = false)]
+mod _pydantic_core {
+    #[allow(clippy::wildcard_imports)]
+    use super::*;
+
+    #[pymodule_export]
+    use crate::{
+        from_json, list_all_errors, to_json, to_jsonable_python, validate_core_schema, ArgsKwargs, PyMultiHostUrl,
+        PySome, PyUrl, PydanticCustomError, PydanticKnownError, PydanticOmit, PydanticSerializationError,
+        PydanticSerializationUnexpectedValue, PydanticUndefinedType, PydanticUseDefault, SchemaError, SchemaSerializer,
+        SchemaValidator, TzInfo, ValidationError,
+    };
+
+    #[pymodule_init]
+    fn module_init(m: &Bound<'_, PyModule>) -> PyResult<()> {
+        m.add("__version__", get_pydantic_core_version())?;
+        m.add("build_profile", env!("PROFILE"))?;
+        m.add("build_info", build_info())?;
+        m.add("_recursion_limit", recursion_guard::RECURSION_GUARD_LIMIT)?;
+        m.add("PydanticUndefined", PydanticUndefinedType::new(m.py()))?;
+        Ok(())
+    }
 }
diff --git a/src/validators/decimal.rs b/src/validators/decimal.rs
index 4f56f4bfd..6c2e55806 100644
--- a/src/validators/decimal.rs
+++ b/src/validators/decimal.rs
@@ -182,11 +182,7 @@ impl Validator for DecimalValidator {
 
         if let Some(multiple_of) = &self.multiple_of {
             // fraction = (decimal / multiple_of) % 1
-            let fraction = unsafe {
-                let division = decimal.div(multiple_of)?;
-                let one = 1u8.into_pyobject(py)?;
-                Bound::from_owned_ptr_or_err(py, pyo3::ffi::PyNumber_Remainder(division.as_ptr(), one.as_ptr()))?
-            };
+            let fraction = (decimal.div(multiple_of)?).rem(1)?;
             let zero = 0u8.into_pyobject(py)?;
             if !fraction.eq(&zero)? {
                 return Err(ValError::new(

From f1aaaaf14c6b2040f8c70203585f6f5c8d74e2d9 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Fri, 7 Feb 2025 12:45:36 -0500
Subject: [PATCH 484/550] Prep for v2.29.0 release :) (#1630)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index d08b98ac4..f1fe843da 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -434,7 +434,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.28.0"
+version = "2.29.0"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index 285805054..3468fec06 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.28.0"
+version = "2.29.0"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From 2e4134c08b4bddca75377328519c2e390e2f1171 Mon Sep 17 00:00:00 2001
From: Michael Jones <mike.ed.jones@gmail.com>
Date: Tue, 11 Feb 2025 08:59:21 +0000
Subject: [PATCH 485/550] Use core schema fns to initalize `SchemaValidator`s
 in the test suite. (#1631)

Co-authored-by: JONEMI21 <michael.jones2@kingfisher.com>
---
 tests/benchmarks/test_micro_benchmarks.py     | 289 ++++-----
 tests/serializers/test_any.py                 |   8 +-
 tests/serializers/test_list_tuple.py          |   8 +-
 tests/serializers/test_simple.py              |  20 +-
 tests/test_build.py                           |   6 +-
 tests/test_config.py                          |  90 ++-
 tests/test_errors.py                          |  28 +-
 tests/test_garbage_collection.py              |   4 +-
 tests/test_hypothesis.py                      |   8 +-
 tests/test_isinstance.py                      |  11 +-
 tests/test_json.py                            |  73 +--
 tests/test_misc.py                            |  32 +-
 tests/validators/test_allow_partial.py        |   2 +-
 tests/validators/test_arguments.py            |  51 +-
 tests/validators/test_bool.py                 |   7 +-
 tests/validators/test_bytes.py                |  11 +-
 tests/validators/test_call.py                 | 108 ++--
 tests/validators/test_callable.py             |   7 +-
 tests/validators/test_chain.py                |  41 +-
 tests/validators/test_complex.py              |  17 +-
 tests/validators/test_custom_error.py         |   4 +-
 tests/validators/test_date.py                 |  17 +-
 tests/validators/test_datetime.py             |  35 +-
 tests/validators/test_decimal.py              |  31 +-
 tests/validators/test_definitions.py          |   6 +-
 .../validators/test_definitions_recursive.py  |  81 +--
 tests/validators/test_dict.py                 |  35 +-
 tests/validators/test_float.py                |  19 +-
 tests/validators/test_frozenset.py            |  36 +-
 tests/validators/test_function.py             |  62 +-
 tests/validators/test_generator.py            |  13 +-
 tests/validators/test_int.py                  |  41 +-
 tests/validators/test_is_instance.py          |  15 +-
 tests/validators/test_list.py                 |  35 +-
 tests/validators/test_literal.py              |   5 +-
 tests/validators/test_model.py                | 433 ++++++-------
 tests/validators/test_model_fields.py         | 590 ++++++++----------
 tests/validators/test_model_init.py           | 125 ++--
 tests/validators/test_none.py                 |   5 +-
 tests/validators/test_nullable.py             |  15 +-
 tests/validators/test_set.py                  |  34 +-
 tests/validators/test_string.py               |  34 +-
 tests/validators/test_tagged_union.py         | 180 +++---
 tests/validators/test_time.py                 |  18 +-
 tests/validators/test_timedelta.py            |  28 +-
 tests/validators/test_tuple.py                |  85 +--
 tests/validators/test_typed_dict.py           | 395 ++++++------
 tests/validators/test_union.py                | 199 +++---
 tests/validators/test_url.py                  |   4 +-
 tests/validators/test_uuid.py                 |  12 +-
 tests/validators/test_with_default.py         | 254 ++++----
 51 files changed, 1752 insertions(+), 1915 deletions(-)

diff --git a/tests/benchmarks/test_micro_benchmarks.py b/tests/benchmarks/test_micro_benchmarks.py
index 2caa6fc83..3435174a5 100644
--- a/tests/benchmarks/test_micro_benchmarks.py
+++ b/tests/benchmarks/test_micro_benchmarks.py
@@ -18,6 +18,7 @@
 import pydantic_core
 from pydantic_core import (
     ArgsKwargs,
+    CoreConfig,
     PydanticCustomError,
     PydanticKnownError,
     SchemaValidator,
@@ -43,26 +44,23 @@ class CoreModel:
             __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__'
 
         return SchemaValidator(
-            {
-                'type': 'model',
-                'cls': CoreModel,
-                'schema': {
-                    'type': 'model-fields',
-                    'fields': {
-                        'name': {'type': 'model-field', 'schema': {'type': 'str'}},
-                        'age': {'type': 'model-field', 'schema': {'type': 'int'}},
-                        'friends': {'type': 'model-field', 'schema': {'type': 'list', 'items_schema': {'type': 'int'}}},
-                        'settings': {
-                            'type': 'model-field',
-                            'schema': {
-                                'type': 'dict',
-                                'keys_schema': {'type': 'str'},
-                                'values_schema': {'type': 'float'},
-                            },
-                        },
-                    },
-                },
-            }
+            schema=core_schema.model_schema(
+                cls=CoreModel,
+                schema=core_schema.model_fields_schema(
+                    fields={
+                        'name': core_schema.model_field(schema=core_schema.str_schema()),
+                        'age': core_schema.model_field(schema=core_schema.int_schema()),
+                        'friends': core_schema.model_field(
+                            schema=core_schema.list_schema(items_schema=core_schema.int_schema())
+                        ),
+                        'settings': core_schema.model_field(
+                            schema=core_schema.dict_schema(
+                                keys_schema=core_schema.str_schema(), values_schema=core_schema.float_schema()
+                            )
+                        ),
+                    }
+                ),
+            )
         )
 
     data = {'name': 'John', 'age': 42, 'friends': list(range(200)), 'settings': {f'v_{i}': i / 2.0 for i in range(50)}}
@@ -88,15 +86,13 @@ class CoreModel:
             __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__'
 
         return SchemaValidator(
-            {
-                'type': 'model',
-                'cls': CoreModel,
-                'schema': {
-                    'type': 'model-fields',
-                    'extra_behavior': 'allow',
-                    'fields': {f'field_{i}': {'type': 'model-field', 'schema': {'type': 'int'}} for i in range(100)},
-                },
-            }
+            schema=core_schema.model_schema(
+                cls=CoreModel,
+                schema=core_schema.model_fields_schema(
+                    extra_behavior='allow',
+                    fields={f'field_{i}': {'type': 'model-field', 'schema': {'type': 'int'}} for i in range(100)},
+                ),
+            )
         )
 
     data = {f'field_{99 - i}': i for i in range(100)}
@@ -127,7 +123,7 @@ def test_core_json_fs(self, core_model_validator, benchmark):
 
 @pytest.mark.benchmark(group='bool')
 def test_bool_core(benchmark):
-    schema_validator = SchemaValidator({'type': 'bool'})
+    schema_validator = SchemaValidator(core_schema.bool_schema())
 
     @benchmark
     def t():
@@ -161,17 +157,15 @@ class MyCoreModel:
         age: int
 
     model_schema_validator = SchemaValidator(
-        {
-            'type': 'model',
-            'cls': MyCoreModel,
-            'schema': {
-                'type': 'model-fields',
-                'fields': {
-                    'name': {'type': 'model-field', 'schema': {'type': 'str'}},
-                    'age': {'type': 'model-field', 'schema': {'type': 'int'}},
-                },
-            },
-        }
+        core_schema.model_schema(
+            cls=MyCoreModel,
+            schema=core_schema.model_fields_schema(
+                fields={
+                    'name': core_schema.model_field(schema=core_schema.str_schema()),
+                    'age': core_schema.model_field(schema=core_schema.int_schema()),
+                }
+            ),
+        )
     )
     benchmark(model_schema_validator.validate_python, small_class_data)
 
@@ -328,13 +322,11 @@ class CoreBranch:
 @pytest.mark.benchmark(group='list[TypedDict]')
 def test_list_of_dict_models_core(benchmark):
     v = SchemaValidator(
-        {
-            'type': 'list',
-            'items_schema': {
-                'type': 'typed-dict',
-                'fields': {'width': {'type': 'typed-dict-field', 'schema': {'type': 'int'}}},
-            },
-        }
+        core_schema.list_schema(
+            items_schema=core_schema.typed_dict_schema(
+                fields={'width': core_schema.typed_dict_field(schema=core_schema.int_schema())}
+            )
+        )
     )
 
     data = [{'width': i} for i in range(100)]
@@ -346,7 +338,7 @@ def test_list_of_dict_models_core(benchmark):
 
 @pytest.mark.benchmark(group='list[int]')
 def test_list_of_ints_core_py(benchmark):
-    v = SchemaValidator({'type': 'list', 'items_schema': {'type': 'int'}})
+    v = SchemaValidator(core_schema.list_schema(items_schema=core_schema.int_schema()))
 
     @benchmark
     def t():
@@ -356,7 +348,7 @@ def t():
 
 @pytest.mark.benchmark(group='list[int] JSON')
 def test_list_of_ints_core_json(benchmark):
-    v = SchemaValidator({'type': 'list', 'items_schema': {'type': 'int'}})
+    v = SchemaValidator(core_schema.list_schema(items_schema=core_schema.int_schema()))
 
     json_data = [json.dumps(d) for d in list_of_ints_data]
 
@@ -386,7 +378,7 @@ def test_list_of_strs_json_cached(benchmark):
 
 @pytest.mark.benchmark(group='list[str]')
 def test_list_of_strs_json_uncached(benchmark):
-    v = SchemaValidator(core_schema.list_schema(core_schema.str_schema()), {'cache_strings': False})
+    v = SchemaValidator(core_schema.list_schema(core_schema.str_schema()), config=CoreConfig(cache_strings=False))
 
     json_data = json.dumps(list_of_strs_data)
     benchmark(v.validate_json, json_data)
@@ -394,7 +386,7 @@ def test_list_of_strs_json_uncached(benchmark):
 
 @pytest.mark.benchmark(group='list[Any]')
 def test_list_of_any_core_py(benchmark):
-    v = SchemaValidator({'type': 'list'})
+    v = SchemaValidator(core_schema.list_schema())
 
     @benchmark
     def t():
@@ -408,7 +400,7 @@ def t():
 
 @pytest.mark.benchmark(group='Set[int]')
 def test_set_of_ints_core(benchmark):
-    v = SchemaValidator({'type': 'set', 'items_schema': {'type': 'int'}})
+    v = SchemaValidator(core_schema.set_schema(items_schema=core_schema.int_schema()))
 
     @benchmark
     def t():
@@ -418,7 +410,7 @@ def t():
 
 @pytest.mark.benchmark(group='Set[int]')
 def test_set_of_ints_core_duplicates(benchmark):
-    v = SchemaValidator({'type': 'set', 'items_schema': {'type': 'int'}})
+    v = SchemaValidator(core_schema.set_schema(items_schema=core_schema.int_schema()))
 
     @benchmark
     def t():
@@ -428,7 +420,7 @@ def t():
 
 @pytest.mark.benchmark(group='Set[int]')
 def test_set_of_ints_core_length(benchmark):
-    v = SchemaValidator({'type': 'set', 'items_schema': {'type': 'int'}, 'max_length': 2000})
+    v = SchemaValidator(core_schema.set_schema(items_schema=core_schema.int_schema(), max_length=2000))
 
     @benchmark
     def t():
@@ -438,7 +430,7 @@ def t():
 
 @pytest.mark.benchmark(group='Set[int] JSON')
 def test_set_of_ints_core_json(benchmark):
-    v = SchemaValidator({'type': 'set', 'items_schema': {'type': 'int'}})
+    v = SchemaValidator(core_schema.set_schema(items_schema=core_schema.int_schema()))
 
     json_data = [json.dumps(list(d)) for d in set_of_ints_data]
 
@@ -450,7 +442,7 @@ def t():
 
 @pytest.mark.benchmark(group='Set[int] JSON')
 def test_set_of_ints_core_json_duplicates(benchmark):
-    v = SchemaValidator({'type': 'set', 'items_schema': {'type': 'int'}})
+    v = SchemaValidator(core_schema.set_schema(items_schema=core_schema.int_schema()))
 
     json_data = [json.dumps(list(d)) for d in set_of_ints_duplicates]
 
@@ -466,14 +458,14 @@ def t():
 
 @pytest.mark.benchmark(group='FrozenSet[int]')
 def test_frozenset_of_ints_core(benchmark):
-    v = SchemaValidator({'type': 'frozenset', 'items_schema': {'type': 'int'}})
+    v = SchemaValidator(core_schema.frozenset_schema(items_schema=core_schema.int_schema()))
 
     benchmark(v.validate_python, frozenset_of_ints)
 
 
 @pytest.mark.benchmark(group='FrozenSet[int]')
 def test_frozenset_of_ints_duplicates_core(benchmark):
-    v = SchemaValidator({'type': 'frozenset', 'items_schema': {'type': 'int'}})
+    v = SchemaValidator(core_schema.frozenset_schema(items_schema=core_schema.int_schema()))
 
     benchmark(v.validate_python, frozenset_of_ints_duplicates)
 
@@ -483,7 +475,9 @@ def test_frozenset_of_ints_duplicates_core(benchmark):
 
 @pytest.mark.benchmark(group='dict[str, int]')
 def test_dict_of_ints_core(benchmark):
-    v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'str'}, 'values_schema': {'type': 'int'}})
+    v = SchemaValidator(
+        core_schema.dict_schema(keys_schema=core_schema.str_schema(), values_schema=core_schema.int_schema())
+    )
 
     @benchmark
     def t():
@@ -493,7 +487,7 @@ def t():
 
 @pytest.mark.benchmark(group='dict[any, any]')
 def test_dict_of_any_core(benchmark):
-    v = SchemaValidator({'type': 'dict'})
+    v = SchemaValidator(core_schema.dict_schema())
 
     @benchmark
     def t():
@@ -503,7 +497,9 @@ def t():
 
 @pytest.mark.benchmark(group='dict[str, int] JSON')
 def test_dict_of_ints_core_json(benchmark):
-    v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'str'}, 'values_schema': {'type': 'int'}})
+    v = SchemaValidator(
+        core_schema.dict_schema(keys_schema=core_schema.str_schema(), values_schema=core_schema.int_schema())
+    )
 
     json_data = [json.dumps(d) for d in dict_of_ints_data]
 
@@ -535,17 +531,14 @@ class MyCoreModel:
         __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__'
 
     v = SchemaValidator(
-        {
-            'type': 'list',
-            'items_schema': {
-                'type': 'model',
-                'cls': MyCoreModel,
-                'schema': {
-                    'type': 'model-fields',
-                    'fields': {'age': {'type': 'model-field', 'schema': {'type': 'int'}}},
-                },
-            },
-        }
+        core_schema.list_schema(
+            items_schema=core_schema.model_schema(
+                cls=MyCoreModel,
+                schema=core_schema.model_fields_schema(
+                    fields={'age': core_schema.model_field(schema=core_schema.int_schema())}
+                ),
+            )
+        )
     )
     benchmark(v.validate_python, many_models_data)
 
@@ -555,7 +548,9 @@ class MyCoreModel:
 
 @pytest.mark.benchmark(group='list[Nullable[int]]')
 def test_list_of_nullable_core(benchmark):
-    v = SchemaValidator({'type': 'list', 'items_schema': {'type': 'nullable', 'schema': {'type': 'int'}}})
+    v = SchemaValidator(
+        core_schema.list_schema(items_schema=core_schema.nullable_schema(schema=core_schema.int_schema()))
+    )
 
     benchmark(v.validate_python, list_of_nullable_data)
 
@@ -565,7 +560,7 @@ def test_list_of_nullable_core(benchmark):
 
 @pytest.mark.benchmark(group='bytes')
 def test_bytes_core(benchmark):
-    v = SchemaValidator({'type': 'bytes'})
+    v = SchemaValidator(core_schema.bytes_schema())
 
     benchmark(v.validate_python, some_bytes)
 
@@ -577,14 +572,12 @@ class CoreModel:
             __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__'
 
         return SchemaValidator(
-            {
-                'type': 'model',
-                'cls': CoreModel,
-                'schema': {
-                    'type': 'model-fields',
-                    'fields': {'dt': {'type': 'model-field', 'schema': {'type': 'datetime'}}},
-                },
-            }
+            schema=core_schema.model_schema(
+                cls=CoreModel,
+                schema=core_schema.model_fields_schema(
+                    fields={'dt': core_schema.model_field(schema=core_schema.datetime_schema())}
+                ),
+            )
         )
 
     @pytest.fixture(scope='class')
@@ -613,25 +606,25 @@ def test_model_core_json(self, core_validator, benchmark, json_dict_data):
 
     @pytest.mark.benchmark(group='datetime datetime')
     def test_core_raw(self, benchmark, datetime_raw):
-        v = SchemaValidator({'type': 'datetime'})
+        v = SchemaValidator(core_schema.datetime_schema())
 
         benchmark(v.validate_python, datetime_raw)
 
     @pytest.mark.benchmark(group='datetime str')
     def test_core_str(self, benchmark, datetime_str):
-        v = SchemaValidator({'type': 'datetime'})
+        v = SchemaValidator(core_schema.datetime_schema())
 
         benchmark(v.validate_python, datetime_str)
 
     @pytest.mark.benchmark(group='datetime future')
     def test_core_future(self, benchmark, datetime_raw):
-        v = SchemaValidator({'type': 'datetime', 'gt': datetime.now()})
+        v = SchemaValidator(core_schema.datetime_schema(gt=datetime.now()))
 
         benchmark(v.validate_python, datetime_raw)
 
     @pytest.mark.benchmark(group='datetime future')
     def test_core_future_str(self, benchmark, datetime_str):
-        v = SchemaValidator({'type': 'datetime', 'gt': datetime.now()})
+        v = SchemaValidator(core_schema.datetime_schema(gt=datetime.now()))
 
         benchmark(v.validate_python, datetime_str)
 
@@ -639,7 +632,7 @@ def test_core_future_str(self, benchmark, datetime_str):
 class TestBenchmarkDateX:
     @pytest.fixture(scope='class')
     def validator(self):
-        return SchemaValidator({'type': 'date'})
+        return SchemaValidator(core_schema.date_schema())
 
     @pytest.mark.benchmark(group='date from date')
     def test_date_from_date(self, benchmark, validator):
@@ -659,13 +652,13 @@ def test_date_from_datetime_str(self, benchmark, validator):
 
     @pytest.mark.benchmark(group='date future')
     def test_core_future(self, benchmark):
-        v = SchemaValidator({'type': 'date', 'gt': date.today()})
+        v = SchemaValidator(core_schema.date_schema(gt=date.today()))
 
         benchmark(v.validate_python, date(2932, 1, 1))
 
     @pytest.mark.benchmark(group='date future')
     def test_core_future_str(self, benchmark):
-        v = SchemaValidator({'type': 'date', 'gt': date.today()})
+        v = SchemaValidator(core_schema.date_schema(gt=date.today()))
 
         benchmark(v.validate_python, str(date(2932, 1, 1)))
 
@@ -673,27 +666,37 @@ def test_core_future_str(self, benchmark):
 class TestBenchmarkUnion:
     @pytest.mark.benchmark(group='smart-union')
     def test_smart_union_core(self, benchmark):
-        v = SchemaValidator({'type': 'union', 'choices': [{'type': 'bool'}, {'type': 'int'}, {'type': 'str'}]})
+        v = SchemaValidator(
+            schema=core_schema.union_schema(
+                choices=[core_schema.bool_schema(), core_schema.int_schema(), core_schema.str_schema()]
+            )
+        )
 
         benchmark(v.validate_python, 1)
 
     @pytest.mark.benchmark(group='smart-union-coerce')
     def test_smart_union_coerce_core(self, benchmark):
-        v = SchemaValidator({'type': 'union', 'choices': [{'type': 'bool'}, {'type': 'str'}]})
+        v = SchemaValidator(
+            schema=core_schema.union_schema(choices=[core_schema.bool_schema(), core_schema.str_schema()])
+        )
 
         benchmark(v.validate_python, 1)  # will be True
 
     @pytest.mark.benchmark(group='strict-union')
     def test_strict_union_core(self, benchmark):
         v = SchemaValidator(
-            {'type': 'union', 'strict': True, 'choices': [{'type': 'bool'}, {'type': 'int'}, {'type': 'str'}]}
+            schema=core_schema.union_schema(
+                strict=True, choices=[core_schema.bool_schema(), core_schema.int_schema(), core_schema.str_schema()]
+            )
         )
 
         benchmark(v.validate_python, 1)
 
     @pytest.mark.benchmark(group='strict-union-error')
     def test_strict_union_error_core(self, benchmark):
-        v = SchemaValidator({'type': 'union', 'strict': True, 'choices': [{'type': 'bool'}, {'type': 'str'}]})
+        v = SchemaValidator(
+            schema=core_schema.union_schema(strict=True, choices=[core_schema.bool_schema(), core_schema.str_schema()])
+        )
 
         def validate_with_expected_error():
             try:
@@ -712,19 +715,17 @@ class CoreModel:
             __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__'
 
         return SchemaValidator(
-            {
-                'type': 'model',
-                'cls': CoreModel,
-                'schema': {
-                    'type': 'model-fields',
-                    'fields': {'u': {'type': 'model-field', 'schema': {'type': 'uuid'}}},
-                },
-            }
+            schema=core_schema.model_schema(
+                cls=CoreModel,
+                schema=core_schema.model_fields_schema(
+                    fields={'u': core_schema.model_field(schema=core_schema.uuid_schema())}
+                ),
+            )
         )
 
     @pytest.fixture(scope='class')
     def validator(self):
-        return SchemaValidator({'type': 'uuid'})
+        return SchemaValidator(core_schema.uuid_schema())
 
     @pytest.fixture(scope='class')
     def pydantic_validator(self):
@@ -802,13 +803,13 @@ def test_model_core_json(self, core_validator, benchmark, json_dict_data):
 
     @pytest.mark.benchmark(group='uuid uuid')
     def test_core_raw(self, benchmark, uuid_raw):
-        v = SchemaValidator({'type': 'uuid'})
+        v = SchemaValidator(core_schema.uuid_schema())
 
         benchmark(v.validate_python, uuid_raw)
 
     @pytest.mark.benchmark(group='uuid str')
     def test_core_str(self, benchmark, uuid_str):
-        v = SchemaValidator({'type': 'uuid'})
+        v = SchemaValidator(core_schema.uuid_schema())
 
         benchmark(v.validate_python, uuid_str)
 
@@ -874,10 +875,15 @@ def t():
 @pytest.mark.benchmark(group='tuple')
 def test_positional_tuple(benchmark):
     v = SchemaValidator(
-        {
-            'type': 'tuple',
-            'items_schema': [{'type': 'int'}, {'type': 'int'}, {'type': 'int'}, {'type': 'int'}, {'type': 'int'}],
-        }
+        core_schema.tuple_schema(
+            items_schema=[
+                core_schema.int_schema(),
+                core_schema.int_schema(),
+                core_schema.int_schema(),
+                core_schema.int_schema(),
+                core_schema.int_schema(),
+            ]
+        )
     )
     assert v.validate_python((1, 2, 3, '4', 5)) == (1, 2, 3, 4, 5)
 
@@ -886,7 +892,7 @@ def test_positional_tuple(benchmark):
 
 @pytest.mark.benchmark(group='tuple')
 def test_variable_tuple(benchmark):
-    v = SchemaValidator({'type': 'tuple', 'items_schema': [{'type': 'int'}], 'variadic_item_index': 0})
+    v = SchemaValidator(core_schema.tuple_schema(items_schema=[core_schema.int_schema()], variadic_item_index=0))
     assert v.validate_python((1, 2, 3, '4', 5)) == (1, 2, 3, 4, 5)
 
     benchmark(v.validate_python, (1, 2, 3, '4', 5))
@@ -894,7 +900,7 @@ def test_variable_tuple(benchmark):
 
 @pytest.mark.benchmark(group='tuple-many')
 def test_tuple_many_variable(benchmark):
-    v = SchemaValidator({'type': 'tuple', 'items_schema': [{'type': 'int'}], 'variadic_item_index': 0})
+    v = SchemaValidator(core_schema.tuple_schema(items_schema=[core_schema.int_schema()], variadic_item_index=0))
     assert v.validate_python(list(range(10))) == tuple(range(10))
 
     benchmark(v.validate_python, list(range(10)))
@@ -902,7 +908,7 @@ def test_tuple_many_variable(benchmark):
 
 @pytest.mark.benchmark(group='tuple-many')
 def test_tuple_many_positional(benchmark):
-    v = SchemaValidator({'type': 'tuple', 'items_schema': [{'type': 'int'}], 'variadic_item_index': 0})
+    v = SchemaValidator(core_schema.tuple_schema(items_schema=[core_schema.int_schema()], variadic_item_index=0))
     assert v.validate_python(list(range(10))) == tuple(range(10))
 
     benchmark(v.validate_python, list(range(10)))
@@ -911,16 +917,15 @@ def test_tuple_many_positional(benchmark):
 @pytest.mark.benchmark(group='arguments')
 def test_arguments(benchmark):
     v = SchemaValidator(
-        {
-            'type': 'arguments',
-            'arguments_schema': [
-                {'name': 'args1', 'mode': 'positional_only', 'schema': {'type': 'int'}},
-                {'name': 'args2', 'mode': 'positional_only', 'schema': {'type': 'str'}},
-                {'name': 'a', 'mode': 'positional_or_keyword', 'schema': {'type': 'bool'}},
-                {'name': 'b', 'mode': 'keyword_only', 'schema': {'type': 'str'}},
-                {'name': 'c', 'mode': 'keyword_only', 'schema': {'type': 'int'}},
-            ],
-        }
+        core_schema.arguments_schema(
+            arguments=[
+                {'name': 'args1', 'mode': 'positional_only', 'schema': core_schema.int_schema()},
+                {'name': 'args2', 'mode': 'positional_only', 'schema': core_schema.str_schema()},
+                {'name': 'a', 'mode': 'positional_or_keyword', 'schema': core_schema.bool_schema()},
+                {'name': 'b', 'mode': 'keyword_only', 'schema': core_schema.str_schema()},
+                {'name': 'c', 'mode': 'keyword_only', 'schema': core_schema.int_schema()},
+            ]
+        )
     )
     assert v.validate_python(ArgsKwargs((1, 'a', 'true'), {'b': 'bb', 'c': 3})) == ((1, 'a', True), {'b': 'bb', 'c': 3})
 
@@ -930,15 +935,13 @@ def test_arguments(benchmark):
 @pytest.mark.benchmark(group='defaults')
 def test_with_default(benchmark):
     v = SchemaValidator(
-        {
-            'type': 'typed-dict',
-            'fields': {
-                'name': {
-                    'type': 'typed-dict-field',
-                    'schema': {'type': 'default', 'schema': {'type': 'str'}, 'default': 'John'},
-                }
-            },
-        }
+        core_schema.typed_dict_schema(
+            fields={
+                'name': core_schema.typed_dict_field(
+                    schema=core_schema.with_default_schema(schema=core_schema.str_schema(), default='John')
+                )
+            }
+        )
     )
     assert v.validate_python({'name': 'Foo'}) == {'name': 'Foo'}
     assert v.validate_python({}) == {'name': 'John'}
@@ -952,10 +955,9 @@ def t():
 @pytest.mark.benchmark(group='chain')
 def test_chain_list(benchmark):
     validator = SchemaValidator(
-        {
-            'type': 'chain',
-            'steps': [{'type': 'str'}, core_schema.with_info_plain_validator_function(lambda v, info: Decimal(v))],
-        }
+        core_schema.chain_schema(
+            steps=[core_schema.str_schema(), core_schema.with_info_plain_validator_function(lambda v, info: Decimal(v))]
+        )
     )
     assert validator.validate_python('42.42') == Decimal('42.42')
 
@@ -967,7 +969,7 @@ def test_chain_function(benchmark):
     validator = SchemaValidator(
         {
             'type': 'function-after',
-            'schema': {'type': 'str'},
+            'schema': core_schema.str_schema(),
             'function': {'type': 'with-info', 'function': lambda v, info: Decimal(v)},
         }
     )
@@ -979,14 +981,13 @@ def test_chain_function(benchmark):
 @pytest.mark.benchmark(group='chain-functions')
 def test_chain_two_functions(benchmark):
     validator = SchemaValidator(
-        {
-            'type': 'chain',
-            'steps': [
-                {'type': 'str'},
+        core_schema.chain_schema(
+            steps=[
+                core_schema.str_schema(),
                 core_schema.with_info_plain_validator_function(lambda v, info: Decimal(v)),
                 core_schema.with_info_plain_validator_function(lambda v, info: v * 2),
-            ],
-        }
+            ]
+        )
     )
     assert validator.validate_python('42.42') == Decimal('84.84')
 
@@ -1000,7 +1001,7 @@ def test_chain_nested_functions(benchmark):
             'type': 'function-after',
             'schema': {
                 'type': 'function-after',
-                'schema': {'type': 'str'},
+                'schema': core_schema.str_schema(),
                 'function': {'type': 'with-info', 'function': lambda v, info: Decimal(v)},
             },
             'function': {'type': 'with-info', 'function': lambda v, info: v * 2},
@@ -1359,7 +1360,7 @@ def f(v: int, info: core_schema.ValidationInfo) -> int:
 class TestBenchmarkDecimal:
     @pytest.fixture(scope='class')
     def validator(self):
-        return SchemaValidator({'type': 'decimal'})
+        return SchemaValidator(core_schema.decimal_schema())
 
     @pytest.fixture(scope='class')
     def pydantic_validator(self):
diff --git a/tests/serializers/test_any.py b/tests/serializers/test_any.py
index 344e0ff02..c3b3e2f8f 100644
--- a/tests/serializers/test_any.py
+++ b/tests/serializers/test_any.py
@@ -15,7 +15,13 @@
 from dirty_equals import HasRepr, IsList
 
 import pydantic_core
-from pydantic_core import PydanticSerializationError, SchemaSerializer, SchemaValidator, core_schema, to_json
+from pydantic_core import (
+    PydanticSerializationError,
+    SchemaSerializer,
+    SchemaValidator,
+    core_schema,
+    to_json,
+)
 
 from ..conftest import plain_repr
 from .test_dataclasses import IsStrictDict, on_pypy
diff --git a/tests/serializers/test_list_tuple.py b/tests/serializers/test_list_tuple.py
index b4bf1208b..5e8443805 100644
--- a/tests/serializers/test_list_tuple.py
+++ b/tests/serializers/test_list_tuple.py
@@ -4,7 +4,13 @@
 
 import pytest
 
-from pydantic_core import PydanticSerializationError, SchemaError, SchemaSerializer, core_schema, validate_core_schema
+from pydantic_core import (
+    PydanticSerializationError,
+    SchemaError,
+    SchemaSerializer,
+    core_schema,
+    validate_core_schema,
+)
 
 
 def test_list_any():
diff --git a/tests/serializers/test_simple.py b/tests/serializers/test_simple.py
index 19b3b4f55..303c23463 100644
--- a/tests/serializers/test_simple.py
+++ b/tests/serializers/test_simple.py
@@ -3,7 +3,7 @@
 
 import pytest
 
-from pydantic_core import SchemaSerializer, core_schema
+from pydantic_core import CoreConfig, SchemaSerializer, core_schema
 
 try:
     import numpy
@@ -149,15 +149,15 @@ def test_numpy():
         (float('-inf'), 'null', {}),
         (float('nan'), 'null', {}),
         # explicit values of ser_json_inf_nan
-        (float('inf'), 'null', {'ser_json_inf_nan': 'null'}),
-        (float('-inf'), 'null', {'ser_json_inf_nan': 'null'}),
-        (float('nan'), 'null', {'ser_json_inf_nan': 'null'}),
-        (float('inf'), 'Infinity', {'ser_json_inf_nan': 'constants'}),
-        (float('-inf'), '-Infinity', {'ser_json_inf_nan': 'constants'}),
-        (float('nan'), 'NaN', {'ser_json_inf_nan': 'constants'}),
-        (float('inf'), '"Infinity"', {'ser_json_inf_nan': 'strings'}),
-        (float('-inf'), '"-Infinity"', {'ser_json_inf_nan': 'strings'}),
-        (float('nan'), '"NaN"', {'ser_json_inf_nan': 'strings'}),
+        (float('inf'), 'null', CoreConfig(ser_json_inf_nan='null')),
+        (float('-inf'), 'null', CoreConfig(ser_json_inf_nan='null')),
+        (float('nan'), 'null', CoreConfig(ser_json_inf_nan='null')),
+        (float('inf'), 'Infinity', CoreConfig(ser_json_inf_nan='constants')),
+        (float('-inf'), '-Infinity', CoreConfig(ser_json_inf_nan='constants')),
+        (float('nan'), 'NaN', CoreConfig(ser_json_inf_nan='constants')),
+        (float('inf'), '"Infinity"', CoreConfig(ser_json_inf_nan='strings')),
+        (float('-inf'), '"-Infinity"', CoreConfig(ser_json_inf_nan='strings')),
+        (float('nan'), '"NaN"', CoreConfig(ser_json_inf_nan='strings')),
     ],
 )
 def test_float_inf_and_nan_serializers(value, expected_json, config):
diff --git a/tests/test_build.py b/tests/test_build.py
index b81179de1..b20a58530 100644
--- a/tests/test_build.py
+++ b/tests/test_build.py
@@ -28,7 +28,7 @@ def test_build_error_deep():
 
 
 def test_schema_as_string():
-    v = SchemaValidator({'type': 'bool'})
+    v = SchemaValidator(cs.bool_schema())
     assert v.validate_python('tRuE') is True
 
 
@@ -53,7 +53,7 @@ def test_schema_wrong_type(pydantic_version):
 
 @pytest.mark.parametrize('pickle_protocol', range(1, pickle.HIGHEST_PROTOCOL + 1))
 def test_pickle(pickle_protocol: int) -> None:
-    v1 = SchemaValidator({'type': 'bool'})
+    v1 = SchemaValidator(cs.bool_schema())
     assert v1.validate_python('tRuE') is True
     p = pickle.dumps(v1, protocol=pickle_protocol)
     v2 = pickle.loads(p)
@@ -98,7 +98,7 @@ def test_function_no_mode():
 
 def test_try_self_schema_discriminator():
     """Trying to use self-schema when it shouldn't be used"""
-    v = SchemaValidator({'type': 'tagged-union', 'choices': {'int': {'type': 'int'}}, 'discriminator': 'self-schema'})
+    v = SchemaValidator(cs.tagged_union_schema(choices={'int': cs.int_schema()}, discriminator='self-schema'))
     assert 'discriminator: LookupKey' in repr(v)
 
 
diff --git a/tests/test_config.py b/tests/test_config.py
index 8f552c20b..6fff90878 100644
--- a/tests/test_config.py
+++ b/tests/test_config.py
@@ -5,12 +5,13 @@
 from dirty_equals import FunctionCheck, HasAttributes, IsInstance
 
 from pydantic_core import CoreConfig, SchemaValidator, ValidationError
+from pydantic_core import core_schema as cs
 
 from .conftest import Err, plain_repr
 
 
 def test_on_field():
-    v = SchemaValidator({'type': 'str', 'min_length': 2, 'max_length': 5})
+    v = SchemaValidator(cs.str_schema(min_length=2, max_length=5))
     r = plain_repr(v)
     assert 'min_length:Some(2)' in r
     assert 'max_length:Some(5)' in r
@@ -19,14 +20,14 @@ def test_on_field():
 
 
 def test_on_config():
-    v = SchemaValidator({'type': 'str'}, {'str_max_length': 5})
+    v = SchemaValidator(cs.str_schema(), config=CoreConfig(str_max_length=5))
     assert 'max_length:Some(5)' in plain_repr(v)
     assert v.isinstance_python('test') is True
     assert v.isinstance_python('test long') is False
 
 
 def test_field_priority_arg():
-    v = SchemaValidator({'type': 'str', 'max_length': 5}, {'str_max_length': 10})
+    v = SchemaValidator(cs.str_schema(max_length=5), config=CoreConfig(str_max_length=10))
     assert 'max_length:Some(5)' in plain_repr(v)
     assert v.isinstance_python('test') is True
     assert v.isinstance_python('test long') is False
@@ -39,12 +40,11 @@ class MyModel:
 
 def test_on_model_class():
     v = SchemaValidator(
-        {
-            'type': 'model',
-            'cls': MyModel,
-            'config': {'str_max_length': 5},
-            'schema': {'type': 'model-fields', 'fields': {'f': {'type': 'model-field', 'schema': {'type': 'str'}}}},
-        }
+        cs.model_schema(
+            cls=MyModel,
+            config=CoreConfig(str_max_length=5),
+            schema=cs.model_fields_schema(fields={'f': cs.model_field(schema=cs.str_schema())}),
+        )
     )
     assert 'max_length:Some(5)' in plain_repr(v)
     assert v.isinstance_python({'f': 'test'}) is True
@@ -53,15 +53,11 @@ def test_on_model_class():
 
 def test_field_priority_model():
     v = SchemaValidator(
-        {
-            'type': 'model',
-            'cls': MyModel,
-            'config': {'str_max_length': 10},
-            'schema': {
-                'type': 'model-fields',
-                'fields': {'f': {'type': 'model-field', 'schema': {'type': 'str', 'max_length': 5}}},
-            },
-        }
+        cs.model_schema(
+            cls=MyModel,
+            config=CoreConfig(str_max_length=10),
+            schema=cs.model_fields_schema(fields={'f': cs.model_field(schema=cs.str_schema(max_length=5))}),
+        )
     )
     assert 'max_length:Some(5)' in plain_repr(v)
     assert v.isinstance_python({'f': 'test'}) is True
@@ -71,29 +67,34 @@ def test_field_priority_model():
 @pytest.mark.parametrize(
     'config,float_field_schema,input_value,expected',
     [
-        ({}, {'type': 'float'}, {'x': 'nan'}, IsInstance(MyModel) & HasAttributes(x=FunctionCheck(math.isnan))),
         (
-            {'allow_inf_nan': True},
-            {'type': 'float'},
+            CoreConfig(),
+            cs.float_schema(),
             {'x': 'nan'},
             IsInstance(MyModel) & HasAttributes(x=FunctionCheck(math.isnan)),
         ),
         (
-            {'allow_inf_nan': False},
-            {'type': 'float'},
+            CoreConfig(allow_inf_nan=True),
+            cs.float_schema(),
+            {'x': 'nan'},
+            IsInstance(MyModel) & HasAttributes(x=FunctionCheck(math.isnan)),
+        ),
+        (
+            CoreConfig(allow_inf_nan=False),
+            cs.float_schema(),
             {'x': 'nan'},
             Err('Input should be a finite number [type=finite_number,'),
         ),
         # field `allow_inf_nan` (if set) should have priority over global config
         (
-            {'allow_inf_nan': True},
-            {'type': 'float', 'allow_inf_nan': False},
+            CoreConfig(allow_inf_nan=True),
+            cs.float_schema(allow_inf_nan=False),
             {'x': 'nan'},
             Err('Input should be a finite number [type=finite_number,'),
         ),
         (
-            {'allow_inf_nan': False},
-            {'type': 'float', 'allow_inf_nan': True},
+            CoreConfig(allow_inf_nan=False),
+            cs.float_schema(allow_inf_nan=True),
             {'x': 'nan'},
             IsInstance(MyModel) & HasAttributes(x=FunctionCheck(math.isnan)),
         ),
@@ -102,12 +103,11 @@ def test_field_priority_model():
 )
 def test_allow_inf_nan(config: CoreConfig, float_field_schema, input_value, expected):
     v = SchemaValidator(
-        {
-            'type': 'model',
-            'cls': MyModel,
-            'schema': {'type': 'model-fields', 'fields': {'x': {'type': 'model-field', 'schema': float_field_schema}}},
-            'config': config,
-        }
+        cs.model_schema(
+            cls=MyModel,
+            schema=cs.model_fields_schema(fields={'x': cs.model_field(schema=float_field_schema)}),
+            config=config,
+        )
     )
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
@@ -120,19 +120,17 @@ def test_allow_inf_nan(config: CoreConfig, float_field_schema, input_value, expe
 @pytest.mark.parametrize(
     'config,input_str',
     (
-        ({}, 'type=string_type, input_value=123, input_type=int'),
-        ({'hide_input_in_errors': False}, 'type=string_type, input_value=123, input_type=int'),
-        ({'hide_input_in_errors': True}, 'type=string_type'),
+        (CoreConfig(), 'type=string_type, input_value=123, input_type=int'),
+        (CoreConfig(hide_input_in_errors=False), 'type=string_type, input_value=123, input_type=int'),
+        (CoreConfig(hide_input_in_errors=True), 'type=string_type'),
     ),
 )
 def test_hide_input_in_errors(config, input_str):
     v = SchemaValidator(
-        {
-            'type': 'model',
-            'cls': MyModel,
-            'schema': {'type': 'model-fields', 'fields': {'f': {'type': 'model-field', 'schema': {'type': 'str'}}}},
-        },
-        config,
+        cs.model_schema(
+            cls=MyModel, schema=cs.model_fields_schema(fields={'f': cs.model_field(schema=cs.str_schema())})
+        ),
+        config=config,
     )
 
     with pytest.raises(ValidationError, match=re.escape(f'Input should be a valid string [{input_str}]')):
@@ -140,14 +138,14 @@ def test_hide_input_in_errors(config, input_str):
 
 
 def test_cache_strings():
-    v = SchemaValidator({'type': 'str'})
+    v = SchemaValidator(cs.str_schema())
     assert 'cache_strings=True' in plain_repr(v)
 
-    v = SchemaValidator({'type': 'str'}, {'cache_strings': True})
+    v = SchemaValidator(cs.str_schema(), config=CoreConfig(cache_strings=True))
     assert 'cache_strings=True' in plain_repr(v)
 
-    v = SchemaValidator({'type': 'str'}, {'cache_strings': False})
+    v = SchemaValidator(cs.str_schema(), config=CoreConfig(cache_strings=False))
     assert 'cache_strings=False' in plain_repr(v)
 
-    v = SchemaValidator({'type': 'str'}, {'cache_strings': 'keys'})
+    v = SchemaValidator(cs.str_schema(), config=CoreConfig(cache_strings='keys'))
     assert "cache_strings='keys'" in plain_repr(v)
diff --git a/tests/test_errors.py b/tests/test_errors.py
index 550f94e3d..ad18a41c8 100644
--- a/tests/test_errors.py
+++ b/tests/test_errors.py
@@ -539,7 +539,7 @@ def test_all_errors():
 
 @pytest.mark.skipif(sys.version_info < (3, 11), reason='This is the modern version used post 3.10.')
 def test_validation_error_cause_contents():
-    enabled_config: CoreConfig = {'validation_error_cause': True}
+    enabled_config: CoreConfig = CoreConfig(validation_error_cause=True)
 
     def multi_raise_py_error(v: Any) -> Any:
         try:
@@ -605,7 +605,7 @@ def outer_raise_py_error(v: Any) -> Any:
 def test_validation_error_cause_contents_legacy():
     from exceptiongroup import BaseExceptionGroup
 
-    enabled_config: CoreConfig = {'validation_error_cause': True}
+    enabled_config: CoreConfig = CoreConfig(validation_error_cause=True)
 
     def multi_raise_py_error(v: Any) -> Any:
         try:
@@ -683,10 +683,10 @@ class CauseResult(enum.Enum):
     [  # Without the backport should still work after 3.10 as not needed:
         (
             'Enabled',
-            {'validation_error_cause': True},
+            CoreConfig(validation_error_cause=True),
             CauseResult.CAUSE if sys.version_info >= (3, 11) else CauseResult.IMPORT_ERROR,
         ),
-        ('Disabled specifically', {'validation_error_cause': False}, CauseResult.NO_CAUSE),
+        ('Disabled specifically', CoreConfig(validation_error_cause=False), CauseResult.NO_CAUSE),
         ('Disabled implicitly', {}, CauseResult.NO_CAUSE),
     ],
 )
@@ -721,7 +721,7 @@ def singular_raise_py_error(v: Any) -> Any:
 def test_validation_error_cause_traceback_preserved():
     """Makes sure historic bug of traceback being lost is fixed."""
 
-    enabled_config: CoreConfig = {'validation_error_cause': True}
+    enabled_config: CoreConfig = CoreConfig(validation_error_cause=True)
 
     def singular_raise_py_error(v: Any) -> Any:
         raise ValueError('Oh no!')
@@ -749,7 +749,7 @@ def __repr__(self):
 
 
 def test_error_on_repr(pydantic_version):
-    s = SchemaValidator({'type': 'int'})
+    s = SchemaValidator(core_schema.int_schema())
     with pytest.raises(ValidationError) as exc_info:
         s.validate_python(BadRepr())
 
@@ -775,7 +775,7 @@ def test_error_on_repr(pydantic_version):
 
 
 def test_error_json(pydantic_version):
-    s = SchemaValidator({'type': 'str', 'min_length': 3})
+    s = SchemaValidator(core_schema.str_schema(min_length=3))
     with pytest.raises(ValidationError) as exc_info:
         s.validate_python('12')
 
@@ -853,7 +853,7 @@ def raise_py_error(v: Any) -> Any:
 
 
 def test_error_json_cycle():
-    s = SchemaValidator({'type': 'str', 'min_length': 3})
+    s = SchemaValidator(core_schema.str_schema(min_length=3))
     cycle = []
     cycle.append(cycle)
     msg = '[type=string_type, input_value=[[...]], input_type=list]'
@@ -875,7 +875,7 @@ def __str__(self):
 
 
 def test_error_json_unknown():
-    s = SchemaValidator({'type': 'str'})
+    s = SchemaValidator(core_schema.str_schema())
     with pytest.raises(ValidationError) as exc_info:
         s.validate_python(Foobar())
 
@@ -1089,7 +1089,7 @@ def test_loc_with_dots(pydantic_version):
 
 
 def test_hide_input_in_error() -> None:
-    s = SchemaValidator({'type': 'int'})
+    s = SchemaValidator(core_schema.int_schema())
     with pytest.raises(ValidationError) as exc_info:
         s.validate_python('definitely not an int')
 
@@ -1098,7 +1098,7 @@ def test_hide_input_in_error() -> None:
 
 
 def test_hide_input_in_json() -> None:
-    s = SchemaValidator({'type': 'int'})
+    s = SchemaValidator(core_schema.int_schema())
     with pytest.raises(ValidationError) as exc_info:
         s.validate_python('definitely not an int')
 
@@ -1111,7 +1111,7 @@ def test_hide_input_in_json() -> None:
     reason='PyPy before 3.9 cannot pickle this correctly',
 )
 def test_validation_error_pickle() -> None:
-    s = SchemaValidator({'type': 'int'})
+    s = SchemaValidator(core_schema.int_schema())
     with pytest.raises(ValidationError) as exc_info:
         s.validate_python('definitely not an int')
 
@@ -1122,7 +1122,7 @@ def test_validation_error_pickle() -> None:
 
 @pytest.mark.skipif('PYDANTIC_ERRORS_INCLUDE_URL' in os.environ, reason="can't test when envvar is set")
 def test_errors_include_url() -> None:
-    s = SchemaValidator({'type': 'int'})
+    s = SchemaValidator(core_schema.int_schema())
     with pytest.raises(ValidationError) as exc_info:
         s.validate_python('definitely not an int')
     assert 'https://errors.pydantic.dev' in repr(exc_info.value)
@@ -1149,7 +1149,7 @@ def test_errors_include_url_envvar(env_var, env_var_value, expected_to_have_url)
     Since it can only be set before `ValidationError.__repr__()` is first called,
     we need to spawn a subprocess to test it.
     """
-    code = "import pydantic_core; pydantic_core.SchemaValidator({'type': 'int'}).validate_python('ooo')"
+    code = "import pydantic_core; from pydantic_core import core_schema; pydantic_core.SchemaValidator(core_schema.int_schema()).validate_python('ooo')"
     env = os.environ.copy()
     env.pop('PYDANTIC_ERRORS_OMIT_URL', None)  # in case the ambient environment has it set
     if env_var_value is not None:
diff --git a/tests/test_garbage_collection.py b/tests/test_garbage_collection.py
index 512e480c5..2213f7cfb 100644
--- a/tests/test_garbage_collection.py
+++ b/tests/test_garbage_collection.py
@@ -57,7 +57,7 @@ class BaseModel:
 
         def __init_subclass__(cls) -> None:
             cls.__validator__ = SchemaValidator(
-                core_schema.model_schema(cls, GC_TEST_SCHEMA_INNER),
+                schema=core_schema.model_schema(cls, GC_TEST_SCHEMA_INNER),
                 config=core_schema.CoreConfig(extra_fields_behavior='allow'),
             )
 
@@ -89,7 +89,7 @@ class MyModel:
             core_schema.model_fields_schema(
                 {'iter': core_schema.model_field(core_schema.generator_schema(core_schema.int_schema()))}
             ),
-        ),
+        )
     )
 
     class MyIterable:
diff --git a/tests/test_hypothesis.py b/tests/test_hypothesis.py
index 51674f620..5a24d6808 100644
--- a/tests/test_hypothesis.py
+++ b/tests/test_hypothesis.py
@@ -15,7 +15,7 @@
 
 @pytest.fixture(scope='module')
 def datetime_schema():
-    return SchemaValidator({'type': 'datetime'})
+    return SchemaValidator(cs.datetime_schema())
 
 
 @given(strategies.datetimes())
@@ -137,7 +137,7 @@ def test_definition_broken(definition_schema):
 @given(strategies.timedeltas())
 @pytest.mark.thread_unsafe  # https://github.com/Quansight-Labs/pytest-run-parallel/issues/20
 def test_pytimedelta_as_timedelta(dt):
-    v = SchemaValidator({'type': 'timedelta', 'gt': dt})
+    v = SchemaValidator(cs.timedelta_schema(gt=dt))
     # simplest way to check `pytimedelta_as_timedelta` is correct is to extract duration from repr of the validator
     m = re.search(r'Duration ?\{\s+positive: ?(\w+),\s+day: ?(\d+),\s+second: ?(\d+),\s+microsecond: ?(\d+)', repr(v))
     pos, day, sec, micro = m.groups()
@@ -148,7 +148,7 @@ def test_pytimedelta_as_timedelta(dt):
 
 @pytest.fixture(scope='module')
 def url_validator():
-    return SchemaValidator({'type': 'url'})
+    return SchemaValidator(cs.url_schema())
 
 
 # Parsing errors which hypothesis is likely to hit
@@ -169,7 +169,7 @@ def test_urls_text(url_validator, text):
 
 @pytest.fixture(scope='module')
 def multi_host_url_validator():
-    return SchemaValidator({'type': 'multi-host-url'})
+    return SchemaValidator(cs.multi_host_url_schema())
 
 
 @given(strategies.text())
diff --git a/tests/test_isinstance.py b/tests/test_isinstance.py
index 38b6f0160..8368e36e8 100644
--- a/tests/test_isinstance.py
+++ b/tests/test_isinstance.py
@@ -1,12 +1,13 @@
 import pytest
 
 from pydantic_core import PydanticOmit, SchemaError, SchemaValidator, ValidationError, core_schema
+from pydantic_core import core_schema as cs
 
 from .conftest import PyAndJson
 
 
 def test_isinstance():
-    v = SchemaValidator({'type': 'int'})
+    v = SchemaValidator(cs.int_schema())
     assert v.validate_python(123) == 123
     assert v.isinstance_python(123) is True
     assert v.validate_python('123') == 123
@@ -19,7 +20,7 @@ def test_isinstance():
 
 
 def test_isinstance_strict():
-    v = SchemaValidator({'type': 'int', 'strict': True})
+    v = SchemaValidator(cs.int_schema(strict=True))
     assert v.validate_python(123) == 123
     assert v.isinstance_python(123) is True
 
@@ -31,11 +32,7 @@ def test_isinstance_strict():
 
 def test_internal_error():
     v = SchemaValidator(
-        {
-            'type': 'model',
-            'cls': int,
-            'schema': {'type': 'model-fields', 'fields': {'f': {'type': 'model-field', 'schema': {'type': 'int'}}}},
-        }
+        cs.model_schema(cls=int, schema=cs.model_fields_schema(fields={'f': cs.model_field(schema=cs.int_schema())}))
     )
     with pytest.raises(AttributeError, match="'int' object has no attribute '__dict__'"):
         v.validate_python({'f': 123})
diff --git a/tests/test_json.py b/tests/test_json.py
index dfa3597e1..6b365a4cb 100644
--- a/tests/test_json.py
+++ b/tests/test_json.py
@@ -7,6 +7,7 @@
 
 import pydantic_core
 from pydantic_core import (
+    CoreConfig,
     PydanticSerializationError,
     SchemaSerializer,
     SchemaValidator,
@@ -25,28 +26,28 @@
     [('false', False), ('true', True), ('0', False), ('1', True), ('"yes"', True), ('"no"', False)],
 )
 def test_bool(input_value, output_value):
-    v = SchemaValidator({'type': 'bool'})
+    v = SchemaValidator(core_schema.bool_schema())
     assert v.validate_json(input_value) == output_value
 
 
 @pytest.mark.parametrize('input_value', ['[1, 2, 3]', b'[1, 2, 3]', bytearray(b'[1, 2, 3]')])
 def test_input_types(input_value):
-    v = SchemaValidator({'type': 'list', 'items_schema': {'type': 'int'}})
+    v = SchemaValidator(core_schema.list_schema(items_schema=core_schema.int_schema()))
     assert v.validate_json(input_value) == [1, 2, 3]
 
 
 def test_input_type_invalid():
-    v = SchemaValidator({'type': 'list', 'items_schema': {'type': 'int'}})
+    v = SchemaValidator(core_schema.list_schema(items_schema=core_schema.int_schema()))
     with pytest.raises(ValidationError, match=r'JSON input should be string, bytes or bytearray \[type=json_type,'):
         v.validate_json([])
 
 
 def test_null():
-    assert SchemaValidator({'type': 'none'}).validate_json('null') is None
+    assert SchemaValidator(core_schema.none_schema()).validate_json('null') is None
 
 
 def test_str():
-    s = SchemaValidator({'type': 'str'})
+    s = SchemaValidator(core_schema.str_schema())
     assert s.validate_json('"foobar"') == 'foobar'
     with pytest.raises(ValidationError, match=r'Input should be a valid string \[type=string_type,'):
         s.validate_json('false')
@@ -55,7 +56,7 @@ def test_str():
 
 
 def test_bytes():
-    s = SchemaValidator({'type': 'bytes'})
+    s = SchemaValidator(core_schema.bytes_schema())
     assert s.validate_json('"foobar"') == b'foobar'
     with pytest.raises(ValidationError, match=r'Input should be a valid bytes \[type=bytes_type,'):
         s.validate_json('false')
@@ -81,7 +82,7 @@ def test_bytes():
     ],
 )
 def test_int(input_value, expected):
-    v = SchemaValidator({'type': 'int'})
+    v = SchemaValidator(core_schema.int_schema())
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_json(input_value)
@@ -102,7 +103,7 @@ def test_int(input_value, expected):
     ],
 )
 def test_float(input_value, expected):
-    v = SchemaValidator({'type': 'float'})
+    v = SchemaValidator(core_schema.float_schema())
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_json(input_value)
@@ -112,13 +113,12 @@ def test_float(input_value, expected):
 
 def test_typed_dict():
     v = SchemaValidator(
-        {
-            'type': 'typed-dict',
-            'fields': {
-                'field_a': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
-                'field_b': {'type': 'typed-dict-field', 'schema': {'type': 'int'}},
-            },
-        }
+        core_schema.typed_dict_schema(
+            fields={
+                'field_a': core_schema.typed_dict_field(schema=core_schema.str_schema()),
+                'field_b': core_schema.typed_dict_field(schema=core_schema.int_schema()),
+            }
+        )
     )
 
     # language=json
@@ -131,20 +131,21 @@ def test_typed_dict():
 
 
 def test_float_no_remainder():
-    v = SchemaValidator({'type': 'int'})
+    v = SchemaValidator(core_schema.int_schema())
     assert v.validate_json('123.0') == 123
 
 
 def test_error_loc():
     v = SchemaValidator(
-        {
-            'type': 'typed-dict',
-            'fields': {
-                'field_a': {'type': 'typed-dict-field', 'schema': {'type': 'list', 'items_schema': {'type': 'int'}}}
+        core_schema.typed_dict_schema(
+            fields={
+                'field_a': core_schema.typed_dict_field(
+                    schema=core_schema.list_schema(items_schema=core_schema.int_schema())
+                )
             },
-            'extras_schema': {'type': 'int'},
-            'extra_behavior': 'allow',
-        }
+            extras_schema=core_schema.int_schema(),
+            extra_behavior='allow',
+        )
     )
 
     # assert v.validate_json('{"field_a": [1, 2, "3"]}') == ({'field_a': [1, 2, 3]}, {'field_a'})
@@ -162,7 +163,9 @@ def test_error_loc():
 
 
 def test_dict():
-    v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'int'}, 'values_schema': {'type': 'int'}})
+    v = SchemaValidator(
+        core_schema.dict_schema(keys_schema=core_schema.int_schema(), values_schema=core_schema.int_schema())
+    )
     assert v.validate_json('{"1": 2, "3": 4}') == {1: 2, 3: 4}
 
     # duplicate keys, the last value wins, like with python
@@ -171,12 +174,12 @@ def test_dict():
 
 
 def test_dict_any_value():
-    v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'str'}})
+    v = SchemaValidator(core_schema.dict_schema(keys_schema=core_schema.str_schema()))
     assert v.validate_json('{"1": 1, "2": "a", "3": null}') == {'1': 1, '2': 'a', '3': None}
 
 
 def test_json_invalid():
-    v = SchemaValidator({'type': 'bool'})
+    v = SchemaValidator(core_schema.bool_schema())
 
     with pytest.raises(ValidationError) as exc_info:
         v.validate_json('"foobar')
@@ -383,7 +386,7 @@ def test_json_bytes_base64_round_trip():
     encoded_url = b'"2AfBVHgkkUYl8_NJythADO7Dq_9_083N-cIQ5KGwMWU="'
     assert to_json(data, bytes_mode='base64') == encoded_url
 
-    v = SchemaValidator({'type': 'bytes'}, {'val_json_bytes': 'base64'})
+    v = SchemaValidator(core_schema.bytes_schema(), config=CoreConfig(val_json_bytes='base64'))
     assert v.validate_json(encoded_url) == data
     assert v.validate_json(encoded_std) == data
 
@@ -394,20 +397,20 @@ def test_json_bytes_base64_round_trip():
 
     assert to_json({'key': data}, bytes_mode='base64') == b'{"key":' + encoded_url + b'}'
     v = SchemaValidator(
-        {'type': 'dict', 'keys_schema': {'type': 'str'}, 'values_schema': {'type': 'bytes'}},
-        {'val_json_bytes': 'base64'},
+        core_schema.dict_schema(keys_schema=core_schema.str_schema(), values_schema=core_schema.bytes_schema()),
+        config=CoreConfig(val_json_bytes='base64'),
     )
     assert v.validate_json(b'{"key":' + encoded_url + b'}') == {'key': data}
 
 
 def test_json_bytes_base64_no_padding():
-    v = SchemaValidator({'type': 'bytes'}, {'val_json_bytes': 'base64'})
+    v = SchemaValidator(core_schema.bytes_schema(), config=CoreConfig(val_json_bytes='base64'))
     base_64_without_padding = 'bm8tcGFkZGluZw'
     assert v.validate_json(json.dumps(base_64_without_padding)) == b'no-padding'
 
 
 def test_json_bytes_base64_invalid():
-    v = SchemaValidator({'type': 'bytes'}, {'val_json_bytes': 'base64'})
+    v = SchemaValidator(core_schema.bytes_schema(), config=CoreConfig(val_json_bytes='base64'))
     wrong_input = 'wrong!'
     with pytest.raises(ValidationError) as exc_info:
         v.validate_json(json.dumps(wrong_input))
@@ -426,19 +429,19 @@ def test_json_bytes_hex_round_trip():
     encoded = b'"68656c6c6f"'
     assert to_json(data, bytes_mode='hex') == encoded
 
-    v = SchemaValidator({'type': 'bytes'}, {'val_json_bytes': 'hex'})
+    v = SchemaValidator(core_schema.bytes_schema(), config=CoreConfig(val_json_bytes='hex'))
     assert v.validate_json(encoded) == data
 
     assert to_json({'key': data}, bytes_mode='hex') == b'{"key":"68656c6c6f"}'
     v = SchemaValidator(
-        {'type': 'dict', 'keys_schema': {'type': 'str'}, 'values_schema': {'type': 'bytes'}},
-        {'val_json_bytes': 'hex'},
+        core_schema.dict_schema(keys_schema=core_schema.str_schema(), values_schema=core_schema.bytes_schema()),
+        config=CoreConfig(val_json_bytes='hex'),
     )
     assert v.validate_json('{"key":"68656c6c6f"}') == {'key': data}
 
 
 def test_json_bytes_hex_invalid():
-    v = SchemaValidator({'type': 'bytes'}, {'val_json_bytes': 'hex'})
+    v = SchemaValidator(core_schema.bytes_schema(), config=CoreConfig(val_json_bytes='hex'))
 
     wrong_input = 'a'
     with pytest.raises(ValidationError) as exc_info:
diff --git a/tests/test_misc.py b/tests/test_misc.py
index 806c4cca9..50162c24b 100644
--- a/tests/test_misc.py
+++ b/tests/test_misc.py
@@ -5,7 +5,7 @@
 import pytest
 from typing_extensions import get_args
 
-from pydantic_core import CoreSchema, CoreSchemaType, PydanticUndefined, core_schema
+from pydantic_core import CoreConfig, CoreSchema, CoreSchemaType, PydanticUndefined, core_schema
 from pydantic_core._pydantic_core import (
     SchemaError,
     SchemaValidator,
@@ -42,7 +42,7 @@ def test_schema_error():
 
 
 def test_validation_error(pydantic_version):
-    v = SchemaValidator({'type': 'int'})
+    v = SchemaValidator(core_schema.int_schema())
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python(1.5)
 
@@ -73,7 +73,7 @@ def test_validation_error(pydantic_version):
 
 
 def test_validation_error_include_context():
-    v = SchemaValidator({'type': 'list', 'max_length': 2})
+    v = SchemaValidator(core_schema.list_schema(max_length=2))
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python([1, 2, 3])
 
@@ -101,7 +101,7 @@ def test_validation_error_include_context():
 
 
 def test_custom_title():
-    v = SchemaValidator({'type': 'int'}, {'title': 'MyInt'})
+    v = SchemaValidator(core_schema.int_schema(), config=CoreConfig(title='MyInt'))
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python(1.5)
 
@@ -116,17 +116,15 @@ class MyModel:
         field_b: int
 
     v = SchemaValidator(
-        {
-            'type': 'model',
-            'cls': MyModel,
-            'schema': {
-                'type': 'model-fields',
-                'fields': {
-                    'x': {'type': 'model-field', 'schema': {'type': 'float'}},
-                    'y': {'type': 'model-field', 'schema': {'type': 'int'}},
-                },
-            },
-        }
+        core_schema.model_schema(
+            cls=MyModel,
+            schema=core_schema.model_fields_schema(
+                fields={
+                    'x': core_schema.model_field(schema=core_schema.float_schema()),
+                    'y': core_schema.model_field(schema=core_schema.int_schema()),
+                }
+            ),
+        )
     )
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python({'x': 'x' * 60, 'y': 'y'})
@@ -193,9 +191,7 @@ def test_undefined():
 def test_unicode_error_input_repr() -> None:
     """https://github.com/pydantic/pydantic/issues/6448"""
 
-    schema = core_schema.int_schema()
-
-    validator = SchemaValidator(schema)
+    validator = SchemaValidator(core_schema.int_schema())
 
     danger_str = 'ÿ' * 1000
     expected = "1 validation error for int\n  Input should be a valid integer, unable to parse string as an integer [type=int_parsing, input_value='ÿÿÿÿÿÿÿÿÿÿÿÿ...ÿÿÿÿÿÿÿÿÿÿÿ', input_type=str]"
diff --git a/tests/validators/test_allow_partial.py b/tests/validators/test_allow_partial.py
index 6880283a8..297727572 100644
--- a/tests/validators/test_allow_partial.py
+++ b/tests/validators/test_allow_partial.py
@@ -263,7 +263,7 @@ def test_tuple_list():
     v = SchemaValidator(
         core_schema.tuple_positional_schema(
             [core_schema.list_schema(core_schema.int_schema()), core_schema.int_schema()]
-        ),
+        )
     )
     assert v.validate_python([['1', '2'], '3'], allow_partial=True) == snapshot(([1, 2], 3))
     with pytest.raises(ValidationError, match=r'1\s+Input should be a valid integer'):
diff --git a/tests/validators/test_arguments.py b/tests/validators/test_arguments.py
index 1fb17dcee..496363a1f 100644
--- a/tests/validators/test_arguments.py
+++ b/tests/validators/test_arguments.py
@@ -7,6 +7,7 @@
 import pytest
 
 from pydantic_core import ArgsKwargs, SchemaError, SchemaValidator, ValidationError, core_schema
+from pydantic_core import core_schema as cs
 
 from ..conftest import Err, PyAndJson, plain_repr
 
@@ -737,17 +738,16 @@ def test_default_factory(py_and_json: PyAndJson, input_value, expected):
 
 def test_repr():
     v = SchemaValidator(
-        {
-            'type': 'arguments',
-            'arguments_schema': [
-                {'name': 'b', 'mode': 'positional_or_keyword', 'schema': {'type': 'int'}},
+        cs.arguments_schema(
+            arguments=[
+                {'name': 'b', 'mode': 'positional_or_keyword', 'schema': cs.int_schema()},
                 {
                     'name': 'a',
                     'mode': 'keyword_only',
-                    'schema': {'type': 'default', 'schema': {'type': 'int'}, 'default_factory': lambda: 42},
+                    'schema': cs.with_default_schema(schema=cs.int_schema(), default_factory=lambda: 42),
                 },
-            ],
-        }
+            ]
+        )
     )
     assert 'positional_params_count:1,' in plain_repr(v)
 
@@ -755,17 +755,16 @@ def test_repr():
 def test_build_non_default_follows():
     with pytest.raises(SchemaError, match="Non-default argument 'b' follows default argument"):
         SchemaValidator(
-            {
-                'type': 'arguments',
-                'arguments_schema': [
+            schema=cs.arguments_schema(
+                arguments=[
                     {
                         'name': 'a',
                         'mode': 'positional_or_keyword',
-                        'schema': {'type': 'default', 'schema': {'type': 'int'}, 'default_factory': lambda: 42},
+                        'schema': cs.with_default_schema(schema=cs.int_schema(), default_factory=lambda: 42),
                     },
-                    {'name': 'b', 'mode': 'positional_or_keyword', 'schema': {'type': 'int'}},
-                ],
-            }
+                    {'name': 'b', 'mode': 'positional_or_keyword', 'schema': cs.int_schema()},
+                ]
+            )
         )
 
 
@@ -773,13 +772,7 @@ def test_build_missing_var_kwargs():
     with pytest.raises(
         SchemaError, match="`var_kwargs_schema` must be specified when `var_kwargs_mode` is `'unpacked-typed-dict'`"
     ):
-        SchemaValidator(
-            {
-                'type': 'arguments',
-                'arguments_schema': [],
-                'var_kwargs_mode': 'unpacked-typed-dict',
-            }
-        )
+        SchemaValidator(cs.arguments_schema(arguments=[], var_kwargs_mode='unpacked-typed-dict'))
 
 
 @pytest.mark.parametrize(
@@ -1104,21 +1097,15 @@ def foobar(*args, **kwargs):
 def test_invalid_schema():
     with pytest.raises(SchemaError, match="'default' and 'default_factory' cannot be used together"):
         SchemaValidator(
-            {
-                'type': 'arguments',
-                'arguments_schema': [
+            schema=cs.arguments_schema(
+                arguments=[
                     {
                         'name': 'a',
                         'mode': 'positional_or_keyword',
-                        'schema': {
-                            'type': 'default',
-                            'schema': {'type': 'int'},
-                            'default': 1,
-                            'default_factory': lambda: 2,
-                        },
+                        'schema': cs.with_default_schema(schema=cs.int_schema(), default=1, default_factory=lambda: 2),
                     }
-                ],
-            }
+                ]
+            )
         )
 
 
diff --git a/tests/validators/test_bool.py b/tests/validators/test_bool.py
index 88f30add4..e151b8e85 100644
--- a/tests/validators/test_bool.py
+++ b/tests/validators/test_bool.py
@@ -3,6 +3,7 @@
 import pytest
 
 from pydantic_core import SchemaValidator, ValidationError, core_schema
+from pydantic_core import core_schema as cs
 
 from ..conftest import Err, PyAndJson, plain_repr
 
@@ -54,7 +55,7 @@ def test_bool_strict(py_and_json: PyAndJson):
 
 
 def test_bool_error(pydantic_version):
-    v = SchemaValidator({'type': 'bool'})
+    v = SchemaValidator(cs.bool_schema())
 
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python('wrong')
@@ -76,12 +77,12 @@ def test_bool_error(pydantic_version):
 
 
 def test_bool_repr():
-    v = SchemaValidator({'type': 'bool'})
+    v = SchemaValidator(cs.bool_schema())
     assert (
         plain_repr(v)
         == 'SchemaValidator(title="bool",validator=Bool(BoolValidator{strict:false}),definitions=[],cache_strings=True)'
     )
-    v = SchemaValidator({'type': 'bool', 'strict': True})
+    v = SchemaValidator(cs.bool_schema(strict=True))
     assert (
         plain_repr(v)
         == 'SchemaValidator(title="bool",validator=Bool(BoolValidator{strict:true}),definitions=[],cache_strings=True)'
diff --git a/tests/validators/test_bytes.py b/tests/validators/test_bytes.py
index 8b9e6318b..1110a34d3 100644
--- a/tests/validators/test_bytes.py
+++ b/tests/validators/test_bytes.py
@@ -4,12 +4,13 @@
 import pytest
 
 from pydantic_core import SchemaValidator, ValidationError
+from pydantic_core import core_schema as cs
 
 from ..conftest import Err, PyAndJson
 
 
 def test_strict_bytes_validator():
-    v = SchemaValidator({'type': 'bytes', 'strict': True})
+    v = SchemaValidator(cs.bytes_schema(strict=True))
 
     assert v.validate_python(b'foo') == b'foo'
     assert v.validate_json('"foo"') == b'foo'
@@ -21,7 +22,7 @@ def test_strict_bytes_validator():
 
 
 def test_lax_bytes_validator():
-    v = SchemaValidator({'type': 'bytes'})
+    v = SchemaValidator(cs.bytes_schema())
 
     assert v.validate_python(b'foo') == b'foo'
     assert v.validate_python('foo') == b'foo'
@@ -56,7 +57,7 @@ def test_lax_bytes_validator():
     ],
 )
 def test_constrained_bytes_python_bytes(opts: dict[str, Any], input, expected):
-    v = SchemaValidator({'type': 'bytes', **opts})
+    v = SchemaValidator(cs.bytes_schema(**opts))
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input)
@@ -90,13 +91,13 @@ def test_constrained_bytes(py_and_json: PyAndJson, opts: dict[str, Any], input,
 
 
 def test_union():
-    v = SchemaValidator({'type': 'union', 'choices': [{'type': 'str'}, {'type': 'bytes'}], 'strict': True})
+    v = SchemaValidator(cs.union_schema(choices=[cs.str_schema(), cs.bytes_schema()], strict=True))
     assert v.validate_python('oh, a string') == 'oh, a string'
     assert v.validate_python(b'oh, bytes') == b'oh, bytes'
 
 
 def test_length_ctx():
-    v = SchemaValidator({'type': 'bytes', 'min_length': 2, 'max_length': 3})
+    v = SchemaValidator(cs.bytes_schema(min_length=2, max_length=3))
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python(b'1')
     assert exc_info.value.errors(include_url=False) == [
diff --git a/tests/validators/test_call.py b/tests/validators/test_call.py
index 55964a754..eb25f1325 100644
--- a/tests/validators/test_call.py
+++ b/tests/validators/test_call.py
@@ -6,6 +6,7 @@
 import pytest
 
 from pydantic_core import ArgsKwargs, SchemaValidator, ValidationError
+from pydantic_core import core_schema as cs
 
 from ..conftest import Err, PyAndJson, plain_repr
 
@@ -68,9 +69,7 @@ def test_function_args_any(input_value, expected):
     def my_function(a, b, c):
         return a + b + c
 
-    v = SchemaValidator(
-        {'type': 'call', 'function': my_function, 'arguments_schema': {'type': 'any'}, 'return_schema': {'type': 'int'}}
-    )
+    v = SchemaValidator(cs.call_schema(function=my_function, arguments=cs.any_schema(), return_schema=cs.int_schema()))
 
     if isinstance(expected, Exception):
         with pytest.raises(type(expected), match=re.escape(str(expected))):
@@ -84,7 +83,7 @@ def test_function_return_any(input_value, expected):
     def my_function(a):
         return a
 
-    v = SchemaValidator({'type': 'call', 'function': my_function, 'arguments_schema': {'type': 'any'}})
+    v = SchemaValidator(cs.call_schema(function=my_function, arguments=cs.any_schema()))
     assert 'name:"call[my_function]"' in plain_repr(v)
 
     assert v.validate_python(input_value) == expected
@@ -95,20 +94,17 @@ def my_function(a):
         return a
 
     v = SchemaValidator(
-        {
-            'type': 'union',
-            'choices': [
-                {
-                    'type': 'call',
-                    'function': my_function,
-                    'arguments_schema': {
-                        'type': 'arguments',
-                        'arguments_schema': [{'name': 'a', 'mode': 'positional_or_keyword', 'schema': {'type': 'int'}}],
-                    },
-                },
-                {'type': 'int'},
-            ],
-        }
+        cs.union_schema(
+            choices=[
+                cs.call_schema(
+                    function=my_function,
+                    arguments=cs.arguments_schema(
+                        arguments=[{'name': 'a', 'mode': 'positional_or_keyword', 'schema': cs.int_schema()}]
+                    ),
+                ),
+                cs.int_schema(),
+            ]
+        )
     )
     assert v.validate_python((1,)) == 1
     with pytest.raises(ValidationError) as exc_info:
@@ -131,17 +127,15 @@ class my_dataclass:
         b: str
 
     v = SchemaValidator(
-        {
-            'type': 'call',
-            'function': my_dataclass,
-            'arguments_schema': {
-                'type': 'arguments',
-                'arguments_schema': [
-                    {'name': 'a', 'mode': 'positional_or_keyword', 'schema': {'type': 'int'}},
-                    {'name': 'b', 'mode': 'positional_or_keyword', 'schema': {'type': 'str'}},
-                ],
-            },
-        }
+        cs.call_schema(
+            function=my_dataclass,
+            arguments=cs.arguments_schema(
+                arguments=[
+                    {'name': 'a', 'mode': 'positional_or_keyword', 'schema': cs.int_schema()},
+                    {'name': 'b', 'mode': 'positional_or_keyword', 'schema': cs.str_schema()},
+                ]
+            ),
+        )
     )
     d = v.validate_python(('1', b'2'))
     assert dataclasses.is_dataclass(d)
@@ -158,17 +152,15 @@ def test_named_tuple():
     Point = namedtuple('Point', ['x', 'y'])
 
     v = SchemaValidator(
-        {
-            'type': 'call',
-            'function': Point,
-            'arguments_schema': {
-                'type': 'arguments',
-                'arguments_schema': [
-                    {'name': 'x', 'mode': 'positional_or_keyword', 'schema': {'type': 'float'}},
-                    {'name': 'y', 'mode': 'positional_or_keyword', 'schema': {'type': 'float'}},
-                ],
-            },
-        }
+        cs.call_schema(
+            function=Point,
+            arguments=cs.arguments_schema(
+                arguments=[
+                    {'name': 'x', 'mode': 'positional_or_keyword', 'schema': cs.float_schema()},
+                    {'name': 'y', 'mode': 'positional_or_keyword', 'schema': cs.float_schema()},
+                ]
+            ),
+        )
     )
     d = v.validate_python(('1.1', '2.2'))
     assert isinstance(d, Point)
@@ -186,17 +178,15 @@ def my_function(a, b, c):
         return a + b + c
 
     v = SchemaValidator(
-        {
-            'type': 'call',
-            'function': partial(my_function, c=3),
-            'arguments_schema': {
-                'type': 'arguments',
-                'arguments_schema': [
-                    {'name': 'a', 'mode': 'positional_or_keyword', 'schema': {'type': 'int'}},
-                    {'name': 'b', 'mode': 'positional_or_keyword', 'schema': {'type': 'int'}},
-                ],
-            },
-        }
+        cs.call_schema(
+            function=partial(my_function, c=3),
+            arguments=cs.arguments_schema(
+                arguments=[
+                    {'name': 'a', 'mode': 'positional_or_keyword', 'schema': cs.int_schema()},
+                    {'name': 'b', 'mode': 'positional_or_keyword', 'schema': cs.int_schema()},
+                ]
+            ),
+        )
     )
     assert 'name:"call[my_function]"' in plain_repr(v)
     assert v.validate_python((1, 2)) == 6
@@ -208,15 +198,13 @@ def my_function(a):
         return a
 
     v = SchemaValidator(
-        {
-            'type': 'call',
-            'function': my_function,
-            'function_name': 'foobar',
-            'arguments_schema': {
-                'type': 'arguments',
-                'arguments_schema': [{'name': 'a', 'mode': 'positional_or_keyword', 'schema': {'type': 'int'}}],
-            },
-        }
+        cs.call_schema(
+            function=my_function,
+            function_name='foobar',
+            arguments=cs.arguments_schema(
+                arguments=[{'name': 'a', 'mode': 'positional_or_keyword', 'schema': cs.int_schema()}]
+            ),
+        )
     )
     assert 'name:"call[foobar]"' in plain_repr(v)
     assert v.validate_python((1,)) == 1
diff --git a/tests/validators/test_callable.py b/tests/validators/test_callable.py
index 62765b0ce..f8ef8bcaf 100644
--- a/tests/validators/test_callable.py
+++ b/tests/validators/test_callable.py
@@ -1,6 +1,7 @@
 import pytest
 
 from pydantic_core import SchemaValidator, ValidationError
+from pydantic_core import core_schema as cs
 
 
 def func():
@@ -17,7 +18,7 @@ def __call__(self, *args, **kwargs):
 
 
 def test_callable():
-    v = SchemaValidator({'type': 'callable'})
+    v = SchemaValidator(cs.callable_schema())
     assert v.validate_python(func) == func
     assert v.isinstance_python(func) is True
 
@@ -47,12 +48,12 @@ def test_callable():
     ],
 )
 def test_callable_cases(input_value, expected):
-    v = SchemaValidator({'type': 'callable'})
+    v = SchemaValidator(cs.callable_schema())
     assert v.isinstance_python(input_value) == expected
 
 
 def test_repr():
-    v = SchemaValidator({'type': 'union', 'choices': [{'type': 'int'}, {'type': 'callable'}]})
+    v = SchemaValidator(cs.union_schema(choices=[cs.int_schema(), cs.callable_schema()]))
     assert v.isinstance_python(4) is True
     assert v.isinstance_python(func) is True
     assert v.isinstance_python('foo') is False
diff --git a/tests/validators/test_chain.py b/tests/validators/test_chain.py
index 0ba59084d..cae3c170d 100644
--- a/tests/validators/test_chain.py
+++ b/tests/validators/test_chain.py
@@ -3,16 +3,16 @@
 import pytest
 
 from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema
+from pydantic_core import core_schema as cs
 
 from ..conftest import PyAndJson
 
 
 def test_chain():
     validator = SchemaValidator(
-        {
-            'type': 'chain',
-            'steps': [{'type': 'str'}, core_schema.with_info_plain_validator_function(lambda v, info: Decimal(v))],
-        }
+        cs.chain_schema(
+            steps=[cs.str_schema(), core_schema.with_info_plain_validator_function(lambda v, info: Decimal(v))]
+        )
     )
 
     assert validator.validate_python('1.44') == Decimal('1.44')
@@ -21,22 +21,21 @@ def test_chain():
 
 def test_chain_many():
     validator = SchemaValidator(
-        {
-            'type': 'chain',
-            'steps': [
+        cs.chain_schema(
+            steps=[
                 core_schema.with_info_plain_validator_function(lambda v, info: f'{v}-1'),
                 core_schema.with_info_plain_validator_function(lambda v, info: f'{v}-2'),
                 core_schema.with_info_plain_validator_function(lambda v, info: f'{v}-3'),
                 core_schema.with_info_plain_validator_function(lambda v, info: f'{v}-4'),
-            ],
-        }
+            ]
+        )
     )
 
     assert validator.validate_python('input') == 'input-1-2-3-4'
 
 
 def test_chain_error():
-    validator = SchemaValidator({'type': 'chain', 'steps': [{'type': 'str'}, {'type': 'int'}]})
+    validator = SchemaValidator(cs.chain_schema(steps=[cs.str_schema(), cs.int_schema()]))
 
     assert validator.validate_python('123') == 123
     assert validator.validate_python(b'123') == 123
@@ -74,13 +73,11 @@ def test_json(py_and_json: PyAndJson, input_value, expected):
 
 def test_flatten():
     validator = SchemaValidator(
-        {
-            'type': 'chain',
-            'steps': [
+        cs.chain_schema(
+            steps=[
                 core_schema.with_info_plain_validator_function(lambda v, info: f'{v}-1'),
-                {
-                    'type': 'chain',
-                    'steps': [
+                cs.chain_schema(
+                    steps=[
                         {
                             'type': 'function-plain',
                             'function': {'type': 'with-info', 'function': lambda v, info: f'{v}-2'},
@@ -89,10 +86,10 @@ def test_flatten():
                             'type': 'function-plain',
                             'function': {'type': 'with-info', 'function': lambda v, info: f'{v}-3'},
                         },
-                    ],
-                },
-            ],
-        }
+                    ]
+                ),
+            ]
+        )
     )
 
     assert validator.validate_python('input') == 'input-1-2-3'
@@ -101,12 +98,12 @@ def test_flatten():
 
 def test_chain_empty():
     with pytest.raises(SchemaError, match='One or more steps are required for a chain validator'):
-        SchemaValidator({'type': 'chain', 'steps': []})
+        SchemaValidator(cs.chain_schema(steps=[]))
 
 
 def test_chain_one():
     validator = SchemaValidator(
-        {'type': 'chain', 'steps': [core_schema.with_info_plain_validator_function(lambda v, info: f'{v}-1')]}
+        cs.chain_schema(steps=[core_schema.with_info_plain_validator_function(lambda v, info: f'{v}-1')])
     )
     assert validator.validate_python('input') == 'input-1'
     assert validator.title == 'function-plain[<lambda>()]'
diff --git a/tests/validators/test_complex.py b/tests/validators/test_complex.py
index 244091265..c3a1076c7 100644
--- a/tests/validators/test_complex.py
+++ b/tests/validators/test_complex.py
@@ -6,6 +6,7 @@
 import pytest
 
 from pydantic_core import SchemaValidator, ValidationError
+from pydantic_core import core_schema as cs
 
 from ..conftest import Err
 
@@ -45,7 +46,7 @@
     ids=repr,
 )
 def test_complex_cases(input_value, expected):
-    v = SchemaValidator({'type': 'complex'})
+    v = SchemaValidator(cs.complex_schema())
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value)
@@ -76,7 +77,7 @@ def test_complex_cases(input_value, expected):
     ids=repr,
 )
 def test_complex_strict(input_value, expected):
-    v = SchemaValidator({'type': 'complex', 'strict': True})
+    v = SchemaValidator(cs.complex_schema(strict=True))
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value)
@@ -89,12 +90,12 @@ def test_complex_strict(input_value, expected):
     reason='PyPy cannot process this string due to a bug, even if this string is considered valid in python',
 )
 def test_valid_complex_string_with_space():
-    v = SchemaValidator({'type': 'complex'})
+    v = SchemaValidator(cs.complex_schema())
     assert v.validate_python('\t( -1.23+4.5J )\n') == complex(-1.23, 4.5)
 
 
 def test_nan_inf_complex():
-    v = SchemaValidator({'type': 'complex'})
+    v = SchemaValidator(cs.complex_schema())
     c = v.validate_python('NaN+Infinityj')
     # c != complex(float('nan'), float('inf')) as nan != nan,
     # so we need to examine the values individually
@@ -105,7 +106,7 @@ def test_nan_inf_complex():
 def test_overflow_complex():
     # Python simply converts too large float values to inf, so these strings
     # are still valid, even if the numbers are out of range
-    v = SchemaValidator({'type': 'complex'})
+    v = SchemaValidator(cs.complex_schema())
 
     c = v.validate_python('5e600j')
     assert math.isinf(c.imag)
@@ -115,7 +116,7 @@ def test_overflow_complex():
 
 
 def test_json_complex():
-    v = SchemaValidator({'type': 'complex'})
+    v = SchemaValidator(cs.complex_schema())
     assert v.validate_json('"-1.23e+4+5.67e-8J"') == complex(-1.23e4, 5.67e-8)
     assert v.validate_json('1') == complex(1, 0)
     assert v.validate_json('1.0') == complex(1, 0)
@@ -135,7 +136,7 @@ def test_json_complex():
 
 
 def test_json_complex_strict():
-    v = SchemaValidator({'type': 'complex', 'strict': True})
+    v = SchemaValidator(cs.complex_schema(strict=True))
     assert v.validate_json('"-1.23e+4+5.67e-8J"') == complex(-1.23e4, 5.67e-8)
     # "1" is a valid complex string
     assert v.validate_json('"1"') == complex(1, 0)
@@ -149,7 +150,7 @@ def test_json_complex_strict():
 
 
 def test_string_complex():
-    v = SchemaValidator({'type': 'complex'})
+    v = SchemaValidator(cs.complex_schema())
     assert v.validate_strings('+1.23e-4-5.67e+8J') == complex(1.23e-4, -5.67e8)
     with pytest.raises(ValidationError, match=re.escape(EXPECTED_PARSE_ERROR_MESSAGE)):
         v.validate_strings("{'real': 1, 'imag': 0}")
diff --git a/tests/validators/test_custom_error.py b/tests/validators/test_custom_error.py
index f2a6e45b5..ada4aef47 100644
--- a/tests/validators/test_custom_error.py
+++ b/tests/validators/test_custom_error.py
@@ -40,5 +40,7 @@ def test_custom_error_invalid():
     msg = "custom_error_message should not be provided if 'custom_error_type' matches a known error"
     with pytest.raises(SchemaError, match=msg):
         SchemaValidator(
-            core_schema.custom_error_schema(core_schema.int_schema(), 'recursion_loop', custom_error_message='xxx')
+            schema=core_schema.custom_error_schema(
+                core_schema.int_schema(), 'recursion_loop', custom_error_message='xxx'
+            )
         )
diff --git a/tests/validators/test_date.py b/tests/validators/test_date.py
index 63e87556c..90cb1d797 100644
--- a/tests/validators/test_date.py
+++ b/tests/validators/test_date.py
@@ -8,6 +8,7 @@
 import pytest
 
 from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema, validate_core_schema
+from pydantic_core import core_schema as cs
 
 from ..conftest import Err, PyAndJson
 
@@ -73,7 +74,7 @@
     ],
 )
 def test_date(input_value, expected):
-    v = SchemaValidator({'type': 'date'})
+    v = SchemaValidator(cs.date_schema())
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             result = v.validate_python(input_value)
@@ -136,7 +137,7 @@ def test_date_json(py_and_json: PyAndJson, input_value, expected):
     ids=repr,
 )
 def test_date_strict(input_value, expected, strict_mode_type):
-    v = SchemaValidator({'type': 'date', 'strict': strict_mode_type.schema})
+    v = SchemaValidator(cs.date_schema(strict=strict_mode_type.schema))
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value, **strict_mode_type.validator_args)
@@ -157,7 +158,7 @@ def test_date_strict(input_value, expected, strict_mode_type):
     ],
 )
 def test_date_strict_json(input_value, expected, strict_mode_type):
-    v = SchemaValidator({'type': 'date', 'strict': strict_mode_type.schema})
+    v = SchemaValidator(cs.date_schema(strict=strict_mode_type.schema))
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_json(input_value, **strict_mode_type.validator_args)
@@ -167,7 +168,7 @@ def test_date_strict_json(input_value, expected, strict_mode_type):
 
 
 def test_date_strict_json_ctx():
-    v = SchemaValidator({'type': 'date', 'strict': True})
+    v = SchemaValidator(cs.date_schema(strict=True))
     with pytest.raises(ValidationError) as exc_info:
         v.validate_json('"foobar"')
     assert exc_info.value.errors(include_url=False) == [
@@ -204,7 +205,7 @@ def test_date_strict_json_ctx():
     ],
 )
 def test_date_kwargs(kwargs: dict[str, Any], input_value: date, expected: Err | date):
-    v = SchemaValidator({'type': 'date', **kwargs})  # type: ignore
+    v = SchemaValidator(cs.date_schema(**kwargs))  # type: ignore
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value)
@@ -219,7 +220,7 @@ def test_invalid_constraint():
 
 
 def test_dict_py():
-    v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'date'}, 'values_schema': {'type': 'int'}})
+    v = SchemaValidator(cs.dict_schema(keys_schema=cs.date_schema(), values_schema=cs.int_schema()))
     assert v.validate_python({date(2000, 1, 1): 2, date(2000, 1, 2): 4}) == {date(2000, 1, 1): 2, date(2000, 1, 2): 4}
 
 
@@ -229,11 +230,11 @@ def test_dict(py_and_json: PyAndJson):
 
 
 def test_union():
-    v = SchemaValidator({'type': 'union', 'choices': [{'type': 'str'}, {'type': 'date'}]})
+    v = SchemaValidator(cs.union_schema(choices=[cs.str_schema(), cs.date_schema()]))
     assert v.validate_python('2022-01-02') == '2022-01-02'
     assert v.validate_python(date(2022, 1, 2)) == date(2022, 1, 2)
 
-    v = SchemaValidator({'type': 'union', 'choices': [{'type': 'date'}, {'type': 'str'}]})
+    v = SchemaValidator(cs.union_schema(choices=[cs.date_schema(), cs.str_schema()]))
     assert v.validate_python('2022-01-02') == '2022-01-02'
     assert v.validate_python(date(2022, 1, 2)) == date(2022, 1, 2)
 
diff --git a/tests/validators/test_datetime.py b/tests/validators/test_datetime.py
index a48a78a78..f9ee69bf4 100644
--- a/tests/validators/test_datetime.py
+++ b/tests/validators/test_datetime.py
@@ -9,6 +9,7 @@
 import pytest
 
 from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema, validate_core_schema
+from pydantic_core import core_schema as cs
 
 from ..conftest import Err, PyAndJson
 
@@ -58,7 +59,7 @@
     ],
 )
 def test_datetime(input_value, expected):
-    v = SchemaValidator({'type': 'datetime'})
+    v = SchemaValidator(cs.datetime_schema())
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             result = v.validate_python(input_value)
@@ -81,7 +82,7 @@ def test_datetime(input_value, expected):
     ],
 )
 def test_datetime_strict(input_value, expected):
-    v = SchemaValidator({'type': 'datetime', 'strict': True})
+    v = SchemaValidator(cs.datetime_schema(strict=True))
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value)
@@ -93,7 +94,7 @@ def test_datetime_strict(input_value, expected):
 def test_keep_tz():
     tz = zoneinfo.ZoneInfo('Europe/London')
     dt = datetime(2022, 6, 14, 12, 13, 14, tzinfo=tz)
-    v = SchemaValidator({'type': 'datetime'})
+    v = SchemaValidator(cs.datetime_schema())
 
     output = v.validate_python(dt)
     assert output == dt
@@ -106,7 +107,7 @@ def test_keep_tz():
 def test_keep_tz_bound():
     tz = zoneinfo.ZoneInfo('Europe/London')
     dt = datetime(2022, 6, 14, 12, 13, 14, tzinfo=tz)
-    v = SchemaValidator({'type': 'datetime', 'gt': datetime(2022, 1, 1)})
+    v = SchemaValidator(cs.datetime_schema(gt=datetime(2022, 1, 1)))
 
     output = v.validate_python(dt)
     assert output == dt
@@ -166,7 +167,7 @@ def test_datetime_json(py_and_json: PyAndJson, input_value, expected):
     ],
 )
 def test_datetime_strict_json(input_value, expected):
-    v = SchemaValidator({'type': 'datetime', 'strict': True})
+    v = SchemaValidator(cs.datetime_schema(strict=True))
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_json(json.dumps(input_value))
@@ -176,7 +177,7 @@ def test_datetime_strict_json(input_value, expected):
 
 
 def test_custom_timezone_repr():
-    output = SchemaValidator({'type': 'datetime'}).validate_python('2022-06-08T12:13:14-12:15')
+    output = SchemaValidator(cs.datetime_schema()).validate_python('2022-06-08T12:13:14-12:15')
     assert output == datetime(2022, 6, 8, 12, 13, 14, tzinfo=timezone(timedelta(hours=-12, minutes=-15)))
     assert output.tzinfo.utcoffset(output) == timedelta(hours=-12, minutes=-15)
     assert output.tzinfo.dst(output) is None
@@ -186,7 +187,7 @@ def test_custom_timezone_repr():
 
 
 def test_custom_timezone_utc_repr():
-    output = SchemaValidator({'type': 'datetime'}).validate_python('2022-06-08T12:13:14Z')
+    output = SchemaValidator(cs.datetime_schema()).validate_python('2022-06-08T12:13:14Z')
     assert output == datetime(2022, 6, 8, 12, 13, 14, tzinfo=timezone(timedelta(0)))
     assert output.tzinfo.utcoffset(output) == timedelta(0)
     assert output.tzinfo.dst(output) is None
@@ -200,19 +201,19 @@ def test_tz_comparison():
     uk_3pm = datetime(2022, 1, 1, 15, 0, 0, tzinfo=tz)
 
     # two times are the same instant, therefore le and ge are both ok
-    v = SchemaValidator({'type': 'datetime', 'le': uk_3pm}).validate_python('2022-01-01T16:00:00+01:00')
+    v = SchemaValidator(cs.datetime_schema(le=uk_3pm)).validate_python('2022-01-01T16:00:00+01:00')
     assert v == datetime(2022, 1, 1, 16, 0, 0, tzinfo=timezone(timedelta(hours=1)))
 
-    v = SchemaValidator({'type': 'datetime', 'ge': uk_3pm}).validate_python('2022-01-01T16:00:00+01:00')
+    v = SchemaValidator(cs.datetime_schema(ge=uk_3pm)).validate_python('2022-01-01T16:00:00+01:00')
     assert v == datetime(2022, 1, 1, 16, 0, 0, tzinfo=timezone(timedelta(hours=1)))
 
     # but not gt
     with pytest.raises(ValidationError, match=r'Input should be greater than 2022-01-01T15:00:00Z \[type=greater_than'):
-        SchemaValidator({'type': 'datetime', 'gt': uk_3pm}).validate_python('2022-01-01T16:00:00+01:00')
+        SchemaValidator(cs.datetime_schema(gt=uk_3pm)).validate_python('2022-01-01T16:00:00+01:00')
 
 
 def test_tz_info_deepcopy():
-    output = SchemaValidator({'type': 'datetime'}).validate_python('2023-02-15T16:23:44.037Z')
+    output = SchemaValidator(cs.datetime_schema()).validate_python('2023-02-15T16:23:44.037Z')
     c = copy.deepcopy(output)
     assert repr(output.tzinfo) == 'TzInfo(UTC)'
     assert repr(c.tzinfo) == 'TzInfo(UTC)'
@@ -220,7 +221,7 @@ def test_tz_info_deepcopy():
 
 
 def test_tz_info_copy():
-    output = SchemaValidator({'type': 'datetime'}).validate_python('2023-02-15T16:23:44.037Z')
+    output = SchemaValidator(cs.datetime_schema()).validate_python('2023-02-15T16:23:44.037Z')
     c = copy.copy(output)
     assert repr(output.tzinfo) == 'TzInfo(UTC)'
     assert repr(c.tzinfo) == 'TzInfo(UTC)'
@@ -238,7 +239,7 @@ def dst(self, _dt):
         def tzname(self, _dt):
             return 'CustomTZ'
 
-    schema = SchemaValidator({'type': 'datetime', 'gt': datetime(2022, 1, 1, 15, 0, 0)})
+    schema = SchemaValidator(cs.datetime_schema(gt=datetime(2022, 1, 1, 15, 0, 0)))
 
     dt = datetime(2022, 1, 1, 16, 0, 0, tzinfo=CustomTz())
     outcome = schema.validate_python(dt)
@@ -252,7 +253,7 @@ class CustomTz(tzinfo):
         def tzname(self, _dt):
             return 'CustomTZ'
 
-    schema = SchemaValidator({'type': 'datetime', 'gt': datetime(2022, 1, 1, 15, 0, 0)})
+    schema = SchemaValidator(cs.datetime_schema(gt=datetime(2022, 1, 1, 15, 0, 0)))
 
     dt = datetime(2022, 1, 1, 16, 0, 0, tzinfo=CustomTz())
     # perhaps this should be a ValidationError? but we don't catch other errors
@@ -277,7 +278,7 @@ def tzname(self, _dt):
 
 
 def test_dict_py():
-    v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'datetime'}, 'values_schema': {'type': 'int'}})
+    v = SchemaValidator(cs.dict_schema(keys_schema=cs.datetime_schema(), values_schema=cs.int_schema()))
     assert v.validate_python({datetime(2000, 1, 1): 2, datetime(2000, 1, 2): 4}) == {
         datetime(2000, 1, 1): 2,
         datetime(2000, 1, 2): 4,
@@ -293,11 +294,11 @@ def test_dict(py_and_json: PyAndJson):
 
 
 def test_union():
-    v = SchemaValidator({'type': 'union', 'choices': [{'type': 'str'}, {'type': 'datetime'}]})
+    v = SchemaValidator(cs.union_schema(choices=[cs.str_schema(), cs.datetime_schema()]))
     assert v.validate_python('2022-01-02T00:00') == '2022-01-02T00:00'
     assert v.validate_python(datetime(2022, 1, 2)) == datetime(2022, 1, 2)
 
-    v = SchemaValidator({'type': 'union', 'choices': [{'type': 'datetime'}, {'type': 'str'}]})
+    v = SchemaValidator(cs.union_schema(choices=[cs.datetime_schema(), cs.str_schema()]))
     assert v.validate_python('2022-01-02T00:00') == '2022-01-02T00:00'
     assert v.validate_python(datetime(2022, 1, 2)) == datetime(2022, 1, 2)
 
diff --git a/tests/validators/test_decimal.py b/tests/validators/test_decimal.py
index 0f165d5a8..074425b5f 100644
--- a/tests/validators/test_decimal.py
+++ b/tests/validators/test_decimal.py
@@ -10,6 +10,7 @@
 from dirty_equals import FunctionCheck, IsStr
 
 from pydantic_core import SchemaValidator, ValidationError, core_schema
+from pydantic_core import core_schema as cs
 
 from ..conftest import Err, PyAndJson, plain_repr
 
@@ -90,7 +91,7 @@ def test_decimal(py_and_json: PyAndJson, input_value, expected):
     ids=repr,
 )
 def test_decimal_strict_py(input_value, expected):
-    v = SchemaValidator({'type': 'decimal', 'strict': True})
+    v = SchemaValidator(cs.decimal_schema(strict=True))
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value)
@@ -120,7 +121,7 @@ def test_decimal_strict_py(input_value, expected):
     ids=repr,
 )
 def test_decimal_strict_json(input_value, expected):
-    v = SchemaValidator({'type': 'decimal', 'strict': True})
+    v = SchemaValidator(cs.decimal_schema(strict=True))
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_json(json.dumps(input_value))
@@ -224,9 +225,7 @@ def test_decimal_multiple_of(py_and_json: PyAndJson, multiple_of: float, input_v
 
 
 def test_union_decimal_py():
-    v = SchemaValidator(
-        {'type': 'union', 'choices': [{'type': 'decimal', 'strict': True}, {'type': 'decimal', 'multiple_of': 7}]}
-    )
+    v = SchemaValidator(cs.union_schema(choices=[cs.decimal_schema(strict=True), cs.decimal_schema(multiple_of=7)]))
     assert v.validate_python('14') == 14
     assert v.validate_python(Decimal(5)) == 5
     with pytest.raises(ValidationError) as exc_info:
@@ -250,9 +249,7 @@ def test_union_decimal_py():
 
 
 def test_union_decimal_json():
-    v = SchemaValidator(
-        {'type': 'union', 'choices': [{'type': 'decimal', 'strict': True}, {'type': 'decimal', 'multiple_of': 7}]}
-    )
+    v = SchemaValidator(cs.union_schema(choices=[cs.decimal_schema(strict=True), cs.decimal_schema(multiple_of=7)]))
     assert v.validate_json(json.dumps('14')) == 14
     assert v.validate_json(json.dumps('5')) == 5
 
@@ -275,21 +272,21 @@ def test_union_decimal_simple(py_and_json: PyAndJson):
 
 
 def test_decimal_repr():
-    v = SchemaValidator({'type': 'decimal'})
+    v = SchemaValidator(cs.decimal_schema())
     assert plain_repr(v).startswith(
         'SchemaValidator(title="decimal",validator=Decimal(DecimalValidator{strict:false,allow_inf_nan:false'
     )
-    v = SchemaValidator({'type': 'decimal', 'strict': True})
+    v = SchemaValidator(cs.decimal_schema(strict=True))
     assert plain_repr(v).startswith(
         'SchemaValidator(title="decimal",validator=Decimal(DecimalValidator{strict:true,allow_inf_nan:false'
     )
-    v = SchemaValidator({'type': 'decimal', 'multiple_of': 7})
+    v = SchemaValidator(cs.decimal_schema(multiple_of=7))
     assert plain_repr(v).startswith('SchemaValidator(title="decimal",validator=Decimal(')
 
 
 @pytest.mark.parametrize('input_value,expected', [(Decimal('1.23'), Decimal('1.23')), (Decimal('1'), Decimal('1.0'))])
 def test_decimal_not_json(input_value, expected):
-    v = SchemaValidator({'type': 'decimal'})
+    v = SchemaValidator(cs.decimal_schema())
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value)
@@ -383,7 +380,7 @@ def test_non_finite_json_values(py_and_json: PyAndJson, input_value, allow_inf_n
     ],
 )
 def test_non_finite_decimal_values(strict, input_value, allow_inf_nan, expected):
-    v = SchemaValidator({'type': 'decimal', 'allow_inf_nan': allow_inf_nan, 'strict': strict})
+    v = SchemaValidator(cs.decimal_schema(allow_inf_nan=allow_inf_nan, strict=strict))
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value)
@@ -419,7 +416,7 @@ def test_non_finite_decimal_values(strict, input_value, allow_inf_nan, expected)
     ],
 )
 def test_non_finite_constrained_decimal_values(input_value, allow_inf_nan, expected):
-    v = SchemaValidator({'type': 'decimal', 'allow_inf_nan': allow_inf_nan, 'gt': 0})
+    v = SchemaValidator(cs.decimal_schema(allow_inf_nan=allow_inf_nan, gt=0))
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value)
@@ -457,12 +454,12 @@ def test_non_finite_constrained_decimal_values(input_value, allow_inf_nan, expec
     ],
 )
 def test_validate_scientific_notation_from_json(input_value, expected):
-    v = SchemaValidator({'type': 'decimal'})
+    v = SchemaValidator(cs.decimal_schema())
     assert v.validate_json(input_value) == expected
 
 
 def test_validate_max_digits_and_decimal_places() -> None:
-    v = SchemaValidator({'type': 'decimal', 'max_digits': 5, 'decimal_places': 2})
+    v = SchemaValidator(cs.decimal_schema(max_digits=5, decimal_places=2))
 
     # valid inputs
     assert v.validate_json('1.23') == Decimal('1.23')
@@ -481,7 +478,7 @@ def test_validate_max_digits_and_decimal_places() -> None:
 
 
 def test_validate_max_digits_and_decimal_places_edge_case() -> None:
-    v = SchemaValidator({'type': 'decimal', 'max_digits': 34, 'decimal_places': 18})
+    v = SchemaValidator(cs.decimal_schema(max_digits=34, decimal_places=18))
 
     # valid inputs
     assert v.validate_python(Decimal('9999999999999999.999999999999999999')) == Decimal(
diff --git a/tests/validators/test_definitions.py b/tests/validators/test_definitions.py
index d4102e95a..1c730ee6f 100644
--- a/tests/validators/test_definitions.py
+++ b/tests/validators/test_definitions.py
@@ -76,7 +76,7 @@ def test_dict_repeat():
 def test_repeated_ref():
     with pytest.raises(SchemaError, match='SchemaError: Duplicate ref: `foobar`'):
         SchemaValidator(
-            core_schema.tuple_positional_schema(
+            schema=core_schema.tuple_positional_schema(
                 [
                     core_schema.definitions_schema(
                         core_schema.definition_reference_schema('foobar'), [core_schema.int_schema(ref='foobar')]
@@ -92,7 +92,7 @@ def test_repeated_ref():
 def test_repeat_after():
     with pytest.raises(SchemaError, match='SchemaError: Duplicate ref: `foobar`'):
         SchemaValidator(
-            core_schema.definitions_schema(
+            schema=core_schema.definitions_schema(
                 core_schema.tuple_positional_schema(
                     [
                         core_schema.definitions_schema(
@@ -147,7 +147,7 @@ def test_definition_chain():
         core_schema.definitions_schema(
             core_schema.definition_reference_schema('foo'),
             [core_schema.definition_reference_schema(ref='foo', schema_ref='bar'), core_schema.int_schema(ref='bar')],
-        ),
+        )
     )
     assert v.validate_python('1') == 1
 
diff --git a/tests/validators/test_definitions_recursive.py b/tests/validators/test_definitions_recursive.py
index e835b9075..4c2577408 100644
--- a/tests/validators/test_definitions_recursive.py
+++ b/tests/validators/test_definitions_recursive.py
@@ -7,7 +7,8 @@
 from dirty_equals import AnyThing, HasAttributes, IsList, IsPartialDict, IsStr, IsTuple
 
 import pydantic_core
-from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema
+from pydantic_core import CoreConfig, SchemaError, SchemaValidator, ValidationError, core_schema
+from pydantic_core import core_schema as cs
 
 from ..conftest import Err, plain_repr
 from .test_typed_dict import Cls
@@ -53,14 +54,13 @@ def test_branch_nullable():
 
 def test_unused_ref():
     v = SchemaValidator(
-        {
-            'type': 'typed-dict',
-            'ref': 'Branch',
-            'fields': {
-                'name': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
-                'other': {'type': 'typed-dict-field', 'schema': {'type': 'int'}},
+        cs.typed_dict_schema(
+            fields={
+                'name': cs.typed_dict_field(schema=cs.str_schema()),
+                'other': cs.typed_dict_field(schema=cs.int_schema()),
             },
-        }
+            ref='Branch',
+        )
     )
     assert v.validate_python({'name': 'root', 'other': '4'}) == {'name': 'root', 'other': 4}
 
@@ -246,26 +246,19 @@ class Branch:
 def test_invalid_schema():
     with pytest.raises(SchemaError, match='Definitions error: definition `Branch` was never filled'):
         SchemaValidator(
-            {
-                'type': 'list',
-                'items_schema': {
-                    'type': 'typed-dict',
-                    'fields': {
-                        'width': {'type': 'typed-dict-field', 'schema': {'type': 'int'}},
-                        'branch': {
-                            'type': 'typed-dict-field',
-                            'schema': {
-                                'type': 'default',
-                                'schema': {
-                                    'type': 'nullable',
-                                    'schema': {'type': 'definition-ref', 'schema_ref': 'Branch'},
-                                },
-                                'default': None,
-                            },
-                        },
-                    },
-                },
-            }
+            schema=cs.list_schema(
+                items_schema=cs.typed_dict_schema(
+                    fields={
+                        'width': cs.typed_dict_field(schema=cs.int_schema()),
+                        'branch': cs.typed_dict_field(
+                            schema=cs.with_default_schema(
+                                schema=cs.nullable_schema(schema=cs.definition_reference_schema(schema_ref='Branch')),
+                                default=None,
+                            )
+                        ),
+                    }
+                )
+            )
         )
 
 
@@ -311,7 +304,7 @@ def test_recursion_branch():
                 )
             ],
         ),
-        {'from_attributes': True},
+        config=CoreConfig(from_attributes=True),
     )
     assert ',definitions=[TypedDict(TypedDictValidator{' in plain_repr(v)
 
@@ -355,7 +348,7 @@ def test_recursion_branch_from_attributes():
                 )
             ],
         ),
-        {'from_attributes': True},
+        config=CoreConfig(from_attributes=True),
     )
 
     assert v.validate_python({'name': 'root'}) == ({'name': 'root', 'branch': None}, None, {'name'})
@@ -762,24 +755,18 @@ def test_many_uses_of_ref():
 def test_error_inside_definition_wrapper():
     with pytest.raises(SchemaError) as exc_info:
         SchemaValidator(
-            {
-                'type': 'typed-dict',
-                'ref': 'Branch',
-                'fields': {
-                    'sub_branch': {
-                        'type': 'typed-dict-field',
-                        'schema': {
-                            'type': 'default',
-                            'schema': {
-                                'type': 'nullable',
-                                'schema': {'type': 'definition-ref', 'schema_ref': 'Branch'},
-                            },
-                            'default': None,
-                            'default_factory': lambda x: 'foobar',
-                        },
-                    }
+            schema=cs.typed_dict_schema(
+                fields={
+                    'sub_branch': cs.typed_dict_field(
+                        schema=cs.with_default_schema(
+                            schema=cs.nullable_schema(schema=cs.definition_reference_schema(schema_ref='Branch')),
+                            default_factory=lambda x: 'foobar',
+                            default=None,
+                        )
+                    )
                 },
-            }
+                ref='Branch',
+            )
         )
     assert str(exc_info.value) == (
         'Error building "typed-dict" validator:\n'
diff --git a/tests/validators/test_dict.py b/tests/validators/test_dict.py
index 0d348b347..bff6cf5a3 100644
--- a/tests/validators/test_dict.py
+++ b/tests/validators/test_dict.py
@@ -7,6 +7,7 @@
 from dirty_equals import HasRepr, IsStr
 
 from pydantic_core import SchemaValidator, ValidationError
+from pydantic_core import core_schema as cs
 
 from ..conftest import Err, PyAndJson
 
@@ -38,7 +39,7 @@ def test_dict(py_and_json: PyAndJson):
     ids=repr,
 )
 def test_dict_cases(input_value, expected):
-    v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'str'}, 'values_schema': {'type': 'str'}})
+    v = SchemaValidator(cs.dict_schema(keys_schema=cs.str_schema(), values_schema=cs.str_schema()))
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value)
@@ -62,7 +63,7 @@ def test_dict_value_error(py_and_json: PyAndJson):
 
 
 def test_dict_error_key_int():
-    v = SchemaValidator({'type': 'dict', 'values_schema': {'type': 'int'}})
+    v = SchemaValidator(cs.dict_schema(values_schema=cs.int_schema()))
     with pytest.raises(ValidationError, match='Input should be a valid integer') as exc_info:
         v.validate_python({1: 2, 3: 'wrong', -4: 'wrong2'})
     # insert_assert(exc_info.value.errors(include_url=False))
@@ -83,7 +84,7 @@ def test_dict_error_key_int():
 
 
 def test_dict_error_key_other():
-    v = SchemaValidator({'type': 'dict', 'values_schema': {'type': 'int'}})
+    v = SchemaValidator(cs.dict_schema(values_schema=cs.int_schema()))
     with pytest.raises(ValidationError, match='Input should be a valid integer') as exc_info:
         v.validate_python({1: 2, (1, 2): 'wrong'})
     assert exc_info.value.errors(include_url=False) == [
@@ -97,8 +98,8 @@ def test_dict_error_key_other():
 
 
 def test_dict_any_value():
-    v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'str'}})
-    v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'str'}})
+    v = SchemaValidator(cs.dict_schema(keys_schema=cs.str_schema()))
+    v = SchemaValidator(cs.dict_schema(keys_schema=cs.str_schema()))
     assert v.validate_python({'1': 1, '2': 'a', '3': None}) == {'1': 1, '2': 'a', '3': None}
 
 
@@ -116,17 +117,15 @@ def __iter__(self):
         def __len__(self):
             return len(self._d)
 
-    v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'int'}, 'values_schema': {'type': 'int'}})
+    v = SchemaValidator(cs.dict_schema(keys_schema=cs.int_schema(), values_schema=cs.int_schema()))
     assert v.validate_python(MyMapping({'1': 2, 3: '4'})) == {1: 2, 3: 4}
-    v = SchemaValidator(
-        {'type': 'dict', 'strict': True, 'keys_schema': {'type': 'int'}, 'values_schema': {'type': 'int'}}
-    )
+    v = SchemaValidator(cs.dict_schema(strict=True, keys_schema=cs.int_schema(), values_schema=cs.int_schema()))
     with pytest.raises(ValidationError, match='Input should be a valid dictionary'):
         v.validate_python(MyMapping({'1': 2, 3: '4'}))
 
 
 def test_key_error():
-    v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'int'}, 'values_schema': {'type': 'int'}})
+    v = SchemaValidator(cs.dict_schema(keys_schema=cs.int_schema(), values_schema=cs.int_schema()))
     assert v.validate_python({'1': True}) == {1: 1}
     with pytest.raises(ValidationError, match=re.escape('x.[key]\n  Input should be a valid integer')) as exc_info:
         v.validate_python({'x': 1})
@@ -151,7 +150,7 @@ def __iter__(self):
         def __len__(self):
             return 1
 
-    v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'int'}, 'values_schema': {'type': 'int'}})
+    v = SchemaValidator(cs.dict_schema(keys_schema=cs.int_schema(), values_schema=cs.int_schema()))
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python(BadMapping())
 
@@ -181,7 +180,7 @@ def __getitem__(self, key):
         def __len__(self):
             return 1
 
-    v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'int'}, 'values_schema': {'type': 'int'}})
+    v = SchemaValidator(cs.dict_schema(keys_schema=cs.int_schema(), values_schema=cs.int_schema()))
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python(BadMapping())
 
@@ -219,7 +218,7 @@ def __len__(self):
     ],
 )
 def test_dict_length_constraints(kwargs: dict[str, Any], input_value, expected):
-    v = SchemaValidator({'type': 'dict', **kwargs})
+    v = SchemaValidator(cs.dict_schema(**kwargs))
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value)
@@ -228,7 +227,7 @@ def test_dict_length_constraints(kwargs: dict[str, Any], input_value, expected):
 
 
 def test_json_dict():
-    v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'int'}, 'values_schema': {'type': 'int'}})
+    v = SchemaValidator(cs.dict_schema(keys_schema=cs.int_schema(), values_schema=cs.int_schema()))
     assert v.validate_json('{"1": 2, "3": 4}') == {1: 2, 3: 4}
     with pytest.raises(ValidationError) as exc_info:
         v.validate_json('1')
@@ -238,14 +237,12 @@ def test_json_dict():
 
 
 def test_dict_complex_key():
-    v = SchemaValidator(
-        {'type': 'dict', 'keys_schema': {'type': 'complex', 'strict': True}, 'values_schema': {'type': 'str'}}
-    )
+    v = SchemaValidator(cs.dict_schema(keys_schema=cs.complex_schema(strict=True), values_schema=cs.str_schema()))
     assert v.validate_python({complex(1, 2): '1'}) == {complex(1, 2): '1'}
     with pytest.raises(ValidationError, match='Input should be an instance of complex'):
         assert v.validate_python({'1+2j': b'1'}) == {complex(1, 2): '1'}
 
-    v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'complex'}, 'values_schema': {'type': 'str'}})
+    v = SchemaValidator(cs.dict_schema(keys_schema=cs.complex_schema(), values_schema=cs.str_schema()))
     with pytest.raises(
         ValidationError, match='Input should be a valid python complex object, a number, or a valid complex string'
     ):
@@ -253,7 +250,7 @@ def test_dict_complex_key():
 
 
 def test_json_dict_complex_key():
-    v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'complex'}, 'values_schema': {'type': 'int'}})
+    v = SchemaValidator(cs.dict_schema(keys_schema=cs.complex_schema(), values_schema=cs.int_schema()))
     assert v.validate_json('{"1+2j": 2, "-3": 4}') == {complex(1, 2): 2, complex(-3, 0): 4}
     assert v.validate_json('{"1+2j": 2, "infj": 4}') == {complex(1, 2): 2, complex(0, float('inf')): 4}
     with pytest.raises(ValidationError, match='Input should be a valid complex string'):
diff --git a/tests/validators/test_float.py b/tests/validators/test_float.py
index 1269a6d51..8a0235ed5 100644
--- a/tests/validators/test_float.py
+++ b/tests/validators/test_float.py
@@ -7,6 +7,7 @@
 from dirty_equals import FunctionCheck, IsFloatNan, IsStr
 
 from pydantic_core import SchemaValidator, ValidationError, core_schema
+from pydantic_core import core_schema as cs
 
 from ..conftest import Err, PyAndJson, plain_repr
 
@@ -200,23 +201,23 @@ def test_union_float_simple(py_and_json: PyAndJson):
 
 
 def test_float_repr():
-    v = SchemaValidator({'type': 'float'})
+    v = SchemaValidator(cs.float_schema())
     assert (
         plain_repr(v)
         == 'SchemaValidator(title="float",validator=Float(FloatValidator{strict:false,allow_inf_nan:true}),definitions=[],cache_strings=True)'
     )
-    v = SchemaValidator({'type': 'float', 'strict': True})
+    v = SchemaValidator(cs.float_schema(strict=True))
     assert (
         plain_repr(v)
         == 'SchemaValidator(title="float",validator=Float(FloatValidator{strict:true,allow_inf_nan:true}),definitions=[],cache_strings=True)'
     )
-    v = SchemaValidator({'type': 'float', 'multiple_of': 7})
+    v = SchemaValidator(cs.float_schema(multiple_of=7))
     assert plain_repr(v).startswith('SchemaValidator(title="constrained-float",validator=ConstrainedFloat(')
 
 
 @pytest.mark.parametrize('input_value,expected', [(Decimal('1.23'), 1.23), (Decimal('1'), 1.0)])
 def test_float_not_json(input_value, expected):
-    v = SchemaValidator({'type': 'float'})
+    v = SchemaValidator(cs.float_schema())
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value)
@@ -315,7 +316,7 @@ def test_non_finite_json_values(py_and_json: PyAndJson, input_value, allow_inf_n
     ],
 )
 def test_non_finite_float_values(strict, input_value, allow_inf_nan, expected):
-    v = SchemaValidator({'type': 'float', 'allow_inf_nan': allow_inf_nan, 'strict': strict})
+    v = SchemaValidator(cs.float_schema(allow_inf_nan=allow_inf_nan, strict=strict))
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value)
@@ -345,7 +346,7 @@ def test_non_finite_float_values(strict, input_value, allow_inf_nan, expected):
     ],
 )
 def test_non_finite_constrained_float_values(input_value, allow_inf_nan, expected):
-    v = SchemaValidator({'type': 'float', 'allow_inf_nan': allow_inf_nan, 'gt': 0})
+    v = SchemaValidator(cs.float_schema(allow_inf_nan=allow_inf_nan, gt=0))
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value)
@@ -383,12 +384,12 @@ def test_non_finite_constrained_float_values(input_value, allow_inf_nan, expecte
     ],
 )
 def test_validate_scientific_notation_from_json(input_value, expected):
-    v = SchemaValidator({'type': 'float'})
+    v = SchemaValidator(cs.float_schema())
     assert v.validate_json(input_value) == expected
 
 
 def test_string_with_underscores() -> None:
-    v = SchemaValidator({'type': 'float'})
+    v = SchemaValidator(cs.float_schema())
     assert v.validate_python('1_000_000.0') == 1_000_000.0
     assert v.validate_json('"1_000_000.0"') == 1_000_000.0
 
@@ -413,7 +414,7 @@ def test_allow_inf_nan_true_json() -> None:
 
 
 def test_allow_inf_nan_false_json() -> None:
-    v = SchemaValidator(core_schema.float_schema(), core_schema.CoreConfig(allow_inf_nan=False))
+    v = SchemaValidator(core_schema.float_schema(), config=core_schema.CoreConfig(allow_inf_nan=False))
 
     assert v.validate_json('123') == 123
     with pytest.raises(ValidationError) as exc_info1:
diff --git a/tests/validators/test_frozenset.py b/tests/validators/test_frozenset.py
index c75175766..e2fe20fc7 100644
--- a/tests/validators/test_frozenset.py
+++ b/tests/validators/test_frozenset.py
@@ -5,6 +5,7 @@
 import pytest
 
 from pydantic_core import SchemaValidator, ValidationError
+from pydantic_core import core_schema as cs
 
 from ..conftest import Err, PyAndJson, infinite_generator, plain_repr
 
@@ -25,14 +26,14 @@ def test_frozenset_ints_both(py_and_json: PyAndJson, input_value, expected):
     [([], frozenset()), ([1, '2', b'3'], {1, '2', b'3'}), (frozenset([1, '2', b'3']), {1, '2', b'3'})],
 )
 def test_frozenset_any(input_value, expected):
-    v = SchemaValidator({'type': 'frozenset'})
+    v = SchemaValidator(cs.frozenset_schema())
     output = v.validate_python(input_value)
     assert output == expected
     assert isinstance(output, frozenset)
 
 
 def test_no_copy():
-    v = SchemaValidator({'type': 'frozenset'})
+    v = SchemaValidator(cs.frozenset_schema())
     input_value = frozenset([1, 2, 3])
     output = v.validate_python(input_value)
     assert output == input_value
@@ -84,7 +85,7 @@ def test_frozenset_no_validators_both(py_and_json: PyAndJson, input_value, expec
 )
 @pytest.mark.thread_unsafe  # generators in parameters not compatible with pytest-run-parallel, https://github.com/Quansight-Labs/pytest-run-parallel/issues/14
 def test_frozenset_ints_python(input_value, expected):
-    v = SchemaValidator({'type': 'frozenset', 'items_schema': {'type': 'int'}})
+    v = SchemaValidator(cs.frozenset_schema(items_schema=cs.int_schema()))
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value)
@@ -99,14 +100,14 @@ def test_frozenset_ints_python(input_value, expected):
     [(frozenset([1, 2.5, '3']), {1, 2.5, '3'}), ([1, 2.5, '3'], {1, 2.5, '3'}), ([(1, 2), (3, 4)], {(1, 2), (3, 4)})],
 )
 def test_frozenset_no_validators_python(input_value, expected):
-    v = SchemaValidator({'type': 'frozenset'})
+    v = SchemaValidator(cs.frozenset_schema())
     output = v.validate_python(input_value)
     assert output == expected
     assert isinstance(output, frozenset)
 
 
 def test_frozenset_multiple_errors():
-    v = SchemaValidator({'type': 'frozenset', 'items_schema': {'type': 'int'}})
+    v = SchemaValidator(cs.frozenset_schema(items_schema=cs.int_schema()))
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python(['a', (1, 2), []])
     assert exc_info.value.errors(include_url=False) == [
@@ -168,7 +169,7 @@ def generate_repeats():
 )
 @pytest.mark.thread_unsafe  # generators in parameters not compatible with pytest-run-parallel, https://github.com/Quansight-Labs/pytest-run-parallel/issues/14
 def test_frozenset_kwargs_python(kwargs: dict[str, Any], input_value, expected):
-    v = SchemaValidator({'type': 'frozenset', **kwargs})
+    v = SchemaValidator(cs.frozenset_schema(**kwargs))
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value)
@@ -180,7 +181,7 @@ def test_frozenset_kwargs_python(kwargs: dict[str, Any], input_value, expected):
 
 @pytest.mark.parametrize('input_value,expected', [({1, 2, 3}, {1, 2, 3}), ([1, 2, 3], [1, 2, 3])])
 def test_union_frozenset_list(input_value, expected):
-    v = SchemaValidator({'type': 'union', 'choices': [{'type': 'frozenset'}, {'type': 'list'}]})
+    v = SchemaValidator(cs.union_schema(choices=[cs.frozenset_schema(), cs.list_schema()]))
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value)
@@ -218,13 +219,12 @@ def test_union_frozenset_list(input_value, expected):
 )
 def test_union_frozenset_int_frozenset_str(input_value, expected):
     v = SchemaValidator(
-        {
-            'type': 'union',
-            'choices': [
-                {'type': 'frozenset', 'items_schema': {'type': 'int', 'strict': True}},
-                {'type': 'frozenset', 'items_schema': {'type': 'str', 'strict': True}},
-            ],
-        }
+        cs.union_schema(
+            choices=[
+                cs.frozenset_schema(items_schema=cs.int_schema(strict=True)),
+                cs.frozenset_schema(items_schema=cs.str_schema(strict=True)),
+            ]
+        )
     )
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)) as exc_info:
@@ -244,7 +244,7 @@ def test_frozenset_as_dict_keys(py_and_json: PyAndJson):
 
 
 def test_repr():
-    v = SchemaValidator({'type': 'frozenset', 'strict': True, 'min_length': 42})
+    v = SchemaValidator(cs.frozenset_schema(strict=True, min_length=42))
     assert plain_repr(v) == (
         'SchemaValidator('
         'title="frozenset[any]",'
@@ -266,7 +266,7 @@ def gen(error: bool):
             raise RuntimeError('my error')
         yield 3
 
-    v = SchemaValidator({'type': 'frozenset', 'items_schema': {'type': 'int'}})
+    v = SchemaValidator(cs.frozenset_schema(items_schema=cs.int_schema()))
     r = v.validate_python(gen(False))
     assert r == {1, 2, 3}
     assert isinstance(r, frozenset)
@@ -295,7 +295,7 @@ def gen(error: bool):
     ],
 )
 def test_frozenset_from_dict_items(input_value, items_schema, expected):
-    v = SchemaValidator({'type': 'frozenset', 'items_schema': items_schema})
+    v = SchemaValidator(cs.frozenset_schema(items_schema=items_schema))
     output = v.validate_python(input_value)
     assert isinstance(output, frozenset)
     assert output == expected
@@ -337,7 +337,7 @@ def test_frozenset_from_dict_items(input_value, items_schema, expected):
     ],
 )
 def test_frozenset_fail_fast(fail_fast, expected):
-    v = SchemaValidator({'type': 'frozenset', 'items_schema': {'type': 'int'}, 'fail_fast': fail_fast})
+    v = SchemaValidator(cs.frozenset_schema(items_schema=cs.int_schema(), fail_fast=fail_fast))
 
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python([1, 'not-num', 'again'])
diff --git a/tests/validators/test_function.py b/tests/validators/test_function.py
index 544bf416d..562687268 100644
--- a/tests/validators/test_function.py
+++ b/tests/validators/test_function.py
@@ -7,7 +7,8 @@
 import pytest
 from dirty_equals import HasRepr
 
-from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema, validate_core_schema
+from pydantic_core import CoreConfig, SchemaError, SchemaValidator, ValidationError, core_schema, validate_core_schema
+from pydantic_core import core_schema as cs
 
 from ..conftest import plain_repr
 
@@ -67,7 +68,7 @@ def my_function(input_value, info):
         {
             'type': 'function-before',
             'function': {'type': 'with-info', 'function': my_function},
-            'schema': {'type': 'str', 'max_length': 5},
+            'schema': cs.str_schema(max_length=5),
         }
     )
 
@@ -90,8 +91,8 @@ def my_function(input_value, info):
     'config,input_str',
     (
         ({}, "type=string_too_long, input_value='12345x', input_type=str"),
-        ({'hide_input_in_errors': False}, "type=string_too_long, input_value='12345x', input_type=str"),
-        ({'hide_input_in_errors': True}, 'type=string_too_long'),
+        (CoreConfig(hide_input_in_errors=False), "type=string_too_long, input_value='12345x', input_type=str"),
+        (CoreConfig(hide_input_in_errors=True), 'type=string_too_long'),
     ),
 )
 def test_function_before_error_hide_input(config, input_str):
@@ -102,9 +103,9 @@ def my_function(input_value, info):
         {
             'type': 'function-before',
             'function': {'type': 'with-info', 'function': my_function},
-            'schema': {'type': 'str', 'max_length': 5},
+            'schema': cs.str_schema(max_length=5),
         },
-        config,
+        config=config,
     )
 
     with pytest.raises(ValidationError, match=re.escape(f'String should have at most 5 characters [{input_str}]')):
@@ -121,10 +122,9 @@ def f(input_value, info):
         {
             'type': 'function-before',
             'function': {'type': 'with-info', 'function': f},
-            'schema': {
-                'type': 'typed-dict',
-                'fields': {'my_field': {'type': 'typed-dict-field', 'schema': {'type': 'str', 'max_length': 5}}},
-            },
+            'schema': cs.typed_dict_schema(
+                fields={'my_field': cs.typed_dict_field(schema=cs.str_schema(max_length=5))}
+            ),
         }
     )
 
@@ -148,7 +148,11 @@ def f(input_value, info):
         (None, {}, 'ValidationInfo(config=None, context=None, data=None, field_name=None)'),
         (None, {'context': {1: 2}}, 'ValidationInfo(config=None, context={1: 2}, data=None, field_name=None)'),
         (None, {'context': None}, 'ValidationInfo(config=None, context=None, data=None, field_name=None)'),
-        ({'title': 'hello'}, {}, "ValidationInfo(config={'title': 'hello'}, context=None, data=None, field_name=None)"),
+        (
+            CoreConfig(title='hello'),
+            {},
+            "ValidationInfo(config={'title': 'hello'}, context=None, data=None, field_name=None)",
+        ),
     ],
 )
 def test_val_info_repr(config, kwargs, expected_repr):
@@ -157,7 +161,7 @@ def f(input_value, info: core_schema.ValidationInfo):
         assert str(info) == expected_repr
         return input_value
 
-    v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.str_schema()), config)
+    v = SchemaValidator(core_schema.with_info_before_validator_function(f, core_schema.str_schema()), config=config)
 
     assert v.validate_python('input value', **kwargs) == 'input value'
 
@@ -241,8 +245,8 @@ def f(input_value, validator, info):
     'config,input_str',
     (
         ({}, "type=int_parsing, input_value='wrong', input_type=str"),
-        ({'hide_input_in_errors': False}, "type=int_parsing, input_value='wrong', input_type=str"),
-        ({'hide_input_in_errors': True}, 'type=int_parsing'),
+        (CoreConfig(hide_input_in_errors=False), "type=int_parsing, input_value='wrong', input_type=str"),
+        (CoreConfig(hide_input_in_errors=True), 'type=int_parsing'),
     ),
 )
 def test_function_wrap_error_hide_input(config, input_str):
@@ -254,7 +258,7 @@ def f(input_value, validator, info):
             assert str(e).startswith('1 validation error for ValidatorCallable\n')
             raise e
 
-    v = SchemaValidator(core_schema.with_info_wrap_validator_function(f, core_schema.int_schema()), config)
+    v = SchemaValidator(core_schema.with_info_wrap_validator_function(f, core_schema.int_schema()), config=config)
 
     with pytest.raises(
         ValidationError,
@@ -346,15 +350,15 @@ def f(input_value, info):
     'config,input_str',
     (
         ({}, "type=value_error, input_value='input value', input_type=str"),
-        ({'hide_input_in_errors': False}, "type=value_error, input_value='input value', input_type=str"),
-        ({'hide_input_in_errors': True}, 'type=value_error'),
+        (CoreConfig(hide_input_in_errors=False), "type=value_error, input_value='input value', input_type=str"),
+        (CoreConfig(hide_input_in_errors=True), 'type=value_error'),
     ),
 )
 def test_function_after_error_hide_input(config, input_str):
     def f(input_value, info):
         raise ValueError('foobar')
 
-    v = SchemaValidator(core_schema.with_info_after_validator_function(f, core_schema.str_schema()), config)
+    v = SchemaValidator(core_schema.with_info_after_validator_function(f, core_schema.str_schema()), config=config)
 
     with pytest.raises(ValidationError, match=re.escape(f'Value error, foobar [{input_str}]')):
         v.validate_python('input value')
@@ -369,20 +373,18 @@ def f(input_value, info):
         return input_value + ' Changed'
 
     v = SchemaValidator(
-        {
-            'type': 'typed-dict',
-            'fields': {
-                'test_field': {
-                    'type': 'typed-dict-field',
-                    'schema': {
+        cs.typed_dict_schema(
+            fields={
+                'test_field': cs.typed_dict_field(
+                    schema={
                         'type': 'function-after',
                         'function': {'type': 'with-info', 'function': f, 'field_name': 'test_field'},
-                        'schema': {'type': 'str'},
-                    },
-                }
+                        'schema': cs.str_schema(),
+                    }
+                )
             },
-            'config': {'allow_inf_nan': True},
-        }
+            config=CoreConfig(allow_inf_nan=True),
+        )
     )
 
     assert v.validate_python({'test_field': b'321'}) == {'test_field': '321 Changed'}
@@ -499,7 +501,7 @@ def __validate__(cls, input_value, info):
         {
             'type': 'function-after',
             'function': {'type': 'with-info', 'function': Foobar.__validate__},
-            'schema': {'type': 'str'},
+            'schema': cs.str_schema(),
         }
     )
 
diff --git a/tests/validators/test_generator.py b/tests/validators/test_generator.py
index f8d7fd429..411b2202e 100644
--- a/tests/validators/test_generator.py
+++ b/tests/validators/test_generator.py
@@ -3,7 +3,8 @@
 import pytest
 from dirty_equals import HasRepr, IsStr
 
-from pydantic_core import SchemaValidator, ValidationError
+from pydantic_core import CoreConfig, SchemaValidator, ValidationError
+from pydantic_core import core_schema as cs
 
 from ..conftest import Err, PyAndJson
 
@@ -33,9 +34,9 @@ def test_generator_json_int(py_and_json: PyAndJson, input_value, expected):
 @pytest.mark.parametrize(
     'config,input_str',
     (
-        ({}, 'type=iterable_type, input_value=5, input_type=int'),
-        ({'hide_input_in_errors': False}, 'type=iterable_type, input_value=5, input_type=int'),
-        ({'hide_input_in_errors': True}, 'type=iterable_type'),
+        (CoreConfig(), 'type=iterable_type, input_value=5, input_type=int'),
+        (CoreConfig(hide_input_in_errors=False), 'type=iterable_type, input_value=5, input_type=int'),
+        (CoreConfig(hide_input_in_errors=True), 'type=iterable_type'),
     ),
 )
 def test_generator_json_hide_input(py_and_json: PyAndJson, config, input_str):
@@ -150,7 +151,7 @@ def gen():
 
 
 def test_generator_too_long():
-    v = SchemaValidator({'type': 'generator', 'items_schema': {'type': 'int'}, 'max_length': 2})
+    v = SchemaValidator(cs.generator_schema(items_schema=cs.int_schema(), max_length=2))
 
     validating_iterator = v.validate_python(gen())
 
@@ -174,7 +175,7 @@ def test_generator_too_long():
 
 
 def test_generator_too_short():
-    v = SchemaValidator({'type': 'generator', 'items_schema': {'type': 'int'}, 'min_length': 4})
+    v = SchemaValidator(cs.generator_schema(items_schema=cs.int_schema(), min_length=4))
 
     validating_iterator = v.validate_python(gen())
 
diff --git a/tests/validators/test_int.py b/tests/validators/test_int.py
index c69d6bb9a..ffd8a85c6 100644
--- a/tests/validators/test_int.py
+++ b/tests/validators/test_int.py
@@ -7,6 +7,7 @@
 from dirty_equals import IsStr
 
 from pydantic_core import SchemaValidator, ValidationError, core_schema
+from pydantic_core import core_schema as cs
 
 from ..conftest import Err, PyAndJson, plain_repr
 
@@ -141,7 +142,7 @@ def test_int_py_and_json(py_and_json: PyAndJson, input_value, expected):
     ids=repr,
 )
 def test_int(input_value, expected):
-    v = SchemaValidator({'type': 'int'})
+    v = SchemaValidator(cs.int_schema())
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value)
@@ -187,7 +188,7 @@ def test_int(input_value, expected):
     ],
 )
 def test_positive_int(input_value, expected):
-    v = SchemaValidator({'type': 'int', 'gt': 0})
+    v = SchemaValidator(cs.int_schema(gt=0))
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value)
@@ -208,7 +209,7 @@ def test_positive_int(input_value, expected):
     ],
 )
 def test_negative_int(input_value, expected):
-    v = SchemaValidator({'type': 'int', 'lt': 0})
+    v = SchemaValidator(cs.int_schema(lt=0))
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value)
@@ -236,7 +237,7 @@ def test_negative_int(input_value, expected):
     ],
 )
 def test_positive_json(input_value, expected):
-    v = SchemaValidator({'type': 'int', 'gt': 0})
+    v = SchemaValidator(cs.int_schema(gt=0))
     json_input = json.dumps(input_value)
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
@@ -258,7 +259,7 @@ def test_positive_json(input_value, expected):
     ],
 )
 def test_negative_json(input_value, expected):
-    v = SchemaValidator({'type': 'int', 'lt': 0})
+    v = SchemaValidator(cs.int_schema(lt=0))
     json_input = json.dumps(input_value)
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
@@ -383,22 +384,22 @@ def test_union_int_simple(py_and_json: PyAndJson):
 
 
 def test_int_repr():
-    v = SchemaValidator({'type': 'int'})
+    v = SchemaValidator(cs.int_schema())
     assert (
         plain_repr(v)
         == 'SchemaValidator(title="int",validator=Int(IntValidator{strict:false}),definitions=[],cache_strings=True)'
     )
-    v = SchemaValidator({'type': 'int', 'strict': True})
+    v = SchemaValidator(cs.int_schema(strict=True))
     assert (
         plain_repr(v)
         == 'SchemaValidator(title="int",validator=Int(IntValidator{strict:true}),definitions=[],cache_strings=True)'
     )
-    v = SchemaValidator({'type': 'int', 'multiple_of': 7})
+    v = SchemaValidator(cs.int_schema(multiple_of=7))
     assert plain_repr(v).startswith('SchemaValidator(title="constrained-int",validator=ConstrainedInt(')
 
 
 def test_too_long(pydantic_version):
-    v = SchemaValidator({'type': 'int'})
+    v = SchemaValidator(cs.int_schema())
 
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python('1' * 4301)
@@ -421,7 +422,7 @@ def test_too_long(pydantic_version):
 
 
 def test_long_python():
-    v = SchemaValidator({'type': 'int'})
+    v = SchemaValidator(cs.int_schema())
 
     s = v.validate_python('1' * 4_300)
     assert s == int('1' * 4_300)
@@ -434,7 +435,7 @@ def test_long_python():
 
 
 def test_long_python_inequality():
-    v = SchemaValidator({'type': 'int', 'gt': 0, 'lt': int('1' * 4_300) - 5})
+    v = SchemaValidator(cs.int_schema(gt=0, lt=int('1' * 4_300) - 5))
 
     s = str(int('1' * 4_300) - 6)
     s = v.validate_python(s)
@@ -446,7 +447,7 @@ def test_long_python_inequality():
 
 
 def test_long_json():
-    v = SchemaValidator({'type': 'int'})
+    v = SchemaValidator(cs.int_schema())
 
     assert v.validate_json('-' + '1' * 400) == int('-' + '1' * 400)
 
@@ -463,7 +464,7 @@ def test_int_key(py_and_json: PyAndJson):
 
 
 def test_string_as_int_with_underscores() -> None:
-    v = SchemaValidator({'type': 'int'})
+    v = SchemaValidator(cs.int_schema())
     assert v.validate_python('1_000_000') == 1_000_000
     assert v.validate_json('"1_000_000"') == 1_000_000
 
@@ -479,7 +480,7 @@ class IntSubclass(int):
 
 
 def test_int_subclass() -> None:
-    v = SchemaValidator({'type': 'int'})
+    v = SchemaValidator(cs.int_schema())
     v_lax = v.validate_python(IntSubclass(1))
     assert v_lax == 1
     assert type(v_lax) == int
@@ -494,7 +495,7 @@ def test_int_subclass() -> None:
 
 
 def test_int_subclass_constraint() -> None:
-    v = SchemaValidator({'type': 'int', 'gt': 0})
+    v = SchemaValidator(cs.int_schema(gt=0))
     v_lax = v.validate_python(IntSubclass(1))
     assert v_lax == 1
     assert type(v_lax) == int
@@ -511,14 +512,14 @@ class FloatSubclass(float):
 
 
 def test_float_subclass() -> None:
-    v = SchemaValidator({'type': 'int'})
+    v = SchemaValidator(cs.int_schema())
     v_lax = v.validate_python(FloatSubclass(1))
     assert v_lax == 1
     assert type(v_lax) == int
 
 
 def test_int_subclass_plain_enum() -> None:
-    v = SchemaValidator({'type': 'int'})
+    v = SchemaValidator(cs.int_schema())
 
     from enum import Enum
 
@@ -531,7 +532,7 @@ class PlainEnum(Enum):
 
 
 def test_allow_inf_nan_true_json() -> None:
-    v = SchemaValidator(core_schema.int_schema(), core_schema.CoreConfig(allow_inf_nan=True))
+    v = SchemaValidator(core_schema.int_schema(), config=core_schema.CoreConfig(allow_inf_nan=True))
 
     assert v.validate_json('123') == 123
     with pytest.raises(ValidationError, match=r'Input should be a finite number \[type=finite_number'):
@@ -543,7 +544,7 @@ def test_allow_inf_nan_true_json() -> None:
 
 
 def test_allow_inf_nan_false_json() -> None:
-    v = SchemaValidator(core_schema.int_schema(), core_schema.CoreConfig(allow_inf_nan=False))
+    v = SchemaValidator(core_schema.int_schema(), config=core_schema.CoreConfig(allow_inf_nan=False))
 
     assert v.validate_json('123') == 123
     with pytest.raises(ValidationError, match=r'Input should be a finite number \[type=finite_number'):
@@ -555,7 +556,7 @@ def test_allow_inf_nan_false_json() -> None:
 
 
 def test_json_big_int_key():
-    v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'int'}, 'values_schema': {'type': 'str'}})
+    v = SchemaValidator(cs.dict_schema(keys_schema=cs.int_schema(), values_schema=cs.str_schema()))
     big_integer = 1433352099889938534014333520998899385340
     assert v.validate_python({big_integer: 'x'}) == {big_integer: 'x'}
     assert v.validate_json('{"' + str(big_integer) + '": "x"}') == {big_integer: 'x'}
diff --git a/tests/validators/test_is_instance.py b/tests/validators/test_is_instance.py
index 9bce323a7..a62406b04 100644
--- a/tests/validators/test_is_instance.py
+++ b/tests/validators/test_is_instance.py
@@ -3,6 +3,7 @@
 import pytest
 
 from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema
+from pydantic_core import core_schema as cs
 
 
 class Foo:
@@ -18,14 +19,14 @@ class Spam:
 
 
 def test_validate_json() -> None:
-    v = SchemaValidator({'type': 'is-instance', 'cls': Foo})
+    v = SchemaValidator(cs.is_instance_schema(cls=Foo))
     with pytest.raises(ValidationError) as exc_info:
         v.validate_json('"foo"')
         assert exc_info.value.errors()[0]['type'] == 'needs_python_object'
 
 
 def test_is_instance():
-    v = SchemaValidator({'type': 'is-instance', 'cls': Foo})
+    v = SchemaValidator(cs.is_instance_schema(cls=Foo))
     foo = Foo()
     assert v.validate_python(foo) == foo
     assert v.isinstance_python(foo) is True
@@ -65,14 +66,14 @@ def test_is_instance():
     ],
 )
 def test_is_instance_cases(schema_class, input_val, value):
-    v = SchemaValidator({'type': 'is-instance', 'cls': schema_class})
+    v = SchemaValidator(cs.is_instance_schema(cls=schema_class))
     assert v.isinstance_python(input_val) == value
 
 
 @pytest.mark.parametrize('input_cls', [123, 'foo', Foo(), [], {1: 2}])
 def test_is_instance_invalid(input_cls):
     with pytest.raises(SchemaError, match="SchemaError: 'cls' must be valid as the first argument to 'isinstance'"):
-        SchemaValidator({'type': 'is-instance', 'cls': input_cls})
+        SchemaValidator(cs.is_instance_schema(cls=input_cls))
 
 
 class HasIsInstanceMeta(type):
@@ -88,7 +89,7 @@ class HasIsInstance(metaclass=HasIsInstanceMeta):
 
 
 def test_instancecheck():
-    v = SchemaValidator({'type': 'is-instance', 'cls': HasIsInstance})
+    v = SchemaValidator(cs.is_instance_schema(cls=HasIsInstance))
     assert v.validate_python('true') == 'true'
 
     with pytest.raises(ValidationError, match='type=is_instance_of'):
@@ -99,7 +100,7 @@ def test_instancecheck():
 
 
 def test_repr():
-    v = SchemaValidator({'type': 'union', 'choices': [{'type': 'int'}, {'type': 'is-instance', 'cls': Foo}]})
+    v = SchemaValidator(cs.union_schema(choices=[cs.int_schema(), cs.is_instance_schema(cls=Foo)]))
     assert v.isinstance_python(4) is True
     assert v.isinstance_python(Bar()) is True
     assert v.isinstance_python('foo') is False
@@ -122,7 +123,7 @@ def test_repr():
     ],
 )
 def test_is_type(input_val, value):
-    v = SchemaValidator({'type': 'is-instance', 'cls': type})
+    v = SchemaValidator(cs.is_instance_schema(cls=type))
     assert v.isinstance_python(input_val) == value
 
 
diff --git a/tests/validators/test_list.py b/tests/validators/test_list.py
index 991a90cbc..124f7062f 100644
--- a/tests/validators/test_list.py
+++ b/tests/validators/test_list.py
@@ -9,6 +9,7 @@
 from dirty_equals import Contains, HasRepr, IsInstance, IsList, IsStr
 
 from pydantic_core import SchemaValidator, ValidationError, core_schema
+from pydantic_core import core_schema as cs
 
 from ..conftest import Err, PyAndJson, infinite_generator
 
@@ -33,7 +34,7 @@ def test_list_py_or_json(py_and_json: PyAndJson, input_value, expected):
 
 
 def test_list_strict():
-    v = SchemaValidator({'type': 'list', 'items_schema': {'type': 'int'}, 'strict': True})
+    v = SchemaValidator(cs.list_schema(items_schema=cs.int_schema(), strict=True))
     assert v.validate_python([1, 2, '33']) == [1, 2, 33]
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python((1, 2, '33'))
@@ -43,7 +44,7 @@ def test_list_strict():
 
 
 def test_list_no_copy():
-    v = SchemaValidator({'type': 'list'})
+    v = SchemaValidator(cs.list_schema())
     assert v.validate_python([1, 2, 3]) is not [1, 2, 3]  # noqa: F632
 
 
@@ -73,7 +74,7 @@ def gen_ints():
 )
 @pytest.mark.thread_unsafe  # generators in parameters not compatible with pytest-run-parallel, https://github.com/Quansight-Labs/pytest-run-parallel/issues/14
 def test_list_int(input_value, expected):
-    v = SchemaValidator({'type': 'list', 'items_schema': {'type': 'int'}})
+    v = SchemaValidator(cs.list_schema(items_schema=cs.int_schema()))
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value)
@@ -82,7 +83,7 @@ def test_list_int(input_value, expected):
 
 
 def test_list_json():
-    v = SchemaValidator({'type': 'list', 'items_schema': {'type': 'int'}})
+    v = SchemaValidator(cs.list_schema(items_schema=cs.int_schema()))
     assert v.validate_json('[1, "2", 3]') == [1, 2, 3]
 
     with pytest.raises(ValidationError) as exc_info:
@@ -107,7 +108,7 @@ def test_list_json():
     ],
 )
 def test_list_any(input_value, expected):
-    v = SchemaValidator({'type': 'list'})
+    v = SchemaValidator(cs.list_schema())
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value)
@@ -127,7 +128,7 @@ def test_list_any(input_value, expected):
     ],
 )
 def test_list_error(input_value, index):
-    v = SchemaValidator({'type': 'list', 'items_schema': {'type': 'int'}})
+    v = SchemaValidator(cs.list_schema(items_schema=cs.int_schema()))
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python(input_value)
     assert exc_info.value.errors(include_url=False) == [
@@ -173,7 +174,7 @@ def test_list_error(input_value, index):
 )
 @pytest.mark.thread_unsafe  # generators in parameters not compatible with pytest-run-parallel, https://github.com/Quansight-Labs/pytest-run-parallel/issues/14
 def test_list_length_constraints(kwargs: dict[str, Any], input_value, expected):
-    v = SchemaValidator({'type': 'list', **kwargs})
+    v = SchemaValidator(cs.list_schema(**kwargs))
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value)
@@ -191,11 +192,7 @@ def test_list_length_constraints(kwargs: dict[str, Any], input_value, expected):
 )
 def test_list_length_constraints_omit(input_value, expected):
     v = SchemaValidator(
-        {
-            'type': 'list',
-            'items_schema': {'type': 'default', 'schema': {'type': 'int'}, 'on_error': 'omit'},
-            'max_length': 4,
-        }
+        cs.list_schema(items_schema=cs.with_default_schema(schema=cs.int_schema(), on_error='omit'), max_length=4)
     )
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
@@ -205,7 +202,7 @@ def test_list_length_constraints_omit(input_value, expected):
 
 
 def test_length_ctx():
-    v = SchemaValidator({'type': 'list', 'min_length': 2, 'max_length': 3})
+    v = SchemaValidator(cs.list_schema(min_length=2, max_length=3))
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python([1])
     # insert_assert(exc_info.value.errors(include_url=False))
@@ -238,7 +235,7 @@ def test_list_function():
     def f(input_value, info):
         return input_value * 2
 
-    v = SchemaValidator({'type': 'list', 'items_schema': core_schema.with_info_plain_validator_function(f)})
+    v = SchemaValidator(cs.list_schema(items_schema=core_schema.with_info_plain_validator_function(f)))
 
     assert v.validate_python([1, 2, 3]) == [2, 4, 6]
 
@@ -247,7 +244,7 @@ def test_list_function_val_error():
     def f(input_value, info):
         raise ValueError(f'error {input_value}')
 
-    v = SchemaValidator({'type': 'list', 'items_schema': core_schema.with_info_plain_validator_function(f)})
+    v = SchemaValidator(cs.list_schema(items_schema=core_schema.with_info_plain_validator_function(f)))
 
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python([1, 2])
@@ -273,7 +270,7 @@ def test_list_function_internal_error():
     def f(input_value, info):
         raise RuntimeError(f'error {input_value}')
 
-    v = SchemaValidator({'type': 'list', 'items_schema': core_schema.with_info_plain_validator_function(f)})
+    v = SchemaValidator(cs.list_schema(items_schema=core_schema.with_info_plain_validator_function(f)))
 
     with pytest.raises(RuntimeError, match='^error 1$') as exc_info:
         v.validate_python([1, 2])
@@ -288,7 +285,7 @@ def gen(error: bool):
             raise RuntimeError('error')
         yield 3
 
-    v = SchemaValidator({'type': 'list', 'items_schema': {'type': 'int'}})
+    v = SchemaValidator(cs.list_schema(items_schema=cs.int_schema()))
     assert v.validate_python(gen(False)) == [1, 2, 3]
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python(gen(True))
@@ -322,7 +319,7 @@ def gen(error: bool):
     ],
 )
 def test_list_from_dict_items(input_value, items_schema, expected):
-    v = SchemaValidator({'type': 'list', 'items_schema': items_schema})
+    v = SchemaValidator(cs.list_schema(items_schema=items_schema))
     output = v.validate_python(input_value)
     assert isinstance(output, list)
     assert output == expected
@@ -350,7 +347,7 @@ def __next__(self):
             else:
                 raise RuntimeError('broken')
 
-    v = SchemaValidator({'type': 'list', 'items_schema': {'type': items_schema}})
+    v = SchemaValidator(cs.list_schema(items_schema={'type': items_schema}))
     assert v.validate_python(BadIter(True)) == [1]
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python(BadIter(False))
diff --git a/tests/validators/test_literal.py b/tests/validators/test_literal.py
index 2b3f88a4e..70b1ba0b0 100644
--- a/tests/validators/test_literal.py
+++ b/tests/validators/test_literal.py
@@ -5,6 +5,7 @@
 import pytest
 
 from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema
+from pydantic_core import core_schema as cs
 
 from ..conftest import Err, PyAndJson, plain_repr
 
@@ -147,7 +148,7 @@ def test_literal_py_and_json(py_and_json: PyAndJson, kwarg_expected, input_value
     ],
 )
 def test_literal_not_json(kwarg_expected, input_value, expected):
-    v = SchemaValidator({'type': 'literal', 'expected': kwarg_expected})
+    v = SchemaValidator(cs.literal_schema(expected=kwarg_expected))
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)) as exc_info:
             v.validate_python(input_value)
@@ -160,7 +161,7 @@ def test_literal_not_json(kwarg_expected, input_value, expected):
 
 def test_build_error():
     with pytest.raises(SchemaError, match='SchemaError: `expected` should have length > 0'):
-        SchemaValidator({'type': 'literal', 'expected': []})
+        SchemaValidator(cs.literal_schema(expected=[]))
 
 
 def test_literal_none():
diff --git a/tests/validators/test_model.py b/tests/validators/test_model.py
index 1d6ab7f47..2ce2c0a56 100644
--- a/tests/validators/test_model.py
+++ b/tests/validators/test_model.py
@@ -7,7 +7,7 @@
 import pytest
 from dirty_equals import HasRepr, IsInstance
 
-from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema
+from pydantic_core import CoreConfig, SchemaError, SchemaValidator, ValidationError, core_schema
 
 
 def test_model_class():
@@ -184,14 +184,12 @@ def __setattr__(self, key, value):
     setattr_calls.clear()
 
     v = SchemaValidator(
-        {
-            'type': 'model',
-            'cls': MyModel,
-            'schema': {
-                'type': 'model-fields',
-                'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}},
-            },
-        }
+        core_schema.model_schema(
+            cls=MyModel,
+            schema=core_schema.model_fields_schema(
+                fields={'field_a': core_schema.model_field(schema=core_schema.str_schema())}
+            ),
+        )
     )
     m = v.validate_python({'field_a': 'test'})
     assert isinstance(m, MyModel)
@@ -317,18 +315,16 @@ def f(input_value, info):
         return input_value
 
     SchemaValidator(
-        {
-            'type': 'model',
-            'cls': MyModel,
-            'schema': {
+        core_schema.model_schema(
+            cls=MyModel,
+            schema={
                 'type': f'function-{mode}',
                 'function': {'type': 'with-info', 'function': f},
-                'schema': {
-                    'type': 'model-fields',
-                    'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}},
-                },
+                'schema': core_schema.model_fields_schema(
+                    fields={'field_a': core_schema.model_field(schema=core_schema.str_schema())}
+                ),
             },
-        }
+        )
     )
 
 
@@ -339,7 +335,7 @@ class MyModel:
     def f(input_value):
         return input_value, {1: 2}, {'field_a'}
 
-    v = SchemaValidator({'type': 'model', 'cls': MyModel, 'schema': core_schema.no_info_plain_validator_function(f)})
+    v = SchemaValidator(core_schema.model_schema(cls=MyModel, schema=core_schema.no_info_plain_validator_function(f)))
     m = v.validate_python({'field_a': 'test'})
     assert isinstance(m, MyModel)
     assert m.__dict__ == {'field_a': 'test'}
@@ -352,17 +348,19 @@ class MyModel:
         __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__'
 
     v = SchemaValidator(
-        {
-            'type': 'model',
-            'cls': MyModel,
-            'schema': {
-                'type': 'union',
-                'choices': [
-                    {'type': 'model-fields', 'fields': {'foo': {'type': 'model-field', 'schema': {'type': 'int'}}}},
-                    {'type': 'model-fields', 'fields': {'bar': {'type': 'model-field', 'schema': {'type': 'int'}}}},
-                ],
-            },
-        }
+        core_schema.model_schema(
+            cls=MyModel,
+            schema=core_schema.union_schema(
+                choices=[
+                    core_schema.model_fields_schema(
+                        fields={'foo': core_schema.model_field(schema=core_schema.int_schema())}
+                    ),
+                    core_schema.model_fields_schema(
+                        fields={'bar': core_schema.model_field(schema=core_schema.int_schema())}
+                    ),
+                ]
+            ),
+        )
     )
     m = v.validate_python({'foo': '123'})
     assert isinstance(m, MyModel)
@@ -379,33 +377,28 @@ class MyModel:
         pass
 
     v = SchemaValidator(
-        {
-            'type': 'model',
-            'cls': MyModel,
-            'schema': {
-                'type': 'tagged-union',
-                'discriminator': 'foo',
-                'choices': {
-                    'apple': {
-                        'type': 'model-fields',
-                        'fields': {
-                            'foo': {'type': 'model-field', 'schema': {'type': 'str'}},
-                            'bar': {'type': 'model-field', 'schema': {'type': 'int'}},
-                        },
-                    },
-                    'banana': {
-                        'type': 'model-fields',
-                        'fields': {
-                            'foo': {'type': 'model-field', 'schema': {'type': 'str'}},
-                            'spam': {
-                                'type': 'model-field',
-                                'schema': {'type': 'list', 'items_schema': {'type': 'int'}},
-                            },
-                        },
-                    },
+        core_schema.model_schema(
+            cls=MyModel,
+            schema=core_schema.tagged_union_schema(
+                discriminator='foo',
+                choices={
+                    'apple': core_schema.model_fields_schema(
+                        fields={
+                            'foo': core_schema.model_field(schema=core_schema.str_schema()),
+                            'bar': core_schema.model_field(schema=core_schema.int_schema()),
+                        }
+                    ),
+                    'banana': core_schema.model_fields_schema(
+                        fields={
+                            'foo': core_schema.model_field(schema=core_schema.str_schema()),
+                            'spam': core_schema.model_field(
+                                schema=core_schema.list_schema(items_schema=core_schema.int_schema())
+                            ),
+                        }
+                    ),
                 },
-            },
-        }
+            ),
+        )
     )
     m = v.validate_python({'foo': 'apple', 'bar': '123'})
     assert isinstance(m, MyModel)
@@ -433,7 +426,7 @@ def test_bad_sub_schema():
     class MyModel:
         pass
 
-    v = SchemaValidator({'type': 'model', 'cls': MyModel, 'schema': {'type': 'int'}})
+    v = SchemaValidator(core_schema.model_schema(cls=MyModel, schema=core_schema.int_schema()))
     with pytest.raises(TypeError):
         v.validate_python(123)
 
@@ -447,18 +440,16 @@ def f(input_value, info):
         return input_value
 
     v = SchemaValidator(
-        {
-            'type': 'model',
-            'cls': MyModel,
-            'schema': {
+        core_schema.model_schema(
+            cls=MyModel,
+            schema={
                 'type': 'function-after',
                 'function': {'type': 'with-info', 'function': f},
-                'schema': {
-                    'type': 'model-fields',
-                    'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}},
-                },
+                'schema': core_schema.model_fields_schema(
+                    fields={'field_a': core_schema.model_field(schema=core_schema.str_schema())}
+                ),
             },
-        }
+        )
     )
     m = v.validate_python({'field_a': 'test'})
     assert isinstance(m, MyModel)
@@ -469,14 +460,12 @@ def f(input_value, info):
 def test_model_class_not_type():
     with pytest.raises(SchemaError, match=re.escape("TypeError: 'int' object cannot be converted to 'PyType'")):
         SchemaValidator(
-            {
-                'type': 'model',
-                'cls': 123,
-                'schema': {
-                    'type': 'model-fields',
-                    'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}},
-                },
-            }
+            schema=core_schema.model_schema(
+                cls=123,
+                schema=core_schema.model_fields_schema(
+                    fields={'field_a': core_schema.model_field(schema=core_schema.str_schema())}
+                ),
+            )
         )
 
 
@@ -489,14 +478,12 @@ def __init__(self):
             self.field_a = 'init'
 
     v = SchemaValidator(
-        {
-            'type': 'model',
-            'cls': MyModel,
-            'schema': {
-                'type': 'model-fields',
-                'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}},
-            },
-        }
+        core_schema.model_schema(
+            cls=MyModel,
+            schema=core_schema.model_fields_schema(
+                fields={'field_a': core_schema.model_field(schema=core_schema.str_schema())}
+            ),
+        )
     )
     m1 = v.validate_python({'field_a': 'test'})
     assert isinstance(m1, MyModel)
@@ -530,15 +517,13 @@ def __init__(self):
             self.field_b = 'init_b'
 
     v = SchemaValidator(
-        {
-            'type': 'model',
-            'cls': MyModel,
-            'schema': {
-                'type': 'model-fields',
-                'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}},
-            },
-            'post_init': 'model_post_init',
-        }
+        core_schema.model_schema(
+            cls=MyModel,
+            schema=core_schema.model_fields_schema(
+                fields={'field_a': core_schema.model_field(schema=core_schema.str_schema())}
+            ),
+            post_init='model_post_init',
+        )
     )
 
     m2 = MySubModel()
@@ -579,16 +564,14 @@ def __init__(self):
             self.field_b = 'init_b'
 
     v = SchemaValidator(
-        {
-            'type': 'model',
-            'cls': MyModel,
-            'schema': {
-                'type': 'model-fields',
-                'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}},
-            },
-            'post_init': 'model_post_init',
-            'revalidate_instances': 'always',
-        }
+        core_schema.model_schema(
+            cls=MyModel,
+            schema=core_schema.model_fields_schema(
+                fields={'field_a': core_schema.model_field(schema=core_schema.str_schema())}
+            ),
+            post_init='model_post_init',
+            revalidate_instances='always',
+        )
     )
 
     m2 = MySubModel()
@@ -619,18 +602,16 @@ def __init__(self):
             self.field_b = 'init_b'
 
     v = SchemaValidator(
-        {
-            'type': 'model',
-            'strict': True,
-            'cls': MyModel,
-            'schema': {
-                'type': 'model-fields',
-                'fields': {
-                    'field_a': {'type': 'model-field', 'schema': {'type': 'str'}},
-                    'field_b': {'type': 'model-field', 'schema': {'type': 'int'}},
-                },
-            },
-        }
+        core_schema.model_schema(
+            strict=True,
+            cls=MyModel,
+            schema=core_schema.model_fields_schema(
+                fields={
+                    'field_a': core_schema.model_field(schema=core_schema.str_schema()),
+                    'field_b': core_schema.model_field(schema=core_schema.int_schema()),
+                }
+            ),
+        )
     )
     assert re.search(r'revalidate: \w+', repr(v)).group(0) == 'revalidate: Never'
     m = MyModel()
@@ -666,22 +647,19 @@ class MyModel:
         field_c: int
 
     v = SchemaValidator(
-        {
-            'type': 'model',
-            'strict': True,
-            'cls': MyModel,
-            'schema': {
-                'type': 'model-fields',
-                'fields': {
-                    'field_a': {'type': 'model-field', 'schema': {'type': 'str'}},
-                    'field_b': {'type': 'model-field', 'schema': {'type': 'int'}},
-                    'field_c': {
-                        'type': 'model-field',
-                        'schema': {'type': 'default', 'default': 42, 'schema': {'type': 'int'}},
-                    },
-                },
-            },
-        }
+        core_schema.model_schema(
+            strict=True,
+            cls=MyModel,
+            schema=core_schema.model_fields_schema(
+                fields={
+                    'field_a': core_schema.model_field(schema=core_schema.str_schema()),
+                    'field_b': core_schema.model_field(schema=core_schema.int_schema()),
+                    'field_c': core_schema.model_field(
+                        schema=core_schema.with_default_schema(default=42, schema=core_schema.int_schema())
+                    ),
+                }
+            ),
+        )
     )
     m = v.validate_json('{"field_a": "foobar", "field_b": "123"}')
     assert isinstance(m, MyModel)
@@ -693,11 +671,12 @@ class MyModel:
 
 def test_internal_error():
     v = SchemaValidator(
-        {
-            'type': 'model',
-            'cls': int,
-            'schema': {'type': 'model-fields', 'fields': {'f': {'type': 'model-field', 'schema': {'type': 'int'}}}},
-        }
+        core_schema.model_schema(
+            cls=int,
+            schema=core_schema.model_fields_schema(
+                fields={'f': core_schema.model_field(schema=core_schema.int_schema())}
+            ),
+        )
     )
     with pytest.raises(AttributeError, match=re.escape("'int' object has no attribute '__dict__'")):
         v.validate_python({'f': 123})
@@ -715,18 +694,16 @@ def __init__(self, a, b, fields_set):
                 self.__pydantic_fields_set__ = fields_set
 
     v = SchemaValidator(
-        {
-            'type': 'model',
-            'cls': MyModel,
-            'revalidate_instances': 'always',
-            'schema': {
-                'type': 'model-fields',
-                'fields': {
-                    'field_a': {'type': 'model-field', 'schema': {'type': 'str'}},
-                    'field_b': {'type': 'model-field', 'schema': {'type': 'int'}},
-                },
-            },
-        }
+        core_schema.model_schema(
+            cls=MyModel,
+            revalidate_instances='always',
+            schema=core_schema.model_fields_schema(
+                fields={
+                    'field_a': core_schema.model_field(schema=core_schema.str_schema()),
+                    'field_b': core_schema.model_field(schema=core_schema.int_schema()),
+                }
+            ),
+        )
     )
     assert re.search(r'revalidate: \w+', repr(v)).group(0) == 'revalidate: Always'
 
@@ -773,18 +750,16 @@ def __init__(self):
             self.field_c = 'init_c'
 
     v = SchemaValidator(
-        {
-            'type': 'model',
-            'cls': MyModel,
-            'revalidate_instances': 'subclass-instances',
-            'schema': {
-                'type': 'model-fields',
-                'fields': {
-                    'field_a': {'type': 'model-field', 'schema': {'type': 'str'}},
-                    'field_b': {'type': 'model-field', 'schema': {'type': 'int'}},
-                },
-            },
-        }
+        core_schema.model_schema(
+            cls=MyModel,
+            revalidate_instances='subclass-instances',
+            schema=core_schema.model_fields_schema(
+                fields={
+                    'field_a': core_schema.model_field(schema=core_schema.str_schema()),
+                    'field_b': core_schema.model_field(schema=core_schema.int_schema()),
+                }
+            ),
+        )
     )
 
     m1 = MyModel()
@@ -816,19 +791,17 @@ def __init__(self, **kwargs):
             self.__dict__.update(kwargs)
 
     v = SchemaValidator(
-        {
-            'type': 'model',
-            'cls': MyModel,
-            'schema': {
-                'type': 'model-fields',
-                'extra_behavior': 'allow',
-                'fields': {
-                    'field_a': {'type': 'model-field', 'schema': {'type': 'str'}},
-                    'field_b': {'type': 'model-field', 'schema': {'type': 'int'}},
+        core_schema.model_schema(
+            cls=MyModel,
+            schema=core_schema.model_fields_schema(
+                extra_behavior='allow',
+                fields={
+                    'field_a': core_schema.model_field(schema=core_schema.str_schema()),
+                    'field_b': core_schema.model_field(schema=core_schema.int_schema()),
                 },
-            },
-            'config': {'revalidate_instances': 'always'},
-        }
+            ),
+            config=CoreConfig(revalidate_instances='always'),
+        )
     )
 
     m = v.validate_python({'field_a': 'test', 'field_b': 12, 'more': (1, 2, 3)})
@@ -867,18 +840,16 @@ def call_me_maybe(self, *args):
             assert self.__pydantic_fields_set__ == {'field_a', 'field_b'}
 
     v = SchemaValidator(
-        {
-            'type': 'model',
-            'cls': MyModel,
-            'post_init': 'call_me_maybe',
-            'schema': {
-                'type': 'model-fields',
-                'fields': {
-                    'field_a': {'type': 'model-field', 'schema': {'type': 'str'}},
-                    'field_b': {'type': 'model-field', 'schema': {'type': 'int'}},
-                },
-            },
-        }
+        core_schema.model_schema(
+            cls=MyModel,
+            post_init='call_me_maybe',
+            schema=core_schema.model_fields_schema(
+                fields={
+                    'field_a': core_schema.model_field(schema=core_schema.str_schema()),
+                    'field_b': core_schema.model_field(schema=core_schema.int_schema()),
+                }
+            ),
+        )
     )
     m = v.validate_python({'field_a': 'test', 'field_b': 12})
     assert isinstance(m, MyModel)
@@ -897,19 +868,17 @@ def call_me_maybe(self, context):
             assert context is None
 
     v = SchemaValidator(
-        {
-            'type': 'model',
-            'cls': MyModel,
-            'post_init': 'call_me_maybe',
-            'schema': {
-                'type': 'model-fields',
-                'fields': {
-                    'field_a': {'type': 'model-field', 'schema': {'type': 'str'}},
-                    'field_b': {'type': 'model-field', 'schema': {'type': 'int'}},
-                },
-            },
-            'config': {'revalidate_instances': 'always'},
-        }
+        core_schema.model_schema(
+            cls=MyModel,
+            post_init='call_me_maybe',
+            schema=core_schema.model_fields_schema(
+                fields={
+                    'field_a': core_schema.model_field(schema=core_schema.str_schema()),
+                    'field_b': core_schema.model_field(schema=core_schema.int_schema()),
+                }
+            ),
+            config=CoreConfig(revalidate_instances='always'),
+        )
     )
     assert re.search(r'revalidate: \w+', repr(v)).group(0) == 'revalidate: Always'
 
@@ -943,15 +912,13 @@ def call_me_maybe(self, context, **kwargs):
                 raise ValueError(f'this is broken: {self.field_a}')
 
     v = SchemaValidator(
-        {
-            'type': 'model',
-            'cls': MyModel,
-            'post_init': 'call_me_maybe',
-            'schema': {
-                'type': 'model-fields',
-                'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}},
-            },
-        }
+        core_schema.model_schema(
+            cls=MyModel,
+            post_init='call_me_maybe',
+            schema=core_schema.model_fields_schema(
+                fields={'field_a': core_schema.model_field(schema=core_schema.str_schema())}
+            ),
+        )
     )
     m = v.validate_python({'field_a': 'test'})
     assert isinstance(m, MyModel)
@@ -979,15 +946,13 @@ def wrong_signature(self):
             pass
 
     v = SchemaValidator(
-        {
-            'type': 'model',
-            'cls': MyModel,
-            'post_init': 'wrong_signature',
-            'schema': {
-                'type': 'model-fields',
-                'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}},
-            },
-        }
+        core_schema.model_schema(
+            cls=MyModel,
+            post_init='wrong_signature',
+            schema=core_schema.model_fields_schema(
+                fields={'field_a': core_schema.model_field(schema=core_schema.str_schema())}
+            ),
+        )
     )
     with pytest.raises(TypeError, match=r'wrong_signature\(\) takes 1 positional argument but 2 were given'):
         v.validate_python({'field_a': 'test'})
@@ -1004,18 +969,16 @@ def call_me_maybe(self, context, **kwargs):
             self.__pydantic_fields_set__ = {'field_a'}
 
     v = SchemaValidator(
-        {
-            'type': 'model',
-            'cls': MyModel,
-            'post_init': 'call_me_maybe',
-            'schema': {
-                'type': 'model-fields',
-                'fields': {
-                    'field_a': {'type': 'model-field', 'schema': {'type': 'str'}},
-                    'field_b': {'type': 'model-field', 'schema': {'type': 'int'}},
-                },
-            },
-        }
+        core_schema.model_schema(
+            cls=MyModel,
+            post_init='call_me_maybe',
+            schema=core_schema.model_fields_schema(
+                fields={
+                    'field_a': core_schema.model_field(schema=core_schema.str_schema()),
+                    'field_b': core_schema.model_field(schema=core_schema.int_schema()),
+                }
+            ),
+        )
     )
     m = v.validate_python({'field_a': 'test', 'field_b': 12})
     assert isinstance(m, MyModel)
@@ -1125,17 +1088,15 @@ def __init__(self):
             self.__pydantic_extra__ = None
 
     v = SchemaValidator(
-        {
-            'type': 'model',
-            'cls': MyModel,
-            'schema': {
-                'type': 'model-fields',
-                'fields': {
-                    'field_a': {'type': 'model-field', 'schema': {'type': 'str'}},
-                    'field_b': {'type': 'model-field', 'schema': {'type': 'int'}},
-                },
-            },
-        }
+        core_schema.model_schema(
+            cls=MyModel,
+            schema=core_schema.model_fields_schema(
+                fields={
+                    'field_a': core_schema.model_field(schema=core_schema.str_schema()),
+                    'field_b': core_schema.model_field(schema=core_schema.int_schema()),
+                }
+            ),
+        )
     )
 
     m = MyModel()
diff --git a/tests/validators/test_model_fields.py b/tests/validators/test_model_fields.py
index 491a3baf8..e5dd53994 100644
--- a/tests/validators/test_model_fields.py
+++ b/tests/validators/test_model_fields.py
@@ -42,13 +42,12 @@ def __repr__(self):
 
 def test_simple():
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'fields': {
-                'field_a': {'type': 'model-field', 'schema': {'type': 'str'}},
-                'field_b': {'type': 'model-field', 'schema': {'type': 'int'}},
-            },
-        }
+        core_schema.model_fields_schema(
+            fields={
+                'field_a': core_schema.model_field(schema=core_schema.str_schema()),
+                'field_b': core_schema.model_field(schema=core_schema.int_schema()),
+            }
+        )
     )
 
     assert v.validate_python({'field_a': b'abc', 'field_b': 1}) == (
@@ -67,7 +66,7 @@ def test_strict():
                 'field_b': {'type': 'model-field', 'schema': {'type': 'int'}},
             },
         },
-        {'strict': True},
+        CoreConfig(strict=True),
     )
 
     assert v.validate_python({'field_a': 'hello', 'field_b': 12}) == (
@@ -86,16 +85,14 @@ def test_strict():
 
 def test_with_default():
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'fields': {
-                'field_a': {'type': 'model-field', 'schema': {'type': 'str'}},
-                'field_b': {
-                    'type': 'model-field',
-                    'schema': {'type': 'default', 'schema': {'type': 'int'}, 'default': 666},
-                },
-            },
-        }
+        core_schema.model_fields_schema(
+            fields={
+                'field_a': core_schema.model_field(schema=core_schema.str_schema()),
+                'field_b': core_schema.model_field(
+                    schema=core_schema.with_default_schema(schema=core_schema.int_schema(), default=666)
+                ),
+            }
+        )
     )
 
     assert v.validate_python({'field_a': b'abc'}) == ({'field_a': 'abc', 'field_b': 666}, None, {'field_a'})
@@ -108,13 +105,12 @@ def test_with_default():
 
 def test_missing_error(pydantic_version):
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'fields': {
-                'field_a': {'type': 'model-field', 'schema': {'type': 'str'}},
-                'field_b': {'type': 'model-field', 'schema': {'type': 'int'}},
-            },
-        }
+        core_schema.model_fields_schema(
+            fields={
+                'field_a': core_schema.model_field(schema=core_schema.str_schema()),
+                'field_b': core_schema.model_field(schema=core_schema.int_schema()),
+            }
+        )
     )
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python({'field_a': b'abc'})
@@ -135,17 +131,21 @@ def test_missing_error(pydantic_version):
         ({}, Map(a=123), ({'a': 123, 'b': 4.2}, None, {'a'})),
         ({}, {b'a': '123'}, Err('Field required [type=missing,')),
         ({}, {'a': '123', 'c': 4}, ({'a': 123, 'b': 4.2}, None, {'a'})),
-        ({'extra_fields_behavior': 'allow'}, {'a': '123', 'c': 4}, ({'a': 123, 'b': 4.2}, {'c': 4}, {'a', 'c'})),
-        ({'extra_fields_behavior': 'allow'}, {'a': '123', b'c': 4}, Err('Keys should be strings [type=invalid_key,')),
+        (CoreConfig(extra_fields_behavior='allow'), {'a': '123', 'c': 4}, ({'a': 123, 'b': 4.2}, {'c': 4}, {'a', 'c'})),
         (
-            {'strict': True},
+            CoreConfig(extra_fields_behavior='allow'),
+            {'a': '123', b'c': 4},
+            Err('Keys should be strings [type=invalid_key,'),
+        ),
+        (
+            CoreConfig(strict=True),
             Map(a=123),
             Err('Input should be a valid dictionary or instance of Model [type=model_type,'),
         ),
         ({}, {'a': '123', 'b': '4.7'}, ({'a': 123, 'b': 4.7}, None, {'a', 'b'})),
         ({}, {'a': '123', 'b': 'nan'}, ({'a': 123, 'b': FunctionCheck(math.isnan)}, None, {'a', 'b'})),
         (
-            {'allow_inf_nan': False},
+            CoreConfig(allow_inf_nan=False),
             {'a': '123', 'b': 'nan'},
             Err('Input should be a finite number [type=finite_number,'),
         ),
@@ -154,17 +154,15 @@ def test_missing_error(pydantic_version):
 )
 def test_config(config: CoreConfig, input_value, expected):
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'fields': {
-                'a': {'type': 'model-field', 'schema': {'type': 'int'}},
-                'b': {
-                    'type': 'model-field',
-                    'schema': {'type': 'default', 'schema': {'type': 'float'}, 'default': 4.2},
-                },
-            },
-        },
-        config,
+        core_schema.model_fields_schema(
+            fields={
+                'a': core_schema.model_field(schema=core_schema.int_schema()),
+                'b': core_schema.model_field(
+                    schema=core_schema.with_default_schema(schema=core_schema.float_schema(), default=4.2)
+                ),
+            }
+        ),
+        config=config,
     )
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
@@ -177,13 +175,12 @@ def test_config(config: CoreConfig, input_value, expected):
 
 def test_ignore_extra():
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'fields': {
-                'field_a': {'type': 'model-field', 'schema': {'type': 'str'}},
-                'field_b': {'type': 'model-field', 'schema': {'type': 'int'}},
-            },
-        }
+        core_schema.model_fields_schema(
+            fields={
+                'field_a': core_schema.model_field(schema=core_schema.str_schema()),
+                'field_b': core_schema.model_field(schema=core_schema.int_schema()),
+            }
+        )
     )
 
     assert v.validate_python({'field_a': b'123', 'field_b': 1, 'field_c': 123}) == (
@@ -195,11 +192,9 @@ def test_ignore_extra():
 
 def test_forbid_extra():
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}},
-            'extra_behavior': 'forbid',
-        }
+        core_schema.model_fields_schema(
+            fields={'field_a': core_schema.model_field(schema=core_schema.str_schema())}, extra_behavior='forbid'
+        )
     )
 
     with pytest.raises(ValidationError) as exc_info:
@@ -213,19 +208,23 @@ def test_forbid_extra():
 def test_allow_extra_invalid():
     with pytest.raises(SchemaError, match='extras_schema can only be used if extra_behavior=allow'):
         SchemaValidator(
-            {'type': 'model-fields', 'fields': {}, 'extras_schema': {'type': 'int'}, 'extra_behavior': 'ignore'}
+            schema=core_schema.model_fields_schema(
+                fields={}, extras_schema=core_schema.int_schema(), extra_behavior='ignore'
+            )
         )
 
 
 def test_allow_extra_wrong():
     with pytest.raises(SchemaError, match='Invalid extra_behavior: `wrong`'):
-        SchemaValidator({'type': 'model-fields', 'fields': {}}, {'extra_fields_behavior': 'wrong'})
+        SchemaValidator(
+            schema=core_schema.model_fields_schema(fields={}), config=CoreConfig(extra_fields_behavior='wrong')
+        )
 
 
 def test_str_config():
     v = SchemaValidator(
-        {'type': 'model-fields', 'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}}},
-        {'str_max_length': 5},
+        core_schema.model_fields_schema(fields={'field_a': core_schema.model_field(schema=core_schema.str_schema())}),
+        config=CoreConfig(str_max_length=5),
     )
     assert v.validate_python({'field_a': 'test'}) == ({'field_a': 'test'}, None, {'field_a'})
 
@@ -235,7 +234,7 @@ def test_str_config():
 
 def test_validate_assignment():
     v = SchemaValidator(
-        {'type': 'model-fields', 'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}}}
+        core_schema.model_fields_schema(fields={'field_a': core_schema.model_field(schema=core_schema.str_schema())})
     )
 
     assert v.validate_python({'field_a': 'test'}) == ({'field_a': 'test'}, None, {'field_a'})
@@ -247,10 +246,9 @@ def test_validate_assignment():
 
 def test_validate_assignment_strict_field():
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'str', 'strict': True}}},
-        }
+        core_schema.model_fields_schema(
+            fields={'field_a': core_schema.model_field(schema=core_schema.str_schema(strict=True))}
+        )
     )
 
     assert v.validate_python({'field_a': 'test'}) == ({'field_a': 'test'}, None, {'field_a'})
@@ -274,27 +272,24 @@ def func_b(input_value, info):
         return input_value / 2
 
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'fields': {
-                'field_a': {
-                    'type': 'model-field',
-                    'schema': {
+        core_schema.model_fields_schema(
+            fields={
+                'field_a': core_schema.model_field(
+                    schema={
                         'type': 'function-after',
                         'function': {'type': 'with-info', 'function': func_a},
-                        'schema': {'type': 'str'},
-                    },
-                },
-                'field_b': {
-                    'type': 'model-field',
-                    'schema': {
+                        'schema': core_schema.str_schema(),
+                    }
+                ),
+                'field_b': core_schema.model_field(
+                    schema={
                         'type': 'function-after',
                         'function': {'type': 'with-info', 'function': func_b},
-                        'schema': {'type': 'int'},
-                    },
-                },
-            },
-        }
+                        'schema': core_schema.int_schema(),
+                    }
+                ),
+            }
+        )
     )
 
     assert v.validate_python({'field_a': 'test', 'field_b': 12.0}) == (
@@ -316,7 +311,7 @@ def func_b(input_value, info):
 
 def test_validate_assignment_ignore_extra():
     v = SchemaValidator(
-        {'type': 'model-fields', 'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}}}
+        core_schema.model_fields_schema(fields={'field_a': core_schema.model_field(schema=core_schema.str_schema())})
     )
 
     assert v.validate_python({'field_a': 'test'}) == ({'field_a': 'test'}, None, {'field_a'})
@@ -338,11 +333,9 @@ def test_validate_assignment_ignore_extra():
 
 def test_validate_assignment_allow_extra():
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}},
-            'extra_behavior': 'allow',
-        }
+        core_schema.model_fields_schema(
+            fields={'field_a': core_schema.model_field(schema=core_schema.str_schema())}, extra_behavior='allow'
+        )
     )
 
     assert v.validate_python({'field_a': 'test'}) == ({'field_a': 'test'}, {}, {'field_a'})
@@ -356,12 +349,11 @@ def test_validate_assignment_allow_extra():
 
 def test_validate_assignment_allow_extra_validate():
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'str'}}},
-            'extras_schema': {'type': 'int'},
-            'extra_behavior': 'allow',
-        }
+        core_schema.model_fields_schema(
+            fields={'field_a': core_schema.model_field(schema=core_schema.str_schema())},
+            extras_schema=core_schema.int_schema(),
+            extra_behavior='allow',
+        )
     )
 
     assert v.validate_assignment({'field_a': 'test'}, 'other_field', '456') == (
@@ -384,13 +376,12 @@ def test_validate_assignment_allow_extra_validate():
 
 def test_validate_assignment_with_strict():
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'fields': {
-                'x': {'type': 'model-field', 'schema': {'type': 'str'}},
-                'y': {'type': 'model-field', 'schema': {'type': 'int'}},
-            },
-        }
+        core_schema.model_fields_schema(
+            fields={
+                'x': core_schema.model_field(schema=core_schema.str_schema()),
+                'y': core_schema.model_field(schema=core_schema.int_schema()),
+            }
+        )
     )
 
     r, model_extra, fields_set = v.validate_python({'x': 'a', 'y': '123'})
@@ -411,10 +402,13 @@ def test_validate_assignment_with_strict():
 
 def test_json_error():
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'list', 'items_schema': {'type': 'int'}}}},
-        }
+        core_schema.model_fields_schema(
+            fields={
+                'field_a': core_schema.model_field(
+                    schema=core_schema.list_schema(items_schema=core_schema.int_schema())
+                )
+            }
+        )
     )
     with pytest.raises(ValidationError) as exc_info:
         v.validate_json('{"field_a": [123, "wrong"]}')
@@ -437,13 +431,12 @@ def test_missing_schema_key():
 def test_fields_required_by_default():
     """By default all fields should be required"""
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'fields': {
-                'x': {'type': 'model-field', 'schema': {'type': 'str'}},
-                'y': {'type': 'model-field', 'schema': {'type': 'str'}},
-            },
-        }
+        core_schema.model_fields_schema(
+            fields={
+                'x': core_schema.model_field(schema=core_schema.str_schema()),
+                'y': core_schema.model_field(schema=core_schema.str_schema()),
+            }
+        )
     )
 
     assert v.validate_python({'x': 'pika', 'y': 'chu'}) == ({'x': 'pika', 'y': 'chu'}, None, {'x', 'y'})
@@ -458,16 +451,14 @@ def test_fields_required_by_default():
 
 def test_fields_required_by_default_with_default():
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'fields': {
-                'x': {'type': 'model-field', 'schema': {'type': 'str'}},
-                'y': {
-                    'type': 'model-field',
-                    'schema': {'type': 'default', 'schema': {'type': 'str'}, 'default': 'bulbi'},
-                },
-            },
-        }
+        core_schema.model_fields_schema(
+            fields={
+                'x': core_schema.model_field(schema=core_schema.str_schema()),
+                'y': core_schema.model_field(
+                    schema=core_schema.with_default_schema(schema=core_schema.str_schema(), default='bulbi')
+                ),
+            }
+        )
     )
 
     assert v.validate_python({'x': 'pika', 'y': 'chu'}) == ({'x': 'pika', 'y': 'chu'}, None, {'x', 'y'})
@@ -611,11 +602,10 @@ def test_aliases_path_multiple(py_and_json: PyAndJson, input_value, expected):
 )
 def test_aliases_path_negative(input_value, expected):
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'fields': {'field_a': {'validation_alias': ['foo', -2], 'type': 'model-field', 'schema': {'type': 'int'}}},
-        },
-        {'loc_by_alias': False},
+        core_schema.model_fields_schema(
+            fields={'field_a': core_schema.model_field(validation_alias=['foo', -2], schema=core_schema.int_schema())}
+        ),
+        config=CoreConfig(loc_by_alias=False),
     )
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=expected.message):
@@ -653,16 +643,13 @@ def test_aliases_path_negative_json(py_and_json: PyAndJson, input_value, expecte
 
 def test_aliases_debug():
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'fields': {
-                'field_a': {
-                    'validation_alias': [['foo', 'bar', 'bat'], ['foo', 3]],
-                    'type': 'model-field',
-                    'schema': {'type': 'int'},
-                }
-            },
-        }
+        core_schema.model_fields_schema(
+            fields={
+                'field_a': core_schema.model_field(
+                    validation_alias=[['foo', 'bar', 'bat'], ['foo', 3]], schema=core_schema.int_schema()
+                )
+            }
+        )
     )
     print(repr(v))
     assert repr(v).startswith('SchemaValidator(title="model-fields", validator=ModelFields(')
@@ -671,16 +658,13 @@ def test_aliases_debug():
 
 def get_int_key():
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'fields': {
-                'field_a': {
-                    'validation_alias': [['foo', 3], ['spam']],
-                    'type': 'model-field',
-                    'schema': {'type': 'int'},
-                }
-            },
-        }
+        core_schema.model_fields_schema(
+            fields={
+                'field_a': core_schema.model_field(
+                    validation_alias=[['foo', 3], ['spam']], schema=core_schema.int_schema()
+                )
+            }
+        )
     )
     assert v.validate_python({'foo': {3: 33}}) == ({'field_a': 33}, {}, {'field_a'})
 
@@ -693,10 +677,9 @@ def __getitem__(self, v):
 
 def get_custom_getitem():
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'fields': {'field_a': {'validation_alias': ['foo'], 'type': 'model-field', 'schema': {'type': 'int'}}},
-        }
+        core_schema.model_fields_schema(
+            fields={'field_a': core_schema.model_field(validation_alias=['foo'], schema=core_schema.int_schema())}
+        )
     )
     assert v.validate_python(GetItemThing()) == ({'field_a': 321}, {}, {'field_a'})
     assert v.validate_python({'bar': GetItemThing()}) == ({'field_a': 321}, {}, {'field_a'})
@@ -735,7 +718,7 @@ def test_paths_allow_by_name(py_and_json: PyAndJson, input_value):
 def test_alias_build_error(alias_schema, error):
     with pytest.raises(SchemaError, match=error):
         SchemaValidator(
-            validate_core_schema(
+            schema=validate_core_schema(
                 {
                     'type': 'model-fields',
                     'fields': {'field_a': {'type': 'model-field', 'schema': {'type': 'int'}, **alias_schema}},
@@ -838,7 +821,7 @@ def test_alias_error_loc_field_names(py_and_json: PyAndJson):
 
 
 def test_empty_model():
-    v = SchemaValidator({'type': 'model-fields', 'fields': {}})
+    v = SchemaValidator(core_schema.model_fields_schema(fields={}))
     assert v.validate_python({}) == ({}, None, set())
     with pytest.raises(
         ValidationError, match=re.escape('Input should be a valid dictionary or instance of Model [type=model_type,')
@@ -848,31 +831,26 @@ def test_empty_model():
 
 def test_model_fields_deep():
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'fields': {
-                'field_a': {'type': 'model-field', 'schema': {'type': 'str'}},
-                'field_b': {
-                    'type': 'model-field',
-                    'schema': {
-                        'type': 'model-fields',
-                        'fields': {
-                            'field_c': {'type': 'model-field', 'schema': {'type': 'str'}},
-                            'field_d': {
-                                'type': 'model-field',
-                                'schema': {
-                                    'type': 'model-fields',
-                                    'fields': {
-                                        'field_e': {'type': 'model-field', 'schema': {'type': 'str'}},
-                                        'field_f': {'type': 'model-field', 'schema': {'type': 'int'}},
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        }
+        core_schema.model_fields_schema(
+            fields={
+                'field_a': core_schema.model_field(schema=core_schema.str_schema()),
+                'field_b': core_schema.model_field(
+                    schema=core_schema.model_fields_schema(
+                        fields={
+                            'field_c': core_schema.model_field(schema=core_schema.str_schema()),
+                            'field_d': core_schema.model_field(
+                                schema=core_schema.model_fields_schema(
+                                    fields={
+                                        'field_e': core_schema.model_field(schema=core_schema.str_schema()),
+                                        'field_f': core_schema.model_field(schema=core_schema.int_schema()),
+                                    }
+                                )
+                            ),
+                        }
+                    )
+                ),
+            }
+        )
     )
     model_dict, model_extra, fields_set = v.validate_python(
         {'field_a': '1', 'field_b': {'field_c': '2', 'field_d': {'field_e': '4', 'field_f': 4}}}
@@ -943,15 +921,14 @@ class MyDataclass:
 @pytest.mark.parametrize('from_attributes_mode', ['schema', 'validation'])
 def test_from_attributes(input_value, expected, from_attributes_mode):
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'fields': {
-                'a': {'type': 'model-field', 'schema': {'type': 'int'}},
-                'b': {'type': 'model-field', 'schema': {'type': 'int'}},
-                'c': {'type': 'model-field', 'schema': {'type': 'str'}},
+        core_schema.model_fields_schema(
+            fields={
+                'a': core_schema.model_field(schema=core_schema.int_schema()),
+                'b': core_schema.model_field(schema=core_schema.int_schema()),
+                'c': core_schema.model_field(schema=core_schema.str_schema()),
             },
-            'from_attributes': from_attributes_mode == 'schema',
-        }
+            from_attributes=from_attributes_mode == 'schema',
+        )
     )
     kwargs = {}
     if from_attributes_mode == 'validation':
@@ -967,16 +944,15 @@ def test_from_attributes(input_value, expected, from_attributes_mode):
 
 def test_from_attributes_type_error():
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'fields': {
-                'a': {'type': 'model-field', 'schema': {'type': 'int'}},
-                'b': {'type': 'model-field', 'schema': {'type': 'int'}},
-                'c': {'type': 'model-field', 'schema': {'type': 'str'}},
+        core_schema.model_fields_schema(
+            fields={
+                'a': core_schema.model_field(schema=core_schema.int_schema()),
+                'b': core_schema.model_field(schema=core_schema.int_schema()),
+                'c': core_schema.model_field(schema=core_schema.str_schema()),
             },
-            'from_attributes': True,
-            'model_name': 'MyModel',
-        }
+            from_attributes=True,
+            model_name='MyModel',
+        )
     )
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python('123')
@@ -1006,12 +982,11 @@ def test_from_attributes_type_error():
 
 def test_from_attributes_by_name():
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'fields': {'a': {'type': 'model-field', 'schema': {'type': 'int'}, 'validation_alias': 'a_alias'}},
-            'from_attributes': True,
-            'populate_by_name': True,
-        }
+        core_schema.model_fields_schema(
+            fields={'a': core_schema.model_field(schema=core_schema.int_schema(), validation_alias='a_alias')},
+            from_attributes=True,
+            populate_by_name=True,
+        )
     )
     assert v.validate_python(Cls(a_alias=1)) == ({'a': 1}, None, {'a'})
     assert v.validate_python(Cls(a=1)) == ({'a': 1}, None, {'a'})
@@ -1019,11 +994,9 @@ def test_from_attributes_by_name():
 
 def test_from_attributes_override_true():
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'fields': {'a': {'type': 'model-field', 'schema': {'type': 'int'}}},
-            'from_attributes': False,
-        }
+        core_schema.model_fields_schema(
+            fields={'a': core_schema.model_field(schema=core_schema.int_schema())}, from_attributes=False
+        )
     )
     with pytest.raises(ValidationError, match='Input should be a valid dictionary'):
         v.validate_python(Cls(a=1))
@@ -1035,11 +1008,9 @@ def test_from_attributes_override_true():
 
 def test_from_attributes_override_false():
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'fields': {'a': {'type': 'model-field', 'schema': {'type': 'int'}}},
-            'from_attributes': True,
-        }
+        core_schema.model_fields_schema(
+            fields={'a': core_schema.model_field(schema=core_schema.int_schema())}, from_attributes=True
+        )
     )
     with pytest.raises(ValidationError, match='Input should be a valid dictionary'):
         v.validate_python(Cls(a=1), from_attributes=False)
@@ -1056,15 +1027,14 @@ def __init__(self):
             self.b = 2
 
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'fields': {
-                'a': {'type': 'model-field', 'schema': {'type': 'int'}},
-                'b': {'type': 'model-field', 'schema': {'type': 'int'}},
-                'c': {'type': 'model-field', 'schema': {'type': 'str'}},
+        core_schema.model_fields_schema(
+            fields={
+                'a': core_schema.model_field(schema=core_schema.int_schema()),
+                'b': core_schema.model_field(schema=core_schema.int_schema()),
+                'c': core_schema.model_field(schema=core_schema.str_schema()),
             },
-            'from_attributes': True,
-        }
+            from_attributes=True,
+        )
     )
 
     with pytest.raises(ValidationError) as exc_info:
@@ -1090,14 +1060,13 @@ def b(self):
             raise RuntimeError('intentional error')
 
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'fields': {
-                'a': {'type': 'model-field', 'schema': {'type': 'int'}},
-                'b': {'type': 'model-field', 'schema': {'type': 'int'}},
+        core_schema.model_fields_schema(
+            fields={
+                'a': core_schema.model_field(schema=core_schema.int_schema()),
+                'b': core_schema.model_field(schema=core_schema.int_schema()),
             },
-            'from_attributes': True,
-        }
+            from_attributes=True,
+        )
     )
 
     with pytest.raises(ValidationError) as exc_info:
@@ -1158,12 +1127,11 @@ class MyDataclass:
         _d: int = 4
 
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'fields': {'a': {'type': 'model-field', 'schema': {'type': 'int'}}},
-            'from_attributes': True,
-            'extra_behavior': 'allow',
-        }
+        core_schema.model_fields_schema(
+            fields={'a': core_schema.model_field(schema=core_schema.int_schema())},
+            from_attributes=True,
+            extra_behavior='allow',
+        )
     )
 
     assert v.validate_python(Foobar()) == ({'a': 1}, {}, {'a'})
@@ -1175,12 +1143,11 @@ class MyDataclass:
 
 def test_from_attributes_extra_ignore_no_attributes_accessed() -> None:
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'fields': {'a': {'type': 'model-field', 'schema': {'type': 'int'}}},
-            'from_attributes': True,
-            'extra_behavior': 'ignore',
-        }
+        core_schema.model_fields_schema(
+            fields={'a': core_schema.model_field(schema=core_schema.int_schema())},
+            from_attributes=True,
+            extra_behavior='ignore',
+        )
     )
 
     accessed: list[str] = []
@@ -1203,12 +1170,11 @@ class Source:
         b = 2
 
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'fields': {'a': {'type': 'model-field', 'schema': {'type': 'int'}}},
-            'from_attributes': True,
-            'extra_behavior': 'forbid',
-        }
+        core_schema.model_fields_schema(
+            fields={'a': core_schema.model_field(schema=core_schema.int_schema())},
+            from_attributes=True,
+            extra_behavior='forbid',
+        )
     )
 
     assert v.validate_python(Source()) == ({'a': 1}, None, {'a'})
@@ -1231,11 +1197,9 @@ def foobar():
 )
 def test_from_attributes_function(input_value, expected):
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'fields': {'a': {'type': 'model-field', 'schema': {'type': 'any'}}},
-            'from_attributes': True,
-        }
+        core_schema.model_fields_schema(
+            fields={'a': core_schema.model_field(schema=core_schema.any_schema())}, from_attributes=True
+        )
     )
 
     model_dict, model_extra, fields_set = v.validate_python(input_value)
@@ -1255,11 +1219,9 @@ def x(self):
             raise BadError('intentional error')
 
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'fields': {'x': {'type': 'model-field', 'schema': {'type': 'int'}}},
-            'from_attributes': True,
-        }
+        core_schema.model_fields_schema(
+            fields={'x': core_schema.model_field(schema=core_schema.int_schema())}, from_attributes=True
+        )
     )
 
     with pytest.raises(ValidationError) as exc_info:
@@ -1314,18 +1276,15 @@ def x(self):
 )
 def test_from_attributes_path(input_value, expected):
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'fields': {
-                'my_field': {
-                    'validation_alias': [['foo', 'bar', 'bat'], ['foo', 3], ['spam']],
-                    'type': 'model-field',
-                    'schema': {'type': 'int'},
-                }
+        core_schema.model_fields_schema(
+            fields={
+                'my_field': core_schema.model_field(
+                    validation_alias=[['foo', 'bar', 'bat'], ['foo', 3], ['spam']], schema=core_schema.int_schema()
+                )
             },
-            'from_attributes': True,
-        },
-        {'loc_by_alias': False},
+            from_attributes=True,
+        ),
+        config=CoreConfig(loc_by_alias=False),
     )
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=expected.message):
@@ -1345,17 +1304,14 @@ def foo(self):
             raise RuntimeError('intentional error')
 
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'fields': {
-                'my_field': {
-                    'validation_alias': [['foo', 'bar', 'bat'], ['foo', 3], ['spam']],
-                    'type': 'model-field',
-                    'schema': {'type': 'int'},
-                }
+        core_schema.model_fields_schema(
+            fields={
+                'my_field': core_schema.model_field(
+                    validation_alias=[['foo', 'bar', 'bat'], ['foo', 3], ['spam']], schema=core_schema.int_schema()
+                )
             },
-            'from_attributes': True,
-        }
+            from_attributes=True,
+        )
     )
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python(PropertyError())
@@ -1405,18 +1361,15 @@ def test_alias_extra(py_and_json: PyAndJson):
 
 def test_alias_extra_from_attributes():
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'extra_behavior': 'allow',
-            'from_attributes': True,
-            'fields': {
-                'field_a': {
-                    'validation_alias': [['FieldA'], ['foo', 2]],
-                    'type': 'model-field',
-                    'schema': {'type': 'int'},
-                }
+        core_schema.model_fields_schema(
+            extra_behavior='allow',
+            from_attributes=True,
+            fields={
+                'field_a': core_schema.model_field(
+                    validation_alias=[['FieldA'], ['foo', 2]], schema=core_schema.int_schema()
+                )
             },
-        }
+        )
     )
     assert v.validate_python({'FieldA': 1}) == ({'field_a': 1}, {}, {'field_a'})
     assert v.validate_python(Cls(FieldA=1)) == ({'field_a': 1}, {}, {'field_a'})
@@ -1453,15 +1406,15 @@ def test_alias_extra_forbid(py_and_json: PyAndJson):
 
 def test_with_default_factory():
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'fields': {
-                'x': {
-                    'type': 'model-field',
-                    'schema': {'type': 'default', 'schema': {'type': 'str'}, 'default_factory': lambda: 'pikachu'},
-                }
-            },
-        }
+        core_schema.model_fields_schema(
+            fields={
+                'x': core_schema.model_field(
+                    schema=core_schema.with_default_schema(
+                        schema=core_schema.str_schema(), default_factory=lambda: 'pikachu'
+                    )
+                )
+            }
+        )
     )
 
     assert v.validate_python({}) == ({'x': 'pikachu'}, None, set())
@@ -1477,15 +1430,15 @@ def test_with_default_factory():
 )
 def test_bad_default_factory(default_factory, error_message):
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'fields': {
-                'x': {
-                    'type': 'model-field',
-                    'schema': {'type': 'default', 'schema': {'type': 'str'}, 'default_factory': default_factory},
-                }
-            },
-        }
+        core_schema.model_fields_schema(
+            fields={
+                'x': core_schema.model_field(
+                    schema=core_schema.with_default_schema(
+                        schema=core_schema.str_schema(), default_factory=default_factory
+                    )
+                )
+            }
+        )
     )
     with pytest.raises(TypeError, match=re.escape(error_message)):
         v.validate_python({})
@@ -1509,15 +1462,13 @@ def test_on_error_bad_name(self):
     def test_on_error_bad_default(self):
         with pytest.raises(SchemaError, match="'on_error = default' requires a `default` or `default_factory`"):
             SchemaValidator(
-                {
-                    'type': 'model-fields',
-                    'fields': {
-                        'x': {
-                            'type': 'model-field',
-                            'schema': {'type': 'default', 'schema': {'type': 'str'}, 'on_error': 'default'},
-                        }
-                    },
-                }
+                schema=core_schema.model_fields_schema(
+                    fields={
+                        'x': core_schema.model_field(
+                            schema=core_schema.with_default_schema(schema=core_schema.str_schema(), on_error='default')
+                        )
+                    }
+                )
             )
 
     def test_on_error_raise_by_default(self, py_and_json: PyAndJson):
@@ -1625,18 +1576,15 @@ def wrap_function(input_value, validator, info):
 
 def test_frozen_field():
     v = SchemaValidator(
-        {
-            'type': 'model-fields',
-            'fields': {
-                'name': {'type': 'model-field', 'schema': {'type': 'str'}},
-                'age': {'type': 'model-field', 'schema': {'type': 'int'}},
-                'is_developer': {
-                    'type': 'model-field',
-                    'schema': {'type': 'default', 'schema': {'type': 'bool'}, 'default': True},
-                    'frozen': True,
-                },
-            },
-        }
+        core_schema.model_fields_schema(
+            fields={
+                'name': core_schema.model_field(schema=core_schema.str_schema()),
+                'age': core_schema.model_field(schema=core_schema.int_schema()),
+                'is_developer': core_schema.model_field(
+                    schema=core_schema.with_default_schema(schema=core_schema.bool_schema(), default=True), frozen=True
+                ),
+            }
+        )
     )
     r1, model_extra, fields_set = v.validate_python({'name': 'Samuel', 'age': '36'})
     assert r1 == {'name': 'Samuel', 'age': 36, 'is_developer': True}
diff --git a/tests/validators/test_model_init.py b/tests/validators/test_model_init.py
index f1226265a..08f13ac54 100644
--- a/tests/validators/test_model_init.py
+++ b/tests/validators/test_model_init.py
@@ -18,17 +18,15 @@ class MyModel:
 
 def test_model_init():
     v = SchemaValidator(
-        {
-            'type': 'model',
-            'cls': MyModel,
-            'schema': {
-                'type': 'model-fields',
-                'fields': {
-                    'field_a': {'type': 'model-field', 'schema': {'type': 'str'}},
-                    'field_b': {'type': 'model-field', 'schema': {'type': 'int'}},
-                },
-            },
-        }
+        core_schema.model_schema(
+            cls=MyModel,
+            schema=core_schema.model_fields_schema(
+                fields={
+                    'field_a': core_schema.model_field(schema=core_schema.str_schema()),
+                    'field_b': core_schema.model_field(schema=core_schema.int_schema()),
+                }
+            ),
+        )
     )
     m = v.validate_python({'field_a': 'test', 'field_b': 12})
     assert isinstance(m, MyModel)
@@ -50,30 +48,25 @@ class MyModel:
         __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__'
 
     v = SchemaValidator(
-        {
-            'type': 'model',
-            'cls': MyModel,
-            'schema': {
-                'type': 'model-fields',
-                'fields': {
-                    'field_a': {'type': 'model-field', 'schema': {'type': 'str'}},
-                    'field_b': {
-                        'type': 'model-field',
-                        'schema': {
-                            'type': 'model',
-                            'cls': MyModel,
-                            'schema': {
-                                'type': 'model-fields',
-                                'fields': {
-                                    'x_a': {'type': 'model-field', 'schema': {'type': 'str'}},
-                                    'x_b': {'type': 'model-field', 'schema': {'type': 'int'}},
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        }
+        core_schema.model_schema(
+            cls=MyModel,
+            schema=core_schema.model_fields_schema(
+                fields={
+                    'field_a': core_schema.model_field(schema=core_schema.str_schema()),
+                    'field_b': core_schema.model_field(
+                        schema=core_schema.model_schema(
+                            cls=MyModel,
+                            schema=core_schema.model_fields_schema(
+                                fields={
+                                    'x_a': core_schema.model_field(schema=core_schema.str_schema()),
+                                    'x_b': core_schema.model_field(schema=core_schema.int_schema()),
+                                }
+                            ),
+                        )
+                    ),
+                }
+            ),
+        )
     )
     m = v.validate_python({'field_a': 'test', 'field_b': {'x_a': 'foo', 'x_b': 12}})
     assert isinstance(m, MyModel)
@@ -102,17 +95,15 @@ def f(input_value, _info):
         {
             'type': 'function-before',
             'function': {'type': 'with-info', 'function': f},
-            'schema': {
-                'type': 'model',
-                'cls': MyModel,
-                'schema': {
-                    'type': 'model-fields',
-                    'fields': {
-                        'field_a': {'type': 'model-field', 'schema': {'type': 'str'}},
-                        'field_b': {'type': 'model-field', 'schema': {'type': 'int'}},
-                    },
-                },
-            },
+            'schema': core_schema.model_schema(
+                cls=MyModel,
+                schema=core_schema.model_fields_schema(
+                    fields={
+                        'field_a': core_schema.model_field(schema=core_schema.str_schema()),
+                        'field_b': core_schema.model_field(schema=core_schema.int_schema()),
+                    }
+                ),
+            ),
         }
     )
 
@@ -138,17 +129,15 @@ def f(input_value, _info):
         {
             'type': 'function-after',
             'function': {'type': 'with-info', 'function': f},
-            'schema': {
-                'type': 'model',
-                'cls': MyModel,
-                'schema': {
-                    'type': 'model-fields',
-                    'fields': {
-                        'field_a': {'type': 'model-field', 'schema': {'type': 'str'}},
-                        'field_b': {'type': 'model-field', 'schema': {'type': 'int'}},
-                    },
-                },
-            },
+            'schema': core_schema.model_schema(
+                cls=MyModel,
+                schema=core_schema.model_fields_schema(
+                    fields={
+                        'field_a': core_schema.model_field(schema=core_schema.str_schema()),
+                        'field_b': core_schema.model_field(schema=core_schema.int_schema()),
+                    }
+                ),
+            ),
         }
     )
 
@@ -176,17 +165,15 @@ def f(input_value, handler, _info):
         {
             'type': 'function-wrap',
             'function': {'type': 'with-info', 'function': f},
-            'schema': {
-                'type': 'model',
-                'cls': MyModel,
-                'schema': {
-                    'type': 'model-fields',
-                    'fields': {
-                        'field_a': {'type': 'model-field', 'schema': {'type': 'str'}},
-                        'field_b': {'type': 'model-field', 'schema': {'type': 'int'}},
-                    },
-                },
-            },
+            'schema': core_schema.model_schema(
+                cls=MyModel,
+                schema=core_schema.model_fields_schema(
+                    fields={
+                        'field_a': core_schema.model_field(schema=core_schema.str_schema()),
+                        'field_b': core_schema.model_field(schema=core_schema.int_schema()),
+                    }
+                ),
+            ),
         }
     )
 
@@ -202,7 +189,7 @@ def f(input_value, handler, _info):
 
 
 def test_simple():
-    v = SchemaValidator({'type': 'str'})
+    v = SchemaValidator(core_schema.str_schema())
     assert v.validate_python(b'abc') == 'abc'
     assert v.isinstance_python(b'abc') is True
 
diff --git a/tests/validators/test_none.py b/tests/validators/test_none.py
index 3a9640e82..7b12f6884 100644
--- a/tests/validators/test_none.py
+++ b/tests/validators/test_none.py
@@ -1,10 +1,11 @@
 import pytest
 
 from pydantic_core import SchemaValidator, ValidationError
+from pydantic_core import core_schema as cs
 
 
 def test_python_none():
-    v = SchemaValidator({'type': 'none'})
+    v = SchemaValidator(cs.none_schema())
     assert v.validate_python(None) is None
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python(1)
@@ -14,7 +15,7 @@ def test_python_none():
 
 
 def test_json_none():
-    v = SchemaValidator({'type': 'none'})
+    v = SchemaValidator(cs.none_schema())
     assert v.validate_json('null') is None
     with pytest.raises(ValidationError) as exc_info:
         v.validate_json('1')
diff --git a/tests/validators/test_nullable.py b/tests/validators/test_nullable.py
index 451559c76..779b2507d 100644
--- a/tests/validators/test_nullable.py
+++ b/tests/validators/test_nullable.py
@@ -9,7 +9,7 @@
 
 
 def test_nullable():
-    v = SchemaValidator({'type': 'nullable', 'schema': {'type': 'int'}})
+    v = SchemaValidator(core_schema.nullable_schema(schema=core_schema.int_schema()))
     assert v.validate_python(None) is None
     assert v.validate_python(1) == 1
     assert v.validate_python('123') == 123
@@ -27,13 +27,12 @@ def test_nullable():
 
 def test_union_nullable_bool_int():
     v = SchemaValidator(
-        {
-            'type': 'union',
-            'choices': [
-                {'type': 'nullable', 'schema': {'type': 'bool'}},
-                {'type': 'nullable', 'schema': {'type': 'int'}},
-            ],
-        }
+        core_schema.union_schema(
+            choices=[
+                core_schema.nullable_schema(schema=core_schema.bool_schema()),
+                core_schema.nullable_schema(schema=core_schema.int_schema()),
+            ]
+        )
     )
     assert v.validate_python(None) is None
     assert v.validate_python(True) is True
diff --git a/tests/validators/test_set.py b/tests/validators/test_set.py
index df94a8e31..6eafe8abb 100644
--- a/tests/validators/test_set.py
+++ b/tests/validators/test_set.py
@@ -5,6 +5,7 @@
 import pytest
 
 from pydantic_core import SchemaValidator, ValidationError
+from pydantic_core import core_schema as cs
 
 from ..conftest import Err, PyAndJson, infinite_generator
 
@@ -75,7 +76,7 @@ def test_frozenset_no_validators_both(py_and_json: PyAndJson, input_value, expec
 )
 @pytest.mark.thread_unsafe  # generators in parameters not compatible with pytest-run-parallel, https://github.com/Quansight-Labs/pytest-run-parallel/issues/14
 def test_set_ints_python(input_value, expected):
-    v = SchemaValidator({'type': 'set', 'items_schema': {'type': 'int'}})
+    v = SchemaValidator(cs.set_schema(items_schema=cs.int_schema()))
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value)
@@ -85,12 +86,12 @@ def test_set_ints_python(input_value, expected):
 
 @pytest.mark.parametrize('input_value,expected', [([1, 2.5, '3'], {1, 2.5, '3'}), ([(1, 2), (3, 4)], {(1, 2), (3, 4)})])
 def test_set_no_validators_python(input_value, expected):
-    v = SchemaValidator({'type': 'set'})
+    v = SchemaValidator(cs.set_schema())
     assert v.validate_python(input_value) == expected
 
 
 def test_set_multiple_errors():
-    v = SchemaValidator({'type': 'set', 'items_schema': {'type': 'int'}})
+    v = SchemaValidator(cs.set_schema(items_schema=cs.int_schema()))
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python(['a', (1, 2), []])
     assert exc_info.value.errors(include_url=False) == [
@@ -106,7 +107,7 @@ def test_set_multiple_errors():
 
 
 def test_list_with_unhashable_items():
-    v = SchemaValidator({'type': 'set'})
+    v = SchemaValidator(cs.set_schema())
 
     class Unhashable:
         __hash__ = None
@@ -165,7 +166,7 @@ def generate_repeats():
 )
 @pytest.mark.thread_unsafe  # generators in parameters not compatible with pytest-run-parallel, https://github.com/Quansight-Labs/pytest-run-parallel/issues/14
 def test_set_kwargs(kwargs: dict[str, Any], input_value, expected):
-    v = SchemaValidator({'type': 'set', **kwargs})
+    v = SchemaValidator(cs.set_schema(**kwargs))
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             r = v.validate_python(input_value)
@@ -176,7 +177,7 @@ def test_set_kwargs(kwargs: dict[str, Any], input_value, expected):
 
 @pytest.mark.parametrize('input_value,expected', [({1, 2, 3}, {1, 2, 3}), ([1, 2, 3], [1, 2, 3])])
 def test_union_set_list(input_value, expected):
-    v = SchemaValidator({'type': 'union', 'choices': [{'type': 'set'}, {'type': 'list'}]})
+    v = SchemaValidator(cs.union_schema(choices=[cs.set_schema(), cs.list_schema()]))
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value)
@@ -214,13 +215,12 @@ def test_union_set_list(input_value, expected):
 )
 def test_union_set_int_set_str(input_value, expected):
     v = SchemaValidator(
-        {
-            'type': 'union',
-            'choices': [
-                {'type': 'set', 'items_schema': {'type': 'int', 'strict': True}},
-                {'type': 'set', 'items_schema': {'type': 'str', 'strict': True}},
-            ],
-        }
+        cs.union_schema(
+            choices=[
+                cs.set_schema(items_schema=cs.int_schema(strict=True)),
+                cs.set_schema(items_schema=cs.str_schema(strict=True)),
+            ]
+        )
     )
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)) as exc_info:
@@ -245,7 +245,7 @@ def gen(error: bool):
             raise RuntimeError('my error')
         yield 3
 
-    v = SchemaValidator({'type': 'set', 'items_schema': {'type': 'int'}})
+    v = SchemaValidator(cs.set_schema(items_schema=cs.int_schema()))
     r = v.validate_python(gen(False))
     assert r == {1, 2, 3}
     assert isinstance(r, set)
@@ -274,7 +274,7 @@ def gen(error: bool):
     ],
 )
 def test_set_from_dict_items(input_value, items_schema, expected):
-    v = SchemaValidator({'type': 'set', 'items_schema': items_schema})
+    v = SchemaValidator(cs.set_schema(items_schema=items_schema))
     output = v.validate_python(input_value)
     assert isinstance(output, set)
     assert output == expected
@@ -291,7 +291,7 @@ def test_set_from_dict_items(input_value, items_schema, expected):
     ],
 )
 def test_set_any(input_value, expected):
-    v = SchemaValidator({'type': 'set'})
+    v = SchemaValidator(cs.set_schema())
     output = v.validate_python(input_value)
     assert output == expected
     assert isinstance(output, set)
@@ -333,7 +333,7 @@ def test_set_any(input_value, expected):
     ],
 )
 def test_set_fail_fast(fail_fast, expected):
-    v = SchemaValidator({'type': 'set', 'items_schema': {'type': 'int'}, 'fail_fast': fail_fast})
+    v = SchemaValidator(cs.set_schema(items_schema=cs.int_schema(), fail_fast=fail_fast))
 
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python([1, 'not-num', 'again'])
diff --git a/tests/validators/test_string.py b/tests/validators/test_string.py
index 864125a47..4f295056b 100644
--- a/tests/validators/test_string.py
+++ b/tests/validators/test_string.py
@@ -6,7 +6,7 @@
 
 import pytest
 
-from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema
+from pydantic_core import CoreConfig, SchemaError, SchemaValidator, ValidationError, core_schema
 
 from ..conftest import Err, PyAndJson, plain_repr
 
@@ -56,7 +56,7 @@ def test_str(py_and_json: PyAndJson, input_value, expected):
     ],
 )
 def test_str_not_json(input_value, expected):
-    v = SchemaValidator({'type': 'str'})
+    v = SchemaValidator(core_schema.str_schema())
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value)
@@ -112,7 +112,7 @@ def test_constrained_str(py_and_json: PyAndJson, kwargs: dict[str, Any], input_v
     ],
 )
 def test_constrained_str_py_only(kwargs: dict[str, Any], input_value, expected):
-    v = SchemaValidator({'type': 'str', **kwargs})
+    v = SchemaValidator(core_schema.str_schema(**kwargs))
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value)
@@ -123,7 +123,7 @@ def test_constrained_str_py_only(kwargs: dict[str, Any], input_value, expected):
 def test_unicode_error():
     # `.to_str()` Returns a `UnicodeEncodeError` if the input is not valid unicode (containing unpaired surrogates).
     # https://github.com/PyO3/pyo3/blob/6503128442b8f3e767c663a6a8d96376d7fb603d/src/types/string.rs#L477
-    v = SchemaValidator({'type': 'str', 'min_length': 1})
+    v = SchemaValidator(core_schema.str_schema(min_length=1))
     assert v.validate_python('🐈 Hello') == '🐈 Hello'
 
     with pytest.raises(ValidationError) as exc_info:
@@ -154,7 +154,7 @@ def test_unicode_error():
     ],
 )
 def test_str_constrained(data: str, max_length: int, error: Union[re.Pattern, None]):
-    v = SchemaValidator({'type': 'str', 'max_length': max_length})
+    v = SchemaValidator(core_schema.str_schema(max_length=max_length))
     if error is None:
         assert v.validate_python(data) == data
     else:
@@ -163,7 +163,7 @@ def test_str_constrained(data: str, max_length: int, error: Union[re.Pattern, No
 
 
 def test_str_constrained_config():
-    v = SchemaValidator({'type': 'str'}, {'str_max_length': 5})
+    v = SchemaValidator(core_schema.str_schema(), config=CoreConfig(str_max_length=5))
     assert v.validate_python('test') == 'test'
 
     with pytest.raises(ValidationError, match='String should have at most 5 characters'):
@@ -209,7 +209,9 @@ def test_regex_error(engine):
 
 
 def test_default_validator():
-    v = SchemaValidator(core_schema.str_schema(strict=True, to_lower=False), {'str_strip_whitespace': False})
+    v = SchemaValidator(
+        core_schema.str_schema(strict=True, to_lower=False), config=CoreConfig(str_strip_whitespace=False)
+    )
     assert (
         plain_repr(v)
         == 'SchemaValidator(title="str",validator=Str(StrValidator{strict:true,coerce_numbers_to_str:false}),definitions=[],cache_strings=True)'
@@ -286,14 +288,14 @@ class StrSubclass(str):
 def test_coerce_numbers_to_str_with_invalid_unicode_character(string) -> None:
     config = core_schema.CoreConfig(coerce_numbers_to_str=True)
 
-    v = SchemaValidator(core_schema.str_schema(strict=string), config)
+    v = SchemaValidator(core_schema.str_schema(strict=string), config=config)
     assert v.validate_python('\ud835') == '\ud835'
 
 
 def test_coerce_numbers_to_str_disabled_in_strict_mode() -> None:
     config = core_schema.CoreConfig(coerce_numbers_to_str=True)
 
-    v = SchemaValidator(core_schema.str_schema(strict=True), config)
+    v = SchemaValidator(core_schema.str_schema(strict=True), config=config)
     with pytest.raises(ValidationError):
         v.validate_python(42)
     with pytest.raises(ValidationError):
@@ -303,7 +305,7 @@ def test_coerce_numbers_to_str_disabled_in_strict_mode() -> None:
 def test_coerce_numbers_to_str_raises_for_bool() -> None:
     config = core_schema.CoreConfig(coerce_numbers_to_str=True)
 
-    v = SchemaValidator(core_schema.str_schema(), config)
+    v = SchemaValidator(core_schema.str_schema(), config=config)
     with pytest.raises(ValidationError):
         v.validate_python(True)
     with pytest.raises(ValidationError):
@@ -321,7 +323,7 @@ def test_coerce_numbers_to_str_raises_for_bool() -> None:
 def test_coerce_numbers_to_str(number: Number, expected_str: str) -> None:
     config = core_schema.CoreConfig(coerce_numbers_to_str=True)
 
-    v = SchemaValidator(core_schema.str_schema(), config)
+    v = SchemaValidator(core_schema.str_schema(), config=config)
     assert v.validate_python(number) == expected_str
 
 
@@ -336,7 +338,7 @@ def test_coerce_numbers_to_str(number: Number, expected_str: str) -> None:
 def test_coerce_numbers_to_str_from_json(number: str, expected_str: str) -> None:
     config = core_schema.CoreConfig(coerce_numbers_to_str=True)
 
-    v = SchemaValidator(core_schema.str_schema(), config)
+    v = SchemaValidator(core_schema.str_schema(), config=config)
     assert v.validate_json(number) == expected_str
 
 
@@ -351,7 +353,9 @@ def test_backtracking_regex_rust_unsupported(mode) -> None:
         elif mode == 'schema':
             SchemaValidator(core_schema.str_schema(pattern=pattern, regex_engine='rust-regex'))
         elif mode == 'config':
-            SchemaValidator(core_schema.str_schema(pattern=pattern), core_schema.CoreConfig(regex_engine='rust-regex'))
+            SchemaValidator(
+                schema=core_schema.str_schema(pattern=pattern), config=core_schema.CoreConfig(regex_engine='rust-regex')
+            )
 
     assert exc_info.value.args[0] == (
         'Error building "str" validator:\n'
@@ -369,7 +373,9 @@ def test_backtracking_regex_python(mode) -> None:
     if mode == 'schema':
         v = SchemaValidator(core_schema.str_schema(pattern=pattern, regex_engine='python-re'))
     elif mode == 'config':
-        v = SchemaValidator(core_schema.str_schema(pattern=pattern), core_schema.CoreConfig(regex_engine='python-re'))
+        v = SchemaValidator(
+            schema=core_schema.str_schema(pattern=pattern), config=core_schema.CoreConfig(regex_engine='python-re')
+        )
     assert v.validate_python('r""') == 'r""'
     assert v.validate_python('r#""#') == 'r#""#'
     with pytest.raises(ValidationError):
diff --git a/tests/validators/test_tagged_union.py b/tests/validators/test_tagged_union.py
index 3061b2c34..1dba17cee 100644
--- a/tests/validators/test_tagged_union.py
+++ b/tests/validators/test_tagged_union.py
@@ -209,36 +209,31 @@ class PlainEnum(Enum):
         TWO = 'two'
 
     v = SchemaValidator(
-        {
-            'type': 'tagged-union',
-            'discriminator': 'foo',
-            'choices': {
-                BarEnum.ONE: {
-                    'type': 'typed-dict',
-                    'fields': {
-                        'foo': {'type': 'typed-dict-field', 'schema': {'type': 'int'}},
-                        'bar': {'type': 'typed-dict-field', 'schema': {'type': 'int'}},
-                    },
-                },
-                FooEnum.BANANA: {
-                    'type': 'typed-dict',
-                    'fields': {
-                        'foo': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
-                        'spam': {
-                            'type': 'typed-dict-field',
-                            'schema': {'type': 'list', 'items_schema': {'type': 'int'}},
-                        },
-                    },
-                },
-                PlainEnum.TWO: {
-                    'type': 'typed-dict',
-                    'fields': {
-                        'foo': {'type': 'typed-dict-field', 'schema': {'type': 'any'}},
-                        'baz': {'type': 'typed-dict-field', 'schema': {'type': 'int'}},
-                    },
-                },
+        core_schema.tagged_union_schema(
+            discriminator='foo',
+            choices={
+                BarEnum.ONE: core_schema.typed_dict_schema(
+                    fields={
+                        'foo': core_schema.typed_dict_field(schema=core_schema.int_schema()),
+                        'bar': core_schema.typed_dict_field(schema=core_schema.int_schema()),
+                    }
+                ),
+                FooEnum.BANANA: core_schema.typed_dict_schema(
+                    fields={
+                        'foo': core_schema.typed_dict_field(schema=core_schema.str_schema()),
+                        'spam': core_schema.typed_dict_field(
+                            schema=core_schema.list_schema(items_schema=core_schema.int_schema())
+                        ),
+                    }
+                ),
+                PlainEnum.TWO: core_schema.typed_dict_schema(
+                    fields={
+                        'foo': core_schema.typed_dict_field(schema=core_schema.any_schema()),
+                        'baz': core_schema.typed_dict_field(schema=core_schema.int_schema()),
+                    }
+                ),
             },
-        }
+        )
     )
 
     assert v.validate_python({'foo': FooEnum.BANANA, 'spam': [1, 2, '3']}) == {'foo': FooEnum.BANANA, 'spam': [1, 2, 3]}
@@ -457,27 +452,24 @@ def discriminator_function(obj):
 
 def test_from_attributes():
     v = SchemaValidator(
-        {
-            'type': 'tagged-union',
-            'discriminator': 'foobar',
-            'choices': {
-                'apple': {
-                    'type': 'model-fields',
-                    'fields': {
-                        'a': {'type': 'model-field', 'schema': {'type': 'str'}},
-                        'b': {'type': 'model-field', 'schema': {'type': 'int'}},
-                    },
-                },
-                'banana': {
-                    'type': 'model-fields',
-                    'fields': {
-                        'c': {'type': 'model-field', 'schema': {'type': 'str'}},
-                        'd': {'type': 'model-field', 'schema': {'type': 'int'}},
-                    },
-                },
+        core_schema.tagged_union_schema(
+            discriminator='foobar',
+            choices={
+                'apple': core_schema.model_fields_schema(
+                    fields={
+                        'a': core_schema.model_field(schema=core_schema.str_schema()),
+                        'b': core_schema.model_field(schema=core_schema.int_schema()),
+                    }
+                ),
+                'banana': core_schema.model_fields_schema(
+                    fields={
+                        'c': core_schema.model_field(schema=core_schema.str_schema()),
+                        'd': core_schema.model_field(schema=core_schema.int_schema()),
+                    }
+                ),
             },
-        },
-        {'from_attributes': True},
+        ),
+        config=CoreConfig(from_attributes=True),
     )
     assert v.validate_python({'foobar': 'apple', 'a': 'apple', 'b': '13'}) == (
         {'a': 'apple', 'b': 13},
@@ -516,7 +508,9 @@ def test_use_ref():
 
 
 def test_downcast_error():
-    v = SchemaValidator({'type': 'tagged-union', 'discriminator': lambda x: 123, 'choices': {'str': {'type': 'str'}}})
+    v = SchemaValidator(
+        core_schema.tagged_union_schema(discriminator=lambda x: 123, choices={'str': core_schema.str_schema()})
+    )
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python('x')
         assert exc_info.value.errors(include_url=False) == [
@@ -531,31 +525,27 @@ def test_downcast_error():
 
 def test_custom_error():
     v = SchemaValidator(
-        {
-            'type': 'tagged-union',
-            'discriminator': 'foo',
-            'custom_error_type': 'snap',
-            'custom_error_message': 'Input should be a foo or bar',
-            'choices': {
-                'apple': {
-                    'type': 'typed-dict',
-                    'fields': {
-                        'foo': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
-                        'bar': {'type': 'typed-dict-field', 'schema': {'type': 'int'}},
-                    },
-                },
-                'banana': {
-                    'type': 'typed-dict',
-                    'fields': {
-                        'foo': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
-                        'spam': {
-                            'type': 'typed-dict-field',
-                            'schema': {'type': 'list', 'items_schema': {'type': 'int'}},
-                        },
-                    },
-                },
+        core_schema.tagged_union_schema(
+            discriminator='foo',
+            custom_error_type='snap',
+            custom_error_message='Input should be a foo or bar',
+            choices={
+                'apple': core_schema.typed_dict_schema(
+                    fields={
+                        'foo': core_schema.typed_dict_field(schema=core_schema.str_schema()),
+                        'bar': core_schema.typed_dict_field(schema=core_schema.int_schema()),
+                    }
+                ),
+                'banana': core_schema.typed_dict_schema(
+                    fields={
+                        'foo': core_schema.typed_dict_field(schema=core_schema.str_schema()),
+                        'spam': core_schema.typed_dict_field(
+                            schema=core_schema.list_schema(items_schema=core_schema.int_schema())
+                        ),
+                    }
+                ),
             },
-        }
+        )
     )
     assert v.validate_python({'foo': 'apple', 'bar': '123'}) == {'foo': 'apple', 'bar': 123}
     with pytest.raises(ValidationError) as exc_info:
@@ -573,30 +563,26 @@ def test_custom_error():
 
 def test_custom_error_type():
     v = SchemaValidator(
-        {
-            'type': 'tagged-union',
-            'discriminator': 'foo',
-            'custom_error_type': 'finite_number',
-            'choices': {
-                'apple': {
-                    'type': 'typed-dict',
-                    'fields': {
-                        'foo': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
-                        'bar': {'type': 'typed-dict-field', 'schema': {'type': 'int'}},
-                    },
-                },
-                'banana': {
-                    'type': 'typed-dict',
-                    'fields': {
-                        'foo': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
-                        'spam': {
-                            'type': 'typed-dict-field',
-                            'schema': {'type': 'list', 'items_schema': {'type': 'int'}},
-                        },
-                    },
-                },
+        core_schema.tagged_union_schema(
+            discriminator='foo',
+            custom_error_type='finite_number',
+            choices={
+                'apple': core_schema.typed_dict_schema(
+                    fields={
+                        'foo': core_schema.typed_dict_field(schema=core_schema.str_schema()),
+                        'bar': core_schema.typed_dict_field(schema=core_schema.int_schema()),
+                    }
+                ),
+                'banana': core_schema.typed_dict_schema(
+                    fields={
+                        'foo': core_schema.typed_dict_field(schema=core_schema.str_schema()),
+                        'spam': core_schema.typed_dict_field(
+                            schema=core_schema.list_schema(items_schema=core_schema.int_schema())
+                        ),
+                    }
+                ),
             },
-        }
+        )
     )
     assert v.validate_python({'foo': 'apple', 'bar': '123'}) == {'foo': 'apple', 'bar': 123}
     with pytest.raises(ValidationError) as exc_info:
diff --git a/tests/validators/test_time.py b/tests/validators/test_time.py
index 1061cd063..069e359ad 100644
--- a/tests/validators/test_time.py
+++ b/tests/validators/test_time.py
@@ -33,7 +33,7 @@
     ],
 )
 def test_time(input_value, expected):
-    v = SchemaValidator({'type': 'time'})
+    v = SchemaValidator(core_schema.time_schema())
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value)
@@ -114,7 +114,7 @@ def test_time_error_microseconds_overflow(py_and_json: PyAndJson) -> None:
     ],
 )
 def test_time_strict(input_value, expected):
-    v = SchemaValidator({'type': 'time', 'strict': True})
+    v = SchemaValidator(core_schema.time_schema(strict=True))
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value)
@@ -132,7 +132,7 @@ def test_time_strict(input_value, expected):
     ],
 )
 def test_time_strict_json(input_value, expected):
-    v = SchemaValidator({'type': 'time', 'strict': True})
+    v = SchemaValidator(core_schema.time_schema(strict=True))
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_json(input_value)
@@ -159,7 +159,7 @@ def test_time_strict_json(input_value, expected):
     ],
 )
 def test_time_kwargs(kwargs: dict[str, Any], input_value, expected):
-    v = SchemaValidator({'type': 'time', **kwargs})
+    v = SchemaValidator(core_schema.time_schema(**kwargs))
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)) as exc_info:
             v.validate_python(input_value)
@@ -174,7 +174,7 @@ def test_time_kwargs(kwargs: dict[str, Any], input_value, expected):
 
 
 def test_time_bound_ctx():
-    v = SchemaValidator({'type': 'time', 'gt': time(12, 13, 14, 123_456)})
+    v = SchemaValidator(core_schema.time_schema(gt=time(12, 13, 14, 123_456)))
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python('12:13')
 
@@ -195,7 +195,9 @@ def test_invalid_constraint():
 
 
 def test_dict_py():
-    v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'time'}, 'values_schema': {'type': 'int'}})
+    v = SchemaValidator(
+        core_schema.dict_schema(keys_schema=core_schema.time_schema(), values_schema=core_schema.int_schema())
+    )
     assert v.validate_python({time(12, 1, 1): 2, time(12, 1, 2): 4}) == {time(12, 1, 1): 2, time(12, 1, 2): 4}
 
 
@@ -205,11 +207,11 @@ def test_dict(py_and_json: PyAndJson):
 
 
 def test_union():
-    v = SchemaValidator({'type': 'union', 'choices': [{'type': 'str'}, {'type': 'time'}]})
+    v = SchemaValidator(core_schema.union_schema(choices=[core_schema.str_schema(), core_schema.time_schema()]))
     assert v.validate_python('12:01:02') == '12:01:02'
     assert v.validate_python(time(12, 1, 2)) == time(12, 1, 2)
 
-    v = SchemaValidator({'type': 'union', 'choices': [{'type': 'time'}, {'type': 'str'}]})
+    v = SchemaValidator(core_schema.union_schema(choices=[core_schema.time_schema(), core_schema.str_schema()]))
     assert v.validate_python('12:01:02') == '12:01:02'
     assert v.validate_python(time(12, 1, 2)) == time(12, 1, 2)
 
diff --git a/tests/validators/test_timedelta.py b/tests/validators/test_timedelta.py
index 6f9f9133f..e9b885481 100644
--- a/tests/validators/test_timedelta.py
+++ b/tests/validators/test_timedelta.py
@@ -5,7 +5,7 @@
 
 import pytest
 
-from pydantic_core import SchemaError, SchemaValidator, ValidationError, validate_core_schema
+from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema, validate_core_schema
 
 from ..conftest import Err, PyAndJson
 
@@ -57,7 +57,7 @@
     ids=repr,
 )
 def test_timedelta(input_value, expected):
-    v = SchemaValidator({'type': 'timedelta'})
+    v = SchemaValidator(core_schema.timedelta_schema())
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value)
@@ -82,7 +82,7 @@ def test_timedelta(input_value, expected):
     ids=repr,
 )
 def test_timedelta_json(input_value, expected):
-    v = SchemaValidator({'type': 'timedelta'})
+    v = SchemaValidator(core_schema.timedelta_schema())
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_json(input_value)
@@ -103,7 +103,7 @@ def test_timedelta_json(input_value, expected):
     ],
 )
 def test_timedelta_strict(input_value, expected):
-    v = SchemaValidator({'type': 'timedelta', 'strict': True})
+    v = SchemaValidator(core_schema.timedelta_schema(strict=True))
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value)
@@ -121,7 +121,7 @@ def test_timedelta_strict(input_value, expected):
     ],
 )
 def test_timedelta_strict_json(input_value, expected):
-    v = SchemaValidator({'type': 'timedelta', 'strict': True})
+    v = SchemaValidator(core_schema.timedelta_schema(strict=True))
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_json(input_value)
@@ -179,7 +179,7 @@ def test_timedelta_strict_json(input_value, expected):
     ids=repr,
 )
 def test_timedelta_kwargs(kwargs: dict[str, Any], input_value, expected):
-    v = SchemaValidator({'type': 'timedelta', **kwargs})
+    v = SchemaValidator(core_schema.timedelta_schema(**kwargs))
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value)
@@ -189,7 +189,7 @@ def test_timedelta_kwargs(kwargs: dict[str, Any], input_value, expected):
 
 
 def test_timedelta_kwargs_strict():
-    v = SchemaValidator({'type': 'timedelta', 'strict': True, 'le': timedelta(days=3)})
+    v = SchemaValidator(core_schema.timedelta_schema(strict=True, le=timedelta(days=3)))
     output = v.validate_python(timedelta(days=2, hours=1))
     assert output == timedelta(days=2, hours=1)
 
@@ -209,7 +209,9 @@ def test_invalid_constraint():
 
 
 def test_dict_py():
-    v = SchemaValidator({'type': 'dict', 'keys_schema': {'type': 'timedelta'}, 'values_schema': {'type': 'int'}})
+    v = SchemaValidator(
+        core_schema.dict_schema(keys_schema=core_schema.timedelta_schema(), values_schema=core_schema.int_schema())
+    )
     assert v.validate_python({timedelta(days=2, hours=1): 2, timedelta(days=2, hours=2): 4}) == {
         timedelta(days=2, hours=1): 2,
         timedelta(days=2, hours=2): 4,
@@ -233,11 +235,11 @@ def test_dict_value(py_and_json: PyAndJson):
 
 
 def test_union():
-    v = SchemaValidator({'type': 'union', 'choices': [{'type': 'str'}, {'type': 'timedelta'}]})
+    v = SchemaValidator(core_schema.union_schema(choices=[core_schema.str_schema(), core_schema.timedelta_schema()]))
     assert v.validate_python('P2DT1H') == 'P2DT1H'
     assert v.validate_python(timedelta(days=2, hours=1)) == timedelta(days=2, hours=1)
 
-    v = SchemaValidator({'type': 'union', 'choices': [{'type': 'timedelta'}, {'type': 'str'}]})
+    v = SchemaValidator(core_schema.union_schema(choices=[core_schema.timedelta_schema(), core_schema.str_schema()]))
     assert v.validate_python('P2DT1H') == 'P2DT1H'
     assert v.validate_python(timedelta(days=2, hours=1)) == timedelta(days=2, hours=1)
 
@@ -265,7 +267,7 @@ def test_union():
     ids=repr,
 )
 def test_pytimedelta_as_timedelta(constraint, expected_duration):
-    v = SchemaValidator({'type': 'timedelta', 'gt': constraint})
+    v = SchemaValidator(core_schema.timedelta_schema(gt=constraint))
     # simplest way to check `pytimedelta_as_timedelta` is correct is to extract duration from repr of the validator
     m = re.search(r'Duration ?\{\s+positive: ?(\w+),\s+day: ?(\d+),\s+second: ?(\d+),\s+microsecond: ?(\d+)', repr(v))
     pos, day, sec, micro = m.groups()
@@ -274,7 +276,7 @@ def test_pytimedelta_as_timedelta(constraint, expected_duration):
 
 
 def test_large_value():
-    v = SchemaValidator({'type': 'timedelta'})
+    v = SchemaValidator(core_schema.timedelta_schema())
     assert v.validate_python('123days, 12:34') == timedelta(days=123, hours=12, minutes=34)
     assert v.validate_python(f'{999_999_999}days, 12:34') == timedelta(days=999_999_999, hours=12, minutes=34)
     with pytest.raises(ValidationError, match='should be a valid timedelta, durations may not exceed 999,999,999 days'):
@@ -283,7 +285,7 @@ def test_large_value():
 
 @pytest.mark.skipif(not pandas, reason='pandas not installed')
 def test_pandas():
-    v = SchemaValidator({'type': 'timedelta', 'ge': timedelta(hours=2)})
+    v = SchemaValidator(core_schema.timedelta_schema(ge=timedelta(hours=2)))
     two_hours = pandas.Timestamp('2023-01-01T02:00:00Z') - pandas.Timestamp('2023-01-01T00:00:00Z')
 
     assert v.validate_python(two_hours) == two_hours
diff --git a/tests/validators/test_tuple.py b/tests/validators/test_tuple.py
index 986b7fcd0..286b327d7 100644
--- a/tests/validators/test_tuple.py
+++ b/tests/validators/test_tuple.py
@@ -35,7 +35,7 @@ def test_tuple_json(py_and_json: PyAndJson, variadic_item_index, items, input_va
 
 
 def test_any_no_copy():
-    v = SchemaValidator({'type': 'tuple', 'items_schema': [{'type': 'any'}], 'variadic_item_index': 0})
+    v = SchemaValidator(core_schema.tuple_schema(items_schema=[core_schema.any_schema()], variadic_item_index=0))
     input_value = (1, '2', b'3')
     output = v.validate_python(input_value)
     assert output == input_value
@@ -60,7 +60,7 @@ def test_tuple_strict_passes_with_tuple(variadic_item_index, items, input_value,
 
 @pytest.mark.parametrize('fail_fast', [True, False])
 def test_empty_positional_tuple(fail_fast):
-    v = SchemaValidator({'type': 'tuple', 'items_schema': [], 'fail_fast': fail_fast})
+    v = SchemaValidator(core_schema.tuple_schema(items_schema=[], fail_fast=fail_fast))
     assert v.validate_python(()) == ()
     assert v.validate_python([]) == ()
     with pytest.raises(ValidationError) as exc_info:
@@ -124,7 +124,9 @@ def test_tuple_strict_fails_without_tuple(wrong_coll_type: type[Any], variadic_i
     ids=repr,
 )
 def test_tuple_var_len_kwargs(kwargs: dict[str, Any], input_value, expected):
-    v = SchemaValidator({'type': 'tuple', 'items_schema': [{'type': 'any'}], 'variadic_item_index': 0, **kwargs})
+    v = SchemaValidator(
+        core_schema.tuple_schema(items_schema=[core_schema.any_schema()], variadic_item_index=0, **kwargs)
+    )
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value)
@@ -180,7 +182,7 @@ def test_tuple_validate_iterator(variadic_item_index, items):
     ],
 )
 def test_tuple_var_len_errors(input_value, index):
-    v = SchemaValidator({'type': 'tuple', 'items_schema': [{'type': 'int'}], 'variadic_item_index': 0})
+    v = SchemaValidator(core_schema.tuple_schema(items_schema=[core_schema.int_schema()], variadic_item_index=0))
     with pytest.raises(ValidationError) as exc_info:
         assert v.validate_python(input_value)
     assert exc_info.value.errors(include_url=False) == [
@@ -208,7 +210,7 @@ def test_tuple_var_len_errors(input_value, index):
     ],
 )
 def test_tuple_fix_len_errors(input_value, items, index):
-    v = SchemaValidator({'type': 'tuple', 'items_schema': items})
+    v = SchemaValidator(core_schema.tuple_schema(items_schema=items))
     with pytest.raises(ValidationError) as exc_info:
         assert v.validate_python(input_value)
     assert exc_info.value.errors(include_url=False) == [
@@ -276,13 +278,12 @@ def test_positional_empty_extra(py_and_json: PyAndJson):
 @pytest.mark.parametrize('input_value,expected', [((1, 2, 3), (1, 2, 3)), ([1, 2, 3], [1, 2, 3])])
 def test_union_tuple_list(input_value, expected):
     v = SchemaValidator(
-        {
-            'type': 'union',
-            'choices': [
-                {'type': 'tuple', 'items_schema': [{'type': 'any'}], 'variadic_item_index': 0},
-                {'type': 'list'},
-            ],
-        }
+        core_schema.union_schema(
+            choices=[
+                core_schema.tuple_schema(items_schema=[core_schema.any_schema()], variadic_item_index=0),
+                core_schema.list_schema(),
+            ]
+        )
     )
     assert v.validate_python(input_value) == expected
 
@@ -320,13 +321,12 @@ def test_union_tuple_list(input_value, expected):
 )
 def test_union_tuple_var_len(input_value, expected):
     v = SchemaValidator(
-        {
-            'type': 'union',
-            'choices': [
-                {'type': 'tuple', 'items_schema': [{'type': 'int'}], 'variadic_item_index': 0, 'strict': True},
-                {'type': 'tuple', 'items_schema': [{'type': 'str'}], 'variadic_item_index': 0, 'strict': True},
-            ],
-        }
+        core_schema.union_schema(
+            choices=[
+                core_schema.tuple_schema(items_schema=[core_schema.int_schema()], variadic_item_index=0, strict=True),
+                core_schema.tuple_schema(items_schema=[core_schema.str_schema()], variadic_item_index=0, strict=True),
+            ]
+        )
     )
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)) as exc_info:
@@ -367,13 +367,18 @@ def test_union_tuple_var_len(input_value, expected):
 )
 def test_union_tuple_fix_len(input_value, expected):
     v = SchemaValidator(
-        {
-            'type': 'union',
-            'choices': [
-                {'type': 'tuple', 'items_schema': [{'type': 'int'}, {'type': 'int'}, {'type': 'int'}], 'strict': True},
-                {'type': 'tuple', 'items_schema': [{'type': 'str'}, {'type': 'str'}, {'type': 'str'}], 'strict': True},
-            ],
-        }
+        core_schema.union_schema(
+            choices=[
+                core_schema.tuple_schema(
+                    items_schema=[core_schema.int_schema(), core_schema.int_schema(), core_schema.int_schema()],
+                    strict=True,
+                ),
+                core_schema.tuple_schema(
+                    items_schema=[core_schema.str_schema(), core_schema.str_schema(), core_schema.str_schema()],
+                    strict=True,
+                ),
+            ]
+        )
     )
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)) as exc_info:
@@ -385,7 +390,7 @@ def test_union_tuple_fix_len(input_value, expected):
 
 
 def test_tuple_fix_error():
-    v = SchemaValidator({'type': 'tuple', 'items_schema': [{'type': 'int'}, {'type': 'str'}]})
+    v = SchemaValidator(core_schema.tuple_schema(items_schema=[core_schema.int_schema(), core_schema.str_schema()]))
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python([1])
 
@@ -407,7 +412,10 @@ def test_tuple_fix_error():
 )
 def test_tuple_fix_extra(input_value, expected):
     v = SchemaValidator(
-        {'type': 'tuple', 'items_schema': [{'type': 'int'}, {'type': 'str'}, {'type': 'str'}], 'variadic_item_index': 2}
+        core_schema.tuple_schema(
+            items_schema=[core_schema.int_schema(), core_schema.str_schema(), core_schema.str_schema()],
+            variadic_item_index=2,
+        )
     )
 
     if isinstance(expected, Err):
@@ -419,7 +427,11 @@ def test_tuple_fix_extra(input_value, expected):
 
 
 def test_tuple_fix_extra_any():
-    v = SchemaValidator({'type': 'tuple', 'items_schema': [{'type': 'str'}, {'type': 'any'}], 'variadic_item_index': 1})
+    v = SchemaValidator(
+        core_schema.tuple_schema(
+            items_schema=[core_schema.str_schema(), core_schema.any_schema()], variadic_item_index=1
+        )
+    )
     assert v.validate_python([b'1']) == ('1',)
     assert v.validate_python([b'1', 2]) == ('1', 2)
     assert v.validate_python((b'1', 2)) == ('1', 2)
@@ -439,7 +451,7 @@ def gen(error: bool):
             raise RuntimeError('error')
         yield 3
 
-    v = SchemaValidator({'type': 'tuple', 'items_schema': [{'type': 'int'}], 'variadic_item_index': 0})
+    v = SchemaValidator(core_schema.tuple_schema(items_schema=[core_schema.int_schema()], variadic_item_index=0))
     assert v.validate_python(gen(False)) == (1, 2, 3)
 
     msg = r'Error iterating over object, error: RuntimeError: error \[type=iteration_error,'
@@ -466,7 +478,7 @@ def gen(error: bool):
     ],
 )
 def test_frozenset_from_dict_items(input_value, items_schema, expected):
-    v = SchemaValidator({'type': 'tuple', 'items_schema': [items_schema], 'variadic_item_index': 0})
+    v = SchemaValidator(core_schema.tuple_schema(items_schema=[items_schema], variadic_item_index=0))
     output = v.validate_python(input_value)
     assert isinstance(output, tuple)
     assert output == expected
@@ -482,12 +494,11 @@ def test_frozenset_from_dict_items(input_value, items_schema, expected):
 )
 def test_length_constraints_omit(input_value, expected):
     v = SchemaValidator(
-        {
-            'type': 'tuple',
-            'items_schema': [{'type': 'default', 'schema': {'type': 'int'}, 'on_error': 'omit'}],
-            'variadic_item_index': 0,
-            'max_length': 4,
-        }
+        core_schema.tuple_schema(
+            items_schema=[core_schema.with_default_schema(schema=core_schema.int_schema(), on_error='omit')],
+            variadic_item_index=0,
+            max_length=4,
+        )
     )
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
diff --git a/tests/validators/test_typed_dict.py b/tests/validators/test_typed_dict.py
index b41a1188f..6e3826a3b 100644
--- a/tests/validators/test_typed_dict.py
+++ b/tests/validators/test_typed_dict.py
@@ -41,13 +41,12 @@ def __repr__(self):
 
 def test_simple():
     v = SchemaValidator(
-        {
-            'type': 'typed-dict',
-            'fields': {
-                'field_a': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
-                'field_b': {'type': 'typed-dict-field', 'schema': {'type': 'int'}},
-            },
-        }
+        core_schema.typed_dict_schema(
+            fields={
+                'field_a': core_schema.typed_dict_field(schema=core_schema.str_schema()),
+                'field_b': core_schema.typed_dict_field(schema=core_schema.int_schema()),
+            }
+        )
     )
 
     assert v.validate_python({'field_a': b'abc', 'field_b': 1}) == {'field_a': 'abc', 'field_b': 1}
@@ -61,7 +60,7 @@ def test_strict():
                 'field_a': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
                 'field_b': {'type': 'typed-dict-field', 'schema': {'type': 'int'}},
             },
-            'config': {'strict': True},
+            'config': CoreConfig(strict=True),
         }
     )
 
@@ -77,16 +76,14 @@ def test_strict():
 
 def test_with_default():
     v = SchemaValidator(
-        {
-            'type': 'typed-dict',
-            'fields': {
-                'field_a': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
-                'field_b': {
-                    'type': 'typed-dict-field',
-                    'schema': {'type': 'default', 'schema': {'type': 'int'}, 'default': 666},
-                },
-            },
-        }
+        core_schema.typed_dict_schema(
+            fields={
+                'field_a': core_schema.typed_dict_field(schema=core_schema.str_schema()),
+                'field_b': core_schema.typed_dict_field(
+                    schema=core_schema.with_default_schema(schema=core_schema.int_schema(), default=666)
+                ),
+            }
+        )
     )
 
     assert v.validate_python({'field_a': b'abc'}) == {'field_a': 'abc', 'field_b': 666}
@@ -95,13 +92,12 @@ def test_with_default():
 
 def test_missing_error(pydantic_version):
     v = SchemaValidator(
-        {
-            'type': 'typed-dict',
-            'fields': {
-                'field_a': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
-                'field_b': {'type': 'typed-dict-field', 'schema': {'type': 'int'}},
-            },
-        }
+        core_schema.typed_dict_schema(
+            fields={
+                'field_a': core_schema.typed_dict_field(schema=core_schema.str_schema()),
+                'field_b': core_schema.typed_dict_field(schema=core_schema.int_schema()),
+            }
+        )
     )
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python({'field_a': b'abc'})
@@ -121,13 +117,17 @@ def test_missing_error(pydantic_version):
         ({}, Map(a=123), {'a': 123}),
         ({}, {b'a': '123'}, Err('Field required [type=missing,')),
         ({}, {'a': '123', 'c': 4}, {'a': 123}),
-        ({'extra_fields_behavior': 'allow'}, {'a': '123', 'c': 4}, {'a': 123, 'c': 4}),
-        ({'extra_fields_behavior': 'allow'}, {'a': '123', b'c': 4}, Err('Keys should be strings [type=invalid_key,')),
-        ({'strict': True}, Map(a=123), Err('Input should be a valid dictionary [type=dict_type,')),
+        (CoreConfig(extra_fields_behavior='allow'), {'a': '123', 'c': 4}, {'a': 123, 'c': 4}),
+        (
+            CoreConfig(extra_fields_behavior='allow'),
+            {'a': '123', b'c': 4},
+            Err('Keys should be strings [type=invalid_key,'),
+        ),
+        (CoreConfig(strict=True), Map(a=123), Err('Input should be a valid dictionary [type=dict_type,')),
         ({}, {'a': '123', 'b': '4.7'}, {'a': 123, 'b': 4.7}),
         ({}, {'a': '123', 'b': 'nan'}, {'a': 123, 'b': FunctionCheck(math.isnan)}),
         (
-            {'allow_inf_nan': False},
+            CoreConfig(allow_inf_nan=False),
             {'a': '123', 'b': 'nan'},
             Err('Input should be a finite number [type=finite_number,'),
         ),
@@ -136,14 +136,13 @@ def test_missing_error(pydantic_version):
 )
 def test_config(config: CoreConfig, input_value, expected):
     v = SchemaValidator(
-        {
-            'type': 'typed-dict',
-            'fields': {
-                'a': {'type': 'typed-dict-field', 'schema': {'type': 'int'}},
-                'b': {'type': 'typed-dict-field', 'schema': {'type': 'float'}, 'required': False},
+        core_schema.typed_dict_schema(
+            fields={
+                'a': core_schema.typed_dict_field(schema=core_schema.int_schema()),
+                'b': core_schema.typed_dict_field(schema=core_schema.float_schema(), required=False),
             },
-            'config': config,
-        }
+            config=config,
+        )
     )
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
@@ -156,13 +155,12 @@ def test_config(config: CoreConfig, input_value, expected):
 
 def test_ignore_extra():
     v = SchemaValidator(
-        {
-            'type': 'typed-dict',
-            'fields': {
-                'field_a': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
-                'field_b': {'type': 'typed-dict-field', 'schema': {'type': 'int'}},
-            },
-        }
+        core_schema.typed_dict_schema(
+            fields={
+                'field_a': core_schema.typed_dict_field(schema=core_schema.str_schema()),
+                'field_b': core_schema.typed_dict_field(schema=core_schema.int_schema()),
+            }
+        )
     )
 
     assert v.validate_python({'field_a': b'123', 'field_b': 1, 'field_c': 123}) == {'field_a': '123', 'field_b': 1}
@@ -170,11 +168,9 @@ def test_ignore_extra():
 
 def test_forbid_extra():
     v = SchemaValidator(
-        {
-            'type': 'typed-dict',
-            'fields': {'field_a': {'type': 'typed-dict-field', 'schema': {'type': 'str'}}},
-            'extra_behavior': 'forbid',
-        }
+        core_schema.typed_dict_schema(
+            fields={'field_a': core_schema.typed_dict_field(schema=core_schema.str_schema())}, extra_behavior='forbid'
+        )
     )
 
     with pytest.raises(ValidationError) as exc_info:
@@ -188,7 +184,9 @@ def test_forbid_extra():
 def test_allow_extra_invalid():
     with pytest.raises(SchemaError, match='extras_schema can only be used if extra_behavior=allow'):
         SchemaValidator(
-            {'type': 'typed-dict', 'fields': {}, 'extras_schema': {'type': 'int'}, 'extra_behavior': 'ignore'}
+            schema=core_schema.typed_dict_schema(
+                fields={}, extras_schema=core_schema.int_schema(), extra_behavior='ignore'
+            )
         )
 
 
@@ -199,11 +197,10 @@ def test_allow_extra_wrong():
 
 def test_str_config():
     v = SchemaValidator(
-        {
-            'type': 'typed-dict',
-            'fields': {'field_a': {'type': 'typed-dict-field', 'schema': {'type': 'str'}}},
-            'config': {'str_max_length': 5},
-        }
+        core_schema.typed_dict_schema(
+            fields={'field_a': core_schema.typed_dict_field(schema=core_schema.str_schema())},
+            config=CoreConfig(str_max_length=5),
+        )
     )
     assert v.validate_python({'field_a': 'test'}) == {'field_a': 'test'}
 
@@ -213,12 +210,13 @@ def test_str_config():
 
 def test_json_error():
     v = SchemaValidator(
-        {
-            'type': 'typed-dict',
-            'fields': {
-                'field_a': {'type': 'typed-dict-field', 'schema': {'type': 'list', 'items_schema': {'type': 'int'}}}
-            },
-        }
+        core_schema.typed_dict_schema(
+            fields={
+                'field_a': core_schema.typed_dict_field(
+                    schema=core_schema.list_schema(items_schema=core_schema.int_schema())
+                )
+            }
+        )
     )
     with pytest.raises(ValidationError) as exc_info:
         v.validate_json('{"field_a": [123, "wrong"]}')
@@ -241,13 +239,12 @@ def test_missing_schema_key():
 def test_fields_required_by_default():
     """By default all fields should be required"""
     v = SchemaValidator(
-        {
-            'type': 'typed-dict',
-            'fields': {
-                'x': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
-                'y': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
-            },
-        }
+        core_schema.typed_dict_schema(
+            fields={
+                'x': core_schema.typed_dict_field(schema=core_schema.str_schema()),
+                'y': core_schema.typed_dict_field(schema=core_schema.str_schema()),
+            }
+        )
     )
 
     assert v.validate_python({'x': 'pika', 'y': 'chu'}) == {'x': 'pika', 'y': 'chu'}
@@ -262,13 +259,12 @@ def test_fields_required_by_default():
 
 def test_fields_required_by_default_with_optional():
     v = SchemaValidator(
-        {
-            'type': 'typed-dict',
-            'fields': {
-                'x': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
-                'y': {'type': 'typed-dict-field', 'schema': {'type': 'str'}, 'required': False},
-            },
-        }
+        core_schema.typed_dict_schema(
+            fields={
+                'x': core_schema.typed_dict_field(schema=core_schema.str_schema()),
+                'y': core_schema.typed_dict_field(schema=core_schema.str_schema(), required=False),
+            }
+        )
     )
 
     assert v.validate_python({'x': 'pika', 'y': 'chu'}) == {'x': 'pika', 'y': 'chu'}
@@ -277,16 +273,14 @@ def test_fields_required_by_default_with_optional():
 
 def test_fields_required_by_default_with_default():
     v = SchemaValidator(
-        {
-            'type': 'typed-dict',
-            'fields': {
-                'x': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
-                'y': {
-                    'type': 'typed-dict-field',
-                    'schema': {'type': 'default', 'schema': {'type': 'str'}, 'default': 'bulbi'},
-                },
-            },
-        }
+        core_schema.typed_dict_schema(
+            fields={
+                'x': core_schema.typed_dict_field(schema=core_schema.str_schema()),
+                'y': core_schema.typed_dict_field(
+                    schema=core_schema.with_default_schema(schema=core_schema.str_schema(), default='bulbi')
+                ),
+            }
+        )
     )
 
     assert v.validate_python({'x': 'pika', 'y': 'chu'}) == {'x': 'pika', 'y': 'chu'}
@@ -296,14 +290,13 @@ def test_fields_required_by_default_with_default():
 def test_all_optional_fields():
     """By default all fields should be optional if `total` is set to `False`"""
     v = SchemaValidator(
-        {
-            'type': 'typed-dict',
-            'total': False,
-            'fields': {
-                'x': {'type': 'typed-dict-field', 'schema': {'type': 'str', 'strict': True}},
-                'y': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
+        core_schema.typed_dict_schema(
+            total=False,
+            fields={
+                'x': core_schema.typed_dict_field(schema=core_schema.str_schema(strict=True)),
+                'y': core_schema.typed_dict_field(schema=core_schema.str_schema()),
             },
-        }
+        )
     )
 
     assert v.validate_python({'x': 'pika', 'y': 'chu'}) == {'x': 'pika', 'y': 'chu'}
@@ -320,14 +313,13 @@ def test_all_optional_fields():
 
 def test_all_optional_fields_with_required_fields():
     v = SchemaValidator(
-        {
-            'type': 'typed-dict',
-            'total': False,
-            'fields': {
-                'x': {'type': 'typed-dict-field', 'schema': {'type': 'str', 'strict': True}, 'required': True},
-                'y': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
+        core_schema.typed_dict_schema(
+            total=False,
+            fields={
+                'x': core_schema.typed_dict_field(schema=core_schema.str_schema(strict=True), required=True),
+                'y': core_schema.typed_dict_field(schema=core_schema.str_schema()),
             },
-        }
+        )
     )
 
     assert v.validate_python({'x': 'pika', 'y': 'chu'}) == {'x': 'pika', 'y': 'chu'}
@@ -345,16 +337,14 @@ def test_field_required_and_default():
     """A field cannot be required and have a default value"""
     with pytest.raises(SchemaError, match="Field 'x': a required field cannot have a default value"):
         SchemaValidator(
-            {
-                'type': 'typed-dict',
-                'fields': {
-                    'x': {
-                        'type': 'typed-dict-field',
-                        'schema': {'type': 'default', 'schema': {'type': 'str'}, 'default': 'pika'},
-                        'required': True,
-                    }
-                },
-            }
+            schema=core_schema.typed_dict_schema(
+                fields={
+                    'x': core_schema.typed_dict_field(
+                        schema=core_schema.with_default_schema(schema=core_schema.str_schema(), default='pika'),
+                        required=True,
+                    )
+                }
+            )
         )
 
 
@@ -501,13 +491,12 @@ def test_aliases_path_multiple(py_and_json: PyAndJson, input_value, expected):
 )
 def test_aliases_path_negative(input_value, expected):
     v = SchemaValidator(
-        {
-            'type': 'typed-dict',
-            'fields': {
-                'field_a': {'validation_alias': ['foo', -2], 'type': 'typed-dict-field', 'schema': {'type': 'int'}}
+        core_schema.typed_dict_schema(
+            fields={
+                'field_a': core_schema.typed_dict_field(validation_alias=['foo', -2], schema=core_schema.int_schema())
             },
-            'config': {'loc_by_alias': False},
-        }
+            config=CoreConfig(loc_by_alias=False),
+        )
     )
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=expected.message):
@@ -547,16 +536,13 @@ def test_aliases_path_negative_json(py_and_json: PyAndJson, input_value, expecte
 
 def test_aliases_debug():
     v = SchemaValidator(
-        {
-            'type': 'typed-dict',
-            'fields': {
-                'field_a': {
-                    'validation_alias': [['foo', 'bar', 'bat'], ['foo', 3]],
-                    'type': 'typed-dict-field',
-                    'schema': {'type': 'int'},
-                }
-            },
-        }
+        core_schema.typed_dict_schema(
+            fields={
+                'field_a': core_schema.typed_dict_field(
+                    validation_alias=[['foo', 'bar', 'bat'], ['foo', 3]], schema=core_schema.int_schema()
+                )
+            }
+        )
     )
     print(repr(v))
     assert repr(v).startswith('SchemaValidator(title="typed-dict", validator=TypedDict(')
@@ -565,16 +551,13 @@ def test_aliases_debug():
 
 def get_int_key():
     v = SchemaValidator(
-        {
-            'type': 'typed-dict',
-            'fields': {
-                'field_a': {
-                    'validation_alias': [['foo', 3], ['spam']],
-                    'type': 'typed-dict-field',
-                    'schema': {'type': 'int'},
-                }
-            },
-        }
+        core_schema.typed_dict_schema(
+            fields={
+                'field_a': core_schema.typed_dict_field(
+                    validation_alias=[['foo', 3], ['spam']], schema=core_schema.int_schema()
+                )
+            }
+        )
     )
     assert v.validate_python({'foo': {3: 33}}) == ({'field_a': 33}, {'field_a'})
 
@@ -587,10 +570,9 @@ def __getitem__(self, v):
 
 def get_custom_getitem():
     v = SchemaValidator(
-        {
-            'type': 'typed-dict',
-            'fields': {'field_a': {'validation_alias': ['foo'], 'type': 'typed-dict-field', 'schema': {'type': 'int'}}},
-        }
+        core_schema.typed_dict_schema(
+            fields={'field_a': core_schema.typed_dict_field(validation_alias=['foo'], schema=core_schema.int_schema())}
+        )
     )
     assert v.validate_python(GetItemThing()) == ({'field_a': 321}, {'field_a'})
     assert v.validate_python({'bar': GetItemThing()}) == ({'field_a': 321}, {'field_a'})
@@ -629,7 +611,7 @@ def test_paths_allow_by_name(py_and_json: PyAndJson, input_value):
 def test_alias_build_error(alias_schema, error):
     with pytest.raises(SchemaError, match=error):
         SchemaValidator(
-            validate_core_schema(
+            schema=validate_core_schema(
                 {
                     'type': 'typed-dict',
                     'fields': {'field_a': {'type': 'typed-dict-field', 'schema': {'type': 'int'}, **alias_schema}},
@@ -732,7 +714,7 @@ def test_alias_error_loc_field_names(py_and_json: PyAndJson):
 
 
 def test_empty_model():
-    v = SchemaValidator({'type': 'typed-dict', 'fields': {}})
+    v = SchemaValidator(core_schema.typed_dict_schema(fields={}))
     assert v.validate_python({}) == {}
     with pytest.raises(ValidationError, match=re.escape('Input should be a valid dictionary [type=dict_type,')):
         v.validate_python('x')
@@ -740,31 +722,26 @@ def test_empty_model():
 
 def test_model_deep():
     v = SchemaValidator(
-        {
-            'type': 'typed-dict',
-            'fields': {
-                'field_a': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
-                'field_b': {
-                    'type': 'typed-dict-field',
-                    'schema': {
-                        'type': 'typed-dict',
-                        'fields': {
-                            'field_c': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
-                            'field_d': {
-                                'type': 'typed-dict-field',
-                                'schema': {
-                                    'type': 'typed-dict',
-                                    'fields': {
-                                        'field_e': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
-                                        'field_f': {'type': 'typed-dict-field', 'schema': {'type': 'int'}},
-                                    },
-                                },
-                            },
-                        },
-                    },
-                },
-            },
-        }
+        core_schema.typed_dict_schema(
+            fields={
+                'field_a': core_schema.typed_dict_field(schema=core_schema.str_schema()),
+                'field_b': core_schema.typed_dict_field(
+                    schema=core_schema.typed_dict_schema(
+                        fields={
+                            'field_c': core_schema.typed_dict_field(schema=core_schema.str_schema()),
+                            'field_d': core_schema.typed_dict_field(
+                                schema=core_schema.typed_dict_schema(
+                                    fields={
+                                        'field_e': core_schema.typed_dict_field(schema=core_schema.str_schema()),
+                                        'field_f': core_schema.typed_dict_field(schema=core_schema.int_schema()),
+                                    }
+                                )
+                            ),
+                        }
+                    )
+                ),
+            }
+        )
     )
     output = v.validate_python({'field_a': '1', 'field_b': {'field_c': '2', 'field_d': {'field_e': '4', 'field_f': 4}}})
     assert output == {'field_a': '1', 'field_b': ({'field_c': '2', 'field_d': {'field_e': '4', 'field_f': 4}})}
@@ -843,15 +820,15 @@ def test_alias_extra_forbid(py_and_json: PyAndJson):
 
 def test_with_default_factory():
     v = SchemaValidator(
-        {
-            'type': 'typed-dict',
-            'fields': {
-                'x': {
-                    'type': 'typed-dict-field',
-                    'schema': {'type': 'default', 'schema': {'type': 'str'}, 'default_factory': lambda: 'pikachu'},
-                }
-            },
-        }
+        core_schema.typed_dict_schema(
+            fields={
+                'x': core_schema.typed_dict_field(
+                    schema=core_schema.with_default_schema(
+                        schema=core_schema.str_schema(), default_factory=lambda: 'pikachu'
+                    )
+                )
+            }
+        )
     )
 
     assert v.validate_python({}) == {'x': 'pikachu'}
@@ -862,16 +839,16 @@ def test_field_required_and_default_factory():
     """A field cannot be required and have a default factory"""
     with pytest.raises(SchemaError, match="Field 'x': a required field cannot have a default value"):
         SchemaValidator(
-            {
-                'type': 'typed-dict',
-                'fields': {
-                    'x': {
-                        'type': 'typed-dict-field',
-                        'schema': {'type': 'default', 'schema': {'type': 'str'}, 'default_factory': lambda: 'pika'},
-                        'required': True,
-                    }
-                },
-            }
+            schema=core_schema.typed_dict_schema(
+                fields={
+                    'x': core_schema.typed_dict_field(
+                        schema=core_schema.with_default_schema(
+                            schema=core_schema.str_schema(), default_factory=lambda: 'pika'
+                        ),
+                        required=True,
+                    )
+                }
+            )
         )
 
 
@@ -884,15 +861,15 @@ def test_field_required_and_default_factory():
 )
 def test_bad_default_factory(default_factory, error_message):
     v = SchemaValidator(
-        {
-            'type': 'typed-dict',
-            'fields': {
-                'x': {
-                    'type': 'typed-dict-field',
-                    'schema': {'type': 'default', 'schema': {'type': 'str'}, 'default_factory': default_factory},
-                }
-            },
-        }
+        core_schema.typed_dict_schema(
+            fields={
+                'x': core_schema.typed_dict_field(
+                    schema=core_schema.with_default_schema(
+                        schema=core_schema.str_schema(), default_factory=default_factory
+                    )
+                )
+            }
+        )
     )
     with pytest.raises(TypeError, match=re.escape(error_message)):
         v.validate_python({})
@@ -916,29 +893,25 @@ def test_on_error_bad_name(self):
     def test_on_error_bad_omit(self):
         with pytest.raises(SchemaError, match="Field 'x': 'on_error = omit' cannot be set for required fields"):
             SchemaValidator(
-                {
-                    'type': 'typed-dict',
-                    'fields': {
-                        'x': {
-                            'type': 'typed-dict-field',
-                            'schema': {'type': 'default', 'schema': {'type': 'str'}, 'on_error': 'omit'},
-                        }
-                    },
-                }
+                schema=core_schema.typed_dict_schema(
+                    fields={
+                        'x': core_schema.typed_dict_field(
+                            schema=core_schema.with_default_schema(schema=core_schema.str_schema(), on_error='omit')
+                        )
+                    }
+                )
             )
 
     def test_on_error_bad_default(self):
         with pytest.raises(SchemaError, match="'on_error = default' requires a `default` or `default_factory`"):
             SchemaValidator(
-                {
-                    'type': 'typed-dict',
-                    'fields': {
-                        'x': {
-                            'type': 'typed-dict-field',
-                            'schema': {'type': 'default', 'schema': {'type': 'str'}, 'on_error': 'default'},
-                        }
-                    },
-                }
+                schema=core_schema.typed_dict_schema(
+                    fields={
+                        'x': core_schema.typed_dict_field(
+                            schema=core_schema.with_default_schema(schema=core_schema.str_schema(), on_error='default')
+                        )
+                    }
+                )
             )
 
     def test_on_error_raise_by_default(self, py_and_json: PyAndJson):
diff --git a/tests/validators/test_union.py b/tests/validators/test_union.py
index 1951fb3de..70acd6cfd 100644
--- a/tests/validators/test_union.py
+++ b/tests/validators/test_union.py
@@ -29,7 +29,7 @@
     ],
 )
 def test_union_bool_int(input_value, expected_value):
-    v = SchemaValidator({'type': 'union', 'choices': [{'type': 'bool'}, {'type': 'int'}]})
+    v = SchemaValidator(core_schema.union_schema(choices=[core_schema.bool_schema(), core_schema.int_schema()]))
     assert v.validate_python(input_value) == expected_value
 
 
@@ -49,7 +49,7 @@ def test_union_bool_int(input_value, expected_value):
     ],
 )
 def test_union_int_bool(input_value, expected_value):
-    v = SchemaValidator({'type': 'union', 'choices': [{'type': 'int'}, {'type': 'bool'}]})
+    v = SchemaValidator(core_schema.union_schema(choices=[core_schema.int_schema(), core_schema.bool_schema()]))
     assert v.validate_python(input_value) == expected_value
 
 
@@ -63,33 +63,28 @@ class ModelB:
     @pytest.fixture(scope='class')
     def schema_validator(self) -> SchemaValidator:
         return SchemaValidator(
-            {
-                'type': 'union',
-                'choices': [
-                    {
-                        'type': 'model',
-                        'cls': self.ModelA,
-                        'schema': {
-                            'type': 'model-fields',
-                            'fields': {
-                                'a': {'type': 'model-field', 'schema': {'type': 'int'}},
-                                'b': {'type': 'model-field', 'schema': {'type': 'str'}},
-                            },
-                        },
-                    },
-                    {
-                        'type': 'model',
-                        'cls': self.ModelB,
-                        'schema': {
-                            'type': 'model-fields',
-                            'fields': {
-                                'c': {'type': 'model-field', 'schema': {'type': 'int'}},
-                                'd': {'type': 'model-field', 'schema': {'type': 'str'}},
-                            },
-                        },
-                    },
-                ],
-            }
+            schema=core_schema.union_schema(
+                choices=[
+                    core_schema.model_schema(
+                        cls=self.ModelA,
+                        schema=core_schema.model_fields_schema(
+                            fields={
+                                'a': core_schema.model_field(schema=core_schema.int_schema()),
+                                'b': core_schema.model_field(schema=core_schema.str_schema()),
+                            }
+                        ),
+                    ),
+                    core_schema.model_schema(
+                        cls=self.ModelB,
+                        schema=core_schema.model_fields_schema(
+                            fields={
+                                'c': core_schema.model_field(schema=core_schema.int_schema()),
+                                'd': core_schema.model_field(schema=core_schema.str_schema()),
+                            }
+                        ),
+                    ),
+                ]
+            )
         )
 
     def test_model_a(self, schema_validator: SchemaValidator):
@@ -131,37 +126,33 @@ class ModelB:
     @pytest.fixture(scope='class')
     def schema_validator(self) -> SchemaValidator:
         return SchemaValidator(
-            {
-                'type': 'union',
-                'choices': [
-                    {
-                        'type': 'model',
-                        'cls': self.ModelA,
-                        'schema': {
-                            'type': 'model-fields',
-                            'fields': {
-                                'a': {'type': 'model-field', 'schema': {'type': 'int'}},
-                                'b': {'type': 'model-field', 'schema': {'type': 'str'}},
-                            },
-                        },
-                    },
-                    {
-                        'type': 'model',
-                        'cls': self.ModelB,
-                        'schema': {
-                            'type': 'model-fields',
-                            'fields': {
-                                'a': {'type': 'model-field', 'schema': {'type': 'int'}},
-                                'b': {'type': 'model-field', 'schema': {'type': 'str'}},
-                                'c': {
-                                    'type': 'model-field',
-                                    'schema': {'type': 'default', 'schema': {'type': 'float'}, 'default': 1.0},
-                                },
-                            },
-                        },
-                    },
-                ],
-            }
+            schema=core_schema.union_schema(
+                choices=[
+                    core_schema.model_schema(
+                        cls=self.ModelA,
+                        schema=core_schema.model_fields_schema(
+                            fields={
+                                'a': core_schema.model_field(schema=core_schema.int_schema()),
+                                'b': core_schema.model_field(schema=core_schema.str_schema()),
+                            }
+                        ),
+                    ),
+                    core_schema.model_schema(
+                        cls=self.ModelB,
+                        schema=core_schema.model_fields_schema(
+                            fields={
+                                'a': core_schema.model_field(schema=core_schema.int_schema()),
+                                'b': core_schema.model_field(schema=core_schema.str_schema()),
+                                'c': core_schema.model_field(
+                                    schema=core_schema.with_default_schema(
+                                        schema=core_schema.float_schema(), default=1.0
+                                    )
+                                ),
+                            }
+                        ),
+                    ),
+                ]
+            )
         )
 
     def test_model_a(self, schema_validator: SchemaValidator):
@@ -194,7 +185,7 @@ def test_model_b_not_ignored(self, schema_validator: SchemaValidator):
 
 
 def test_nullable_via_union():
-    v = SchemaValidator({'type': 'union', 'choices': [{'type': 'none'}, {'type': 'int'}]})
+    v = SchemaValidator(core_schema.union_schema(choices=[core_schema.none_schema(), core_schema.int_schema()]))
     assert v.validate_python(None) is None
     assert v.validate_python(1) == 1
     with pytest.raises(ValidationError) as exc_info:
@@ -212,13 +203,12 @@ def test_nullable_via_union():
 
 def test_union_list_bool_int():
     v = SchemaValidator(
-        {
-            'type': 'union',
-            'choices': [
-                {'type': 'list', 'items_schema': {'type': 'bool'}},
-                {'type': 'list', 'items_schema': {'type': 'int'}},
-            ],
-        }
+        core_schema.union_schema(
+            choices=[
+                core_schema.list_schema(items_schema=core_schema.bool_schema()),
+                core_schema.list_schema(items_schema=core_schema.int_schema()),
+            ]
+        )
     )
     assert v.validate_python(['true', True, 'no']) == [True, True, False]
     assert v.validate_python([5, 6, '789']) == [5, 6, 789]
@@ -260,11 +250,11 @@ def test_no_choices(pydantic_version):
 def test_empty_choices():
     msg = r'Error building "union" validator:\s+SchemaError: One or more union choices required'
     with pytest.raises(SchemaError, match=msg):
-        SchemaValidator({'type': 'union', 'choices': []})
+        SchemaValidator(core_schema.union_schema(choices=[]))
 
 
 def test_one_choice():
-    v = SchemaValidator({'type': 'union', 'choices': [{'type': 'str'}]})
+    v = SchemaValidator(core_schema.union_schema(choices=[core_schema.str_schema()]))
     assert (
         plain_repr(v)
         == 'SchemaValidator(title="str",validator=Str(StrValidator{strict:false,coerce_numbers_to_str:false}),definitions=[],cache_strings=True)'
@@ -273,7 +263,9 @@ def test_one_choice():
 
 
 def test_strict_union():
-    v = SchemaValidator({'type': 'union', 'strict': True, 'choices': [{'type': 'bool'}, {'type': 'int'}]})
+    v = SchemaValidator(
+        core_schema.union_schema(strict=True, choices=[core_schema.bool_schema(), core_schema.int_schema()])
+    )
     assert v.validate_python(1) == 1
     assert v.validate_python(123) == 123
 
@@ -288,12 +280,11 @@ def test_strict_union():
 
 def test_custom_error():
     v = SchemaValidator(
-        {
-            'type': 'union',
-            'choices': [{'type': 'str'}, {'type': 'bytes'}],
-            'custom_error_type': 'my_error',
-            'custom_error_message': 'Input should be a string or bytes',
-        }
+        core_schema.union_schema(
+            choices=[core_schema.str_schema(), core_schema.bytes_schema()],
+            custom_error_type='my_error',
+            custom_error_message='Input should be a string or bytes',
+        )
     )
     assert v.validate_python('hello') == 'hello'
     assert v.validate_python(b'hello') == b'hello'
@@ -307,7 +298,9 @@ def test_custom_error():
 
 def test_custom_error_type():
     v = SchemaValidator(
-        {'type': 'union', 'choices': [{'type': 'str'}, {'type': 'bytes'}], 'custom_error_type': 'string_type'}
+        core_schema.union_schema(
+            choices=[core_schema.str_schema(), core_schema.bytes_schema()], custom_error_type='string_type'
+        )
     )
     assert v.validate_python('hello') == 'hello'
     assert v.validate_python(b'hello') == b'hello'
@@ -321,12 +314,11 @@ def test_custom_error_type():
 
 def test_custom_error_type_context():
     v = SchemaValidator(
-        {
-            'type': 'union',
-            'choices': [{'type': 'str'}, {'type': 'bytes'}],
-            'custom_error_type': 'less_than',
-            'custom_error_context': {'lt': 42},
-        }
+        core_schema.union_schema(
+            choices=[core_schema.str_schema(), core_schema.bytes_schema()],
+            custom_error_type='less_than',
+            custom_error_context={'lt': 42},
+        )
     )
     assert v.validate_python('hello') == 'hello'
     assert v.validate_python(b'hello') == b'hello'
@@ -418,7 +410,9 @@ def test_strict_reference():
 
 def test_case_labels():
     v = SchemaValidator(
-        {'type': 'union', 'choices': [{'type': 'none'}, ({'type': 'int'}, 'my_label'), {'type': 'str'}]}
+        core_schema.union_schema(
+            choices=[core_schema.none_schema(), ({'type': 'int'}, 'my_label'), core_schema.str_schema()]
+        )
     )
     assert v.validate_python(None) is None
     assert v.validate_python(1) == 1
@@ -782,22 +776,17 @@ class ModelA:
         pass
 
     validator = SchemaValidator(
-        {
-            'type': 'union',
-            'choices': [
-                {
-                    'type': 'model',
-                    'cls': ModelA,
-                    'schema': {
-                        'type': 'model-fields',
-                        'fields': {
-                            'a': {'type': 'model-field', 'schema': {'type': 'int'}},
-                        },
-                    },
-                },
-                {'type': 'literal', 'expected': [True]},
-            ],
-        }
+        core_schema.union_schema(
+            choices=[
+                core_schema.model_schema(
+                    cls=ModelA,
+                    schema=core_schema.model_fields_schema(
+                        fields={'a': core_schema.model_field(schema=core_schema.int_schema())}
+                    ),
+                ),
+                core_schema.literal_schema(expected=[True]),
+            ]
+        )
     )
 
     # validation against Literal[True] fails bc of the unhashable dict
@@ -834,7 +823,7 @@ class ModelB(ModelA):
 
     @pytest.mark.parametrize('choices', permute_choices([model_a_schema, model_b_schema]))
     def test_more_specific_data_matches_subclass(self, choices) -> None:
-        validator = SchemaValidator(schema=core_schema.union_schema(choices))
+        validator = SchemaValidator(core_schema.union_schema(choices))
         assert isinstance(validator.validate_python({'a': 1}), self.ModelA)
         assert isinstance(validator.validate_python({'a': 1, 'b': 2}), self.ModelB)
 
@@ -869,7 +858,7 @@ class ModelB:
 
     @pytest.mark.parametrize('choices', permute_choices([model_a_schema, model_b_schema]))
     def test_fields_set_ensures_best_match(self, choices) -> None:
-        validator = SchemaValidator(schema=core_schema.union_schema(choices))
+        validator = SchemaValidator(core_schema.union_schema(choices))
         assert isinstance(validator.validate_python({'a': 1}), self.ModelA)
         assert isinstance(validator.validate_python({'b': 1}), self.ModelB)
 
@@ -882,7 +871,7 @@ class WrapModel:
             val: Optional[Union[self.ModelA, self.ModelB]] = None
 
         val = SchemaValidator(
-            core_schema.model_schema(
+            schema=core_schema.model_schema(
                 WrapModel,
                 core_schema.model_fields_schema(
                     fields={
@@ -1261,7 +1250,7 @@ class ModelB:
     for model_a_schema in model_a_schema_options:
         for model_b_schema in model_b_schema_options:
             validator = SchemaValidator(
-                core_schema.union_schema(
+                schema=core_schema.union_schema(
                     [
                         core_schema.model_schema(
                             ModelA,
diff --git a/tests/validators/test_url.py b/tests/validators/test_url.py
index e8534a26a..c2f3f2e14 100644
--- a/tests/validators/test_url.py
+++ b/tests/validators/test_url.py
@@ -5,7 +5,7 @@
 import pytest
 from dirty_equals import HasRepr, IsInstance
 
-from pydantic_core import MultiHostUrl, SchemaError, SchemaValidator, Url, ValidationError, core_schema
+from pydantic_core import CoreConfig, MultiHostUrl, SchemaError, SchemaValidator, Url, ValidationError, core_schema
 
 from ..conftest import Err, PyAndJson
 
@@ -367,7 +367,7 @@ def test_multi_host_default_host_no_comma():
 
 @pytest.fixture(scope='module', name='strict_url_validator')
 def strict_url_validator_fixture():
-    return SchemaValidator(core_schema.url_schema(), {'strict': True})
+    return SchemaValidator(core_schema.url_schema(), config=CoreConfig(strict=True))
 
 
 @pytest.mark.parametrize(
diff --git a/tests/validators/test_uuid.py b/tests/validators/test_uuid.py
index d1475f38e..5448f25f4 100644
--- a/tests/validators/test_uuid.py
+++ b/tests/validators/test_uuid.py
@@ -81,7 +81,7 @@ class MyStr(str): ...
     ],
 )
 def test_uuid(input_value, expected):
-    v = SchemaValidator({'type': 'uuid'})
+    v = SchemaValidator(core_schema.uuid_schema())
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             result = v.validate_python(input_value)
@@ -102,7 +102,7 @@ def test_uuid(input_value, expected):
     ],
 )
 def test_uuid_strict(input_value, expected):
-    v = SchemaValidator({'type': 'uuid', 'strict': True})
+    v = SchemaValidator(core_schema.uuid_schema(strict=True))
     if isinstance(expected, Err):
         with pytest.raises(ValidationError, match=re.escape(expected.message)):
             v.validate_python(input_value)
@@ -150,9 +150,9 @@ def test_uuid_strict(input_value, expected):
     ],
 )
 def test_uuid_version(input_value, version, expected):
-    schema = {'type': 'uuid'}
+    schema = core_schema.uuid_schema()
     if version is not None:
-        schema['version'] = version
+        schema = core_schema.uuid_schema(version=version)
 
     v = SchemaValidator(schema)
 
@@ -193,7 +193,7 @@ def test_uuid_json(py_and_json: PyAndJson, input_value, expected):
 
 
 def test_uuid_deepcopy():
-    output = SchemaValidator({'type': 'uuid'}).validate_python('a6cc5730-2261-11ee-9c43-2eb5a363657c')
+    output = SchemaValidator(core_schema.uuid_schema()).validate_python('a6cc5730-2261-11ee-9c43-2eb5a363657c')
     c = copy.deepcopy(output)
     assert repr(output) == "UUID('a6cc5730-2261-11ee-9c43-2eb5a363657c')"
     assert c == output
@@ -201,7 +201,7 @@ def test_uuid_deepcopy():
 
 
 def test_uuid_copy():
-    output = SchemaValidator({'type': 'uuid'}).validate_python('a6cc5730-2261-11ee-9c43-2eb5a363657c')
+    output = SchemaValidator(core_schema.uuid_schema()).validate_python('a6cc5730-2261-11ee-9c43-2eb5a363657c')
     c = copy.copy(output)
     assert repr(output) == "UUID('a6cc5730-2261-11ee-9c43-2eb5a363657c')"
     assert c == output
diff --git a/tests/validators/test_with_default.py b/tests/validators/test_with_default.py
index 7c5972c5a..2b092d066 100644
--- a/tests/validators/test_with_default.py
+++ b/tests/validators/test_with_default.py
@@ -21,16 +21,14 @@
 
 def test_typed_dict_default():
     v = SchemaValidator(
-        {
-            'type': 'typed-dict',
-            'fields': {
-                'x': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
-                'y': {
-                    'type': 'typed-dict-field',
-                    'schema': {'type': 'default', 'schema': {'type': 'str'}, 'default': '[default]'},
-                },
-            },
-        }
+        core_schema.typed_dict_schema(
+            fields={
+                'x': core_schema.typed_dict_field(schema=core_schema.str_schema()),
+                'y': core_schema.typed_dict_field(
+                    schema=core_schema.with_default_schema(schema=core_schema.str_schema(), default='[default]')
+                ),
+            }
+        )
     )
     assert v.validate_python({'x': 'x', 'y': 'y'}) == {'x': 'x', 'y': 'y'}
     assert v.validate_python({'x': 'x'}) == {'x': 'x', 'y': '[default]'}
@@ -38,17 +36,15 @@ def test_typed_dict_default():
 
 def test_typed_dict_omit():
     v = SchemaValidator(
-        {
-            'type': 'typed-dict',
-            'fields': {
-                'x': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
-                'y': {
-                    'type': 'typed-dict-field',
-                    'schema': {'type': 'default', 'schema': {'type': 'str'}, 'on_error': 'omit'},
-                    'required': False,
-                },
-            },
-        }
+        core_schema.typed_dict_schema(
+            fields={
+                'x': core_schema.typed_dict_field(schema=core_schema.str_schema()),
+                'y': core_schema.typed_dict_field(
+                    schema=core_schema.with_default_schema(schema=core_schema.str_schema(), on_error='omit'),
+                    required=False,
+                ),
+            }
+        )
     )
     assert v.validate_python({'x': 'x', 'y': 'y'}) == {'x': 'x', 'y': 'y'}
     assert v.validate_python({'x': 'x'}) == {'x': 'x'}
@@ -57,16 +53,17 @@ def test_typed_dict_omit():
 
 def test_arguments():
     v = SchemaValidator(
-        {
-            'type': 'arguments',
-            'arguments_schema': [
+        core_schema.arguments_schema(
+            arguments=[
                 {
                     'name': 'a',
                     'mode': 'positional_or_keyword',
-                    'schema': {'type': 'default', 'schema': {'type': 'int'}, 'default_factory': lambda: 1},
+                    'schema': core_schema.with_default_schema(
+                        schema=core_schema.int_schema(), default_factory=lambda: 1
+                    ),
                 }
-            ],
-        }
+            ]
+        )
     )
     assert v.validate_python({'a': 2}) == ((), {'a': 2})
     assert v.validate_python(ArgsKwargs((2,))) == ((2,), {})
@@ -77,16 +74,17 @@ def test_arguments():
 def test_arguments_omit():
     with pytest.raises(SchemaError, match="Parameter 'a': omit_on_error cannot be used with arguments"):
         SchemaValidator(
-            {
-                'type': 'arguments',
-                'arguments_schema': [
+            schema=core_schema.arguments_schema(
+                arguments=[
                     {
                         'name': 'a',
                         'mode': 'positional_or_keyword',
-                        'schema': {'type': 'default', 'schema': {'type': 'int'}, 'default': 1, 'on_error': 'omit'},
+                        'schema': core_schema.with_default_schema(
+                            schema=core_schema.int_schema(), default=1, on_error='omit'
+                        ),
                     }
-                ],
-            }
+                ]
+            )
         )
 
 
@@ -113,7 +111,9 @@ def test_list_json(py_and_json: PyAndJson, input_value, expected):
 )
 def test_list(input_value, expected):
     v = SchemaValidator(
-        {'type': 'list', 'items_schema': {'type': 'default', 'schema': {'type': 'int'}, 'on_error': 'omit'}}
+        core_schema.list_schema(
+            items_schema=core_schema.with_default_schema(schema=core_schema.int_schema(), on_error='omit')
+        )
     )
     assert v.validate_python(input_value) == expected
 
@@ -130,7 +130,9 @@ def test_list(input_value, expected):
 )
 def test_set(input_value, expected):
     v = SchemaValidator(
-        {'type': 'set', 'items_schema': {'type': 'default', 'schema': {'type': 'int'}, 'on_error': 'omit'}}
+        core_schema.set_schema(
+            items_schema=core_schema.with_default_schema(schema=core_schema.int_schema(), on_error='omit')
+        )
     )
     assert v.validate_python(input_value) == expected
 
@@ -150,11 +152,10 @@ def test_dict_values(py_and_json: PyAndJson):
 
 def test_dict_keys():
     v = SchemaValidator(
-        {
-            'type': 'dict',
-            'keys_schema': {'type': 'default', 'schema': {'type': 'int'}, 'on_error': 'omit'},
-            'values_schema': {'type': 'str'},
-        }
+        core_schema.dict_schema(
+            keys_schema=core_schema.with_default_schema(schema=core_schema.int_schema(), on_error='omit'),
+            values_schema=core_schema.str_schema(),
+        )
     )
     assert v.validate_python({1: 'a', '2': 'b'}) == {1: 'a', 2: 'b'}
     assert v.validate_python({1: 'a', 'wrong': 'b'}) == {1: 'a'}
@@ -176,10 +177,12 @@ def test_tuple_variable(py_and_json: PyAndJson):
 
 def test_tuple_positional():
     v = SchemaValidator(
-        {
-            'type': 'tuple',
-            'items_schema': [{'type': 'int'}, {'type': 'default', 'schema': {'type': 'int'}, 'default': 42}],
-        }
+        core_schema.tuple_schema(
+            items_schema=[
+                core_schema.int_schema(),
+                core_schema.with_default_schema(schema=core_schema.int_schema(), default=42),
+            ]
+        )
     )
     assert v.validate_python((1, '2')) == (1, 2)
     assert v.validate_python([1, '2']) == (1, 2)
@@ -189,15 +192,14 @@ def test_tuple_positional():
 
 def test_tuple_positional_omit():
     v = SchemaValidator(
-        {
-            'type': 'tuple',
-            'items_schema': [
-                {'type': 'int'},
-                {'type': 'int'},
-                {'type': 'default', 'schema': {'type': 'int'}, 'on_error': 'omit'},
+        core_schema.tuple_schema(
+            items_schema=[
+                core_schema.int_schema(),
+                core_schema.int_schema(),
+                core_schema.with_default_schema(schema=core_schema.int_schema(), on_error='omit'),
             ],
-            'variadic_item_index': 2,
-        }
+            variadic_item_index=2,
+        )
     )
     assert v.validate_python((1, '2')) == (1, 2)
     assert v.validate_python((1, '2', 3, '4')) == (1, 2, 3, 4)
@@ -207,7 +209,7 @@ def test_tuple_positional_omit():
 
 
 def test_on_error_default():
-    v = SchemaValidator({'type': 'default', 'schema': {'type': 'int'}, 'default': 2, 'on_error': 'default'})
+    v = SchemaValidator(core_schema.with_default_schema(schema=core_schema.int_schema(), default=2, on_error='default'))
     assert v.validate_python(42) == 42
     assert v.validate_python('42') == 42
     assert v.validate_python('wrong') == 2
@@ -218,7 +220,7 @@ def broken():
         raise RuntimeError('this is broken')
 
     v = SchemaValidator(
-        {'type': 'default', 'schema': {'type': 'int'}, 'on_error': 'default', 'default_factory': broken}
+        core_schema.with_default_schema(schema=core_schema.int_schema(), on_error='default', default_factory=broken)
     )
     assert v.validate_python(42) == 42
     assert v.validate_python('42') == 42
@@ -231,13 +233,12 @@ def broken(x):
         return 7
 
     v = SchemaValidator(
-        {
-            'type': 'default',
-            'schema': {'type': 'int'},
-            'on_error': 'default',
-            'default_factory': broken,
-            'default_factory_takes_data': False,
-        }
+        core_schema.with_default_schema(
+            schema=core_schema.int_schema(),
+            on_error='default',
+            default_factory=broken,
+            default_factory_takes_data=False,
+        )
     )
     assert v.validate_python(42) == 42
     assert v.validate_python('42') == 42
@@ -247,16 +248,16 @@ def broken(x):
 
 def test_typed_dict_error():
     v = SchemaValidator(
-        {
-            'type': 'typed-dict',
-            'fields': {
-                'x': {'type': 'typed-dict-field', 'schema': {'type': 'str'}},
-                'y': {
-                    'type': 'typed-dict-field',
-                    'schema': {'type': 'default', 'schema': {'type': 'str'}, 'default_factory': lambda y: y * 2},
-                },
-            },
-        }
+        core_schema.typed_dict_schema(
+            fields={
+                'x': core_schema.typed_dict_field(schema=core_schema.str_schema()),
+                'y': core_schema.typed_dict_field(
+                    schema=core_schema.with_default_schema(
+                        schema=core_schema.str_schema(), default_factory=lambda y: y * 2
+                    )
+                ),
+            }
+        )
     )
     assert v.validate_python({'x': 'x', 'y': 'y'}) == {'x': 'x', 'y': 'y'}
     with pytest.raises(TypeError, match=r"<lambda>\(\) missing 1 required positional argument: 'y'"):
@@ -264,7 +265,9 @@ def test_typed_dict_error():
 
 
 def test_on_error_default_not_int():
-    v = SchemaValidator({'type': 'default', 'schema': {'type': 'int'}, 'default': [1, 2, 3], 'on_error': 'default'})
+    v = SchemaValidator(
+        core_schema.with_default_schema(schema=core_schema.int_schema(), default=[1, 2, 3], on_error='default')
+    )
     assert v.validate_python(42) == 42
     assert v.validate_python('42') == 42
     assert v.validate_python('wrong') == [1, 2, 3]
@@ -272,7 +275,7 @@ def test_on_error_default_not_int():
 
 def test_on_error_default_factory():
     v = SchemaValidator(
-        {'type': 'default', 'schema': {'type': 'int'}, 'default_factory': lambda: 17, 'on_error': 'default'}
+        core_schema.with_default_schema(schema=core_schema.int_schema(), default_factory=lambda: 17, on_error='default')
     )
     assert v.validate_python(42) == 42
     assert v.validate_python('42') == 42
@@ -280,7 +283,7 @@ def test_on_error_default_factory():
 
 
 def test_on_error_omit():
-    v = SchemaValidator({'type': 'default', 'schema': {'type': 'int'}, 'on_error': 'omit'})
+    v = SchemaValidator(core_schema.with_default_schema(schema=core_schema.int_schema(), on_error='omit'))
     assert v.validate_python(42) == 42
     with pytest.raises(SchemaError, match='Uncaught Omit error, please check your usage of `default` validators.'):
         v.validate_python('wrong')
@@ -288,12 +291,16 @@ def test_on_error_omit():
 
 def test_on_error_wrong():
     with pytest.raises(SchemaError, match="'on_error = default' requires a `default` or `default_factory`"):
-        SchemaValidator({'type': 'default', 'schema': {'type': 'int'}, 'on_error': 'default'})
+        SchemaValidator(core_schema.with_default_schema(schema=core_schema.int_schema(), on_error='default'))
 
 
 def test_build_default_and_default_factory():
     with pytest.raises(SchemaError, match="'default' and 'default_factory' cannot be used together"):
-        SchemaValidator({'type': 'default', 'schema': {'type': 'int'}, 'default_factory': lambda: 1, 'default': 2})
+        SchemaValidator(
+            schema=core_schema.with_default_schema(
+                schema=core_schema.int_schema(), default_factory=lambda: 1, default=2
+            )
+        )
 
 
 def test_model_class():
@@ -303,22 +310,19 @@ class MyModel:
         field_b: int
 
     v = SchemaValidator(
-        {
-            'type': 'model',
-            'cls': MyModel,
-            'schema': {
-                'type': 'default',
-                'schema': {
-                    'type': 'model-fields',
-                    'fields': {
-                        'field_a': {'type': 'model-field', 'schema': {'type': 'str'}},
-                        'field_b': {'type': 'model-field', 'schema': {'type': 'int'}},
-                    },
-                },
-                'default': ({'field_a': '[default-a]', 'field_b': '[default-b]'}, None, set()),
-                'on_error': 'default',
-            },
-        }
+        core_schema.model_schema(
+            cls=MyModel,
+            schema=core_schema.with_default_schema(
+                schema=core_schema.model_fields_schema(
+                    fields={
+                        'field_a': core_schema.model_field(schema=core_schema.str_schema()),
+                        'field_b': core_schema.model_field(schema=core_schema.int_schema()),
+                    }
+                ),
+                default=({'field_a': '[default-a]', 'field_b': '[default-b]'}, None, set()),
+                on_error='default',
+            ),
+        )
     )
     m = v.validate_python({'field_a': 'test', 'field_b': 12})
     assert isinstance(m, MyModel)
@@ -440,35 +444,27 @@ class Model:
         str_dict_with_default: dict[str, str] = stored_empty_dict
 
     v = SchemaValidator(
-        {
-            'type': 'model',
-            'cls': Model,
-            'schema': {
-                'type': 'model-fields',
-                'fields': {
-                    'int_list_with_default': {
-                        'type': 'model-field',
-                        'schema': {
-                            'type': 'default',
-                            'schema': {'type': 'list', 'items_schema': {'type': 'int'}},
-                            'default': stored_empty_list,
-                        },
-                    },
-                    'str_dict_with_default': {
-                        'type': 'model-field',
-                        'schema': {
-                            'type': 'default',
-                            'schema': {
-                                'type': 'dict',
-                                'keys_schema': {'type': 'str'},
-                                'values_schema': {'type': 'str'},
-                            },
-                            'default': stored_empty_dict,
-                        },
-                    },
-                },
-            },
-        }
+        core_schema.model_schema(
+            cls=Model,
+            schema=core_schema.model_fields_schema(
+                fields={
+                    'int_list_with_default': core_schema.model_field(
+                        schema=core_schema.with_default_schema(
+                            schema=core_schema.list_schema(items_schema=core_schema.int_schema()),
+                            default=stored_empty_list,
+                        )
+                    ),
+                    'str_dict_with_default': core_schema.model_field(
+                        schema=core_schema.with_default_schema(
+                            schema=core_schema.dict_schema(
+                                keys_schema=core_schema.str_schema(), values_schema=core_schema.str_schema()
+                            ),
+                            default=stored_empty_dict,
+                        )
+                    ),
+                }
+            ),
+        )
     )
 
     m1 = v.validate_python({})
@@ -504,7 +500,7 @@ def test_default_value() -> None:
 def test_default_value_validate_default() -> None:
     s = core_schema.with_default_schema(core_schema.list_schema(core_schema.int_schema()), default=['1', '2', '3'])
 
-    v = SchemaValidator(s, core_schema.CoreConfig(validate_default=True))
+    v = SchemaValidator(s, config=core_schema.CoreConfig(validate_default=True))
 
     r = v.get_default_value()
     assert r is not None
@@ -514,7 +510,7 @@ def test_default_value_validate_default() -> None:
 def test_default_value_validate_default_fail() -> None:
     s = core_schema.with_default_schema(core_schema.list_schema(core_schema.int_schema()), default=['a'])
 
-    v = SchemaValidator(s, core_schema.CoreConfig(validate_default=True))
+    v = SchemaValidator(s, config=core_schema.CoreConfig(validate_default=True))
 
     with pytest.raises(ValidationError) as exc_info:
         v.get_default_value()
@@ -531,7 +527,7 @@ def test_default_value_validate_default_fail() -> None:
 def test_default_value_validate_default_strict_pass() -> None:
     s = core_schema.with_default_schema(core_schema.list_schema(core_schema.int_schema()), default=[1, 2, 3])
 
-    v = SchemaValidator(s, core_schema.CoreConfig(validate_default=True))
+    v = SchemaValidator(s, config=core_schema.CoreConfig(validate_default=True))
 
     r = v.get_default_value(strict=True)
     assert r is not None
@@ -541,7 +537,7 @@ def test_default_value_validate_default_strict_pass() -> None:
 def test_default_value_validate_default_strict_fail() -> None:
     s = core_schema.with_default_schema(core_schema.list_schema(core_schema.int_schema()), default=['1'])
 
-    v = SchemaValidator(s, core_schema.CoreConfig(validate_default=True))
+    v = SchemaValidator(s, config=core_schema.CoreConfig(validate_default=True))
 
     with pytest.raises(ValidationError) as exc_info:
         v.get_default_value(strict=True)
@@ -553,7 +549,7 @@ def test_default_value_validate_default_strict_fail() -> None:
 @pytest.mark.parametrize('validate_default', [True, False])
 def test_no_default_value(validate_default: bool) -> None:
     s = core_schema.list_schema(core_schema.int_schema())
-    v = SchemaValidator(s, core_schema.CoreConfig(validate_default=validate_default))
+    v = SchemaValidator(s, config=core_schema.CoreConfig(validate_default=validate_default))
 
     assert v.get_default_value() is None
 
@@ -600,7 +596,11 @@ def f(v: Union[Some[Any], None]) -> str:
     res = f(SchemaValidator(core_schema.with_default_schema(core_schema.int_schema(), default=3)).get_default_value())
     assert res == 'case3: 3'
 
-    res = f(SchemaValidator(core_schema.with_default_schema(core_schema.int_schema(), default='4')).get_default_value())
+    res = f(
+        SchemaValidator(
+            schema=core_schema.with_default_schema(core_schema.int_schema(), default='4')
+        ).get_default_value()
+    )
     assert res == 'case4: str(4)'
 
     res = f(SchemaValidator(core_schema.int_schema()).get_default_value())

From 51bae7d864b6a9305d8eabbcef3fba585ca9a47a Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 12 Feb 2025 15:00:26 +0000
Subject: [PATCH 486/550] Bump url from 2.5.2 to 2.5.4 (#1585)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock                   | 48 +++---------------------------------
 Cargo.toml                   |  2 +-
 tests/validators/test_url.py | 12 ++++-----
 3 files changed, 11 insertions(+), 51 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index f1fe843da..42b1220ea 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -251,16 +251,6 @@ dependencies = [
  "syn",
 ]
 
-[[package]]
-name = "idna"
-version = "0.5.0"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "634d9b1461af396cad843f47fdba5597a4f9e6ddd4bfb6ff5d85028c25cb12f6"
-dependencies = [
- "unicode-bidi",
- "unicode-normalization",
-]
-
 [[package]]
 name = "idna"
 version = "1.0.3"
@@ -440,7 +430,7 @@ dependencies = [
  "base64",
  "enum_dispatch",
  "hex",
- "idna 1.0.3",
+ "idna",
  "jiter",
  "num-bigint",
  "pyo3",
@@ -714,42 +704,12 @@ dependencies = [
  "zerovec",
 ]
 
-[[package]]
-name = "tinyvec"
-version = "1.6.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c55115c6fbe2d2bef26eb09ad74bde02d8255476fc0c7b515ef09fbb35742d82"
-dependencies = [
- "tinyvec_macros",
-]
-
-[[package]]
-name = "tinyvec_macros"
-version = "0.1.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1f3ccbac311fea05f86f61904b462b55fb3df8837a366dfc601a0161d0532f20"
-
-[[package]]
-name = "unicode-bidi"
-version = "0.3.15"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "08f95100a766bf4f8f28f90d77e0a5461bbdb219042e7679bebe79004fed8d75"
-
 [[package]]
 name = "unicode-ident"
 version = "1.0.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
 
-[[package]]
-name = "unicode-normalization"
-version = "0.1.23"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a56d1686db2308d901306f92a263857ef59ea39678a5458e7cb17f01415101f5"
-dependencies = [
- "tinyvec",
-]
-
 [[package]]
 name = "unindent"
 version = "0.2.3"
@@ -758,12 +718,12 @@ checksum = "c7de7d73e1754487cb58364ee906a499937a0dfabd86bcb980fa99ec8c8fa2ce"
 
 [[package]]
 name = "url"
-version = "2.5.2"
+version = "2.5.4"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "22784dbdf76fdde8af1aeda5622b546b422b6fc585325248a2bf9f5e41e94d6c"
+checksum = "32f8b686cadd1473f4bd0117a5d28d36b1ade384ea9b5069a1c40aefed7fda60"
 dependencies = [
  "form_urlencoded",
- "idna 0.5.0",
+ "idna",
  "percent-encoding",
 ]
 
diff --git a/Cargo.toml b/Cargo.toml
index 3468fec06..6f8842bea 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -39,7 +39,7 @@ serde = { version = "1.0.217", features = ["derive"] }
 speedate = "0.15.0"
 smallvec = "1.13.2"
 ahash = "0.8.10"
-url = "2.5.0"
+url = "2.5.4"
 # idna is already required by url, added here to be explicit
 idna = "1.0.3"
 base64 = "0.22.1"
diff --git a/tests/validators/test_url.py b/tests/validators/test_url.py
index c2f3f2e14..13c01182a 100644
--- a/tests/validators/test_url.py
+++ b/tests/validators/test_url.py
@@ -125,9 +125,9 @@ def url_test_case_helper(
         ('http://1...1', Err('invalid IPv4 address')),
         ('https://[2001:0db8:85a3:0000:0000:8a2e:0370:7334[', Err('invalid IPv6 address')),
         ('https://[', Err('invalid IPv6 address')),
-        ('https://example com', Err('invalid domain character')),
-        ('http://exam%ple.com', Err('invalid domain character')),
-        ('http:// /', Err('invalid domain character')),
+        ('https://example com', Err('invalid international domain name')),
+        ('http://exam%ple.com', Err('invalid international domain name')),
+        ('http:// /', Err('invalid international domain name')),
         ('/more', Err('relative URL without a base')),
         ('http://example.com./foobar', {'str()': 'http://example.com./foobar'}),
         # works since we're in lax mode
@@ -172,7 +172,7 @@ def url_test_case_helper(
         ('https:more', {'str()': 'https://more/', 'host': 'more'}),
         ('file:///foobar', {'str()': 'file:///foobar', 'host': None, 'unicode_host()': None}),
         ('file:///:80', {'str()': 'file:///:80'}),
-        ('file://:80', Err('invalid domain character')),
+        ('file://:80', Err('invalid international domain name')),
         ('foobar://:80', Err('empty host')),
         # with bashslashes
         ('file:\\\\foobar\\more', {'str()': 'file://foobar/more', 'host': 'foobar', 'path': '/more'}),
@@ -383,7 +383,7 @@ def strict_url_validator_fixture():
         ('https:/more', Err('expected //', 'url_syntax_violation')),
         ('https:more', Err('expected //', 'url_syntax_violation')),
         ('file:///foobar', {'str()': 'file:///foobar', 'host': None, 'unicode_host()': None}),
-        ('file://:80', Err('invalid domain character', 'url_parsing')),
+        ('file://:80', Err('invalid international domain name', 'url_parsing')),
         ('file:/xx', Err('expected // after file:', 'url_syntax_violation')),
         ('foobar://:80', Err('empty host', 'url_parsing')),
         ('mongodb+srv://server.example.com/', 'mongodb+srv://server.example.com/'),
@@ -1046,7 +1046,7 @@ def test_zero_schemas():
         (
             'http://127.0.0.1%0d%0aConnection%3a%20keep-alive',
             # dict(scheme='http', host='127.0.0.1%0d%0aconnection%3a%20keep-alive'), CHANGED
-            Err('Input should be a valid URL, invalid domain character [type=url_parsing,'),
+            Err('Input should be a valid URL, invalid international domain name [type=url_parsing,'),
         ),
         # NodeJS unicode -> double dot
         ('http://google.com/\uff2e\uff2e/abc', dict(scheme='http', host='google.com', path='/%EF%BC%AE%EF%BC%AE/abc')),

From 0a467e9a641fcdfa4c3c92d17d8d7476d8d9dd8c Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Wed, 12 Feb 2025 21:25:12 +0100
Subject: [PATCH 487/550] Fix enum strict JSON validation when validators are
 present (#1632)

---
 src/validators/enum_.rs        |  4 ++--
 tests/validators/test_enums.py | 17 +++++++++++++++++
 2 files changed, 19 insertions(+), 2 deletions(-)

diff --git a/src/validators/enum_.rs b/src/validators/enum_.rs
index 03393829a..0e34cb182 100644
--- a/src/validators/enum_.rs
+++ b/src/validators/enum_.rs
@@ -8,7 +8,7 @@ use pyo3::types::{PyDict, PyFloat, PyInt, PyList, PyString, PyType};
 
 use crate::build_tools::{is_strict, py_schema_err};
 use crate::errors::{ErrorType, ValError, ValResult};
-use crate::input::Input;
+use crate::input::{Input, InputType};
 use crate::tools::{safe_repr, SchemaDict};
 
 use super::is_instance::class_repr;
@@ -107,7 +107,7 @@ impl<T: EnumValidateValue> Validator for EnumValidator<T> {
             return Ok(exact_py_input.clone().unbind());
         }
         let strict = state.strict_or(self.strict);
-        if strict && input.as_python().is_some() {
+        if strict && state.extra().input_type == InputType::Python {
             // TODO what about instances of subclasses?
             return Err(ValError::new(
                 ErrorType::IsInstanceOf {
diff --git a/tests/validators/test_enums.py b/tests/validators/test_enums.py
index 83e286417..1e932d7ce 100644
--- a/tests/validators/test_enums.py
+++ b/tests/validators/test_enums.py
@@ -487,3 +487,20 @@ def __new__(cls, species: str, sound: str):
     assert v.validate_python('meow') is Animal.CAT
     assert v.validate_python('dog') is Animal.DOG
     assert v.validate_python('woof') is Animal.DOG
+
+
+def test_strict_enum_wrap_json() -> None:
+    """https://github.com/pydantic/pydantic/issues/11070"""
+
+    class Animal(str, Enum):
+        CAT = 'cat'
+        DOG = 'dog'
+
+    schema = core_schema.no_info_wrap_validator_function(
+        lambda v, handler: handler(v),
+        core_schema.enum_schema(Animal, list(Animal.__members__.values()), sub_type='str', strict=True),
+    )
+    v = SchemaValidator(schema)
+
+    assert v.validate_python(Animal.CAT) == Animal.CAT
+    assert v.validate_json('"dog"') == Animal.DOG

From 7da479897b1a89bc3627ede6802b8c87db0ef722 Mon Sep 17 00:00:00 2001
From: Andrew Steinborn <andrew@steinborn.me>
Date: Thu, 13 Feb 2025 01:35:34 -0500
Subject: [PATCH 488/550] Add support for validating v7 UUIDs (#1634)

---
 python/pydantic_core/core_schema.py | 4 ++--
 src/validators/uuid.rs              | 2 ++
 tests/validators/test_uuid.py       | 4 ++++
 3 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index c477bae1d..c6faad921 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -1437,7 +1437,7 @@ def callable_schema(
 
 class UuidSchema(TypedDict, total=False):
     type: Required[Literal['uuid']]
-    version: Literal[1, 3, 4, 5]
+    version: Literal[1, 3, 4, 5, 7]
     strict: bool
     ref: str
     metadata: dict[str, Any]
@@ -1446,7 +1446,7 @@ class UuidSchema(TypedDict, total=False):
 
 def uuid_schema(
     *,
-    version: Literal[1, 3, 4, 5] | None = None,
+    version: Literal[1, 3, 4, 5, 7] | None = None,
     strict: bool | None = None,
     ref: str | None = None,
     metadata: dict[str, Any] | None = None,
diff --git a/src/validators/uuid.rs b/src/validators/uuid.rs
index cd7dc580a..093c4d113 100644
--- a/src/validators/uuid.rs
+++ b/src/validators/uuid.rs
@@ -42,6 +42,7 @@ enum Version {
     UUIDv3 = 3,
     UUIDv4 = 4,
     UUIDv5 = 5,
+    UUIDv7 = 7,
 }
 
 impl From<Version> for usize {
@@ -57,6 +58,7 @@ impl From<u8> for Version {
             3 => Version::UUIDv3,
             4 => Version::UUIDv4,
             5 => Version::UUIDv5,
+            7 => Version::UUIDv7,
             _ => unreachable!(),
         }
     }
diff --git a/tests/validators/test_uuid.py b/tests/validators/test_uuid.py
index 5448f25f4..c0ad68345 100644
--- a/tests/validators/test_uuid.py
+++ b/tests/validators/test_uuid.py
@@ -26,6 +26,7 @@ class MyStr(str): ...
         ('6ba7b810-9dad-11d1-80b4-00c04fd430c8', UUID('6ba7b810-9dad-11d1-80b4-00c04fd430c8')),
         ('886313e1-3b8a-5372-9b90-0c9aee199e5d', UUID('886313e1-3b8a-5372-9b90-0c9aee199e5d')),
         ('c0a8f9a8-aa5e-482b-a067-9cb3a51f5c11', UUID('c0a8f9a8-aa5e-482b-a067-9cb3a51f5c11')),
+        ('0194fdc2-5d6a-733c-97f9-2feeb9d2a609', UUID('0194fdc2-5d6a-733c-97f9-2feeb9d2a609')),
         ('00000000-8000-4000-8000-000000000000', UUID('00000000-8000-4000-8000-000000000000')),
         ('00000000-0000-4000-0000-000000000000', UUID('00000000-0000-4000-0000-000000000000')),
         (MyStr('00000000-0000-4000-0000-000000000000'), UUID('00000000-0000-4000-0000-000000000000')),
@@ -124,6 +125,7 @@ def test_uuid_strict(input_value, expected):
         (UUID('0e7ac198-9acd-4c0c-b4b4-761974bf71d7'), 4, UUID('0e7ac198-9acd-4c0c-b4b4-761974bf71d7')),
         ('0e7ac198-9acd-4c0c-b4b4-761974bf71d7', 4, UUID('0e7ac198-9acd-4c0c-b4b4-761974bf71d7')),
         (UUID('0e7ac198-9acd-4c0c-b4b4-761974bf71d7'), 4, UUID('0e7ac198-9acd-4c0c-b4b4-761974bf71d7')),
+        ('0194fdc2-5d6a-733c-97f9-2feeb9d2a609', 7, UUID('0194fdc2-5d6a-733c-97f9-2feeb9d2a609')),
         # Cases from pydantic#7355 and pydantic#7537
         # `UUID.version` makes sense for RFC 4122 UUIDs only. For non RFC 4122 UUIDs Python uses `UUID.version=None`
         ('00000000-8000-4000-8000-000000000000', 4, UUID('00000000-8000-4000-8000-000000000000')),
@@ -137,6 +139,8 @@ def test_uuid_strict(input_value, expected):
         (UUID('b34b6755-f49c-3bd2-6f06-131a708c2bf3'), None, UUID('b34b6755-f49c-3bd2-6f06-131a708c2bf3')),
         (UUID('b34b6755-f49c-3bd2-6f06-131a708c2bf3'), 4, Err('UUID version 4 expected')),
         # Invalid UUIDs
+        ('a6cc5730-2261-11ee-9c43-2eb5a363657c', 7, Err('UUID version 7 expected')),
+        (UUID('a6cc5730-2261-11ee-9c43-2eb5a363657c'), 7, Err('UUID version 7 expected')),
         ('a6cc5730-2261-11ee-9c43-2eb5a363657c', 5, Err('UUID version 5 expected')),
         (UUID('a6cc5730-2261-11ee-9c43-2eb5a363657c'), 5, Err('UUID version 5 expected')),
         ('04e4aeb3-8f20-30d0-8852-d295e1265eed', 4, Err('UUID version 4 expected')),

From 741961c05847d9e9ee517cd783e24c2b58e5596b Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Thu, 13 Feb 2025 09:40:14 +0000
Subject: [PATCH 489/550] refactor `LookupKey` logic to reduce redundancy
 (#1635)

---
 src/common/union.rs    |   2 +-
 src/errors/location.rs |  27 ---
 src/errors/mod.rs      |   2 +-
 src/lookup_key.rs      | 368 ++++++++++++++++++++++++-----------------
 4 files changed, 215 insertions(+), 184 deletions(-)

diff --git a/src/common/union.rs b/src/common/union.rs
index 5aeb4c926..b6bc4fc78 100644
--- a/src/common/union.rs
+++ b/src/common/union.rs
@@ -4,7 +4,7 @@ use pyo3::{PyTraverseError, PyVisit};
 use crate::lookup_key::LookupKey;
 use crate::py_gc::PyGcTraverse;
 
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub enum Discriminator {
     /// use `LookupKey` to find the tag, same as we do to find values in typed_dict aliases
     LookupKey(LookupKey),
diff --git a/src/errors/location.rs b/src/errors/location.rs
index 636ba6f1a..d020519e7 100644
--- a/src/errors/location.rs
+++ b/src/errors/location.rs
@@ -8,8 +8,6 @@ use pyo3::types::{PyList, PyTuple};
 use serde::ser::SerializeSeq;
 use serde::{Serialize, Serializer};
 
-use crate::lookup_key::{LookupPath, PathItem};
-
 /// Used to store individual items of the error location, e.g. a string for key/field names
 /// or a number for array indices.
 #[derive(Clone, Eq, PartialEq, IntoPyObjectRef)]
@@ -71,20 +69,6 @@ impl From<usize> for LocItem {
     }
 }
 
-/// eventually it might be good to combine PathItem and LocItem
-impl From<PathItem> for LocItem {
-    fn from(path_item: PathItem) -> Self {
-        match path_item {
-            PathItem::S(s, _) => s.into(),
-            PathItem::Pos(val) => val.into(),
-            PathItem::Neg(val) => {
-                let neg_value = -(val as i64);
-                neg_value.into()
-            }
-        }
-    }
-}
-
 impl Serialize for LocItem {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -137,17 +121,6 @@ impl<'py> IntoPyObject<'py> for &'_ Location {
     }
 }
 
-impl From<&LookupPath> for Location {
-    fn from(lookup_path: &LookupPath) -> Self {
-        let v = lookup_path
-            .iter()
-            .rev()
-            .map(|path_item| path_item.clone().into())
-            .collect();
-        Self::List(v)
-    }
-}
-
 impl fmt::Display for Location {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
diff --git a/src/errors/mod.rs b/src/errors/mod.rs
index c80f402bb..b8bb12ee1 100644
--- a/src/errors/mod.rs
+++ b/src/errors/mod.rs
@@ -7,7 +7,7 @@ mod validation_exception;
 mod value_exception;
 
 pub use self::line_error::{InputValue, ToErrorValue, ValError, ValLineError, ValResult};
-pub use self::location::LocItem;
+pub use self::location::{LocItem, Location};
 pub use self::types::{list_all_errors, ErrorType, ErrorTypeDefaults, Number};
 pub use self::validation_exception::{PyLineError, ValidationError};
 pub use self::value_exception::{PydanticCustomError, PydanticKnownError, PydanticOmit, PydanticUseDefault};
diff --git a/src/lookup_key.rs b/src/lookup_key.rs
index a89d46522..c83a00583 100644
--- a/src/lookup_key.rs
+++ b/src/lookup_key.rs
@@ -1,4 +1,4 @@
-use core::slice::Iter;
+use std::convert::Infallible;
 use std::fmt;
 
 use pyo3::exceptions::{PyAttributeError, PyTypeError};
@@ -9,29 +9,17 @@ use pyo3::IntoPyObjectExt;
 use jiter::{JsonObject, JsonValue};
 
 use crate::build_tools::py_schema_err;
-use crate::errors::{py_err_string, ErrorType, ToErrorValue, ValError, ValLineError, ValResult};
+use crate::errors::{py_err_string, ErrorType, LocItem, Location, ToErrorValue, ValError, ValLineError, ValResult};
 use crate::input::StringMapping;
 use crate::tools::{extract_i64, py_err};
 
 /// Used for getting items from python dicts, python objects, or JSON objects, in different ways
-#[derive(Debug, Clone)]
+#[derive(Debug)]
 pub(crate) enum LookupKey {
     /// simply look up a key in a dict, equivalent to `d.get(key)`
-    /// we save both the string and pystring to save creating the pystring for python
-    Simple {
-        key: String,
-        py_key: Py<PyString>,
-        path: LookupPath,
-    },
+    Simple(LookupPath),
     /// look up a key by either string, equivalent to `d.get(choice1, d.get(choice2))`
-    Choice {
-        key1: String,
-        py_key1: Py<PyString>,
-        path1: LookupPath,
-        key2: String,
-        py_key2: Py<PyString>,
-        path2: LookupPath,
-    },
+    Choice { path1: LookupPath, path2: LookupPath },
     /// look up keys by one or more "paths" a path might be `['foo', 'bar']` to get `d.?foo.?bar`
     /// ints are also supported to index arrays/lists/tuples and dicts with int keys
     /// we reuse Location as the enum is the same, and the meaning is the same
@@ -41,8 +29,13 @@ pub(crate) enum LookupKey {
 impl fmt::Display for LookupKey {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Self::Simple { key, .. } => write!(f, "'{key}'"),
-            Self::Choice { key1, key2, .. } => write!(f, "'{key1}' | '{key2}'"),
+            Self::Simple(path) => write!(f, "'{key}'", key = path.first_key()),
+            Self::Choice { path1, path2 } => write!(
+                f,
+                "'{key1}' | '{key2}'",
+                key1 = path1.first_key(),
+                key2 = path2.first_key()
+            ),
             Self::PathChoices(paths) => write!(
                 f,
                 "{}",
@@ -59,14 +52,10 @@ impl LookupKey {
             let path1 = LookupPath::from_str(py, &alias, Some(alias_py.clone()));
             match alt_alias {
                 Some(alt_alias) => Ok(Self::Choice {
-                    key1: alias.to_string(),
-                    py_key1: alias_py.clone().into(),
                     path1,
-                    key2: alt_alias.to_string(),
-                    py_key2: PyString::new(py, alt_alias).into(),
                     path2: LookupPath::from_str(py, alt_alias, None),
                 }),
-                None => Ok(Self::simple(py, &alias, Some(alias_py.clone()))),
+                None => Ok(Self::Simple(path1)),
             }
         } else {
             let list = value.downcast::<PyList>()?;
@@ -95,15 +84,7 @@ impl LookupKey {
     }
 
     fn simple(py: Python, key: &str, opt_py_key: Option<Bound<'_, PyString>>) -> Self {
-        let py_key = match &opt_py_key {
-            Some(py_key) => py_key.clone(),
-            None => PyString::new(py, key),
-        };
-        Self::Simple {
-            key: key.to_string(),
-            py_key: py_key.into(),
-            path: LookupPath::from_str(py, key, opt_py_key),
-        }
+        Self::Simple(LookupPath::from_str(py, key, opt_py_key))
     }
 
     pub fn py_get_dict_item<'py, 's>(
@@ -111,28 +92,34 @@ impl LookupKey {
         dict: &Bound<'py, PyDict>,
     ) -> ValResult<Option<(&'s LookupPath, Bound<'py, PyAny>)>> {
         match self {
-            Self::Simple { py_key, path, .. } => match dict.get_item(py_key)? {
-                Some(value) => Ok(Some((path, value))),
+            Self::Simple(path) => match dict.get_item(&path.first_item.py_key)? {
+                Some(value) => {
+                    debug_assert!(path.rest.is_empty());
+                    Ok(Some((path, value)))
+                }
                 None => Ok(None),
             },
-            Self::Choice {
-                py_key1,
-                path1,
-                py_key2,
-                path2,
-                ..
-            } => match dict.get_item(py_key1)? {
-                Some(value) => Ok(Some((path1, value))),
-                None => match dict.get_item(py_key2)? {
-                    Some(value) => Ok(Some((path2, value))),
+            Self::Choice { path1, path2, .. } => match dict.get_item(&path1.first_item.py_key)? {
+                Some(value) => {
+                    debug_assert!(path1.rest.is_empty());
+                    Ok(Some((path1, value)))
+                }
+                None => match dict.get_item(&path2.first_item.py_key)? {
+                    Some(value) => {
+                        debug_assert!(path2.rest.is_empty());
+                        Ok(Some((path2, value)))
+                    }
                     None => Ok(None),
                 },
             },
             Self::PathChoices(path_choices) => {
                 for path in path_choices {
-                    // iterate over the path and plug each value into the py_any from the last step, starting with dict
+                    let Some(first_value) = dict.get_item(&path.first_item.py_key)? else {
+                        continue;
+                    };
+                    // iterate over the path and plug each value into the py_any from the last step,
                     // this could just be a loop but should be somewhat faster with a functional design
-                    if let Some(v) = path.iter().try_fold((**dict).clone(), |d, loc| loc.py_get_item(&d)) {
+                    if let Some(v) = path.rest.iter().try_fold(first_value, |d, loc| loc.py_get_item(&d)) {
                         // Successfully found an item, return it
                         return Ok(Some((path, v)));
                     }
@@ -160,28 +147,34 @@ impl LookupKey {
         dict: &Bound<'py, PyMapping>,
     ) -> ValResult<Option<(&'s LookupPath, Bound<'py, PyAny>)>> {
         match self {
-            Self::Simple { py_key, path, .. } => match dict.get_item(py_key) {
-                Ok(value) => Ok(Some((path, value))),
+            Self::Simple(path) => match dict.get_item(&path.first_item.py_key) {
+                Ok(value) => {
+                    debug_assert!(path.rest.is_empty());
+                    Ok(Some((path, value)))
+                }
                 _ => Ok(None),
             },
-            Self::Choice {
-                py_key1,
-                path1,
-                py_key2,
-                path2,
-                ..
-            } => match dict.get_item(py_key1) {
-                Ok(value) => Ok(Some((path1, value))),
-                _ => match dict.get_item(py_key2) {
-                    Ok(value) => Ok(Some((path2, value))),
+            Self::Choice { path1, path2, .. } => match dict.get_item(&path1.first_item.py_key) {
+                Ok(value) => {
+                    debug_assert!(path1.rest.is_empty());
+                    Ok(Some((path1, value)))
+                }
+                _ => match dict.get_item(&path2.first_item.py_key) {
+                    Ok(value) => {
+                        debug_assert!(path2.rest.is_empty());
+                        Ok(Some((path2, value)))
+                    }
                     _ => Ok(None),
                 },
             },
             Self::PathChoices(path_choices) => {
                 for path in path_choices {
-                    // iterate over the path and plug each value into the py_any from the last step, starting with dict
+                    let Some(first_value) = dict.get_item(&path.first_item.py_key).ok() else {
+                        continue;
+                    };
+                    // iterate over the path and plug each value into the py_any from the last step,
                     // this could just be a loop but should be somewhat faster with a functional design
-                    if let Some(v) = path.iter().try_fold((**dict).clone(), |d, loc| loc.py_get_item(&d)) {
+                    if let Some(v) = path.rest.iter().try_fold(first_value, |d, loc| loc.py_get_item(&d)) {
                         // Successfully found an item, return it
                         return Ok(Some((path, v)));
                     }
@@ -197,20 +190,23 @@ impl LookupKey {
         obj: &Bound<'py, PyAny>,
     ) -> PyResult<Option<(&'s LookupPath, Bound<'py, PyAny>)>> {
         match self {
-            Self::Simple { py_key, path, .. } => match py_get_attrs(obj, py_key)? {
-                Some(value) => Ok(Some((path, value))),
+            Self::Simple(path) => match py_get_attrs(obj, &path.first_item.py_key)? {
+                Some(value) => {
+                    debug_assert!(path.rest.is_empty());
+                    Ok(Some((path, value)))
+                }
                 None => Ok(None),
             },
-            Self::Choice {
-                py_key1,
-                path1,
-                py_key2,
-                path2,
-                ..
-            } => match py_get_attrs(obj, py_key1)? {
-                Some(value) => Ok(Some((path1, value))),
-                None => match py_get_attrs(obj, py_key2)? {
-                    Some(value) => Ok(Some((path2, value))),
+            Self::Choice { path1, path2, .. } => match py_get_attrs(obj, &path1.first_item.py_key)? {
+                Some(value) => {
+                    debug_assert!(path1.rest.is_empty());
+                    Ok(Some((path1, value)))
+                }
+                None => match py_get_attrs(obj, &path2.first_item.py_key)? {
+                    Some(value) => {
+                        debug_assert!(path2.rest.is_empty());
+                        Ok(Some((path2, value)))
+                    }
                     None => Ok(None),
                 },
             },
@@ -218,8 +214,10 @@ impl LookupKey {
                 'outer: for path in path_choices {
                     // similar to above, but using `py_get_attrs`, we can't use try_fold because of the extra Err
                     // so we have to loop manually
-                    let mut v = obj.clone();
-                    for loc in path.iter() {
+                    let Some(mut v) = path.first_item.py_get_attrs(obj)? else {
+                        continue;
+                    };
+                    for loc in &path.rest {
                         v = match loc.py_get_attrs(&v) {
                             Ok(Some(v)) => v,
                             Ok(None) => {
@@ -265,34 +263,37 @@ impl LookupKey {
         dict: &'a JsonObject<'data>,
     ) -> ValResult<Option<(&'s LookupPath, &'a JsonValue<'data>)>> {
         match self {
-            Self::Simple { key, path, .. } => match dict.get(key.as_str()) {
-                Some(value) => Ok(Some((path, value))),
+            Self::Simple(path) => match dict.get(path.first_key()) {
+                Some(value) => {
+                    debug_assert!(path.rest.is_empty());
+                    Ok(Some((path, value)))
+                }
                 None => Ok(None),
             },
-            Self::Choice {
-                key1,
-                path1,
-                key2,
-                path2,
-                ..
-            } => match dict.get(key1.as_str()) {
-                Some(value) => Ok(Some((path1, value))),
-                None => match dict.get(key2.as_str()) {
-                    Some(value) => Ok(Some((path2, value))),
+            Self::Choice { path1, path2 } => match dict.get(path1.first_key()) {
+                Some(value) => {
+                    debug_assert!(path1.rest.is_empty());
+                    Ok(Some((path1, value)))
+                }
+                None => match dict.get(path2.first_key()) {
+                    Some(value) => {
+                        debug_assert!(path2.rest.is_empty());
+                        Ok(Some((path2, value)))
+                    }
                     None => Ok(None),
                 },
             },
             Self::PathChoices(path_choices) => {
                 for path in path_choices {
-                    let mut path_iter = path.iter();
-
                     // first step is different from the rest as we already know dict is JsonObject
                     // because of above checks, we know that path should have at least one element, hence unwrap
-                    let v: &JsonValue = match path_iter.next().unwrap().json_obj_get(dict) {
+                    let v: &JsonValue = match dict.get(path.first_item.key.as_str()) {
                         Some(v) => v,
                         None => continue,
                     };
 
+                    let mut path_iter = path.rest.iter();
+
                     // similar to above
                     // iterate over the path and plug each value into the JsonValue from the last step, starting with v
                     // from the first step, this could just be a loop but should be somewhat faster with a functional design
@@ -316,27 +317,37 @@ impl LookupKey {
     ) -> ValLineError {
         if loc_by_alias {
             let lookup_path = match self {
-                Self::Simple { path, .. } => path,
+                Self::Simple(path, ..) => path,
                 Self::Choice { path1, .. } => path1,
                 Self::PathChoices(paths) => paths.first().unwrap(),
             };
-            ValLineError::new_with_full_loc(error_type, input, lookup_path.into())
+
+            let mut location = Vec::with_capacity(1 + lookup_path.rest.len());
+            for item in lookup_path.rest.iter().rev() {
+                location.push(item.to_loc_item());
+            }
+            location.push(LocItem::from(&lookup_path.first_item.key));
+
+            ValLineError::new_with_full_loc(error_type, input, Location::List(location))
         } else {
             ValLineError::new_with_loc(error_type, input, field_name.to_string())
         }
     }
 }
 
-#[derive(Debug, Clone)]
-pub(crate) struct LookupPath(Vec<PathItem>);
+#[derive(Debug)]
+pub(crate) struct LookupPath {
+    /// All paths must start with a string key
+    first_item: PathItemString,
+    /// Most paths will have no extra items, though some do so we encode this here
+    rest: Vec<PathItem>,
+}
 
 impl fmt::Display for LookupPath {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        for (i, item) in self.0.iter().enumerate() {
-            if i != 0 {
-                write!(f, ".")?;
-            }
-            write!(f, "{item}")?;
+        write!(f, "{first_key}", first_key = &self.first_item)?;
+        for item in &self.rest {
+            write!(f, ".{item}")?;
         }
         Ok(())
     }
@@ -348,66 +359,87 @@ impl LookupPath {
             Some(py_key) => py_key,
             None => PyString::new(py, key),
         };
-        Self(vec![PathItem::S(key.to_string(), py_key.into())])
+        Self {
+            first_item: PathItemString {
+                key: key.to_string(),
+                py_key: py_key.clone().unbind(),
+            },
+            rest: Vec::new(),
+        }
     }
 
     fn from_list(obj: &Bound<'_, PyAny>) -> PyResult<LookupPath> {
-        let v = obj
-            .downcast::<PyList>()?
-            .iter()
-            .enumerate()
-            .map(|(index, obj)| PathItem::from_py(index, &obj))
-            .collect::<PyResult<Vec<PathItem>>>()?;
-
-        if v.is_empty() {
-            py_schema_err!("Each alias path should have at least one element")
-        } else {
-            Ok(Self(v))
-        }
+        let mut iter = obj.downcast::<PyList>()?.iter();
+
+        let Some(first_item) = iter.next() else {
+            return py_schema_err!("Each alias path should have at least one element");
+        };
+
+        let Ok(first_item_py_str) = first_item.downcast_into::<PyString>() else {
+            return py_err!(PyTypeError; "The first item in an alias path should be a string");
+        };
+
+        let first_item = PathItemString {
+            key: first_item_py_str.to_str()?.to_owned(),
+            py_key: first_item_py_str.clone().unbind(),
+        };
+
+        let rest = iter.map(PathItem::from_py).collect::<PyResult<_>>()?;
+
+        Ok(Self { first_item, rest })
     }
 
     pub fn apply_error_loc(&self, mut line_error: ValLineError, loc_by_alias: bool, field_name: &str) -> ValLineError {
         if loc_by_alias {
-            for path_item in self.iter().rev() {
-                line_error = line_error.with_outer_location(path_item.clone());
+            for path_item in self.rest.iter().rev() {
+                line_error = line_error.with_outer_location(path_item.to_loc_item());
             }
+            line_error = line_error.with_outer_location(&self.first_item.key);
             line_error
         } else {
             line_error.with_outer_location(field_name)
         }
     }
 
-    pub fn iter(&self) -> Iter<PathItem> {
-        self.0.iter()
-    }
-
     /// get the `str` from the first item in the path, note paths always have length > 0, and the first item
     /// is always a string
     pub fn first_key(&self) -> &str {
-        self.0.first().unwrap().get_key()
+        &self.first_item.key
     }
 }
 
 #[derive(Debug, Clone)]
 pub(crate) enum PathItem {
-    /// string type key, used to get or identify items from a dict or anything that implements `__getitem__`
-    /// as above we store both the string and pystring to save creating the pystring for python
-    S(String, Py<PyString>),
+    S(PathItemString),
     /// integer key, used to get items from a list, tuple OR a dict with int keys `dict[int, ...]` (python only)
     Pos(usize),
     Neg(usize),
 }
 
+/// string type key, used to get or identify items from a dict or anything that implements `__getitem__`
+/// we store both the string and pystring to save creating the pystring for python
+#[derive(Debug, Clone)]
+pub(crate) struct PathItemString {
+    key: String,
+    py_key: Py<PyString>,
+}
+
 impl fmt::Display for PathItem {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match self {
-            Self::S(key, _) => write!(f, "'{key}'"),
+            Self::S(key) => key.fmt(f),
             Self::Pos(key) => write!(f, "{key}"),
             Self::Neg(key) => write!(f, "-{key}"),
         }
     }
 }
 
+impl fmt::Display for PathItemString {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "'{key}'", key = &self.key)
+    }
+}
+
 impl<'py> IntoPyObject<'py> for &'_ PathItem {
     type Target = PyAny;
     type Output = Bound<'py, PyAny>;
@@ -415,7 +447,7 @@ impl<'py> IntoPyObject<'py> for &'_ PathItem {
 
     fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
         match self {
-            PathItem::S(_, val) => Ok(val.bind(py).clone().into_any()),
+            PathItem::S(path_item_string) => path_item_string.into_bound_py_any(py),
             PathItem::Pos(val) => val.into_bound_py_any(py),
             PathItem::Neg(val) => {
                 let neg_value = -(*val as i64);
@@ -425,23 +457,33 @@ impl<'py> IntoPyObject<'py> for &'_ PathItem {
     }
 }
 
+impl<'a, 'py> IntoPyObject<'py> for &'a PathItemString {
+    type Target = PyString;
+    type Output = Borrowed<'a, 'py, PyString>;
+    type Error = Infallible;
+
+    fn into_pyobject(self, py: Python<'py>) -> Result<Self::Output, Self::Error> {
+        Ok(self.py_key.bind_borrowed(py))
+    }
+}
+
 impl PathItem {
-    pub fn from_py(index: usize, obj: &Bound<'_, PyAny>) -> PyResult<Self> {
-        if let Ok(py_str_key) = obj.downcast::<PyString>() {
-            let str_key = py_str_key.to_str()?.to_string();
-            Ok(Self::S(str_key, py_str_key.clone().into()))
-        } else if let Ok(usize_key) = obj.extract::<usize>() {
-            if index == 0 {
-                py_err!(PyTypeError; "The first item in an alias path should be a string")
-            } else {
-                Ok(Self::Pos(usize_key))
-            }
-        } else if let Some(int_key) = extract_i64(obj) {
-            if index == 0 {
-                py_err!(PyTypeError; "The first item in an alias path should be a string")
-            } else {
-                Ok(Self::Neg(int_key.unsigned_abs() as usize))
+    pub fn from_py(obj: Bound<'_, PyAny>) -> PyResult<Self> {
+        let obj = match obj.downcast_into::<PyString>() {
+            Ok(py_str_key) => {
+                let str_key = py_str_key.to_str()?.to_string();
+                return Ok(Self::S(PathItemString {
+                    key: str_key,
+                    py_key: py_str_key.unbind(),
+                }));
             }
+            Err(e) => e.into_inner(),
+        };
+
+        if let Ok(usize_key) = obj.extract::<usize>() {
+            Ok(Self::Pos(usize_key))
+        } else if let Some(int_key) = extract_i64(&obj) {
+            Ok(Self::Neg(int_key.unsigned_abs() as usize))
         } else {
             py_err!(PyTypeError; "Item in an alias path should be a string or int")
         }
@@ -457,23 +499,9 @@ impl PathItem {
         }
     }
 
-    pub fn get_key(&self) -> &str {
-        match self {
-            Self::S(key, _) => key.as_str(),
-            _ => unreachable!(),
-        }
-    }
-
     pub fn py_get_attrs<'py>(&self, obj: &Bound<'py, PyAny>) -> PyResult<Option<Bound<'py, PyAny>>> {
         match self {
-            Self::S(_, py_key) => {
-                // if obj is a dict, we want to use get_item, not getattr
-                if obj.downcast::<PyDict>().is_ok() {
-                    Ok(self.py_get_item(obj))
-                } else {
-                    py_get_attrs(obj, py_key)
-                }
-            }
+            Self::S(path_item_string) => path_item_string.py_get_attrs(obj),
             // int, we fall back to py_get_item - e.g. we want to use get_item for a list, tuple, dict, etc.
             _ => Ok(self.py_get_item(obj)),
         }
@@ -499,10 +527,40 @@ impl PathItem {
 
     pub fn json_obj_get<'a, 'data>(&self, json_obj: &'a JsonObject<'data>) -> Option<&'a JsonValue<'data>> {
         match self {
-            Self::S(key, _) => json_obj.get(key.as_str()),
+            Self::S(PathItemString { key, .. }) => json_obj.get(key.as_str()),
             _ => None,
         }
     }
+
+    fn to_loc_item(&self) -> LocItem {
+        match self {
+            Self::S(PathItemString { key, .. }) => LocItem::from(key),
+            Self::Pos(index) => LocItem::from(*index),
+            Self::Neg(index) => LocItem::from(-(*index as i64)),
+        }
+    }
+}
+
+impl PathItemString {
+    fn py_get_attrs<'py>(&self, obj: &Bound<'py, PyAny>) -> PyResult<Option<Bound<'py, PyAny>>> {
+        // if obj is a dict, we want to use get_item, not getattr
+        if obj.downcast::<PyDict>().is_ok() {
+            Ok(py_get_item(obj, self))
+        } else {
+            py_get_attrs(obj, &self.py_key)
+        }
+    }
+}
+
+/// wrapper around `getitem` that excludes string indexing `None` for strings
+fn py_get_item<'py>(py_any: &Bound<'py, PyAny>, index: impl IntoPyObject<'py>) -> Option<Bound<'py, PyAny>> {
+    // we definitely don't want to index strings, so explicitly omit this case
+    if py_any.is_instance_of::<PyString>() {
+        None
+    } else {
+        // otherwise, blindly try getitem on v since no better logic is realistic
+        py_any.get_item(index).ok()
+    }
 }
 
 /// wrapper around `getattr` that returns `Ok(None)` for attribute errors, but returns other errors

From a0e60bd001bac58f38e3e30503d757392fef9329 Mon Sep 17 00:00:00 2001
From: Andrew Steinborn <git@steinborn.me>
Date: Mon, 17 Feb 2025 05:23:57 -0500
Subject: [PATCH 490/550] Add support for UUIDv6 and UUIDv8 validation (#1636)

---
 python/pydantic_core/core_schema.py |  2 +-
 src/validators/uuid.rs              |  8 ++++++--
 tests/validators/test_uuid.py       | 11 +++++++++++
 3 files changed, 18 insertions(+), 3 deletions(-)

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index c6faad921..e999bdcfc 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -1446,7 +1446,7 @@ class UuidSchema(TypedDict, total=False):
 
 def uuid_schema(
     *,
-    version: Literal[1, 3, 4, 5, 7] | None = None,
+    version: Literal[1, 3, 4, 5, 6, 7, 8] | None = None,
     strict: bool | None = None,
     ref: str | None = None,
     metadata: dict[str, Any] | None = None,
diff --git a/src/validators/uuid.rs b/src/validators/uuid.rs
index 093c4d113..995f2d183 100644
--- a/src/validators/uuid.rs
+++ b/src/validators/uuid.rs
@@ -42,7 +42,9 @@ enum Version {
     UUIDv3 = 3,
     UUIDv4 = 4,
     UUIDv5 = 5,
+    UUIDv6 = 6,
     UUIDv7 = 7,
+    UUIDv8 = 8,
 }
 
 impl From<Version> for usize {
@@ -58,7 +60,9 @@ impl From<u8> for Version {
             3 => Version::UUIDv3,
             4 => Version::UUIDv4,
             5 => Version::UUIDv5,
+            6 => Version::UUIDv6,
             7 => Version::UUIDv7,
+            8 => Version::UUIDv8,
             _ => unreachable!(),
         }
     }
@@ -136,8 +140,8 @@ impl Validator for UuidValidator {
             }
             let uuid = self.get_uuid(input)?;
             // This block checks if the UUID version matches the expected version and
-            // if the UUID variant conforms to RFC 4122. When dealing with Python inputs,
-            // UUIDs must adhere to RFC 4122 standards.
+            // if the UUID variant conforms to RFC 9562 (superseding RFC 4122).
+            // When dealing with Python inputs, UUIDs must adhere to RFC 9562 standards.
             if let Some(expected_version) = self.version {
                 if uuid.get_version_num() != expected_version || uuid.get_variant() != Variant::RFC4122 {
                     return Err(ValError::new(
diff --git a/tests/validators/test_uuid.py b/tests/validators/test_uuid.py
index c0ad68345..4269868bc 100644
--- a/tests/validators/test_uuid.py
+++ b/tests/validators/test_uuid.py
@@ -26,7 +26,9 @@ class MyStr(str): ...
         ('6ba7b810-9dad-11d1-80b4-00c04fd430c8', UUID('6ba7b810-9dad-11d1-80b4-00c04fd430c8')),
         ('886313e1-3b8a-5372-9b90-0c9aee199e5d', UUID('886313e1-3b8a-5372-9b90-0c9aee199e5d')),
         ('c0a8f9a8-aa5e-482b-a067-9cb3a51f5c11', UUID('c0a8f9a8-aa5e-482b-a067-9cb3a51f5c11')),
+        ('1efea93d-7bb8-6ea0-afdc-e76cbc0c8e05', UUID('1efea93d-7bb8-6ea0-afdc-e76cbc0c8e05')),
         ('0194fdc2-5d6a-733c-97f9-2feeb9d2a609', UUID('0194fdc2-5d6a-733c-97f9-2feeb9d2a609')),
+        ('c0a8f9a8-aa5e-882b-a067-9cb3a51f5c11', UUID('c0a8f9a8-aa5e-882b-a067-9cb3a51f5c11')),
         ('00000000-8000-4000-8000-000000000000', UUID('00000000-8000-4000-8000-000000000000')),
         ('00000000-0000-4000-0000-000000000000', UUID('00000000-0000-4000-0000-000000000000')),
         (MyStr('00000000-0000-4000-0000-000000000000'), UUID('00000000-0000-4000-0000-000000000000')),
@@ -126,6 +128,11 @@ def test_uuid_strict(input_value, expected):
         ('0e7ac198-9acd-4c0c-b4b4-761974bf71d7', 4, UUID('0e7ac198-9acd-4c0c-b4b4-761974bf71d7')),
         (UUID('0e7ac198-9acd-4c0c-b4b4-761974bf71d7'), 4, UUID('0e7ac198-9acd-4c0c-b4b4-761974bf71d7')),
         ('0194fdc2-5d6a-733c-97f9-2feeb9d2a609', 7, UUID('0194fdc2-5d6a-733c-97f9-2feeb9d2a609')),
+        (UUID('0194fdc2-5d6a-733c-97f9-2feeb9d2a609'), 7, UUID('0194fdc2-5d6a-733c-97f9-2feeb9d2a609')),
+        ('1efea93d-7bb8-6ea0-afdc-e76cbc0c8e05', 6, UUID('1efea93d-7bb8-6ea0-afdc-e76cbc0c8e05')),
+        (UUID('1efea93d-7bb8-6ea0-afdc-e76cbc0c8e05'), 6, UUID('1efea93d-7bb8-6ea0-afdc-e76cbc0c8e05')),
+        ('c0a8f9a8-aa5e-882b-a067-9cb3a51f5c11', 8, UUID('c0a8f9a8-aa5e-882b-a067-9cb3a51f5c11')),
+        (UUID('c0a8f9a8-aa5e-882b-a067-9cb3a51f5c11'), 8, UUID('c0a8f9a8-aa5e-882b-a067-9cb3a51f5c11')),
         # Cases from pydantic#7355 and pydantic#7537
         # `UUID.version` makes sense for RFC 4122 UUIDs only. For non RFC 4122 UUIDs Python uses `UUID.version=None`
         ('00000000-8000-4000-8000-000000000000', 4, UUID('00000000-8000-4000-8000-000000000000')),
@@ -139,6 +146,10 @@ def test_uuid_strict(input_value, expected):
         (UUID('b34b6755-f49c-3bd2-6f06-131a708c2bf3'), None, UUID('b34b6755-f49c-3bd2-6f06-131a708c2bf3')),
         (UUID('b34b6755-f49c-3bd2-6f06-131a708c2bf3'), 4, Err('UUID version 4 expected')),
         # Invalid UUIDs
+        ('1efea93d-7bb8-6ea0-afdc-e76cbc0c8e05', 8, Err('UUID version 8 expected')),
+        (UUID('1efea93d-7bb8-6ea0-afdc-e76cbc0c8e05'), 8, Err('UUID version 8 expected')),
+        ('c0a8f9a8-aa5e-882b-a067-9cb3a51f5c11', 6, Err('UUID version 6 expected')),
+        (UUID('c0a8f9a8-aa5e-882b-a067-9cb3a51f5c11'), 6, Err('UUID version 6 expected')),
         ('a6cc5730-2261-11ee-9c43-2eb5a363657c', 7, Err('UUID version 7 expected')),
         (UUID('a6cc5730-2261-11ee-9c43-2eb5a363657c'), 7, Err('UUID version 7 expected')),
         ('a6cc5730-2261-11ee-9c43-2eb5a363657c', 5, Err('UUID version 5 expected')),

From 68b678de298a0086f59e611e66b56164196cc52d Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Mon, 24 Feb 2025 15:13:48 +0000
Subject: [PATCH 491/550] pin nightly for wasm build (#1644)

---
 .github/workflows/ci.yml | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 74200993d..a134ff801 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -315,10 +315,12 @@ jobs:
       - uses: actions/checkout@v4
 
       - name: install rust nightly
-        uses: dtolnay/rust-toolchain@nightly
+        uses: dtolnay/rust-toolchain@master
         with:
           components: rust-src
           targets: wasm32-unknown-emscripten
+          # might be able to unpin when pydodide uses emscripten 4, see below
+          toolchain: nightly-2025-02-17
 
       - name: cache rust
         uses: Swatinem/rust-cache@v2

From 248bd8b816bae9b03b4169be0878a24e9b6910ba Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Mon, 24 Feb 2025 16:52:57 +0100
Subject: [PATCH 492/550] Remove unneeded `Option` map in
 `PyMultiHostUrl.build` (#1643)

---
 src/url.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/url.rs b/src/url.rs
index 816227bd4..692ac80c2 100644
--- a/src/url.rs
+++ b/src/url.rs
@@ -400,7 +400,7 @@ impl PyMultiHostUrl {
                     username: username.map(Into::into),
                     password: password.map(Into::into),
                     host: host.map(Into::into),
-                    port: port.map(Into::into),
+                    port,
                 };
                 format!("{scheme}://{url_host}")
             } else {

From 6a31b3b70b4477ade32171eb2dd9e3e0865ba9a2 Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Mon, 24 Feb 2025 17:21:33 +0100
Subject: [PATCH 493/550] Add API documentation for `ErrorDetails.url` (#1642)

---
 python/pydantic_core/__init__.py | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/python/pydantic_core/__init__.py b/python/pydantic_core/__init__.py
index 791de9d92..2de8b301d 100644
--- a/python/pydantic_core/__init__.py
+++ b/python/pydantic_core/__init__.py
@@ -89,6 +89,11 @@ class ErrorDetails(_TypedDict):
     Values which are required to render the error message, and could hence be useful in rendering custom error messages.
     Also useful for passing custom error data forward.
     """
+    url: _NotRequired[str]
+    """
+    The documentation URL giving information about the error. No URL is available if
+    a [`PydanticCustomError`][pydantic_core.PydanticCustomError] is used.
+    """
 
 
 class InitErrorDetails(_TypedDict):

From bd0bde24f171a01ff80cc8a26b070ddbcf20d850 Mon Sep 17 00:00:00 2001
From: sobolevn <mail@sobolevn.me>
Date: Tue, 25 Feb 2025 15:17:45 +0300
Subject: [PATCH 494/550] Fix typo in `InitErrorDetails.type` documentation
 (#1645)

---
 python/pydantic_core/__init__.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/python/pydantic_core/__init__.py b/python/pydantic_core/__init__.py
index 2de8b301d..98b64b86e 100644
--- a/python/pydantic_core/__init__.py
+++ b/python/pydantic_core/__init__.py
@@ -98,7 +98,7 @@ class ErrorDetails(_TypedDict):
 
 class InitErrorDetails(_TypedDict):
     type: str | PydanticCustomError
-    """The type of error that occurred, this should a "slug" identifier that changes rarely or never."""
+    """The type of error that occurred, this should be a "slug" identifier that changes rarely or never."""
     loc: _NotRequired[tuple[int | str, ...]]
     """Tuple of strings and ints identifying where in the schema the error occurred."""
     input: _Any

From 21eef8db71f30937de89367d0a596928b0e0ee0b Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Tue, 25 Feb 2025 13:37:11 +0000
Subject: [PATCH 495/550] bump to PyO3 0.23.5, support PyPy 3.11 (#1646)

---
 .github/workflows/ci.yml |  8 ++++----
 Cargo.lock               | 20 ++++++++++----------
 Cargo.toml               |  6 +++---
 src/argument_markers.rs  |  7 +------
 4 files changed, 18 insertions(+), 23 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index a134ff801..72cf0ac9a 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -422,7 +422,7 @@ jobs:
           - os: linux
             manylinux: auto
             target: x86_64
-            interpreter: pypy3.9 pypy3.10
+            interpreter: pypy3.9 pypy3.10 pypy3.11
 
           # musllinux
           - os: linux
@@ -442,7 +442,7 @@ jobs:
             target: x86_64
           - os: macos
             target: aarch64
-            interpreter: 3.9 pypy3.9 pypy3.10
+            interpreter: 3.9 pypy3.9 pypy3.10 pypy3.11
 
           # windows;
           # x86_64 pypy builds are not PGO optimized
@@ -450,7 +450,7 @@ jobs:
           # aarch64 only 3.11 and up, also not PGO optimized
           - os: windows
             target: x86_64
-            interpreter: pypy3.9 pypy3.10
+            interpreter: pypy3.9 pypy3.10 pypy3.11
           - os: windows
             target: i686
             python-architecture: x86
@@ -484,7 +484,7 @@ jobs:
         with:
           target: ${{ matrix.target }}
           manylinux: ${{ matrix.manylinux }}
-          args: --release --out dist --interpreter ${{ matrix.interpreter || '3.9 3.10 3.11 3.12 3.13 pypy3.9 pypy3.10' }}
+          args: --release --out dist --interpreter ${{ matrix.interpreter || '3.9 3.10 3.11 3.12 3.13 pypy3.9 pypy3.10 pypy3.11' }}
           rust-toolchain: stable
           docker-options: -e CI
 
diff --git a/Cargo.lock b/Cargo.lock
index 42b1220ea..ba2992d59 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -449,9 +449,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.23.4"
+version = "0.23.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "57fe09249128b3173d092de9523eaa75136bf7ba85e0d69eca241c7939c933cc"
+checksum = "7778bffd85cf38175ac1f545509665d0b9b92a198ca7941f131f85f7a4f9a872"
 dependencies = [
  "cfg-if",
  "indoc",
@@ -468,9 +468,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.23.4"
+version = "0.23.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1cd3927b5a78757a0d71aa9dff669f903b1eb64b54142a9bd9f757f8fde65fd7"
+checksum = "94f6cbe86ef3bf18998d9df6e0f3fc1050a8c5efa409bf712e661a4366e010fb"
 dependencies = [
  "once_cell",
  "python3-dll-a",
@@ -479,9 +479,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.23.4"
+version = "0.23.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dab6bb2102bd8f991e7749f130a70d05dd557613e39ed2deeee8e9ca0c4d548d"
+checksum = "e9f1b4c431c0bb1c8fb0a338709859eed0d030ff6daa34368d3b152a63dfdd8d"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -489,9 +489,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.23.4"
+version = "0.23.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91871864b353fd5ffcb3f91f2f703a22a9797c91b9ab497b1acac7b07ae509c7"
+checksum = "fbc2201328f63c4710f68abdf653c89d8dbc2858b88c5d88b0ff38a75288a9da"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -501,9 +501,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.23.4"
+version = "0.23.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "43abc3b80bc20f3facd86cd3c60beed58c3e2aa26213f3cda368de39c60a27e4"
+checksum = "fca6726ad0f3da9c9de093d6f116a93c1a38e417ed73bf138472cf4064f72028"
 dependencies = [
  "heck",
  "proc-macro2",
diff --git a/Cargo.toml b/Cargo.toml
index 6f8842bea..c7be6ad02 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -29,7 +29,7 @@ rust-version = "1.75"
 [dependencies]
 # TODO it would be very nice to remove the "py-clone" feature as it can panic,
 # but needs a bit of work to make sure it's not used in the codebase
-pyo3 = { version = "0.23.4", features = ["generate-import-lib", "num-bigint", "py-clone"] }
+pyo3 = { version = "0.23.5", features = ["generate-import-lib", "num-bigint", "py-clone"] }
 regex = "1.11.1"
 strum = { version = "0.26.3", features = ["derive"] }
 strum_macros = "0.26.4"
@@ -73,12 +73,12 @@ debug = true
 strip = false
 
 [dev-dependencies]
-pyo3 = { version = "0.23.3", features = ["auto-initialize"] }
+pyo3 = { version = "0.23.5", features = ["auto-initialize"] }
 
 [build-dependencies]
 version_check = "0.9.5"
 # used where logic has to be version/distribution specific, e.g. pypy
-pyo3-build-config = { version = "0.23.3" }
+pyo3-build-config = { version = "0.23.5" }
 
 [lints.clippy]
 dbg_macro = "warn"
diff --git a/src/argument_markers.rs b/src/argument_markers.rs
index 1b74a62f1..f22a32c78 100644
--- a/src/argument_markers.rs
+++ b/src/argument_markers.rs
@@ -5,12 +5,7 @@ use pyo3::types::{PyDict, PyTuple};
 
 use crate::tools::safe_repr;
 
-// see https://github.com/PyO3/pyo3/issues/4894 - freelist is currently unsound with GIL disabled
-#[cfg_attr(
-    not(Py_GIL_DISABLED),
-    pyclass(module = "pydantic_core._pydantic_core", get_all, frozen, freelist = 100)
-)]
-#[cfg_attr(Py_GIL_DISABLED, pyclass(module = "pydantic_core._pydantic_core", get_all, frozen))]
+#[pyclass(module = "pydantic_core._pydantic_core", get_all, frozen, freelist = 100)]
 #[derive(Debug, Clone)]
 pub struct ArgsKwargs {
     pub(crate) args: Py<PyTuple>,

From c40a138f8b47bb55e3eb0cf1647e1f736494e8ad Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Tue, 25 Feb 2025 08:41:19 -0500
Subject: [PATCH 496/550] Fix strict behavior for unions (#1638)

---
 python/pydantic_core/core_schema.py           |  3 --
 src/validators/union.rs                       | 22 +--------
 tests/benchmarks/test_micro_benchmarks.py     |  8 ++--
 tests/validators/test_bytes.py                |  2 +-
 .../validators/test_definitions_recursive.py  |  8 ++--
 tests/validators/test_union.py                | 48 ++++++++++++++++---
 6 files changed, 54 insertions(+), 37 deletions(-)

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index e999bdcfc..9bf0d2349 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -2525,7 +2525,6 @@ def union_schema(
     custom_error_message: str | None = None,
     custom_error_context: dict[str, str | int] | None = None,
     mode: Literal['smart', 'left_to_right'] | None = None,
-    strict: bool | None = None,
     ref: str | None = None,
     metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
@@ -2551,7 +2550,6 @@ def union_schema(
         mode: How to select which choice to return
             * `smart` (default) will try to return the choice which is the closest match to the input value
             * `left_to_right` will return the first choice in `choices` which succeeds validation
-        strict: Whether the underlying schemas 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
         serialization: Custom serialization schema
@@ -2564,7 +2562,6 @@ def union_schema(
         custom_error_message=custom_error_message,
         custom_error_context=custom_error_context,
         mode=mode,
-        strict=strict,
         ref=ref,
         metadata=metadata,
         serialization=serialization,
diff --git a/src/validators/union.rs b/src/validators/union.rs
index bfe744212..dccc09ce7 100644
--- a/src/validators/union.rs
+++ b/src/validators/union.rs
@@ -8,7 +8,7 @@ use pyo3::{intern, PyTraverseError, PyVisit};
 use smallvec::SmallVec;
 
 use crate::build_tools::py_schema_err;
-use crate::build_tools::{is_strict, schema_or_config};
+use crate::build_tools::schema_or_config;
 use crate::common::union::{Discriminator, SMALL_UNION_THRESHOLD};
 use crate::errors::{ErrorType, ToErrorValue, ValError, ValLineError, ValResult};
 use crate::input::{BorrowInput, Input, ValidatedDict};
@@ -43,7 +43,6 @@ pub struct UnionValidator {
     mode: UnionMode,
     choices: Vec<(CombinedValidator, Option<String>)>,
     custom_error: Option<CustomError>,
-    strict: bool,
     name: String,
 }
 
@@ -91,7 +90,6 @@ impl BuildValidator for UnionValidator {
                     mode,
                     choices,
                     custom_error: CustomError::build(schema, config, definitions)?,
-                    strict: is_strict(schema, config)?,
                     name: format!("{}[{descr}]", Self::EXPECTED_TYPE),
                 }
                 .into())
@@ -110,17 +108,11 @@ impl UnionValidator {
         let old_exactness = state.exactness;
         let old_fields_set_count = state.fields_set_count;
 
-        let strict = state.strict_or(self.strict);
         let mut errors = MaybeErrors::new(self.custom_error.as_ref());
 
         let mut best_match: Option<(Py<PyAny>, Exactness, Option<usize>)> = None;
 
         for (choice, label) in &self.choices {
-            let state = &mut state.rebind_extra(|extra| {
-                if strict {
-                    extra.strict = Some(strict);
-                }
-            });
             state.exactness = Some(Exactness::Exact);
             state.fields_set_count = None;
             let result = choice.validate(py, input, state);
@@ -197,14 +189,6 @@ impl UnionValidator {
     ) -> ValResult<PyObject> {
         let mut errors = MaybeErrors::new(self.custom_error.as_ref());
 
-        let mut rebound_state;
-        let state = if state.strict_or(self.strict) {
-            rebound_state = state.rebind_extra(|extra| extra.strict = Some(true));
-            &mut rebound_state
-        } else {
-            state
-        };
-
         for (validator, label) in &self.choices {
             match validator.validate(py, input, state) {
                 Err(ValError::LineErrors(lines)) => errors.push(validator, label.as_deref(), lines),
@@ -300,7 +284,6 @@ pub struct TaggedUnionValidator {
     discriminator: Discriminator,
     lookup: LiteralLookup<CombinedValidator>,
     from_attributes: bool,
-    strict: bool,
     custom_error: Option<CustomError>,
     tags_repr: String,
     discriminator_repr: String,
@@ -349,7 +332,6 @@ impl BuildValidator for TaggedUnionValidator {
             discriminator,
             lookup,
             from_attributes,
-            strict: is_strict(schema, config)?,
             custom_error: CustomError::build(schema, config, definitions)?,
             tags_repr,
             discriminator_repr,
@@ -371,7 +353,7 @@ impl Validator for TaggedUnionValidator {
         match &self.discriminator {
             Discriminator::LookupKey(lookup_key) => {
                 let from_attributes = state.extra().from_attributes.unwrap_or(self.from_attributes);
-                let dict = input.validate_model_fields(self.strict, from_attributes)?;
+                let dict = input.validate_model_fields(state.strict_or(false), from_attributes)?;
                 // note this methods returns PyResult<Option<(data, data)>>, the outer Err is just for
                 // errors when getting attributes which should be "raised"
                 let tag = match dict.get_item(lookup_key)? {
diff --git a/tests/benchmarks/test_micro_benchmarks.py b/tests/benchmarks/test_micro_benchmarks.py
index 3435174a5..5640431ae 100644
--- a/tests/benchmarks/test_micro_benchmarks.py
+++ b/tests/benchmarks/test_micro_benchmarks.py
@@ -686,8 +686,9 @@ def test_smart_union_coerce_core(self, benchmark):
     def test_strict_union_core(self, benchmark):
         v = SchemaValidator(
             schema=core_schema.union_schema(
-                strict=True, choices=[core_schema.bool_schema(), core_schema.int_schema(), core_schema.str_schema()]
-            )
+                choices=[core_schema.bool_schema(), core_schema.int_schema(), core_schema.str_schema()]
+            ),
+            config=CoreConfig(strict=True),
         )
 
         benchmark(v.validate_python, 1)
@@ -695,7 +696,8 @@ def test_strict_union_core(self, benchmark):
     @pytest.mark.benchmark(group='strict-union-error')
     def test_strict_union_error_core(self, benchmark):
         v = SchemaValidator(
-            schema=core_schema.union_schema(strict=True, choices=[core_schema.bool_schema(), core_schema.str_schema()])
+            schema=core_schema.union_schema(choices=[core_schema.bool_schema(), core_schema.str_schema()]),
+            config=CoreConfig(strict=True),
         )
 
         def validate_with_expected_error():
diff --git a/tests/validators/test_bytes.py b/tests/validators/test_bytes.py
index 1110a34d3..0506957ec 100644
--- a/tests/validators/test_bytes.py
+++ b/tests/validators/test_bytes.py
@@ -91,7 +91,7 @@ def test_constrained_bytes(py_and_json: PyAndJson, opts: dict[str, Any], input,
 
 
 def test_union():
-    v = SchemaValidator(cs.union_schema(choices=[cs.str_schema(), cs.bytes_schema()], strict=True))
+    v = SchemaValidator(cs.union_schema(choices=[cs.str_schema(strict=True), cs.bytes_schema(strict=True)]))
     assert v.validate_python('oh, a string') == 'oh, a string'
     assert v.validate_python(b'oh, bytes') == b'oh, bytes'
 
diff --git a/tests/validators/test_definitions_recursive.py b/tests/validators/test_definitions_recursive.py
index 4c2577408..34b8ca445 100644
--- a/tests/validators/test_definitions_recursive.py
+++ b/tests/validators/test_definitions_recursive.py
@@ -611,11 +611,11 @@ def test_union_cycle(strict: bool):
                                 'foobar': core_schema.typed_dict_field(
                                     core_schema.list_schema(core_schema.definition_reference_schema('root-schema'))
                                 )
-                            }
+                            },
+                            strict=strict,
                         )
                     ],
                     auto_collapse=False,
-                    strict=strict,
                     ref='root-schema',
                 )
             ],
@@ -700,11 +700,11 @@ def f(input_value, info):
                         )
                     ],
                     auto_collapse=False,
-                    strict=strict,
                     ref='root-schema',
                 )
             ],
-        )
+        ),
+        config=CoreConfig(strict=strict),
     )
 
     with pytest.raises(ValidationError) as exc_info:
diff --git a/tests/validators/test_union.py b/tests/validators/test_union.py
index 70acd6cfd..f35ebfec0 100644
--- a/tests/validators/test_union.py
+++ b/tests/validators/test_union.py
@@ -8,7 +8,7 @@
 import pytest
 from dirty_equals import IsFloat, IsInt
 
-from pydantic_core import SchemaError, SchemaValidator, ValidationError, core_schema, validate_core_schema
+from pydantic_core import CoreConfig, SchemaError, SchemaValidator, ValidationError, core_schema, validate_core_schema
 
 from ..conftest import plain_repr
 
@@ -262,16 +262,47 @@ def test_one_choice():
     assert v.validate_python('hello') == 'hello'
 
 
-def test_strict_union():
+def test_strict_union_flag() -> None:
+    v = SchemaValidator(core_schema.union_schema(choices=[core_schema.bool_schema(), core_schema.int_schema()]))
+    assert v.validate_python(1, strict=True) == 1
+    assert v.validate_python(123, strict=True) == 123
+
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_python('123', strict=True)
+
+    assert exc_info.value.errors(include_url=False) == [
+        {'type': 'bool_type', 'loc': ('bool',), 'msg': 'Input should be a valid boolean', 'input': '123'},
+        {'type': 'int_type', 'loc': ('int',), 'msg': 'Input should be a valid integer', 'input': '123'},
+    ]
+
+
+def test_strict_union_config_level() -> None:
     v = SchemaValidator(
-        core_schema.union_schema(strict=True, choices=[core_schema.bool_schema(), core_schema.int_schema()])
+        core_schema.union_schema(choices=[core_schema.bool_schema(), core_schema.int_schema()]),
+        config=CoreConfig(strict=True),
     )
+
     assert v.validate_python(1) == 1
     assert v.validate_python(123) == 123
 
     with pytest.raises(ValidationError) as exc_info:
         v.validate_python('123')
+    assert exc_info.value.errors(include_url=False) == [
+        {'type': 'bool_type', 'loc': ('bool',), 'msg': 'Input should be a valid boolean', 'input': '123'},
+        {'type': 'int_type', 'loc': ('int',), 'msg': 'Input should be a valid integer', 'input': '123'},
+    ]
 
+
+def test_strict_union_member_level() -> None:
+    v = SchemaValidator(
+        core_schema.union_schema(choices=[core_schema.bool_schema(strict=True), core_schema.int_schema(strict=True)])
+    )
+
+    assert v.validate_python(1) == 1
+    assert v.validate_python(123) == 123
+
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_python('123')
     assert exc_info.value.errors(include_url=False) == [
         {'type': 'bool_type', 'loc': ('bool',), 'msg': 'Input should be a valid boolean', 'input': '123'},
         {'type': 'int_type', 'loc': ('int',), 'msg': 'Input should be a valid integer', 'input': '123'},
@@ -469,10 +500,10 @@ def test_left_to_right_union():
 
 
 def test_left_to_right_union_strict():
-    choices = [core_schema.int_schema(), core_schema.float_schema()]
+    choices = [core_schema.int_schema(strict=True), core_schema.float_schema(strict=True)]
 
     # left_to_right union will select not cast if int first (strict int will not accept float)
-    v = SchemaValidator(core_schema.union_schema(choices, mode='left_to_right', strict=True))
+    v = SchemaValidator(core_schema.union_schema(choices, mode='left_to_right'))
     out = v.validate_python(1)
     assert out == 1
     assert isinstance(out, int)
@@ -482,7 +513,12 @@ def test_left_to_right_union_strict():
     assert isinstance(out, float)
 
     # reversing union will select float always (as strict float will accept int)
-    v = SchemaValidator(core_schema.union_schema(list(reversed(choices)), mode='left_to_right', strict=True))
+    v = SchemaValidator(
+        core_schema.union_schema(
+            list(reversed(choices)),
+            mode='left_to_right',
+        )
+    )
     out = v.validate_python(1.0)
     assert out == 1.0
     assert isinstance(out, float)

From 7dc19c3651b2d481b0990017b499ff4bad0954c3 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Tue, 25 Feb 2025 15:31:21 +0000
Subject: [PATCH 497/550] update python3-dll-a for PyPy 3.11 (#1647)

---
 Cargo.lock | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index ba2992d59..11885ec4e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -514,9 +514,9 @@ dependencies = [
 
 [[package]]
 name = "python3-dll-a"
-version = "0.2.12"
+version = "0.2.13"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9b66f9171950e674e64bad3456e11bb3cca108e5c34844383cfe277f45c8a7a8"
+checksum = "49fe4227a288cf9493942ad0220ea3f185f4d1f2a14f197f7344d6d02f4ed4ed"
 dependencies = [
  "cc",
 ]

From 8c59fa2956f224a46ecebe3ddf22400d92c497c5 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Tue, 25 Feb 2025 11:55:33 -0500
Subject: [PATCH 498/550] Improving the alias configuration API for validation
 and serialization (#1640)

Co-authored-by: Victorien <65306057+Viicos@users.noreply.github.com>
Co-authored-by: David Hewitt <david.hewitt@pydantic.dev>
---
 benches/main.rs                               | 120 +++++++++--------
 python/pydantic_core/_pydantic_core.pyi       |  26 +++-
 python/pydantic_core/core_schema.py           |  34 ++---
 src/errors/validation_exception.rs            |   2 +-
 src/lookup_key.rs                             |  44 +++++++
 src/serializers/computed_fields.rs            |   6 +-
 src/serializers/extra.rs                      |  12 +-
 src/serializers/fields.rs                     |   7 +-
 src/serializers/mod.rs                        |  18 +--
 src/serializers/type_serializers/dataclass.rs |   9 +-
 src/serializers/type_serializers/function.rs  |   4 +-
 src/serializers/type_serializers/model.rs     |   9 +-
 .../type_serializers/typed_dict.rs            |   9 +-
 src/url.rs                                    |   4 +-
 src/validators/arguments.rs                   |  51 +++++---
 src/validators/dataclass.rs                   |  35 ++---
 src/validators/generator.rs                   |   4 +
 src/validators/mod.rs                         |  67 +++++++++-
 src/validators/model_fields.rs                |  31 +++--
 src/validators/typed_dict.rs                  |  33 +++--
 src/validators/validation_state.rs            |   8 ++
 tests/serializers/test_dataclasses.py         |  49 ++++++-
 tests/serializers/test_functions.py           |  22 ++--
 tests/serializers/test_model.py               |  93 ++++++++++---
 tests/serializers/test_typed_dict.py          |  46 ++++++-
 tests/serializers/test_union.py               |   4 +-
 tests/test.rs                                 |   8 +-
 tests/test_json.py                            |   4 +-
 tests/test_typing.py                          |   4 +-
 tests/validators/test_arguments.py            |  81 +++++++++++-
 tests/validators/test_dataclasses.py          | 122 ++++++++++++++++++
 tests/validators/test_model_fields.py         |  90 +++++++++++--
 tests/validators/test_typed_dict.py           |  83 +++++++++++-
 33 files changed, 901 insertions(+), 238 deletions(-)

diff --git a/benches/main.rs b/benches/main.rs
index 0198c2943..c558ca3c6 100644
--- a/benches/main.rs
+++ b/benches/main.rs
@@ -34,7 +34,7 @@ fn ints_json(bench: &mut Bencher) {
         let validator = build_schema_validator(py, c"{'type': 'int'}");
 
         let result = validator
-            .validate_json(py, &json(py, "123"), None, None, None, false.into())
+            .validate_json(py, &json(py, "123"), None, None, None, false.into(), None, None)
             .unwrap();
         let result_int: i64 = result.extract(py).unwrap();
         assert_eq!(result_int, 123);
@@ -42,7 +42,7 @@ fn ints_json(bench: &mut Bencher) {
         bench.iter(|| {
             black_box(
                 validator
-                    .validate_json(py, &json(py, "123"), None, None, None, false.into())
+                    .validate_json(py, &json(py, "123"), None, None, None, false.into(), None, None)
                     .unwrap(),
             )
         })
@@ -56,7 +56,7 @@ fn ints_python(bench: &mut Bencher) {
 
         let Ok(input) = 123_i64.into_pyobject(py);
         let result = validator
-            .validate_python(py, &input, None, None, None, None, false.into())
+            .validate_python(py, &input, None, None, None, None, false.into(), None, None)
             .unwrap();
         let result_int: i64 = result.extract(py).unwrap();
         assert_eq!(result_int, 123);
@@ -65,7 +65,7 @@ fn ints_python(bench: &mut Bencher) {
         bench.iter(|| {
             black_box(
                 validator
-                    .validate_python(py, &input, None, None, None, None, false.into())
+                    .validate_python(py, &input, None, None, None, None, false.into(), None, None)
                     .unwrap(),
             )
         })
@@ -84,7 +84,7 @@ fn list_int_json(bench: &mut Bencher) {
         bench.iter(|| {
             black_box(
                 validator
-                    .validate_json(py, &json(py, &code), None, None, None, false.into())
+                    .validate_json(py, &json(py, &code), None, None, None, false.into(), None, None)
                     .unwrap(),
             )
         })
@@ -110,7 +110,7 @@ fn list_int_python(bench: &mut Bencher) {
         let input = black_box(input.bind(py));
         bench.iter(|| {
             let v = validator
-                .validate_python(py, &input, None, None, None, None, false.into())
+                .validate_python(py, &input, None, None, None, None, false.into(), None, None)
                 .unwrap();
             black_box(v)
         })
@@ -122,11 +122,15 @@ fn list_int_python_isinstance(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let (validator, input) = list_int_input(py);
         let input = black_box(input.bind(py));
-        let v = validator.isinstance_python(py, &input, None, None, None, None).unwrap();
+        let v = validator
+            .isinstance_python(py, &input, None, None, None, None, None, None)
+            .unwrap();
         assert!(v);
 
         bench.iter(|| {
-            let v = validator.isinstance_python(py, &input, None, None, None, None).unwrap();
+            let v = validator
+                .isinstance_python(py, &input, None, None, None, None, None, None)
+                .unwrap();
             black_box(v)
         })
     })
@@ -144,7 +148,7 @@ fn list_error_json(bench: &mut Bencher) {
                 .join(", ")
         );
 
-        match validator.validate_json(py, &json(py, &code), None, None, None, false.into()) {
+        match validator.validate_json(py, &json(py, &code), None, None, None, false.into(), None, None) {
             Ok(_) => panic!("unexpectedly valid"),
             Err(e) => {
                 let v = e.value(py);
@@ -156,7 +160,7 @@ fn list_error_json(bench: &mut Bencher) {
         };
 
         bench.iter(
-            || match validator.validate_json(py, &json(py, &code), None, None, None, false.into()) {
+            || match validator.validate_json(py, &json(py, &code), None, None, None, false.into(), None, None) {
                 Ok(_) => panic!("unexpectedly valid"),
                 Err(e) => black_box(e),
             },
@@ -177,7 +181,7 @@ fn list_error_python_input(py: Python<'_>) -> (SchemaValidator, PyObject) {
 
     let input = py.eval(&code, None, None).unwrap().extract().unwrap();
 
-    match validator.validate_python(py, &input, None, None, None, None, false.into()) {
+    match validator.validate_python(py, &input, None, None, None, None, false.into(), None, None) {
         Ok(_) => panic!("unexpectedly valid"),
         Err(e) => {
             let v = e.value(py);
@@ -197,7 +201,7 @@ fn list_error_python(bench: &mut Bencher) {
 
         let input = black_box(input.bind(py));
         bench.iter(|| {
-            let result = validator.validate_python(py, &input, None, None, None, None, false.into());
+            let result = validator.validate_python(py, &input, None, None, None, None, false.into(), None, None);
 
             match result {
                 Ok(_) => panic!("unexpectedly valid"),
@@ -212,11 +216,17 @@ fn list_error_python_isinstance(bench: &mut Bencher) {
     Python::with_gil(|py| {
         let (validator, input) = list_error_python_input(py);
         let input = black_box(input.bind(py));
-        let r = validator.isinstance_python(py, &input, None, None, None, None).unwrap();
+        let r = validator
+            .isinstance_python(py, &input, None, None, None, None, None, None)
+            .unwrap();
         assert!(!r);
 
         bench.iter(|| {
-            black_box(validator.isinstance_python(py, &input, None, None, None, None).unwrap());
+            black_box(
+                validator
+                    .isinstance_python(py, &input, None, None, None, None, None, None)
+                    .unwrap(),
+            );
         })
     })
 }
@@ -233,7 +243,7 @@ fn list_any_json(bench: &mut Bencher) {
         bench.iter(|| {
             black_box(
                 validator
-                    .validate_json(py, &json(py, &code), None, None, None, false.into())
+                    .validate_json(py, &json(py, &code), None, None, None, false.into(), None, None)
                     .unwrap(),
             )
         })
@@ -253,7 +263,7 @@ fn list_any_python(bench: &mut Bencher) {
         let input = black_box(input);
         bench.iter(|| {
             let v = validator
-                .validate_python(py, &input, None, None, None, None, false.into())
+                .validate_python(py, &input, None, None, None, None, false.into(), None, None)
                 .unwrap();
             black_box(v)
         })
@@ -287,7 +297,7 @@ fn dict_json(bench: &mut Bencher) {
         bench.iter(|| {
             black_box(
                 validator
-                    .validate_json(py, &json(py, &code), None, None, None, false.into())
+                    .validate_json(py, &json(py, &code), None, None, None, false.into(), None, None)
                     .unwrap(),
             )
         })
@@ -314,7 +324,7 @@ fn dict_python(bench: &mut Bencher) {
         let input = black_box(input);
         bench.iter(|| {
             let v = validator
-                .validate_python(py, &input, None, None, None, None, false.into())
+                .validate_python(py, &input, None, None, None, None, false.into(), None, None)
                 .unwrap();
             black_box(v)
         })
@@ -344,7 +354,7 @@ fn dict_value_error(bench: &mut Bencher) {
 
         let input = py.eval(&code, None, None).unwrap();
 
-        match validator.validate_python(py, &input, None, None, None, None, false.into()) {
+        match validator.validate_python(py, &input, None, None, None, None, false.into(), None, None) {
             Ok(_) => panic!("unexpectedly valid"),
             Err(e) => {
                 let v = e.value(py);
@@ -357,7 +367,7 @@ fn dict_value_error(bench: &mut Bencher) {
 
         let input = black_box(input);
         bench.iter(|| {
-            let result = validator.validate_python(py, &input, None, None, None, None, false.into());
+            let result = validator.validate_python(py, &input, None, None, None, None, false.into(), None, None);
 
             match result {
                 Ok(_) => panic!("unexpectedly valid"),
@@ -395,7 +405,7 @@ fn typed_dict_json(bench: &mut Bencher) {
         bench.iter(|| {
             black_box(
                 validator
-                    .validate_json(py, &json(py, code), None, None, None, false.into())
+                    .validate_json(py, &json(py, code), None, None, None, false.into(), None, None)
                     .unwrap(),
             )
         })
@@ -430,7 +440,7 @@ fn typed_dict_python(bench: &mut Bencher) {
         let input = black_box(input);
         bench.iter(|| {
             let v = validator
-                .validate_python(py, &input, None, None, None, None, false.into())
+                .validate_python(py, &input, None, None, None, None, false.into(), None, None)
                 .unwrap();
             black_box(v)
         })
@@ -471,7 +481,7 @@ fn typed_dict_deep_error(bench: &mut Bencher) {
         let input = py.eval(code, None, None).unwrap();
         let input = black_box(input);
 
-        match validator.validate_python(py, &input, None, None, None, None, false.into()) {
+        match validator.validate_python(py, &input, None, None, None, None, false.into(), None, None) {
             Ok(_) => panic!("unexpectedly valid"),
             Err(e) => {
                 let v = e.value(py);
@@ -483,7 +493,7 @@ fn typed_dict_deep_error(bench: &mut Bencher) {
         };
 
         bench.iter(|| {
-            let result = validator.validate_python(py, &input, None, None, None, None, false.into());
+            let result = validator.validate_python(py, &input, None, None, None, None, false.into(), None, None);
 
             match result {
                 Ok(_) => panic!("unexpectedly valid"),
@@ -510,7 +520,7 @@ fn complete_model(bench: &mut Bencher) {
         bench.iter(|| {
             black_box(
                 validator
-                    .validate_python(py, &input, None, None, None, None, false.into())
+                    .validate_python(py, &input, None, None, None, None, false.into(), None, None)
                     .unwrap(),
             );
         })
@@ -532,13 +542,13 @@ fn nested_model_using_definitions(bench: &mut Bencher) {
         let input = black_box(input);
 
         validator
-            .validate_python(py, &input, None, None, None, None, false.into())
+            .validate_python(py, &input, None, None, None, None, false.into(), None, None)
             .unwrap();
 
         bench.iter(|| {
             black_box(
                 validator
-                    .validate_python(py, &input, None, None, None, None, false.into())
+                    .validate_python(py, &input, None, None, None, None, false.into(), None, None)
                     .unwrap(),
             );
         })
@@ -560,13 +570,13 @@ fn nested_model_inlined(bench: &mut Bencher) {
         let input = black_box(input);
 
         validator
-            .validate_python(py, &input, None, None, None, None, false.into())
+            .validate_python(py, &input, None, None, None, None, false.into(), None, None)
             .unwrap();
 
         bench.iter(|| {
             black_box(
                 validator
-                    .validate_python(py, &input, None, None, None, None, false.into())
+                    .validate_python(py, &input, None, None, None, None, false.into(), None, None)
                     .unwrap(),
             );
         })
@@ -580,7 +590,7 @@ fn literal_ints_few_python(bench: &mut Bencher) {
 
         let Ok(input) = 4_i64.into_pyobject(py);
         let result = validator
-            .validate_python(py, &input, None, None, None, None, false.into())
+            .validate_python(py, &input, None, None, None, None, false.into(), None, None)
             .unwrap();
         let result_int: i64 = result.extract(py).unwrap();
         assert_eq!(result_int, 4);
@@ -589,7 +599,7 @@ fn literal_ints_few_python(bench: &mut Bencher) {
         bench.iter(|| {
             black_box(
                 validator
-                    .validate_python(py, &input, None, None, None, None, false.into())
+                    .validate_python(py, &input, None, None, None, None, false.into(), None, None)
                     .unwrap(),
             )
         })
@@ -604,7 +614,7 @@ fn literal_strings_few_small_python(bench: &mut Bencher) {
         let input = py.eval(c"'4'", None, None).unwrap();
         let input_str: String = input.extract().unwrap();
         let result = validator
-            .validate_python(py, &input, None, None, None, None, false.into())
+            .validate_python(py, &input, None, None, None, None, false.into(), None, None)
             .unwrap();
         let result_str: String = result.extract(py).unwrap();
         assert_eq!(result_str, input_str);
@@ -613,7 +623,7 @@ fn literal_strings_few_small_python(bench: &mut Bencher) {
         bench.iter(|| {
             black_box(
                 validator
-                    .validate_python(py, &input, None, None, None, None, false.into())
+                    .validate_python(py, &input, None, None, None, None, false.into(), None, None)
                     .unwrap(),
             )
         })
@@ -631,7 +641,7 @@ fn literal_strings_few_large_python(bench: &mut Bencher) {
         let input = py.eval(c"'a' * 25 + '4'", None, None).unwrap();
         let input_str: String = input.extract().unwrap();
         let result = validator
-            .validate_python(py, &input, None, None, None, None, false.into())
+            .validate_python(py, &input, None, None, None, None, false.into(), None, None)
             .unwrap();
         let result_str: String = result.extract(py).unwrap();
         assert_eq!(result_str, input_str);
@@ -640,7 +650,7 @@ fn literal_strings_few_large_python(bench: &mut Bencher) {
         bench.iter(|| {
             black_box(
                 validator
-                    .validate_python(py, &input, None, None, None, None, false.into())
+                    .validate_python(py, &input, None, None, None, None, false.into(), None, None)
                     .unwrap(),
             )
         })
@@ -674,7 +684,7 @@ class Foo(Enum):
 
         let input = py.eval(c"Foo.v4", Some(&globals), None).unwrap();
         let result = validator
-            .validate_python(py, &input, None, None, None, None, false.into())
+            .validate_python(py, &input, None, None, None, None, false.into(), None, None)
             .unwrap();
         assert!(input.eq(result).unwrap());
 
@@ -682,7 +692,7 @@ class Foo(Enum):
         bench.iter(|| {
             black_box(
                 validator
-                    .validate_python(py, &input, None, None, None, None, false.into())
+                    .validate_python(py, &input, None, None, None, None, false.into(), None, None)
                     .unwrap(),
             )
         })
@@ -696,7 +706,7 @@ fn literal_ints_many_python(bench: &mut Bencher) {
 
         let Ok(input) = 99_i64.into_pyobject(py);
         let result = validator
-            .validate_python(py, &input, None, None, None, None, false.into())
+            .validate_python(py, &input, None, None, None, None, false.into(), None, None)
             .unwrap();
         let result_int: i64 = result.extract(py).unwrap();
         assert_eq!(result_int, 99);
@@ -705,7 +715,7 @@ fn literal_ints_many_python(bench: &mut Bencher) {
         bench.iter(|| {
             black_box(
                 validator
-                    .validate_python(py, &input, None, None, None, None, false.into())
+                    .validate_python(py, &input, None, None, None, None, false.into(), None, None)
                     .unwrap(),
             )
         })
@@ -721,7 +731,7 @@ fn literal_strings_many_small_python(bench: &mut Bencher) {
         let input = py.eval(c"'99'", None, None).unwrap();
         let input_str: String = input.extract().unwrap();
         let result = validator
-            .validate_python(py, &input, None, None, None, None, false.into())
+            .validate_python(py, &input, None, None, None, None, false.into(), None, None)
             .unwrap();
         let result_str: String = result.extract(py).unwrap();
         assert_eq!(result_str, input_str);
@@ -730,7 +740,7 @@ fn literal_strings_many_small_python(bench: &mut Bencher) {
         bench.iter(|| {
             black_box(
                 validator
-                    .validate_python(py, &input, None, None, None, None, false.into())
+                    .validate_python(py, &input, None, None, None, None, false.into(), None, None)
                     .unwrap(),
             )
         })
@@ -748,7 +758,7 @@ fn literal_strings_many_large_python(bench: &mut Bencher) {
         let input = py.eval(c"'a' * 25 + '99'", None, None).unwrap();
         let input_str: String = input.extract().unwrap();
         let result = validator
-            .validate_python(py, &input, None, None, None, None, false.into())
+            .validate_python(py, &input, None, None, None, None, false.into(), None, None)
             .unwrap();
         let result_str: String = result.extract(py).unwrap();
         assert_eq!(result_str, input_str);
@@ -757,7 +767,7 @@ fn literal_strings_many_large_python(bench: &mut Bencher) {
         bench.iter(|| {
             black_box(
                 validator
-                    .validate_python(py, &input, None, None, None, None, false.into())
+                    .validate_python(py, &input, None, None, None, None, false.into(), None, None)
                     .unwrap(),
             )
         })
@@ -771,7 +781,7 @@ fn literal_ints_many_json(bench: &mut Bencher) {
 
         let input_json = py.eval(c"'99'", None, None).unwrap();
         let result = validator
-            .validate_json(py, &input_json, None, None, None, false.into())
+            .validate_json(py, &input_json, None, None, None, false.into(), None, None)
             .unwrap();
         let result_int: i64 = result.extract(py).unwrap();
         assert_eq!(result_int, 99);
@@ -780,7 +790,7 @@ fn literal_ints_many_json(bench: &mut Bencher) {
         bench.iter(|| {
             black_box(
                 validator
-                    .validate_json(py, &input_json, None, None, None, false.into())
+                    .validate_json(py, &input_json, None, None, None, false.into(), None, None)
                     .unwrap(),
             )
         })
@@ -799,7 +809,7 @@ fn literal_strings_many_large_json(bench: &mut Bencher) {
         let input_json = py.eval(c"'\"' + 'a' * 25 + '99' + '\"'", None, None).unwrap();
         let input_str: String = input.extract().unwrap();
         let result = validator
-            .validate_json(py, &input_json, None, None, None, false.into())
+            .validate_json(py, &input_json, None, None, None, false.into(), None, None)
             .unwrap();
         let result_str: String = result.extract(py).unwrap();
         assert_eq!(result_str, input_str);
@@ -808,7 +818,7 @@ fn literal_strings_many_large_json(bench: &mut Bencher) {
         bench.iter(|| {
             black_box(
                 validator
-                    .validate_json(py, &input_json, None, None, None, false.into())
+                    .validate_json(py, &input_json, None, None, None, false.into(), None, None)
                     .unwrap(),
             )
         })
@@ -844,7 +854,7 @@ class Foo(Enum):
             let input = py.eval(c"'null'", None, None).unwrap();
             let input_str: String = input.extract().unwrap();
             let result = validator
-                .validate_python(py, &input, None, None, None, None, false.into())
+                .validate_python(py, &input, None, None, None, None, false.into(), None, None)
                 .unwrap();
             let result_str: String = result.extract(py).unwrap();
             assert_eq!(result_str, input_str);
@@ -853,7 +863,7 @@ class Foo(Enum):
             bench.iter(|| {
                 black_box(
                     validator
-                        .validate_python(py, &input, None, None, None, None, false.into())
+                        .validate_python(py, &input, None, None, None, None, false.into(), None, None)
                         .unwrap(),
                 )
             })
@@ -864,7 +874,7 @@ class Foo(Enum):
             let input = py.eval(c"-1", None, None).unwrap();
             let input_int: i64 = input.extract().unwrap();
             let result = validator
-                .validate_python(py, &input, None, None, None, None, false.into())
+                .validate_python(py, &input, None, None, None, None, false.into(), None, None)
                 .unwrap();
             let result_int: i64 = result.extract(py).unwrap();
             assert_eq!(result_int, input_int);
@@ -873,7 +883,7 @@ class Foo(Enum):
             bench.iter(|| {
                 black_box(
                     validator
-                        .validate_python(py, &input, None, None, None, None, false.into())
+                        .validate_python(py, &input, None, None, None, None, false.into(), None, None)
                         .unwrap(),
                 )
             })
@@ -883,7 +893,7 @@ class Foo(Enum):
         {
             let input = py.eval(c"None", None, None).unwrap();
             let result = validator
-                .validate_python(py, &input, None, None, None, None, false.into())
+                .validate_python(py, &input, None, None, None, None, false.into(), None, None)
                 .unwrap();
             assert!(input.eq(result).unwrap());
 
@@ -891,7 +901,7 @@ class Foo(Enum):
             bench.iter(|| {
                 black_box(
                     validator
-                        .validate_python(py, &input, None, None, None, None, false.into())
+                        .validate_python(py, &input, None, None, None, None, false.into(), None, None)
                         .unwrap(),
                 )
             })
@@ -901,7 +911,7 @@ class Foo(Enum):
         {
             let input = py.eval(c"Foo.v4", Some(&globals), None).unwrap();
             let result = validator
-                .validate_python(py, &input, None, None, None, None, false.into())
+                .validate_python(py, &input, None, None, None, None, false.into(), None, None)
                 .unwrap();
             assert!(input.eq(result).unwrap());
 
@@ -909,7 +919,7 @@ class Foo(Enum):
             bench.iter(|| {
                 black_box(
                     validator
-                        .validate_python(py, &input, None, None, None, None, false.into())
+                        .validate_python(py, &input, None, None, None, None, false.into(), None, None)
                         .unwrap(),
                 )
             })
diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index 7245c37f7..3220b3ef8 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -97,6 +97,8 @@ class SchemaValidator:
         context: Any | None = None,
         self_instance: Any | None = None,
         allow_partial: bool | Literal['off', 'on', 'trailing-strings'] = False,
+        by_alias: bool | None = None,
+        by_name: bool | None = None,
     ) -> Any:
         """
         Validate a Python object against the schema and return the validated object.
@@ -114,6 +116,8 @@ class SchemaValidator:
             allow_partial: Whether to allow partial validation; if `True` errors in the last element of sequences
                 and mappings are ignored.
                 `'trailing-strings'` means any final unfinished JSON string is included in the result.
+            by_alias: Whether to use the field's alias when validating against the provided input data.
+            by_name: Whether to use the field's name when validating against the provided input data.
 
         Raises:
             ValidationError: If validation fails.
@@ -130,6 +134,8 @@ class SchemaValidator:
         from_attributes: bool | None = None,
         context: Any | None = None,
         self_instance: Any | None = None,
+        by_alias: bool | None = None,
+        by_name: bool | None = None,
     ) -> bool:
         """
         Similar to [`validate_python()`][pydantic_core.SchemaValidator.validate_python] but returns a boolean.
@@ -148,6 +154,8 @@ class SchemaValidator:
         context: Any | None = None,
         self_instance: Any | None = None,
         allow_partial: bool | Literal['off', 'on', 'trailing-strings'] = False,
+        by_alias: bool | None = None,
+        by_name: bool | None = None,
     ) -> Any:
         """
         Validate JSON data directly against the schema and return the validated Python object.
@@ -168,6 +176,8 @@ class SchemaValidator:
             allow_partial: Whether to allow partial validation; if `True` incomplete JSON will be parsed successfully
                 and errors in the last element of sequences and mappings are ignored.
                 `'trailing-strings'` means any final unfinished JSON string is included in the result.
+            by_alias: Whether to use the field's alias when validating against the provided input data.
+            by_name: Whether to use the field's name when validating against the provided input data.
 
         Raises:
             ValidationError: If validation fails or if the JSON data is invalid.
@@ -183,6 +193,8 @@ class SchemaValidator:
         strict: bool | None = None,
         context: Any | None = None,
         allow_partial: bool | Literal['off', 'on', 'trailing-strings'] = False,
+        by_alias: bool | None = None,
+        by_name: bool | None = None,
     ) -> Any:
         """
         Validate a string against the schema and return the validated Python object.
@@ -199,6 +211,8 @@ class SchemaValidator:
             allow_partial: Whether to allow partial validation; if `True` errors in the last element of sequences
                 and mappings are ignored.
                 `'trailing-strings'` means any final unfinished JSON string is included in the result.
+            by_alias: Whether to use the field's alias when validating against the provided input data.
+            by_name: Whether to use the field's name when validating against the provided input data.
 
         Raises:
             ValidationError: If validation fails or if the JSON data is invalid.
@@ -216,6 +230,8 @@ class SchemaValidator:
         strict: bool | None = None,
         from_attributes: bool | None = None,
         context: Any | None = None,
+        by_alias: bool | None = None,
+        by_name: bool | None = None,
     ) -> dict[str, Any] | tuple[dict[str, Any], dict[str, Any] | None, set[str]]:
         """
         Validate an assignment to a field on a model.
@@ -230,6 +246,8 @@ class SchemaValidator:
                 If `None`, the value of [`CoreConfig.from_attributes`][pydantic_core.core_schema.CoreConfig] is used.
             context: The context to use for validation, this is passed to functional validators as
                 [`info.context`][pydantic_core.core_schema.ValidationInfo.context].
+            by_alias: Whether to use the field's alias when validating against the provided input data.
+            by_name: Whether to use the field's name when validating against the provided input data.
 
         Raises:
             ValidationError: If validation fails.
@@ -283,7 +301,7 @@ class SchemaSerializer:
         mode: str | None = None,
         include: _IncEx | None = None,
         exclude: _IncEx | None = None,
-        by_alias: bool = True,
+        by_alias: bool | None = None,
         exclude_unset: bool = False,
         exclude_defaults: bool = False,
         exclude_none: bool = False,
@@ -329,7 +347,7 @@ class SchemaSerializer:
         indent: int | None = None,
         include: _IncEx | None = None,
         exclude: _IncEx | None = None,
-        by_alias: bool = True,
+        by_alias: bool | None = None,
         exclude_unset: bool = False,
         exclude_defaults: bool = False,
         exclude_none: bool = False,
@@ -374,7 +392,7 @@ def to_json(
     indent: int | None = None,
     include: _IncEx | None = None,
     exclude: _IncEx | None = None,
-    by_alias: bool = True,
+    by_alias: bool | None = None,
     exclude_none: bool = False,
     round_trip: bool = False,
     timedelta_mode: Literal['iso8601', 'float'] = 'iso8601',
@@ -450,7 +468,7 @@ def to_jsonable_python(
     *,
     include: _IncEx | None = None,
     exclude: _IncEx | None = None,
-    by_alias: bool = True,
+    by_alias: bool | None = None,
     exclude_none: bool = False,
     round_trip: bool = False,
     timedelta_mode: Literal['iso8601', 'float'] = 'iso8601',
diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index 9bf0d2349..c4a26041a 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -54,8 +54,6 @@ class CoreConfig(TypedDict, total=False):
             `field_names` to construct error `loc`s. Default is `True`.
         revalidate_instances: Whether instances of models and dataclasses should re-validate. Default is 'never'.
         validate_default: Whether to validate default values during validation. Default is `False`.
-        populate_by_name: Whether an aliased field may be populated by its name as given by the model attribute,
-            as well as the alias. (Replaces 'allow_population_by_field_name' in Pydantic v1.) Default is `False`.
         str_max_length: The maximum length for string fields.
         str_min_length: The minimum length for string fields.
         str_strip_whitespace: Whether to strip whitespace from string fields.
@@ -74,6 +72,9 @@ class CoreConfig(TypedDict, total=False):
         regex_engine: The regex engine to use for regex pattern validation. Default is 'rust-regex'. See `StringSchema`.
         cache_strings: Whether to cache strings. Default is `True`, `True` or `'all'` is required to cache strings
             during general validation since validators don't know if they're in a key or a value.
+        validate_by_alias: Whether to use the field's alias when validating against the provided input data. Default is `True`.
+        validate_by_name: Whether to use the field's name when validating against the provided input data. Default is `False`. Replacement for `populate_by_name`.
+        serialize_by_alias: Whether to serialize by alias. Default is `False`, expected to change to `True` in V3.
     """
 
     title: str
@@ -91,7 +92,6 @@ class CoreConfig(TypedDict, total=False):
     # whether to validate default values during validation, default False
     validate_default: bool
     # used on typed-dicts and arguments
-    populate_by_name: bool  # replaces `allow_population_by_field_name` in pydantic v1
     # fields related to string fields only
     str_max_length: int
     str_min_length: int
@@ -111,6 +111,9 @@ class CoreConfig(TypedDict, total=False):
     coerce_numbers_to_str: bool  # default: False
     regex_engine: Literal['rust-regex', 'python-re']  # default: 'rust-regex'
     cache_strings: Union[bool, Literal['all', 'keys', 'none']]  # default: 'True'
+    validate_by_alias: bool  # default: True
+    validate_by_name: bool  # default: False
+    serialize_by_alias: bool  # default: False
 
 
 IncExCall: TypeAlias = 'set[int | str] | dict[int | str, IncExCall] | None'
@@ -2885,7 +2888,6 @@ class TypedDictSchema(TypedDict, total=False):
     # all these values can be set via config, equivalent fields have `typed_dict_` prefix
     extra_behavior: ExtraBehavior
     total: bool  # default: True
-    populate_by_name: bool  # replaces `allow_population_by_field_name` in pydantic v1
     ref: str
     metadata: dict[str, Any]
     serialization: SerSchema
@@ -2901,7 +2903,6 @@ def typed_dict_schema(
     extras_schema: CoreSchema | None = None,
     extra_behavior: ExtraBehavior | None = None,
     total: bool | None = None,
-    populate_by_name: bool | None = None,
     ref: str | None = None,
     metadata: dict[str, Any] | None = None,
     serialization: SerSchema | None = None,
@@ -2935,7 +2936,6 @@ class MyTypedDict(TypedDict):
         metadata: Any other information you want to include with the schema, not used by pydantic-core
         extra_behavior: The extra behavior to use for the typed dict
         total: Whether the typed dict is total, otherwise uses `typed_dict_total` from config
-        populate_by_name: Whether the typed dict should populate by name
         serialization: Custom serialization schema
     """
     return _dict_not_none(
@@ -2947,7 +2947,6 @@ class MyTypedDict(TypedDict):
         extras_schema=extras_schema,
         extra_behavior=extra_behavior,
         total=total,
-        populate_by_name=populate_by_name,
         ref=ref,
         metadata=metadata,
         serialization=serialization,
@@ -3009,9 +3008,7 @@ class ModelFieldsSchema(TypedDict, total=False):
     computed_fields: list[ComputedField]
     strict: bool
     extras_schema: CoreSchema
-    # all these values can be set via config, equivalent fields have `typed_dict_` prefix
     extra_behavior: ExtraBehavior
-    populate_by_name: bool  # replaces `allow_population_by_field_name` in pydantic v1
     from_attributes: bool
     ref: str
     metadata: dict[str, Any]
@@ -3026,7 +3023,6 @@ def model_fields_schema(
     strict: bool | None = None,
     extras_schema: CoreSchema | None = None,
     extra_behavior: ExtraBehavior | None = None,
-    populate_by_name: bool | None = None,
     from_attributes: bool | None = None,
     ref: str | None = None,
     metadata: dict[str, Any] | None = None,
@@ -3055,7 +3051,6 @@ def model_fields_schema(
         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
         extra_behavior: The extra behavior to use for the typed dict
-        populate_by_name: Whether the typed dict should populate by name
         from_attributes: Whether the typed dict should be populated from attributes
         serialization: Custom serialization schema
     """
@@ -3067,7 +3062,6 @@ def model_fields_schema(
         strict=strict,
         extras_schema=extras_schema,
         extra_behavior=extra_behavior,
-        populate_by_name=populate_by_name,
         from_attributes=from_attributes,
         ref=ref,
         metadata=metadata,
@@ -3251,7 +3245,6 @@ class DataclassArgsSchema(TypedDict, total=False):
     dataclass_name: Required[str]
     fields: Required[list[DataclassField]]
     computed_fields: list[ComputedField]
-    populate_by_name: bool  # default: False
     collect_init_only: bool  # default: False
     ref: str
     metadata: dict[str, Any]
@@ -3264,7 +3257,6 @@ def dataclass_args_schema(
     fields: list[DataclassField],
     *,
     computed_fields: list[ComputedField] | None = None,
-    populate_by_name: bool | None = None,
     collect_init_only: bool | None = None,
     ref: str | None = None,
     metadata: dict[str, Any] | None = None,
@@ -3292,7 +3284,6 @@ def dataclass_args_schema(
         dataclass_name: The name of the dataclass being validated
         fields: The fields to use for the dataclass
         computed_fields: Computed fields to use when serializing the dataclass
-        populate_by_name: Whether to populate by name
         collect_init_only: Whether to collect init only fields into a dict to pass to `__post_init__`
         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
@@ -3304,7 +3295,6 @@ def dataclass_args_schema(
         dataclass_name=dataclass_name,
         fields=fields,
         computed_fields=computed_fields,
-        populate_by_name=populate_by_name,
         collect_init_only=collect_init_only,
         ref=ref,
         metadata=metadata,
@@ -3433,7 +3423,8 @@ def arguments_parameter(
 class ArgumentsSchema(TypedDict, total=False):
     type: Required[Literal['arguments']]
     arguments_schema: Required[list[ArgumentsParameter]]
-    populate_by_name: bool
+    validate_by_name: bool
+    validate_by_alias: bool
     var_args_schema: CoreSchema
     var_kwargs_mode: VarKwargsMode
     var_kwargs_schema: CoreSchema
@@ -3445,7 +3436,8 @@ class ArgumentsSchema(TypedDict, total=False):
 def arguments_schema(
     arguments: list[ArgumentsParameter],
     *,
-    populate_by_name: bool | None = None,
+    validate_by_name: bool | None = None,
+    validate_by_alias: bool | None = None,
     var_args_schema: CoreSchema | None = None,
     var_kwargs_mode: VarKwargsMode | None = None,
     var_kwargs_schema: CoreSchema | None = None,
@@ -3472,7 +3464,8 @@ def arguments_schema(
 
     Args:
         arguments: The arguments to use for the arguments schema
-        populate_by_name: Whether to populate by name
+        validate_by_name: Whether to populate by the parameter names, defaults to `False`.
+        validate_by_alias: Whether to populate by the parameter aliases, defaults to `True`.
         var_args_schema: The variable args schema to use for the arguments schema
         var_kwargs_mode: The validation mode to use for variadic keyword arguments. If `'uniform'`, every value of the
             keyword arguments will be validated against the `var_kwargs_schema` schema. If `'unpacked-typed-dict'`,
@@ -3485,7 +3478,8 @@ def arguments_schema(
     return _dict_not_none(
         type='arguments',
         arguments_schema=arguments,
-        populate_by_name=populate_by_name,
+        validate_by_name=validate_by_name,
+        validate_by_alias=validate_by_alias,
         var_args_schema=var_args_schema,
         var_kwargs_mode=var_kwargs_mode,
         var_kwargs_schema=var_kwargs_schema,
diff --git a/src/errors/validation_exception.rs b/src/errors/validation_exception.rs
index 2ce752b42..16e89eb68 100644
--- a/src/errors/validation_exception.rs
+++ b/src/errors/validation_exception.rs
@@ -344,7 +344,7 @@ impl ValidationError {
         let extra = state.extra(
             py,
             &SerMode::Json,
-            true,
+            None,
             false,
             false,
             true,
diff --git a/src/lookup_key.rs b/src/lookup_key.rs
index c83a00583..9b06db8fa 100644
--- a/src/lookup_key.rs
+++ b/src/lookup_key.rs
@@ -577,3 +577,47 @@ fn py_get_attrs<'py>(obj: &Bound<'py, PyAny>, attr_name: &Py<PyString>) -> PyRes
         }
     }
 }
+
+#[derive(Debug)]
+#[allow(clippy::struct_field_names)]
+pub struct LookupKeyCollection {
+    by_name: LookupKey,
+    by_alias: Option<LookupKey>,
+    by_alias_then_name: Option<LookupKey>,
+}
+
+impl LookupKeyCollection {
+    pub fn new(py: Python, validation_alias: Option<Bound<'_, PyAny>>, field_name: &str) -> PyResult<Self> {
+        let by_name = LookupKey::from_string(py, field_name);
+
+        if let Some(va) = validation_alias {
+            let by_alias = Some(LookupKey::from_py(py, &va, None)?);
+            let by_alias_then_name = Some(LookupKey::from_py(py, &va, Some(field_name))?);
+            Ok(Self {
+                by_name,
+                by_alias,
+                by_alias_then_name,
+            })
+        } else {
+            Ok(Self {
+                by_name,
+                by_alias: None,
+                by_alias_then_name: None,
+            })
+        }
+    }
+
+    pub fn select(&self, validate_by_alias: bool, validate_by_name: bool) -> PyResult<&LookupKey> {
+        let lookup_key_selection = match (validate_by_alias, validate_by_name) {
+            (true, true) => self.by_alias_then_name.as_ref().unwrap_or(&self.by_name),
+            (true, false) => self.by_alias.as_ref().unwrap_or(&self.by_name),
+            (false, true) => &self.by_name,
+            (false, false) => {
+                // Note: we shouldn't hit this branch much, as this is enforced in `pydantic` with a `PydanticUserError`
+                // at config creation time / validation function call time.
+                return py_schema_err!("`validate_by_name` and `validate_by_alias` cannot both be set to `False`.");
+            }
+        };
+        Ok(lookup_key_selection)
+    }
+}
diff --git a/src/serializers/computed_fields.rs b/src/serializers/computed_fields.rs
index 3f81a825c..6e6786d73 100644
--- a/src/serializers/computed_fields.rs
+++ b/src/serializers/computed_fields.rs
@@ -98,7 +98,7 @@ impl ComputedFields {
                     exclude: next_exclude.as_ref(),
                     extra: &field_extra,
                 };
-                let key = match extra.by_alias {
+                let key = match extra.serialize_by_alias_or(computed_field.serialize_by_alias) {
                     true => computed_field.alias.as_str(),
                     false => computed_field.property_name.as_str(),
                 };
@@ -116,6 +116,7 @@ struct ComputedField {
     serializer: CombinedSerializer,
     alias: String,
     alias_py: Py<PyString>,
+    serialize_by_alias: Option<bool>,
 }
 
 impl ComputedField {
@@ -139,6 +140,7 @@ impl ComputedField {
             serializer,
             alias: alias_py.extract()?,
             alias_py: alias_py.into(),
+            serialize_by_alias: config.get_as(intern!(py, "serialize_by_alias"))?,
         })
     }
 
@@ -163,7 +165,7 @@ impl ComputedField {
             if extra.exclude_none && value.is_none(py) {
                 return Ok(());
             }
-            let key = match extra.by_alias {
+            let key = match extra.serialize_by_alias_or(self.serialize_by_alias) {
                 true => self.alias_py.bind(py),
                 false => property_name_py,
             };
diff --git a/src/serializers/extra.rs b/src/serializers/extra.rs
index 295a2de18..a369859fb 100644
--- a/src/serializers/extra.rs
+++ b/src/serializers/extra.rs
@@ -84,7 +84,7 @@ impl SerializationState {
         &'py self,
         py: Python<'py>,
         mode: &'py SerMode,
-        by_alias: bool,
+        by_alias: Option<bool>,
         exclude_none: bool,
         round_trip: bool,
         serialize_unknown: bool,
@@ -122,7 +122,7 @@ pub(crate) struct Extra<'a> {
     pub mode: &'a SerMode,
     pub ob_type_lookup: &'a ObTypeLookup,
     pub warnings: &'a CollectWarnings,
-    pub by_alias: bool,
+    pub by_alias: Option<bool>,
     pub exclude_unset: bool,
     pub exclude_defaults: bool,
     pub exclude_none: bool,
@@ -147,7 +147,7 @@ impl<'a> Extra<'a> {
     pub fn new(
         py: Python<'a>,
         mode: &'a SerMode,
-        by_alias: bool,
+        by_alias: Option<bool>,
         warnings: &'a CollectWarnings,
         exclude_unset: bool,
         exclude_defaults: bool,
@@ -204,6 +204,10 @@ impl<'a> Extra<'a> {
     pub(crate) fn model_type_name(&self) -> Option<Bound<'a, PyString>> {
         self.model.and_then(|model| model.get_type().name().ok())
     }
+
+    pub fn serialize_by_alias_or(&self, serialize_by_alias: Option<bool>) -> bool {
+        self.by_alias.or(serialize_by_alias).unwrap_or(false)
+    }
 }
 
 #[derive(Clone, Copy, PartialEq, Eq)]
@@ -228,7 +232,7 @@ impl SerCheck {
 pub(crate) struct ExtraOwned {
     mode: SerMode,
     warnings: CollectWarnings,
-    by_alias: bool,
+    by_alias: Option<bool>,
     exclude_unset: bool,
     exclude_defaults: bool,
     exclude_none: bool,
diff --git a/src/serializers/fields.rs b/src/serializers/fields.rs
index 662ec936f..b0da9ba56 100644
--- a/src/serializers/fields.rs
+++ b/src/serializers/fields.rs
@@ -29,6 +29,7 @@ pub(super) struct SerField {
     // None serializer means exclude
     pub serializer: Option<CombinedSerializer>,
     pub required: bool,
+    pub serialize_by_alias: Option<bool>,
 }
 
 impl_py_gc_traverse!(SerField { serializer });
@@ -40,6 +41,7 @@ impl SerField {
         alias: Option<String>,
         serializer: Option<CombinedSerializer>,
         required: bool,
+        serialize_by_alias: Option<bool>,
     ) -> Self {
         let alias_py = alias.as_ref().map(|alias| PyString::new(py, alias.as_str()).into());
         Self {
@@ -48,11 +50,12 @@ impl SerField {
             alias_py,
             serializer,
             required,
+            serialize_by_alias,
         }
     }
 
     pub fn get_key_py<'py>(&self, py: Python<'py>, extra: &Extra) -> &Bound<'py, PyAny> {
-        if extra.by_alias {
+        if extra.serialize_by_alias_or(self.serialize_by_alias) {
             if let Some(ref alias_py) = self.alias_py {
                 return alias_py.bind(py);
             }
@@ -61,7 +64,7 @@ impl SerField {
     }
 
     pub fn get_key_json<'a>(&'a self, key_str: &'a str, extra: &Extra) -> Cow<'a, str> {
-        if extra.by_alias {
+        if extra.serialize_by_alias_or(self.serialize_by_alias) {
             if let Some(ref alias) = self.alias {
                 return Cow::Borrowed(alias.as_str());
             }
diff --git a/src/serializers/mod.rs b/src/serializers/mod.rs
index e652a75de..6ed496aab 100644
--- a/src/serializers/mod.rs
+++ b/src/serializers/mod.rs
@@ -54,7 +54,7 @@ impl SchemaSerializer {
         &'b self,
         py: Python<'a>,
         mode: &'a SerMode,
-        by_alias: bool,
+        by_alias: Option<bool>,
         warnings: &'a CollectWarnings,
         exclude_unset: bool,
         exclude_defaults: bool,
@@ -106,7 +106,7 @@ impl SchemaSerializer {
     }
 
     #[allow(clippy::too_many_arguments)]
-    #[pyo3(signature = (value, *, mode = None, include = None, exclude = None, by_alias = true,
+    #[pyo3(signature = (value, *, mode = None, include = None, exclude = None, by_alias = None,
         exclude_unset = false, exclude_defaults = false, exclude_none = false, round_trip = false, warnings = WarningsArg::Bool(true),
         fallback = None, serialize_as_any = false, context = None))]
     pub fn to_python(
@@ -116,7 +116,7 @@ impl SchemaSerializer {
         mode: Option<&str>,
         include: Option<&Bound<'_, PyAny>>,
         exclude: Option<&Bound<'_, PyAny>>,
-        by_alias: bool,
+        by_alias: Option<bool>,
         exclude_unset: bool,
         exclude_defaults: bool,
         exclude_none: bool,
@@ -155,7 +155,7 @@ impl SchemaSerializer {
     }
 
     #[allow(clippy::too_many_arguments)]
-    #[pyo3(signature = (value, *, indent = None, include = None, exclude = None, by_alias = true,
+    #[pyo3(signature = (value, *, indent = None, include = None, exclude = None, by_alias = None,
         exclude_unset = false, exclude_defaults = false, exclude_none = false, round_trip = false, warnings = WarningsArg::Bool(true),
         fallback = None, serialize_as_any = false, context = None))]
     pub fn to_json(
@@ -165,7 +165,7 @@ impl SchemaSerializer {
         indent: Option<usize>,
         include: Option<&Bound<'_, PyAny>>,
         exclude: Option<&Bound<'_, PyAny>>,
-        by_alias: bool,
+        by_alias: Option<bool>,
         exclude_unset: bool,
         exclude_defaults: bool,
         exclude_none: bool,
@@ -239,7 +239,7 @@ impl SchemaSerializer {
 
 #[allow(clippy::too_many_arguments)]
 #[pyfunction]
-#[pyo3(signature = (value, *, indent = None, include = None, exclude = None, by_alias = true,
+#[pyo3(signature = (value, *, indent = None, include = None, exclude = None, by_alias = None,
     exclude_none = false, round_trip = false, timedelta_mode = "iso8601", bytes_mode = "utf8",
     inf_nan_mode = "constants", serialize_unknown = false, fallback = None, serialize_as_any = false,
     context = None))]
@@ -249,7 +249,7 @@ pub fn to_json(
     indent: Option<usize>,
     include: Option<&Bound<'_, PyAny>>,
     exclude: Option<&Bound<'_, PyAny>>,
-    by_alias: bool,
+    by_alias: Option<bool>,
     exclude_none: bool,
     round_trip: bool,
     timedelta_mode: &str,
@@ -282,7 +282,7 @@ pub fn to_json(
 
 #[allow(clippy::too_many_arguments)]
 #[pyfunction]
-#[pyo3(signature = (value, *, include = None, exclude = None, by_alias = true, exclude_none = false, round_trip = false,
+#[pyo3(signature = (value, *, include = None, exclude = None, by_alias = None, exclude_none = false, round_trip = false,
     timedelta_mode = "iso8601", bytes_mode = "utf8", inf_nan_mode = "constants", serialize_unknown = false, fallback = None,
     serialize_as_any = false, context = None))]
 pub fn to_jsonable_python(
@@ -290,7 +290,7 @@ pub fn to_jsonable_python(
     value: &Bound<'_, PyAny>,
     include: Option<&Bound<'_, PyAny>>,
     exclude: Option<&Bound<'_, PyAny>>,
-    by_alias: bool,
+    by_alias: Option<bool>,
     exclude_none: bool,
     round_trip: bool,
     timedelta_mode: &str,
diff --git a/src/serializers/type_serializers/dataclass.rs b/src/serializers/type_serializers/dataclass.rs
index 5b3c425df..a080a9b4f 100644
--- a/src/serializers/type_serializers/dataclass.rs
+++ b/src/serializers/type_serializers/dataclass.rs
@@ -37,6 +37,8 @@ impl BuildSerializer for DataclassArgsBuilder {
             _ => FieldsMode::SimpleDict,
         };
 
+        let serialize_by_alias = config.get_as(intern!(py, "serialize_by_alias"))?;
+
         for (index, item) in fields_list.iter().enumerate() {
             let field_info = item.downcast::<PyDict>()?;
             let name: String = field_info.get_as_req(intern!(py, "name"))?;
@@ -45,14 +47,17 @@ impl BuildSerializer for DataclassArgsBuilder {
 
             if !field_info.get_as(intern!(py, "init_only"))?.unwrap_or(false) {
                 if field_info.get_as(intern!(py, "serialization_exclude"))? == Some(true) {
-                    fields.insert(name, SerField::new(py, key_py, None, None, true));
+                    fields.insert(name, SerField::new(py, key_py, None, None, true, serialize_by_alias));
                 } else {
                     let schema = field_info.get_as_req(intern!(py, "schema"))?;
                     let serializer = CombinedSerializer::build(&schema, config, definitions)
                         .map_err(|e| py_schema_error_type!("Field `{}`:\n  {}", index, e))?;
 
                     let alias = field_info.get_as(intern!(py, "serialization_alias"))?;
-                    fields.insert(name, SerField::new(py, key_py, alias, Some(serializer), true));
+                    fields.insert(
+                        name,
+                        SerField::new(py, key_py, alias, Some(serializer), true, serialize_by_alias),
+                    );
                 }
             }
         }
diff --git a/src/serializers/type_serializers/function.rs b/src/serializers/type_serializers/function.rs
index 3aac20d7c..79317035d 100644
--- a/src/serializers/type_serializers/function.rs
+++ b/src/serializers/type_serializers/function.rs
@@ -547,7 +547,7 @@ struct SerializationInfo {
     #[pyo3(get, name = "mode")]
     _mode: SerMode,
     #[pyo3(get)]
-    by_alias: bool,
+    by_alias: Option<bool>,
     #[pyo3(get)]
     exclude_unset: bool,
     #[pyo3(get)]
@@ -668,7 +668,7 @@ impl SerializationInfo {
                 None => "None".to_owned(),
             },
             self._mode,
-            py_bool(self.by_alias),
+            py_bool(self.by_alias.unwrap_or(false)),
             py_bool(self.exclude_unset),
             py_bool(self.exclude_defaults),
             py_bool(self.exclude_none),
diff --git a/src/serializers/type_serializers/model.rs b/src/serializers/type_serializers/model.rs
index 198032ed4..274fb48a0 100644
--- a/src/serializers/type_serializers/model.rs
+++ b/src/serializers/type_serializers/model.rs
@@ -47,6 +47,8 @@ impl BuildSerializer for ModelFieldsBuilder {
             (_, _) => None,
         };
 
+        let serialize_by_alias = config.get_as(intern!(py, "serialize_by_alias"))?;
+
         for (key, value) in fields_dict {
             let key_py = key.downcast_into::<PyString>()?;
             let key: String = key_py.extract()?;
@@ -55,7 +57,7 @@ impl BuildSerializer for ModelFieldsBuilder {
             let key_py: Py<PyString> = key_py.into();
 
             if field_info.get_as(intern!(py, "serialization_exclude"))? == Some(true) {
-                fields.insert(key, SerField::new(py, key_py, None, None, true));
+                fields.insert(key, SerField::new(py, key_py, None, None, true, serialize_by_alias));
             } else {
                 let alias: Option<String> = field_info.get_as(intern!(py, "serialization_alias"))?;
 
@@ -63,7 +65,10 @@ impl BuildSerializer for ModelFieldsBuilder {
                 let serializer = CombinedSerializer::build(&schema, config, definitions)
                     .map_err(|e| py_schema_error_type!("Field `{}`:\n  {}", key, e))?;
 
-                fields.insert(key, SerField::new(py, key_py, alias, Some(serializer), true));
+                fields.insert(
+                    key,
+                    SerField::new(py, key_py, alias, Some(serializer), true, serialize_by_alias),
+                );
             }
         }
 
diff --git a/src/serializers/type_serializers/typed_dict.rs b/src/serializers/type_serializers/typed_dict.rs
index e80a9e9b3..d93a88550 100644
--- a/src/serializers/type_serializers/typed_dict.rs
+++ b/src/serializers/type_serializers/typed_dict.rs
@@ -32,6 +32,8 @@ impl BuildSerializer for TypedDictBuilder {
             _ => FieldsMode::SimpleDict,
         };
 
+        let serialize_by_alias = config.get_as(intern!(py, "serialize_by_alias"))?;
+
         let fields_dict: Bound<'_, PyDict> = schema.get_as_req(intern!(py, "fields"))?;
         let mut fields: AHashMap<String, SerField> = AHashMap::with_capacity(fields_dict.len());
 
@@ -52,14 +54,17 @@ impl BuildSerializer for TypedDictBuilder {
             let required = field_info.get_as(intern!(py, "required"))?.unwrap_or(total);
 
             if field_info.get_as(intern!(py, "serialization_exclude"))? == Some(true) {
-                fields.insert(key, SerField::new(py, key_py, None, None, required));
+                fields.insert(key, SerField::new(py, key_py, None, None, required, serialize_by_alias));
             } else {
                 let alias: Option<String> = field_info.get_as(intern!(py, "serialization_alias"))?;
 
                 let schema = field_info.get_as_req(intern!(py, "schema"))?;
                 let serializer = CombinedSerializer::build(&schema, config, definitions)
                     .map_err(|e| py_schema_error_type!("Field `{}`:\n  {}", key, e))?;
-                fields.insert(key, SerField::new(py, key_py, alias, Some(serializer), required));
+                fields.insert(
+                    key,
+                    SerField::new(py, key_py, alias, Some(serializer), required, serialize_by_alias),
+                );
             }
         }
 
diff --git a/src/url.rs b/src/url.rs
index 692ac80c2..8d31fb27e 100644
--- a/src/url.rs
+++ b/src/url.rs
@@ -45,7 +45,7 @@ impl PyUrl {
     pub fn py_new(py: Python, url: &Bound<'_, PyAny>) -> PyResult<Self> {
         let schema_obj = SCHEMA_DEFINITION_URL
             .get_or_init(py, || build_schema_validator(py, "url"))
-            .validate_python(py, url, None, None, None, None, false.into())?;
+            .validate_python(py, url, None, None, None, None, false.into(), None, None)?;
         schema_obj.extract(py)
     }
 
@@ -225,7 +225,7 @@ impl PyMultiHostUrl {
     pub fn py_new(py: Python, url: &Bound<'_, PyAny>) -> PyResult<Self> {
         let schema_obj = SCHEMA_DEFINITION_MULTI_HOST_URL
             .get_or_init(py, || build_schema_validator(py, "multi-host-url"))
-            .validate_python(py, url, None, None, None, None, false.into())?;
+            .validate_python(py, url, None, None, None, None, false.into(), None, None)?;
         schema_obj.extract(py)
     }
 
diff --git a/src/validators/arguments.rs b/src/validators/arguments.rs
index ef129610a..7c397d69f 100644
--- a/src/validators/arguments.rs
+++ b/src/validators/arguments.rs
@@ -11,7 +11,7 @@ use crate::build_tools::py_schema_err;
 use crate::build_tools::{schema_or_config_same, ExtraBehavior};
 use crate::errors::{ErrorTypeDefaults, ValError, ValLineError, ValResult};
 use crate::input::{Arguments, BorrowInput, Input, KeywordArgs, PositionalArgs, ValidationMatch};
-use crate::lookup_key::LookupKey;
+use crate::lookup_key::LookupKeyCollection;
 use crate::tools::SchemaDict;
 
 use super::validation_state::ValidationState;
@@ -42,9 +42,10 @@ impl FromStr for VarKwargsMode {
 struct Parameter {
     positional: bool,
     name: String,
-    kw_lookup_key: Option<LookupKey>,
     kwarg_key: Option<Py<PyString>>,
     validator: CombinedValidator,
+    lookup_key_collection: LookupKeyCollection,
+    mode: String,
 }
 
 #[derive(Debug)]
@@ -56,6 +57,8 @@ pub struct ArgumentsValidator {
     var_kwargs_validator: Option<Box<CombinedValidator>>,
     loc_by_alias: bool,
     extra: ExtraBehavior,
+    validate_by_alias: Option<bool>,
+    validate_by_name: Option<bool>,
 }
 
 impl BuildValidator for ArgumentsValidator {
@@ -68,8 +71,6 @@ impl BuildValidator for ArgumentsValidator {
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
 
-        let populate_by_name = schema_or_config_same(schema, config, intern!(py, "populate_by_name"))?.unwrap_or(false);
-
         let arguments_schema: Bound<'_, PyList> = schema.get_as_req(intern!(py, "arguments_schema"))?;
         let mut parameters: Vec<Parameter> = Vec::with_capacity(arguments_schema.len());
 
@@ -97,18 +98,11 @@ impl BuildValidator for ArgumentsValidator {
                 had_keyword_only = true;
             }
 
-            let mut kw_lookup_key = None;
-            let mut kwarg_key = None;
-            if mode == "keyword_only" || mode == "positional_or_keyword" {
-                kw_lookup_key = match arg.get_item(intern!(py, "alias"))? {
-                    Some(alias) => {
-                        let alt_alias = if populate_by_name { Some(name.as_str()) } else { None };
-                        Some(LookupKey::from_py(py, &alias, alt_alias)?)
-                    }
-                    None => Some(LookupKey::from_string(py, &name)),
-                };
-                kwarg_key = Some(py_name.unbind());
-            }
+            let kwarg_key = if matches!(mode, "keyword_only" | "positional_or_keyword") {
+                Some(py_name.unbind())
+            } else {
+                None
+            };
 
             let schema = arg.get_as_req(intern!(py, "schema"))?;
 
@@ -132,12 +126,17 @@ impl BuildValidator for ArgumentsValidator {
             } else if has_default {
                 had_default_arg = true;
             }
+
+            let validation_alias = arg.get_item(intern!(py, "alias"))?;
+            let lookup_key_collection = LookupKeyCollection::new(py, validation_alias, name.as_str())?;
+
             parameters.push(Parameter {
                 positional,
                 name,
-                kw_lookup_key,
                 kwarg_key,
                 validator,
+                lookup_key_collection,
+                mode: mode.to_string(),
             });
         }
 
@@ -168,6 +167,8 @@ impl BuildValidator for ArgumentsValidator {
             var_kwargs_validator,
             loc_by_alias: config.get_as(intern!(py, "loc_by_alias"))?.unwrap_or(true),
             extra: ExtraBehavior::from_schema_or_config(py, schema, config, ExtraBehavior::Forbid)?,
+            validate_by_alias: schema_or_config_same(schema, config, intern!(py, "validate_by_alias"))?,
+            validate_by_name: schema_or_config_same(schema, config, intern!(py, "validate_by_name"))?,
         }
         .into())
     }
@@ -198,6 +199,9 @@ impl Validator for ArgumentsValidator {
         let mut errors: Vec<ValLineError> = Vec::new();
         let mut used_kwargs: AHashSet<&str> = AHashSet::with_capacity(self.parameters.len());
 
+        let validate_by_alias = state.validate_by_alias_or(self.validate_by_alias);
+        let validate_by_name = state.validate_by_name_or(self.validate_by_name);
+
         // go through arguments getting the value from args or kwargs and validating it
         for (index, parameter) in self.parameters.iter().enumerate() {
             let mut pos_value = None;
@@ -207,8 +211,17 @@ impl Validator for ArgumentsValidator {
                 }
             }
             let mut kw_value = None;
+            let mut kw_lookup_key = None;
+            if matches!(parameter.mode.as_str(), "keyword_only" | "positional_or_keyword") {
+                kw_lookup_key = Some(
+                    parameter
+                        .lookup_key_collection
+                        .select(validate_by_alias, validate_by_name)?,
+                );
+            }
+
             if let Some(kwargs) = args.kwargs() {
-                if let Some(ref lookup_key) = parameter.kw_lookup_key {
+                if let Some(lookup_key) = kw_lookup_key {
                     if let Some((lookup_path, value)) = kwargs.get_item(lookup_key)? {
                         used_kwargs.insert(lookup_path.first_key());
                         kw_value = Some((lookup_path, value));
@@ -254,7 +267,7 @@ impl Validator for ArgumentsValidator {
                         } else {
                             output_args.push(value);
                         }
-                    } else if let Some(ref lookup_key) = parameter.kw_lookup_key {
+                    } else if let Some(lookup_key) = kw_lookup_key {
                         let error_type = if parameter.positional {
                             ErrorTypeDefaults::MissingArgument
                         } else {
diff --git a/src/validators/dataclass.rs b/src/validators/dataclass.rs
index a774c6c9a..69c8279ea 100644
--- a/src/validators/dataclass.rs
+++ b/src/validators/dataclass.rs
@@ -12,7 +12,7 @@ use crate::errors::{ErrorType, ErrorTypeDefaults, ValError, ValLineError, ValRes
 use crate::input::{
     input_as_python_instance, Arguments, BorrowInput, Input, InputType, KeywordArgs, PositionalArgs, ValidationMatch,
 };
-use crate::lookup_key::LookupKey;
+use crate::lookup_key::LookupKeyCollection;
 use crate::tools::SchemaDict;
 use crate::validators::function::convert_err;
 
@@ -27,7 +27,7 @@ struct Field {
     py_name: Py<PyString>,
     init: bool,
     init_only: bool,
-    lookup_key: LookupKey,
+    lookup_key_collection: LookupKeyCollection,
     validator: CombinedValidator,
     frozen: bool,
 }
@@ -42,6 +42,8 @@ pub struct DataclassArgsValidator {
     extra_behavior: ExtraBehavior,
     extras_validator: Option<Box<CombinedValidator>>,
     loc_by_alias: bool,
+    validate_by_alias: Option<bool>,
+    validate_by_name: Option<bool>,
 }
 
 impl BuildValidator for DataclassArgsValidator {
@@ -54,8 +56,6 @@ impl BuildValidator for DataclassArgsValidator {
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
 
-        let populate_by_name = schema_or_config_same(schema, config, intern!(py, "populate_by_name"))?.unwrap_or(false);
-
         let extra_behavior = ExtraBehavior::from_schema_or_config(py, schema, config, ExtraBehavior::Ignore)?;
 
         let extras_validator = match (schema.get_item(intern!(py, "extras_schema"))?, &extra_behavior) {
@@ -75,14 +75,6 @@ impl BuildValidator for DataclassArgsValidator {
             let py_name: Bound<'_, PyString> = field.get_as_req(intern!(py, "name"))?;
             let name: String = py_name.extract()?;
 
-            let lookup_key = match field.get_item(intern!(py, "validation_alias"))? {
-                Some(alias) => {
-                    let alt_alias = if populate_by_name { Some(name.as_str()) } else { None };
-                    LookupKey::from_py(py, &alias, alt_alias)?
-                }
-                None => LookupKey::from_string(py, &name),
-            };
-
             let schema = field.get_as_req(intern!(py, "schema"))?;
 
             let validator = match build_validator(&schema, config, definitions) {
@@ -101,11 +93,14 @@ impl BuildValidator for DataclassArgsValidator {
                 positional_count += 1;
             }
 
+            let validation_alias = field.get_item(intern!(py, "validation_alias"))?;
+            let lookup_key_collection = LookupKeyCollection::new(py, validation_alias, name.as_str())?;
+
             fields.push(Field {
                 kw_only,
                 name,
                 py_name: py_name.into(),
-                lookup_key,
+                lookup_key_collection,
                 validator,
                 init: field.get_as(intern!(py, "init"))?.unwrap_or(true),
                 init_only: field.get_as(intern!(py, "init_only"))?.unwrap_or(false),
@@ -130,6 +125,8 @@ impl BuildValidator for DataclassArgsValidator {
             extra_behavior,
             extras_validator,
             loc_by_alias: config.get_as(intern!(py, "loc_by_alias"))?.unwrap_or(true),
+            validate_by_alias: config.get_as(intern!(py, "validate_by_alias"))?,
+            validate_by_name: config.get_as(intern!(py, "validate_by_name"))?,
         }
         .into())
     }
@@ -158,6 +155,10 @@ impl Validator for DataclassArgsValidator {
         let mut used_keys: AHashSet<&str> = AHashSet::with_capacity(self.fields.len());
 
         let state = &mut state.rebind_extra(|extra| extra.data = Some(output_dict.clone()));
+
+        let validate_by_alias = state.validate_by_alias_or(self.validate_by_alias);
+        let validate_by_name = state.validate_by_name_or(self.validate_by_name);
+
         let mut fields_set_count: usize = 0;
 
         macro_rules! set_item {
@@ -200,9 +201,13 @@ impl Validator for DataclassArgsValidator {
                 }
             }
 
+            let lookup_key = field
+                .lookup_key_collection
+                .select(validate_by_alias, validate_by_name)?;
+
             let mut kw_value = None;
             if let Some(kwargs) = args.kwargs() {
-                if let Some((lookup_path, value)) = kwargs.get_item(&field.lookup_key)? {
+                if let Some((lookup_path, value)) = kwargs.get_item(lookup_key)? {
                     used_keys.insert(lookup_path.first_key());
                     kw_value = Some((lookup_path, value));
                 }
@@ -253,7 +258,7 @@ impl Validator for DataclassArgsValidator {
                         }
                         Ok(None) => {
                             // This means there was no default value
-                            errors.push(field.lookup_key.error(
+                            errors.push(lookup_key.error(
                                 ErrorTypeDefaults::Missing,
                                 input,
                                 self.loc_by_alias,
diff --git a/src/validators/generator.rs b/src/validators/generator.rs
index 5e1b21c80..bc0cbd82a 100644
--- a/src/validators/generator.rs
+++ b/src/validators/generator.rs
@@ -279,6 +279,8 @@ impl InternalValidator {
             context: self.context.as_ref().map(|data| data.bind(py)),
             self_instance: self.self_instance.as_ref().map(|data| data.bind(py)),
             cache_str: self.cache_str,
+            by_alias: None,
+            by_name: None,
         };
         let mut state = ValidationState::new(extra, &mut self.recursion_guard, false.into());
         state.exactness = self.exactness;
@@ -314,6 +316,8 @@ impl InternalValidator {
             context: self.context.as_ref().map(|data| data.bind(py)),
             self_instance: self.self_instance.as_ref().map(|data| data.bind(py)),
             cache_str: self.cache_str,
+            by_alias: None,
+            by_name: None,
         };
         let mut state = ValidationState::new(extra, &mut self.recursion_guard, false.into());
         state.exactness = self.exactness;
diff --git a/src/validators/mod.rs b/src/validators/mod.rs
index 75f39df29..4e40bf080 100644
--- a/src/validators/mod.rs
+++ b/src/validators/mod.rs
@@ -164,7 +164,7 @@ impl SchemaValidator {
     }
 
     #[allow(clippy::too_many_arguments)]
-    #[pyo3(signature = (input, *, strict=None, from_attributes=None, context=None, self_instance=None, allow_partial=PartialMode::Off))]
+    #[pyo3(signature = (input, *, strict=None, from_attributes=None, context=None, self_instance=None, allow_partial=PartialMode::Off, by_alias=None, by_name=None))]
     pub fn validate_python(
         &self,
         py: Python,
@@ -174,6 +174,8 @@ impl SchemaValidator {
         context: Option<&Bound<'_, PyAny>>,
         self_instance: Option<&Bound<'_, PyAny>>,
         allow_partial: PartialMode,
+        by_alias: Option<bool>,
+        by_name: Option<bool>,
     ) -> PyResult<PyObject> {
         #[allow(clippy::used_underscore_items)]
         self._validate(
@@ -185,11 +187,14 @@ impl SchemaValidator {
             context,
             self_instance,
             allow_partial,
+            by_alias,
+            by_name,
         )
         .map_err(|e| self.prepare_validation_err(py, e, InputType::Python))
     }
 
-    #[pyo3(signature = (input, *, strict=None, from_attributes=None, context=None, self_instance=None))]
+    #[allow(clippy::too_many_arguments)]
+    #[pyo3(signature = (input, *, strict=None, from_attributes=None, context=None, self_instance=None, by_alias=None, by_name=None))]
     pub fn isinstance_python(
         &self,
         py: Python,
@@ -198,6 +203,8 @@ impl SchemaValidator {
         from_attributes: Option<bool>,
         context: Option<&Bound<'_, PyAny>>,
         self_instance: Option<&Bound<'_, PyAny>>,
+        by_alias: Option<bool>,
+        by_name: Option<bool>,
     ) -> PyResult<bool> {
         #[allow(clippy::used_underscore_items)]
         match self._validate(
@@ -209,6 +216,8 @@ impl SchemaValidator {
             context,
             self_instance,
             false.into(),
+            by_alias,
+            by_name,
         ) {
             Ok(_) => Ok(true),
             Err(ValError::InternalErr(err)) => Err(err),
@@ -218,7 +227,8 @@ impl SchemaValidator {
         }
     }
 
-    #[pyo3(signature = (input, *, strict=None, context=None, self_instance=None, allow_partial=PartialMode::Off))]
+    #[allow(clippy::too_many_arguments)]
+    #[pyo3(signature = (input, *, strict=None, context=None, self_instance=None, allow_partial=PartialMode::Off, by_alias=None, by_name=None))]
     pub fn validate_json(
         &self,
         py: Python,
@@ -227,6 +237,8 @@ impl SchemaValidator {
         context: Option<&Bound<'_, PyAny>>,
         self_instance: Option<&Bound<'_, PyAny>>,
         allow_partial: PartialMode,
+        by_alias: Option<bool>,
+        by_name: Option<bool>,
     ) -> PyResult<PyObject> {
         let r = match json::validate_json_bytes(input) {
             #[allow(clippy::used_underscore_items)]
@@ -238,13 +250,16 @@ impl SchemaValidator {
                 context,
                 self_instance,
                 allow_partial,
+                by_alias,
+                by_name,
             ),
             Err(err) => Err(err),
         };
         r.map_err(|e| self.prepare_validation_err(py, e, InputType::Json))
     }
 
-    #[pyo3(signature = (input, *, strict=None, context=None, allow_partial=PartialMode::Off))]
+    #[allow(clippy::too_many_arguments)]
+    #[pyo3(signature = (input, *, strict=None, context=None, allow_partial=PartialMode::Off, by_alias=None, by_name=None))]
     pub fn validate_strings(
         &self,
         py: Python,
@@ -252,19 +267,32 @@ impl SchemaValidator {
         strict: Option<bool>,
         context: Option<&Bound<'_, PyAny>>,
         allow_partial: PartialMode,
+        by_alias: Option<bool>,
+        by_name: Option<bool>,
     ) -> PyResult<PyObject> {
         let t = InputType::String;
         let string_mapping = StringMapping::new_value(input).map_err(|e| self.prepare_validation_err(py, e, t))?;
 
         #[allow(clippy::used_underscore_items)]
-        match self._validate(py, &string_mapping, t, strict, None, context, None, allow_partial) {
+        match self._validate(
+            py,
+            &string_mapping,
+            t,
+            strict,
+            None,
+            context,
+            None,
+            allow_partial,
+            by_alias,
+            by_name,
+        ) {
             Ok(r) => Ok(r),
             Err(e) => Err(self.prepare_validation_err(py, e, t)),
         }
     }
 
     #[allow(clippy::too_many_arguments)]
-    #[pyo3(signature = (obj, field_name, field_value, *, strict=None, from_attributes=None, context=None))]
+    #[pyo3(signature = (obj, field_name, field_value, *, strict=None, from_attributes=None, context=None, by_alias=None, by_name=None))]
     pub fn validate_assignment(
         &self,
         py: Python,
@@ -274,6 +302,8 @@ impl SchemaValidator {
         strict: Option<bool>,
         from_attributes: Option<bool>,
         context: Option<&Bound<'_, PyAny>>,
+        by_alias: Option<bool>,
+        by_name: Option<bool>,
     ) -> PyResult<PyObject> {
         let extra = Extra {
             input_type: InputType::Python,
@@ -283,6 +313,8 @@ impl SchemaValidator {
             context,
             self_instance: None,
             cache_str: self.cache_str,
+            by_alias,
+            by_name,
         };
 
         let guard = &mut RecursionState::default();
@@ -307,6 +339,8 @@ impl SchemaValidator {
             context,
             self_instance: None,
             cache_str: self.cache_str,
+            by_alias: None,
+            by_name: None,
         };
         let recursion_guard = &mut RecursionState::default();
         let mut state = ValidationState::new(extra, recursion_guard, false.into());
@@ -356,6 +390,8 @@ impl SchemaValidator {
         context: Option<&Bound<'py, PyAny>>,
         self_instance: Option<&Bound<'py, PyAny>>,
         allow_partial: PartialMode,
+        by_alias: Option<bool>,
+        by_name: Option<bool>,
     ) -> ValResult<PyObject> {
         let mut recursion_guard = RecursionState::default();
         let mut state = ValidationState::new(
@@ -366,6 +402,8 @@ impl SchemaValidator {
                 self_instance,
                 input_type,
                 self.cache_str,
+                by_alias,
+                by_name,
             ),
             &mut recursion_guard,
             allow_partial,
@@ -383,6 +421,8 @@ impl SchemaValidator {
         context: Option<&Bound<'_, PyAny>>,
         self_instance: Option<&Bound<'_, PyAny>>,
         allow_partial: PartialMode,
+        by_alias: Option<bool>,
+        by_name: Option<bool>,
     ) -> ValResult<PyObject> {
         let json_value = jiter::JsonValue::parse_with_config(json_data, true, allow_partial)
             .map_err(|e| json::map_json_err(input, e, json_data))?;
@@ -396,6 +436,8 @@ impl SchemaValidator {
             context,
             self_instance,
             allow_partial,
+            by_alias,
+            by_name,
         )
     }
 
@@ -432,7 +474,7 @@ impl<'py> SelfValidator<'py> {
         let py = schema.py();
         let mut recursion_guard = RecursionState::default();
         let mut state = ValidationState::new(
-            Extra::new(strict, None, None, None, InputType::Python, true.into()),
+            Extra::new(strict, None, None, None, InputType::Python, true.into(), None, None),
             &mut recursion_guard,
             false.into(),
         );
@@ -638,9 +680,14 @@ pub struct Extra<'a, 'py> {
     self_instance: Option<&'a Bound<'py, PyAny>>,
     /// Whether to use a cache of short strings to accelerate python string construction
     cache_str: StringCacheMode,
+    /// Whether to use the field's alias to match the input data to an attribute.
+    by_alias: Option<bool>,
+    /// Whether to use the field's name to match the input data to an attribute.
+    by_name: Option<bool>,
 }
 
 impl<'a, 'py> Extra<'a, 'py> {
+    #[allow(clippy::too_many_arguments)]
     pub fn new(
         strict: Option<bool>,
         from_attributes: Option<bool>,
@@ -648,6 +695,8 @@ impl<'a, 'py> Extra<'a, 'py> {
         self_instance: Option<&'a Bound<'py, PyAny>>,
         input_type: InputType,
         cache_str: StringCacheMode,
+        by_alias: Option<bool>,
+        by_name: Option<bool>,
     ) -> Self {
         Extra {
             input_type,
@@ -657,6 +706,8 @@ impl<'a, 'py> Extra<'a, 'py> {
             context,
             self_instance,
             cache_str,
+            by_alias,
+            by_name,
         }
     }
 }
@@ -671,6 +722,8 @@ impl Extra<'_, '_> {
             context: self.context,
             self_instance: self.self_instance,
             cache_str: self.cache_str,
+            by_alias: self.by_alias,
+            by_name: self.by_name,
         }
     }
 }
diff --git a/src/validators/model_fields.rs b/src/validators/model_fields.rs
index 392760964..1ef684890 100644
--- a/src/validators/model_fields.rs
+++ b/src/validators/model_fields.rs
@@ -12,7 +12,7 @@ use crate::errors::LocItem;
 use crate::errors::{ErrorType, ErrorTypeDefaults, ValError, ValLineError, ValResult};
 use crate::input::ConsumeIterator;
 use crate::input::{BorrowInput, Input, ValidatedDict, ValidationMatch};
-use crate::lookup_key::LookupKey;
+use crate::lookup_key::LookupKeyCollection;
 use crate::tools::SchemaDict;
 
 use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
@@ -20,7 +20,7 @@ use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuild
 #[derive(Debug)]
 struct Field {
     name: String,
-    lookup_key: LookupKey,
+    lookup_key_collection: LookupKeyCollection,
     name_py: Py<PyString>,
     validator: CombinedValidator,
     frozen: bool,
@@ -37,6 +37,8 @@ pub struct ModelFieldsValidator {
     strict: bool,
     from_attributes: bool,
     loc_by_alias: bool,
+    validate_by_alias: Option<bool>,
+    validate_by_name: Option<bool>,
 }
 
 impl BuildValidator for ModelFieldsValidator {
@@ -48,10 +50,10 @@ impl BuildValidator for ModelFieldsValidator {
         definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
+
         let strict = is_strict(schema, config)?;
 
         let from_attributes = schema_or_config_same(schema, config, intern!(py, "from_attributes"))?.unwrap_or(false);
-        let populate_by_name = schema_or_config_same(schema, config, intern!(py, "populate_by_name"))?.unwrap_or(false);
 
         let extra_behavior = ExtraBehavior::from_schema_or_config(py, schema, config, ExtraBehavior::Ignore)?;
 
@@ -79,17 +81,12 @@ impl BuildValidator for ModelFieldsValidator {
                 Err(err) => return py_schema_err!("Field \"{}\":\n  {}", field_name, err),
             };
 
-            let lookup_key = match field_info.get_item(intern!(py, "validation_alias"))? {
-                Some(alias) => {
-                    let alt_alias = if populate_by_name { Some(field_name) } else { None };
-                    LookupKey::from_py(py, &alias, alt_alias)?
-                }
-                None => LookupKey::from_string(py, field_name),
-            };
+            let validation_alias = field_info.get_item(intern!(py, "validation_alias"))?;
+            let lookup_key_collection = LookupKeyCollection::new(py, validation_alias, field_name)?;
 
             fields.push(Field {
                 name: field_name.to_string(),
-                lookup_key,
+                lookup_key_collection,
                 name_py: field_name_py.into(),
                 validator,
                 frozen: field_info.get_as::<bool>(intern!(py, "frozen"))?.unwrap_or(false),
@@ -104,6 +101,8 @@ impl BuildValidator for ModelFieldsValidator {
             strict,
             from_attributes,
             loc_by_alias: config.get_as(intern!(py, "loc_by_alias"))?.unwrap_or(true),
+            validate_by_alias: config.get_as(intern!(py, "validate_by_alias"))?,
+            validate_by_name: config.get_as(intern!(py, "validate_by_name"))?,
         }
         .into())
     }
@@ -156,6 +155,9 @@ impl Validator for ModelFieldsValidator {
         let mut fields_set_vec: Vec<Py<PyString>> = Vec::with_capacity(self.fields.len());
         let mut fields_set_count: usize = 0;
 
+        let validate_by_alias = state.validate_by_alias_or(self.validate_by_alias);
+        let validate_by_name = state.validate_by_name_or(self.validate_by_name);
+
         // we only care about which keys have been used if we're iterating over the object for extra after
         // the first pass
         let mut used_keys: Option<AHashSet<&str>> =
@@ -169,7 +171,10 @@ impl Validator for ModelFieldsValidator {
             let state = &mut state.rebind_extra(|extra| extra.data = Some(model_dict.clone()));
 
             for field in &self.fields {
-                let op_key_value = match dict.get_item(&field.lookup_key) {
+                let lookup_key = field
+                    .lookup_key_collection
+                    .select(validate_by_alias, validate_by_name)?;
+                let op_key_value = match dict.get_item(lookup_key) {
                     Ok(v) => v,
                     Err(ValError::LineErrors(line_errors)) => {
                         for err in line_errors {
@@ -209,7 +214,7 @@ impl Validator for ModelFieldsValidator {
                     }
                     Ok(None) => {
                         // This means there was no default value
-                        errors.push(field.lookup_key.error(
+                        errors.push(lookup_key.error(
                             ErrorTypeDefaults::Missing,
                             input,
                             self.loc_by_alias,
diff --git a/src/validators/typed_dict.rs b/src/validators/typed_dict.rs
index 3365c0169..999926762 100644
--- a/src/validators/typed_dict.rs
+++ b/src/validators/typed_dict.rs
@@ -3,14 +3,14 @@ use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyString};
 
 use crate::build_tools::py_schema_err;
-use crate::build_tools::{is_strict, schema_or_config, schema_or_config_same, ExtraBehavior};
+use crate::build_tools::{is_strict, schema_or_config, ExtraBehavior};
 use crate::errors::LocItem;
 use crate::errors::{ErrorTypeDefaults, ValError, ValLineError, ValResult};
 use crate::input::BorrowInput;
 use crate::input::ConsumeIterator;
 use crate::input::ValidationMatch;
 use crate::input::{Input, ValidatedDict};
-use crate::lookup_key::LookupKey;
+use crate::lookup_key::LookupKeyCollection;
 use crate::tools::SchemaDict;
 use ahash::AHashSet;
 use jiter::PartialMode;
@@ -20,7 +20,7 @@ use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuild
 #[derive(Debug)]
 struct TypedDictField {
     name: String,
-    lookup_key: LookupKey,
+    lookup_key_collection: LookupKeyCollection,
     name_py: Py<PyString>,
     required: bool,
     validator: CombinedValidator,
@@ -35,6 +35,8 @@ pub struct TypedDictValidator {
     extras_validator: Option<Box<CombinedValidator>>,
     strict: bool,
     loc_by_alias: bool,
+    validate_by_alias: Option<bool>,
+    validate_by_name: Option<bool>,
 }
 
 impl BuildValidator for TypedDictValidator {
@@ -55,7 +57,6 @@ impl BuildValidator for TypedDictValidator {
 
         let total =
             schema_or_config(schema, config, intern!(py, "total"), intern!(py, "typed_dict_total"))?.unwrap_or(true);
-        let populate_by_name = schema_or_config_same(schema, config, intern!(py, "populate_by_name"))?.unwrap_or(false);
 
         let extra_behavior = ExtraBehavior::from_schema_or_config(py, schema, config, ExtraBehavior::Ignore)?;
 
@@ -108,17 +109,12 @@ impl BuildValidator for TypedDictValidator {
                 }
             }
 
-            let lookup_key = match field_info.get_item(intern!(py, "validation_alias"))? {
-                Some(alias) => {
-                    let alt_alias = if populate_by_name { Some(field_name) } else { None };
-                    LookupKey::from_py(py, &alias, alt_alias)?
-                }
-                None => LookupKey::from_string(py, field_name),
-            };
+            let validation_alias = field_info.get_item(intern!(py, "validation_alias"))?;
+            let lookup_key_collection = LookupKeyCollection::new(py, validation_alias, field_name)?;
 
             fields.push(TypedDictField {
                 name: field_name.to_string(),
-                lookup_key,
+                lookup_key_collection,
                 name_py: field_name_py.into(),
                 validator,
                 required,
@@ -130,6 +126,8 @@ impl BuildValidator for TypedDictValidator {
             extras_validator,
             strict,
             loc_by_alias: config.get_as(intern!(py, "loc_by_alias"))?.unwrap_or(true),
+            validate_by_alias: config.get_as(intern!(py, "validate_by_alias"))?,
+            validate_by_name: config.get_as(intern!(py, "validate_by_name"))?,
         }
         .into())
     }
@@ -160,6 +158,9 @@ impl Validator for TypedDictValidator {
         };
         let allow_partial = state.allow_partial;
 
+        let validate_by_alias = state.validate_by_alias_or(self.validate_by_alias);
+        let validate_by_name = state.validate_by_name_or(self.validate_by_name);
+
         // we only care about which keys have been used if we're iterating over the object for extra after
         // the first pass
         let mut used_keys: Option<AHashSet<&str>> =
@@ -171,10 +172,14 @@ impl Validator for TypedDictValidator {
 
         {
             let state = &mut state.rebind_extra(|extra| extra.data = Some(output_dict.clone()));
+
             let mut fields_set_count: usize = 0;
 
             for field in &self.fields {
-                let op_key_value = match dict.get_item(&field.lookup_key) {
+                let lookup_key = field
+                    .lookup_key_collection
+                    .select(validate_by_alias, validate_by_name)?;
+                let op_key_value = match dict.get_item(lookup_key) {
                     Ok(v) => v,
                     Err(ValError::LineErrors(line_errors)) => {
                         let field_loc: LocItem = field.name.clone().into();
@@ -229,7 +234,7 @@ impl Validator for TypedDictValidator {
                     Ok(None) => {
                         // This means there was no default value
                         if field.required {
-                            errors.push(field.lookup_key.error(
+                            errors.push(lookup_key.error(
                                 ErrorTypeDefaults::Missing,
                                 input,
                                 self.loc_by_alias,
diff --git a/src/validators/validation_state.rs b/src/validators/validation_state.rs
index 8ee41f5de..b5bf37f48 100644
--- a/src/validators/validation_state.rs
+++ b/src/validators/validation_state.rs
@@ -64,6 +64,14 @@ impl<'a, 'py> ValidationState<'a, 'py> {
         self.extra.strict.unwrap_or(default)
     }
 
+    pub fn validate_by_alias_or(&self, default: Option<bool>) -> bool {
+        self.extra.by_alias.or(default).unwrap_or(true)
+    }
+
+    pub fn validate_by_name_or(&self, default: Option<bool>) -> bool {
+        self.extra.by_name.or(default).unwrap_or(false)
+    }
+
     /// Sets the exactness to the lower of the current exactness
     /// and the given exactness.
     ///
diff --git a/tests/serializers/test_dataclasses.py b/tests/serializers/test_dataclasses.py
index d7fbcffaf..e14ea268e 100644
--- a/tests/serializers/test_dataclasses.py
+++ b/tests/serializers/test_dataclasses.py
@@ -84,9 +84,9 @@ def test_serialization_alias():
         ['a', 'b'],
     )
     s = SchemaSerializer(schema)
-    assert s.to_python(Foo(a='hello', b=b'more')) == IsStrictDict(a='hello', BAR=b'more')
-    assert s.to_python(Foo(a='hello', b=b'more'), mode='json') == IsStrictDict(a='hello', BAR='more')
-    j = s.to_json(Foo(a='hello', b=b'more'))
+    assert s.to_python(Foo(a='hello', b=b'more'), by_alias=True) == IsStrictDict(a='hello', BAR=b'more')
+    assert s.to_python(Foo(a='hello', b=b'more'), mode='json', by_alias=True) == IsStrictDict(a='hello', BAR='more')
+    j = s.to_json(Foo(a='hello', b=b'more'), by_alias=True)
 
     if on_pypy:
         assert json.loads(j) == {'a': 'hello', 'BAR': 'more'}
@@ -235,3 +235,46 @@ class Bar:
     s = SchemaSerializer(schema)
     assert s.to_python(Foo(x=1), warnings='error') == {'x': 1}
     assert s.to_python(Foo(x=1, init_var=2), warnings='error') == {'x': 1}
+
+
+@pytest.mark.parametrize(
+    'config,runtime,expected',
+    [
+        (True, True, {'my_alias': 'hello'}),
+        (True, False, {'my_field': 'hello'}),
+        (True, None, {'my_alias': 'hello'}),
+        (False, True, {'my_alias': 'hello'}),
+        (False, False, {'my_field': 'hello'}),
+        (False, None, {'my_field': 'hello'}),
+        (None, True, {'my_alias': 'hello'}),
+        (None, False, {'my_field': 'hello'}),
+        (None, None, {'my_field': 'hello'}),
+    ],
+)
+def test_by_alias_and_name_config_interaction(config, runtime, expected) -> None:
+    """This test reflects the priority that applies for config vs runtime serialization alias configuration.
+
+    If the runtime value (by_alias) is set, that value is used.
+    If the runtime value is unset, the config value (serialize_by_alias) is used.
+    If neither are set, the default, False, is used.
+    """
+
+    @dataclasses.dataclass
+    class Foo:
+        my_field: str
+
+    schema = core_schema.dataclass_schema(
+        Foo,
+        core_schema.dataclass_args_schema(
+            'Foo',
+            [
+                core_schema.dataclass_field(
+                    name='my_field', schema=core_schema.str_schema(), serialization_alias='my_alias'
+                ),
+            ],
+        ),
+        ['my_field'],
+        config=core_schema.CoreConfig(serialize_by_alias=config or False),
+    )
+    s = SchemaSerializer(schema)
+    assert s.to_python(Foo(my_field='hello'), by_alias=runtime) == expected
diff --git a/tests/serializers/test_functions.py b/tests/serializers/test_functions.py
index a151b7454..738e8acc2 100644
--- a/tests/serializers/test_functions.py
+++ b/tests/serializers/test_functions.py
@@ -68,7 +68,7 @@ def double(value, info):
     # insert_assert(f_info)
     assert f_info == {
         'mode': 'python',
-        'by_alias': True,
+        'by_alias': None,
         'exclude_unset': False,
         'exclude_defaults': False,
         'exclude_none': False,
@@ -77,7 +77,7 @@ def double(value, info):
     }
     assert s.to_python('x') == 'xx'
 
-    assert s.to_python(4, mode='foobar') == 8
+    assert s.to_python(4, mode='foobar', by_alias=True) == 8
     # insert_assert(f_info)
     assert f_info == {
         'mode': 'foobar',
@@ -93,7 +93,7 @@ def double(value, info):
     # insert_assert(f_info)
     assert f_info == {
         'mode': 'json',
-        'by_alias': True,
+        'by_alias': None,
         'exclude_unset': False,
         'exclude_defaults': False,
         'exclude_none': False,
@@ -119,7 +119,7 @@ def double(value, info):
         'include': {3, 2, 1},
         'exclude': {'foo': {'bar'}},
         'mode': 'python',
-        'by_alias': True,
+        'by_alias': None,
         'exclude_unset': False,
         'exclude_defaults': False,
         'exclude_none': False,
@@ -132,7 +132,7 @@ def double(value, info):
     assert f_info == {
         'context': 'context',
         'mode': 'python',
-        'by_alias': True,
+        'by_alias': None,
         'exclude_unset': False,
         'exclude_defaults': False,
         'exclude_none': False,
@@ -230,27 +230,27 @@ def append_args(value, info):
         )
     )
     assert s.to_python(123) == (
-        "123 info=SerializationInfo(include=None, exclude=None, context=None, mode='python', by_alias=True, exclude_unset=False, "
+        "123 info=SerializationInfo(include=None, exclude=None, context=None, mode='python', by_alias=False, exclude_unset=False, "
         'exclude_defaults=False, exclude_none=False, round_trip=False, serialize_as_any=False)'
     )
     assert s.to_python(123, mode='other') == (
-        "123 info=SerializationInfo(include=None, exclude=None, context=None, mode='other', by_alias=True, exclude_unset=False, "
+        "123 info=SerializationInfo(include=None, exclude=None, context=None, mode='other', by_alias=False, exclude_unset=False, "
         'exclude_defaults=False, exclude_none=False, round_trip=False, serialize_as_any=False)'
     )
     assert s.to_python(123, include={'x'}) == (
-        "123 info=SerializationInfo(include={'x'}, exclude=None, context=None, mode='python', by_alias=True, exclude_unset=False, "
+        "123 info=SerializationInfo(include={'x'}, exclude=None, context=None, mode='python', by_alias=False, exclude_unset=False, "
         'exclude_defaults=False, exclude_none=False, round_trip=False, serialize_as_any=False)'
     )
     assert s.to_python(123, context='context') == (
-        "123 info=SerializationInfo(include=None, exclude=None, context='context', mode='python', by_alias=True, exclude_unset=False, "
+        "123 info=SerializationInfo(include=None, exclude=None, context='context', mode='python', by_alias=False, exclude_unset=False, "
         'exclude_defaults=False, exclude_none=False, round_trip=False, serialize_as_any=False)'
     )
     assert s.to_python(123, mode='json', exclude={1: {2}}) == (
-        "123 info=SerializationInfo(include=None, exclude={1: {2}}, context=None, mode='json', by_alias=True, exclude_unset=False, "
+        "123 info=SerializationInfo(include=None, exclude={1: {2}}, context=None, mode='json', by_alias=False, exclude_unset=False, "
         'exclude_defaults=False, exclude_none=False, round_trip=False, serialize_as_any=False)'
     )
     assert s.to_json(123) == (
-        b"\"123 info=SerializationInfo(include=None, exclude=None, context=None, mode='json', by_alias=True, exclude_unset=False, "
+        b"\"123 info=SerializationInfo(include=None, exclude=None, context=None, mode='json', by_alias=False, exclude_unset=False, "
         b'exclude_defaults=False, exclude_none=False, round_trip=False, serialize_as_any=False)"'
     )
 
diff --git a/tests/serializers/test_model.py b/tests/serializers/test_model.py
index cb0298622..8786359e8 100644
--- a/tests/serializers/test_model.py
+++ b/tests/serializers/test_model.py
@@ -217,7 +217,7 @@ def test_alias():
         )
     )
     value = BasicModel(cat=0, dog=1, bird=2)
-    assert s.to_python(value) == IsStrictDict(Meow=0, Woof=1, bird=2)
+    assert s.to_python(value, by_alias=True) == IsStrictDict(Meow=0, Woof=1, bird=2)
 
 
 def test_model_wrong_warn():
@@ -700,9 +700,9 @@ def volume(self) -> int:
             ),
         )
     )
-    assert s.to_python(Model(3, 4)) == {'width': 3, 'height': 4, 'Area': 12, 'volume': 48}
-    assert s.to_python(Model(3, 4), mode='json') == {'width': 3, 'height': 4, 'Area': 12, 'volume': 48}
-    assert s.to_json(Model(3, 4)) == b'{"width":3,"height":4,"Area":12,"volume":48}'
+    assert s.to_python(Model(3, 4), by_alias=True) == {'width': 3, 'height': 4, 'Area': 12, 'volume': 48}
+    assert s.to_python(Model(3, 4), mode='json', by_alias=True) == {'width': 3, 'height': 4, 'Area': 12, 'volume': 48}
+    assert s.to_json(Model(3, 4), by_alias=True) == b'{"width":3,"height":4,"Area":12,"volume":48}'
 
 
 def test_computed_field_exclude_none():
@@ -734,17 +734,28 @@ def volume(self) -> None:
             ),
         )
     )
-    assert s.to_python(Model(3, 4), exclude_none=False) == {'width': 3, 'height': 4, 'Area': 12, 'volume': None}
-    assert s.to_python(Model(3, 4), exclude_none=True) == {'width': 3, 'height': 4, 'Area': 12}
-    assert s.to_python(Model(3, 4), mode='json', exclude_none=False) == {
+    assert s.to_python(Model(3, 4), exclude_none=False, by_alias=True) == {
         'width': 3,
         'height': 4,
         'Area': 12,
         'volume': None,
     }
-    assert s.to_python(Model(3, 4), mode='json', exclude_none=True) == {'width': 3, 'height': 4, 'Area': 12}
-    assert s.to_json(Model(3, 4), exclude_none=False) == b'{"width":3,"height":4,"Area":12,"volume":null}'
-    assert s.to_json(Model(3, 4), exclude_none=True) == b'{"width":3,"height":4,"Area":12}'
+    assert s.to_python(Model(3, 4), exclude_none=True, by_alias=True) == {'width': 3, 'height': 4, 'Area': 12}
+    assert s.to_python(Model(3, 4), mode='json', exclude_none=False, by_alias=True) == {
+        'width': 3,
+        'height': 4,
+        'Area': 12,
+        'volume': None,
+    }
+    assert s.to_python(Model(3, 4), mode='json', exclude_none=True, by_alias=True) == {
+        'width': 3,
+        'height': 4,
+        'Area': 12,
+    }
+    assert (
+        s.to_json(Model(3, 4), exclude_none=False, by_alias=True) == b'{"width":3,"height":4,"Area":12,"volume":null}'
+    )
+    assert s.to_json(Model(3, 4), exclude_none=True, by_alias=True) == b'{"width":3,"height":4,"Area":12}'
 
 
 def test_computed_field_exclude_none_different_order():
@@ -779,17 +790,28 @@ def area(self) -> int:
             ),
         )
     )
-    assert s.to_python(Model(3, 4), exclude_none=False) == {'width': 3, 'height': 4, 'Area': 12, 'volume': None}
-    assert s.to_python(Model(3, 4), exclude_none=True) == {'width': 3, 'height': 4, 'Area': 12}
-    assert s.to_python(Model(3, 4), mode='json', exclude_none=False) == {
+    assert s.to_python(Model(3, 4), by_alias=True, exclude_none=False) == {
         'width': 3,
         'height': 4,
         'Area': 12,
         'volume': None,
     }
-    assert s.to_python(Model(3, 4), mode='json', exclude_none=True) == {'width': 3, 'height': 4, 'Area': 12}
-    assert s.to_json(Model(3, 4), exclude_none=False) == b'{"width":3,"height":4,"volume":null,"Area":12}'
-    assert s.to_json(Model(3, 4), exclude_none=True) == b'{"width":3,"height":4,"Area":12}'
+    assert s.to_python(Model(3, 4), by_alias=True, exclude_none=True) == {'width': 3, 'height': 4, 'Area': 12}
+    assert s.to_python(Model(3, 4), by_alias=True, mode='json', exclude_none=False) == {
+        'width': 3,
+        'height': 4,
+        'Area': 12,
+        'volume': None,
+    }
+    assert s.to_python(Model(3, 4), mode='json', by_alias=True, exclude_none=True) == {
+        'width': 3,
+        'height': 4,
+        'Area': 12,
+    }
+    assert (
+        s.to_json(Model(3, 4), exclude_none=False, by_alias=True) == b'{"width":3,"height":4,"volume":null,"Area":12}'
+    )
+    assert s.to_json(Model(3, 4), exclude_none=True, by_alias=True) == b'{"width":3,"height":4,"Area":12}'
 
 
 @pytest.mark.skipif(cached_property is None, reason='cached_property is not available')
@@ -1152,3 +1174,42 @@ class BModel(BasicModel): ...
     with pytest.warns(UserWarning, match='Expected 2 fields but got 1 for type `.*AModel` with value `.*`.+'):
         value = BasicModel(root=AModel(type='a'))
         s.to_python(value)
+
+
+@pytest.mark.parametrize(
+    'config,runtime,expected',
+    [
+        (True, True, {'my_alias': 1}),
+        (True, False, {'my_field': 1}),
+        (True, None, {'my_alias': 1}),
+        (False, True, {'my_alias': 1}),
+        (False, False, {'my_field': 1}),
+        (False, None, {'my_field': 1}),
+        (None, True, {'my_alias': 1}),
+        (None, False, {'my_field': 1}),
+        (None, None, {'my_field': 1}),
+    ],
+)
+def test_by_alias_and_name_config_interaction(config, runtime, expected) -> None:
+    """This test reflects the priority that applies for config vs runtime serialization alias configuration.
+
+    If the runtime value (by_alias) is set, that value is used.
+    If the runtime value is unset, the config value (serialize_by_alias) is used.
+    If neither are set, the default, False, is used.
+    """
+
+    class Model:
+        def __init__(self, my_field: int) -> None:
+            self.my_field = my_field
+
+    schema = core_schema.model_schema(
+        Model,
+        core_schema.model_fields_schema(
+            {
+                'my_field': core_schema.model_field(core_schema.int_schema(), serialization_alias='my_alias'),
+            }
+        ),
+        config=core_schema.CoreConfig(serialize_by_alias=config or False),
+    )
+    s = SchemaSerializer(schema)
+    assert s.to_python(Model(1), by_alias=runtime) == expected
diff --git a/tests/serializers/test_typed_dict.py b/tests/serializers/test_typed_dict.py
index 5fc9adcda..bd2016d18 100644
--- a/tests/serializers/test_typed_dict.py
+++ b/tests/serializers/test_typed_dict.py
@@ -114,16 +114,16 @@ def test_alias():
         )
     )
     value = {'cat': 0, 'dog': 1, 'bird': 2}
-    assert s.to_python(value) == IsStrictDict(Meow=0, Woof=1, bird=2)
-    assert s.to_python(value, exclude={'dog'}) == IsStrictDict(Meow=0, bird=2)
+    assert s.to_python(value, by_alias=True) == IsStrictDict(Meow=0, Woof=1, bird=2)
+    assert s.to_python(value, exclude={'dog'}, by_alias=True) == IsStrictDict(Meow=0, bird=2)
     assert s.to_python(value, by_alias=False) == IsStrictDict(cat=0, dog=1, bird=2)
 
-    assert s.to_python(value, mode='json') == IsStrictDict(Meow=0, Woof=1, bird=2)
-    assert s.to_python(value, mode='json', include={'cat'}) == IsStrictDict(Meow=0)
+    assert s.to_python(value, mode='json', by_alias=True) == IsStrictDict(Meow=0, Woof=1, bird=2)
+    assert s.to_python(value, mode='json', include={'cat'}, by_alias=True) == IsStrictDict(Meow=0)
     assert s.to_python(value, mode='json', by_alias=False) == IsStrictDict(cat=0, dog=1, bird=2)
 
-    assert json.loads(s.to_json(value)) == IsStrictDict(Meow=0, Woof=1, bird=2)
-    assert json.loads(s.to_json(value, include={'cat', 'bird'})) == IsStrictDict(Meow=0, bird=2)
+    assert json.loads(s.to_json(value, by_alias=True)) == IsStrictDict(Meow=0, Woof=1, bird=2)
+    assert json.loads(s.to_json(value, include={'cat', 'bird'}, by_alias=True)) == IsStrictDict(Meow=0, bird=2)
     assert json.loads(s.to_json(value, by_alias=False)) == IsStrictDict(cat=0, dog=1, bird=2)
 
 
@@ -333,3 +333,37 @@ def test_extra_custom_serializer():
     m = {'extra': 'extra'}
 
     assert s.to_python(m) == {'extra': 'extra bam!'}
+
+
+@pytest.mark.parametrize(
+    'config,runtime,expected',
+    [
+        (True, True, {'my_alias': 1}),
+        (True, False, {'my_field': 1}),
+        (True, None, {'my_alias': 1}),
+        (False, True, {'my_alias': 1}),
+        (False, False, {'my_field': 1}),
+        (False, None, {'my_field': 1}),
+        (None, True, {'my_alias': 1}),
+        (None, False, {'my_field': 1}),
+        (None, None, {'my_field': 1}),
+    ],
+)
+def test_by_alias_and_name_config_interaction(config, runtime, expected) -> None:
+    """This test reflects the priority that applies for config vs runtime serialization alias configuration.
+
+    If the runtime value (by_alias) is set, that value is used.
+    If the runtime value is unset, the config value (serialize_by_alias) is used.
+    If neither are set, the default, False, is used.
+    """
+
+    class Model(TypedDict):
+        my_field: int
+
+    schema = core_schema.typed_dict_schema(
+        {
+            'my_field': core_schema.typed_dict_field(core_schema.int_schema(), serialization_alias='my_alias'),
+        },
+    )
+    s = SchemaSerializer(schema, config=core_schema.CoreConfig(serialize_by_alias=config or False))
+    assert s.to_python(Model(my_field=1), by_alias=runtime) == expected
diff --git a/tests/serializers/test_union.py b/tests/serializers/test_union.py
index 96bfb54f7..15b9bf2c0 100644
--- a/tests/serializers/test_union.py
+++ b/tests/serializers/test_union.py
@@ -760,8 +760,8 @@ class ModelB:
 
     model_a = ModelA(field=1)
     model_b = ModelB(field=1)
-    assert s.to_python(model_a) == {'field': 1, 'TAG': 'a'}
-    assert s.to_python(model_b) == {'field': 1, 'TAG': 'b'}
+    assert s.to_python(model_a, by_alias=True) == {'field': 1, 'TAG': 'a'}
+    assert s.to_python(model_b, by_alias=True) == {'field': 1, 'TAG': 'b'}
 
 
 def test_union_model_wrap_serializer():
diff --git a/tests/test.rs b/tests/test.rs
index b59fbec54..58e2904f5 100644
--- a/tests/test.rs
+++ b/tests/test.rs
@@ -95,7 +95,7 @@ a = A()
                     None,
                     None,
                     None,
-                    true,
+                    Some(true),
                     false,
                     false,
                     false,
@@ -136,7 +136,7 @@ json_input = '{"a": "something"}'
             let json_input = locals.get_item("json_input").unwrap().unwrap();
             let binding = SchemaValidator::py_new(py, &schema, None)
                 .unwrap()
-                .validate_json(py, &json_input, None, None, None, false.into())
+                .validate_json(py, &json_input, None, None, None, false.into(), None, None)
                 .unwrap();
             let validation_result: Bound<'_, PyAny> = binding.extract(py).unwrap();
             let repr = format!("{}", validation_result.repr().unwrap());
@@ -203,7 +203,7 @@ dump_json_input_2 = {'a': 'something'}
                     None,
                     None,
                     None,
-                    false,
+                    Some(false),
                     false,
                     false,
                     false,
@@ -224,7 +224,7 @@ dump_json_input_2 = {'a': 'something'}
                     None,
                     None,
                     None,
-                    false,
+                    Some(false),
                     false,
                     false,
                     false,
diff --git a/tests/test_json.py b/tests/test_json.py
index 6b365a4cb..4d40ceb16 100644
--- a/tests/test_json.py
+++ b/tests/test_json.py
@@ -282,9 +282,9 @@ def __init__(self, my_foo: int, my_inners: list['Foobar']):
     Foobar.__pydantic_serializer__ = s
 
     instance = Foobar(my_foo=1, my_inners=[Foobar(my_foo=2, my_inners=[])])
-    assert to_jsonable_python(instance) == {'myFoo': 1, 'myInners': [{'myFoo': 2, 'myInners': []}]}
+    assert to_jsonable_python(instance, by_alias=True) == {'myFoo': 1, 'myInners': [{'myFoo': 2, 'myInners': []}]}
     assert to_jsonable_python(instance, by_alias=False) == {'my_foo': 1, 'my_inners': [{'my_foo': 2, 'my_inners': []}]}
-    assert to_json(instance) == b'{"myFoo":1,"myInners":[{"myFoo":2,"myInners":[]}]}'
+    assert to_json(instance, by_alias=True) == b'{"myFoo":1,"myInners":[{"myFoo":2,"myInners":[]}]}'
     assert to_json(instance, by_alias=False) == b'{"my_foo":1,"my_inners":[{"my_foo":2,"my_inners":[]}]}'
 
 
diff --git a/tests/test_typing.py b/tests/test_typing.py
index 2f460fb48..20a50a368 100644
--- a/tests/test_typing.py
+++ b/tests/test_typing.py
@@ -232,7 +232,7 @@ def f(input: Any, info: core_schema.SerializationInfo, /) -> str:
         )
     )
     assert s.to_python(123) == (
-        "SerializationInfo(include=None, exclude=None, context=None, mode='python', by_alias=True, exclude_unset=False, "
+        "SerializationInfo(include=None, exclude=None, context=None, mode='python', by_alias=False, exclude_unset=False, "
         'exclude_defaults=False, exclude_none=False, round_trip=False, serialize_as_any=False)'
     )
 
@@ -253,7 +253,7 @@ def f(
     # insert_assert(s.to_python(123, mode='json'))
     assert s.to_python(123, mode='json') == (
         'SerializationCallable(serializer=str) '
-        "SerializationInfo(include=None, exclude=None, context=None, mode='json', by_alias=True, exclude_unset=False, "
+        "SerializationInfo(include=None, exclude=None, context=None, mode='json', by_alias=False, exclude_unset=False, "
         'exclude_defaults=False, exclude_none=False, round_trip=False, serialize_as_any=False)'
     )
 
diff --git a/tests/validators/test_arguments.py b/tests/validators/test_arguments.py
index 496363a1f..ec7c409bb 100644
--- a/tests/validators/test_arguments.py
+++ b/tests/validators/test_arguments.py
@@ -2,7 +2,7 @@
 import sys
 from functools import wraps
 from inspect import Parameter, signature
-from typing import Any, get_type_hints
+from typing import Any, Union, get_type_hints
 
 import pytest
 
@@ -883,14 +883,14 @@ def test_alias(py_and_json: PyAndJson, input_value, expected):
     ],
     ids=repr,
 )
-def test_alias_populate_by_name(py_and_json: PyAndJson, input_value, expected):
+def test_alias_validate_by_name(py_and_json: PyAndJson, input_value, expected):
     v = py_and_json(
         {
             'type': 'arguments',
             'arguments_schema': [
                 {'name': 'a', 'mode': 'positional_or_keyword', 'schema': {'type': 'int'}, 'alias': 'Foo'}
             ],
-            'populate_by_name': True,
+            'validate_by_name': True,
         }
     )
     if isinstance(expected, Err):
@@ -900,6 +900,34 @@ def test_alias_populate_by_name(py_and_json: PyAndJson, input_value, expected):
         assert v.validate_test(input_value) == expected
 
 
+def test_only_validate_by_name(py_and_json) -> None:
+    schema = core_schema.arguments_schema(
+        [
+            core_schema.arguments_parameter(name='a', schema=core_schema.str_schema(), alias='FieldA'),
+        ],
+        validate_by_name=True,
+        validate_by_alias=False,
+    )
+    v = py_and_json(schema)
+    assert v.validate_test(ArgsKwargs((), {'a': 'hello'})) == ((), {'a': 'hello'})
+    with pytest.raises(ValidationError, match=r'a\n +Missing required argument \[type=missing_argument,'):
+        assert v.validate_test(ArgsKwargs((), {'FieldA': 'hello'}))
+
+
+def test_only_allow_alias(py_and_json) -> None:
+    schema = core_schema.arguments_schema(
+        [
+            core_schema.arguments_parameter(name='a', schema=core_schema.str_schema(), alias='FieldA'),
+        ],
+        validate_by_name=False,
+        validate_by_alias=True,
+    )
+    v = py_and_json(schema)
+    assert v.validate_test(ArgsKwargs((), {'FieldA': 'hello'})) == ((), {'a': 'hello'})
+    with pytest.raises(ValidationError, match=r'FieldA\n +Missing required argument \[type=missing_argument,'):
+        assert v.validate_test(ArgsKwargs((), {'a': 'hello'}))
+
+
 def validate(config=None):
     def decorator(function):
         parameters = signature(function).parameters
@@ -1145,3 +1173,50 @@ def test_error_display(pydantic_version):
         '[{"type":"missing_argument","loc":["b"],"msg":"Missing required argument",'
         '"input":"ArgsKwargs((), {\'a\': 1})"}]'
     )
+
+
+@pytest.mark.parametrize('config_by_alias', [None, True, False])
+@pytest.mark.parametrize('config_by_name', [None, True, False])
+@pytest.mark.parametrize('runtime_by_alias', [None, True, False])
+@pytest.mark.parametrize('runtime_by_name', [None, True, False])
+def test_by_alias_and_name_config_interaction(
+    config_by_alias: Union[bool, None],
+    config_by_name: Union[bool, None],
+    runtime_by_alias: Union[bool, None],
+    runtime_by_name: Union[bool, None],
+) -> None:
+    """This test reflects the priority that applies for config vs runtime validation alias configuration.
+
+    Runtime values take precedence over config values, when set.
+    By default, by_alias is True and by_name is False.
+    """
+
+    if config_by_alias is False and config_by_name is False and runtime_by_alias is False and runtime_by_name is False:
+        pytest.skip("Can't have both by_alias and by_name as effectively False")
+
+    schema = core_schema.arguments_schema(
+        arguments=[
+            core_schema.arguments_parameter(name='my_field', schema=core_schema.int_schema(), alias='my_alias'),
+        ],
+        **({'validate_by_alias': config_by_alias} if config_by_alias is not None else {}),
+        **({'validate_by_name': config_by_name} if config_by_name is not None else {}),
+    )
+    s = SchemaValidator(schema)
+
+    alias_allowed = next(x for x in (runtime_by_alias, config_by_alias, True) if x is not None)
+    name_allowed = next(x for x in (runtime_by_name, config_by_name, False) if x is not None)
+
+    if alias_allowed:
+        assert s.validate_python(
+            ArgsKwargs((), {'my_alias': 1}), by_alias=runtime_by_alias, by_name=runtime_by_name
+        ) == (
+            (),
+            {'my_field': 1},
+        )
+    if name_allowed:
+        assert s.validate_python(
+            ArgsKwargs((), {'my_field': 1}), by_alias=runtime_by_alias, by_name=runtime_by_name
+        ) == (
+            (),
+            {'my_field': 1},
+        )
diff --git a/tests/validators/test_dataclasses.py b/tests/validators/test_dataclasses.py
index 09bd4e762..cfead4423 100644
--- a/tests/validators/test_dataclasses.py
+++ b/tests/validators/test_dataclasses.py
@@ -1708,3 +1708,125 @@ class Foo:
             assert exc_info.value.errors(include_url=False) == expected.errors
     else:
         assert dataclasses.asdict(v.validate_python(input_value)) == expected
+
+
+@dataclasses.dataclass
+class BasicDataclass:
+    a: str
+
+
+def test_alias_allow_pop(py_and_json: PyAndJson):
+    schema = core_schema.dataclass_schema(
+        BasicDataclass,
+        core_schema.dataclass_args_schema(
+            'BasicDataclass',
+            [
+                core_schema.dataclass_field(name='a', schema=core_schema.str_schema(), validation_alias='FieldA'),
+            ],
+        ),
+        ['a'],
+        config=core_schema.CoreConfig(validate_by_name=True, validate_by_alias=True),
+    )
+    v = py_and_json(schema)
+    assert v.validate_test({'FieldA': 'hello'}) == BasicDataclass(a='hello')
+    assert v.validate_test({'a': 'hello'}) == BasicDataclass(a='hello')
+    assert v.validate_test(
+        {
+            'FieldA': 'hello',
+            'a': 'world',
+        }
+    ) == BasicDataclass(a='hello')
+    with pytest.raises(ValidationError, match=r'FieldA\n +Field required \[type=missing,'):
+        assert v.validate_test({'foobar': 'hello'})
+
+
+def test_only_validate_by_name(py_and_json) -> None:
+    schema = core_schema.dataclass_schema(
+        BasicDataclass,
+        core_schema.dataclass_args_schema(
+            'BasicDataclass',
+            [
+                core_schema.dataclass_field(name='a', schema=core_schema.str_schema(), validation_alias='FieldA'),
+            ],
+        ),
+        ['a'],
+        config=core_schema.CoreConfig(validate_by_name=True, validate_by_alias=False),
+    )
+    v = py_and_json(schema)
+    assert v.validate_test({'a': 'hello'}) == BasicDataclass(a='hello')
+    with pytest.raises(ValidationError, match=r'a\n +Field required \[type=missing,'):
+        assert v.validate_test({'FieldA': 'hello'})
+
+
+def test_only_allow_alias(py_and_json) -> None:
+    schema = core_schema.dataclass_schema(
+        BasicDataclass,
+        core_schema.dataclass_args_schema(
+            'BasicDataclass',
+            [
+                core_schema.dataclass_field(name='a', schema=core_schema.str_schema(), validation_alias='FieldA'),
+            ],
+        ),
+        ['a'],
+        config=core_schema.CoreConfig(validate_by_name=False, validate_by_alias=True),
+    )
+    v = py_and_json(schema)
+    assert v.validate_test({'FieldA': 'hello'}) == BasicDataclass(a='hello')
+    with pytest.raises(ValidationError, match=r'FieldA\n +Field required \[type=missing,'):
+        assert v.validate_test({'a': 'hello'})
+
+
+@pytest.mark.parametrize('config_by_alias', [None, True, False])
+@pytest.mark.parametrize('config_by_name', [None, True, False])
+@pytest.mark.parametrize('runtime_by_alias', [None, True, False])
+@pytest.mark.parametrize('runtime_by_name', [None, True, False])
+def test_by_alias_and_name_config_interaction(
+    config_by_alias: Union[bool, None],
+    config_by_name: Union[bool, None],
+    runtime_by_alias: Union[bool, None],
+    runtime_by_name: Union[bool, None],
+) -> None:
+    """This test reflects the priority that applies for config vs runtime validation alias configuration.
+
+    Runtime values take precedence over config values, when set.
+    By default, by_alias is True and by_name is False.
+    """
+
+    if config_by_alias is False and config_by_name is False and runtime_by_alias is False and runtime_by_name is False:
+        pytest.skip("Can't have both by_alias and by_name as effectively False")
+
+    core_config = {
+        **({'validate_by_alias': config_by_alias} if config_by_alias is not None else {}),
+        **({'validate_by_name': config_by_name} if config_by_name is not None else {}),
+    }
+
+    @dataclasses.dataclass
+    class MyDataclass:
+        my_field: int
+
+    schema = core_schema.dataclass_schema(
+        MyDataclass,
+        core_schema.dataclass_args_schema(
+            'MyDataclass',
+            [
+                core_schema.dataclass_field(
+                    name='my_field', schema=core_schema.int_schema(), validation_alias='my_alias'
+                ),
+            ],
+        ),
+        ['my_field'],
+        config=core_schema.CoreConfig(**core_config),
+    )
+    s = SchemaValidator(schema)
+
+    alias_allowed = next(x for x in (runtime_by_alias, config_by_alias, True) if x is not None)
+    name_allowed = next(x for x in (runtime_by_name, config_by_name, False) if x is not None)
+
+    if alias_allowed:
+        assert dataclasses.asdict(
+            s.validate_python({'my_alias': 1}, by_alias=runtime_by_alias, by_name=runtime_by_name)
+        ) == {'my_field': 1}
+    if name_allowed:
+        assert dataclasses.asdict(
+            s.validate_python({'my_field': 1}, by_alias=runtime_by_alias, by_name=runtime_by_name)
+        ) == {'my_field': 1}
diff --git a/tests/validators/test_model_fields.py b/tests/validators/test_model_fields.py
index e5dd53994..22b8620a8 100644
--- a/tests/validators/test_model_fields.py
+++ b/tests/validators/test_model_fields.py
@@ -506,9 +506,9 @@ def test_alias_allow_pop(py_and_json: PyAndJson):
     v = py_and_json(
         {
             'type': 'model-fields',
-            'populate_by_name': True,
             'fields': {'field_a': {'validation_alias': 'FieldA', 'type': 'model-field', 'schema': {'type': 'int'}}},
-        }
+        },
+        config=CoreConfig(validate_by_name=True),
     )
     assert v.validate_test({'FieldA': '123'}) == ({'field_a': 123}, None, {'field_a'})
     assert v.validate_test({'field_a': '123'}) == ({'field_a': 123}, None, {'field_a'})
@@ -517,6 +517,32 @@ def test_alias_allow_pop(py_and_json: PyAndJson):
         assert v.validate_test({'foobar': '123'})
 
 
+def test_only_validate_by_name(py_and_json) -> None:
+    v = py_and_json(
+        {
+            'type': 'model-fields',
+            'fields': {'field_a': {'validation_alias': 'FieldA', 'type': 'model-field', 'schema': {'type': 'int'}}},
+        },
+        config=CoreConfig(validate_by_name=True, validate_by_alias=False),
+    )
+    assert v.validate_test({'field_a': '123'}) == ({'field_a': 123}, None, {'field_a'})
+    with pytest.raises(ValidationError, match=r'field_a\n +Field required \[type=missing,'):
+        assert v.validate_test({'FieldA': '123'})
+
+
+def test_only_allow_alias(py_and_json) -> None:
+    v = py_and_json(
+        {
+            'type': 'model-fields',
+            'fields': {'field_a': {'validation_alias': 'FieldA', 'type': 'model-field', 'schema': {'type': 'int'}}},
+        },
+        config=CoreConfig(validate_by_name=False, validate_by_alias=True),
+    )
+    assert v.validate_test({'FieldA': '123'}) == ({'field_a': 123}, None, {'field_a'})
+    with pytest.raises(ValidationError, match=r'FieldA\n +Field required \[type=missing,'):
+        assert v.validate_test({'field_a': '123'})
+
+
 @pytest.mark.parametrize(
     'input_value,expected',
     [
@@ -697,8 +723,8 @@ def test_paths_allow_by_name(py_and_json: PyAndJson, input_value):
                     'schema': {'type': 'int'},
                 }
             },
-            'populate_by_name': True,
-        }
+        },
+        config=CoreConfig(validate_by_name=True),
     )
     assert v.validate_test(input_value) == ({'field_a': 42}, None, {'field_a'})
 
@@ -985,8 +1011,8 @@ def test_from_attributes_by_name():
         core_schema.model_fields_schema(
             fields={'a': core_schema.model_field(schema=core_schema.int_schema(), validation_alias='a_alias')},
             from_attributes=True,
-            populate_by_name=True,
-        )
+        ),
+        config=CoreConfig(validate_by_name=True),
     )
     assert v.validate_python(Cls(a_alias=1)) == ({'a': 1}, None, {'a'})
     assert v.validate_python(Cls(a=1)) == ({'a': 1}, None, {'a'})
@@ -1383,9 +1409,9 @@ def test_alias_extra_by_name(py_and_json: PyAndJson):
             'type': 'model-fields',
             'extra_behavior': 'allow',
             'from_attributes': True,
-            'populate_by_name': True,
             'fields': {'field_a': {'validation_alias': 'FieldA', 'type': 'model-field', 'schema': {'type': 'int'}}},
-        }
+        },
+        config=CoreConfig(validate_by_name=True),
     )
     assert v.validate_test({'FieldA': 1}) == ({'field_a': 1}, {}, {'field_a'})
     assert v.validate_test({'field_a': 1}) == ({'field_a': 1}, {}, {'field_a'})
@@ -1730,3 +1756,51 @@ def test_extra_behavior_ignore(config: Union[core_schema.CoreConfig, None], sche
         }
     ]
     assert 'not_f' not in m
+
+
+@pytest.mark.parametrize('config_by_alias', [None, True, False])
+@pytest.mark.parametrize('config_by_name', [None, True, False])
+@pytest.mark.parametrize('runtime_by_alias', [None, True, False])
+@pytest.mark.parametrize('runtime_by_name', [None, True, False])
+def test_by_alias_and_name_config_interaction(
+    config_by_alias: Union[bool, None],
+    config_by_name: Union[bool, None],
+    runtime_by_alias: Union[bool, None],
+    runtime_by_name: Union[bool, None],
+) -> None:
+    """This test reflects the priority that applies for config vs runtime validation alias configuration.
+
+    Runtime values take precedence over config values, when set.
+    By default, by_alias is True and by_name is False.
+    """
+
+    if config_by_alias is False and config_by_name is False and runtime_by_alias is False and runtime_by_name is False:
+        pytest.skip("Can't have both by_alias and by_name as effectively False")
+
+    class Model:
+        def __init__(self, my_field: int) -> None:
+            self.my_field = my_field
+
+    core_config = {
+        **({'validate_by_alias': config_by_alias} if config_by_alias is not None else {}),
+        **({'validate_by_name': config_by_name} if config_by_name is not None else {}),
+    }
+
+    schema = core_schema.model_schema(
+        Model,
+        core_schema.model_fields_schema(
+            {
+                'my_field': core_schema.model_field(core_schema.int_schema(), validation_alias='my_alias'),
+            }
+        ),
+        config=core_schema.CoreConfig(**core_config),
+    )
+    s = SchemaValidator(schema)
+
+    alias_allowed = next(x for x in (runtime_by_alias, config_by_alias, True) if x is not None)
+    name_allowed = next(x for x in (runtime_by_name, config_by_name, False) if x is not None)
+
+    if alias_allowed:
+        assert s.validate_python({'my_alias': 1}, by_alias=runtime_by_alias, by_name=runtime_by_name).my_field == 1
+    if name_allowed:
+        assert s.validate_python({'my_field': 1}, by_alias=runtime_by_alias, by_name=runtime_by_name).my_field == 1
diff --git a/tests/validators/test_typed_dict.py b/tests/validators/test_typed_dict.py
index 6e3826a3b..b224b65ea 100644
--- a/tests/validators/test_typed_dict.py
+++ b/tests/validators/test_typed_dict.py
@@ -393,11 +393,11 @@ def test_alias_allow_pop(py_and_json: PyAndJson):
     v = py_and_json(
         {
             'type': 'typed-dict',
-            'populate_by_name': True,
             'fields': {
                 'field_a': {'validation_alias': 'FieldA', 'type': 'typed-dict-field', 'schema': {'type': 'int'}}
             },
-        }
+            'config': {'validate_by_name': True, 'validate_by_alias': True},
+        },
     )
     assert v.validate_test({'FieldA': '123'}) == {'field_a': 123}
     assert v.validate_test({'field_a': '123'}) == {'field_a': 123}
@@ -406,6 +406,36 @@ def test_alias_allow_pop(py_and_json: PyAndJson):
         assert v.validate_test({'foobar': '123'})
 
 
+def test_only_validate_by_name(py_and_json) -> None:
+    v = py_and_json(
+        {
+            'type': 'typed-dict',
+            'fields': {
+                'field_a': {'validation_alias': 'FieldA', 'type': 'typed-dict-field', 'schema': {'type': 'int'}}
+            },
+            'config': {'validate_by_name': True, 'validate_by_alias': False},
+        }
+    )
+    assert v.validate_test({'field_a': '123'}) == {'field_a': 123}
+    with pytest.raises(ValidationError, match=r'field_a\n +Field required \[type=missing,'):
+        assert v.validate_test({'FieldA': '123'})
+
+
+def test_only_allow_alias(py_and_json) -> None:
+    v = py_and_json(
+        {
+            'type': 'typed-dict',
+            'fields': {
+                'field_a': {'validation_alias': 'FieldA', 'type': 'typed-dict-field', 'schema': {'type': 'int'}}
+            },
+            'config': {'validate_by_name': False, 'validate_by_alias': True},
+        }
+    )
+    assert v.validate_test({'FieldA': '123'}) == {'field_a': 123}
+    with pytest.raises(ValidationError, match=r'FieldA\n +Field required \[type=missing,'):
+        assert v.validate_test({'field_a': '123'})
+
+
 @pytest.mark.parametrize(
     'input_value,expected',
     [
@@ -590,8 +620,8 @@ def test_paths_allow_by_name(py_and_json: PyAndJson, input_value):
                     'schema': {'type': 'int'},
                 }
             },
-            'populate_by_name': True,
-        }
+            'config': {'validate_by_name': True},
+        },
     )
     assert v.validate_test(input_value) == {'field_a': 42}
 
@@ -795,11 +825,11 @@ def test_alias_extra_by_name(py_and_json: PyAndJson):
         {
             'type': 'typed-dict',
             'extra_behavior': 'allow',
-            'populate_by_name': True,
             'fields': {
                 'field_a': {'validation_alias': 'FieldA', 'type': 'typed-dict-field', 'schema': {'type': 'int'}}
             },
-        }
+            'config': {'validate_by_name': True},
+        },
     )
     assert v.validate_test({'FieldA': 1}) == {'field_a': 1}
     assert v.validate_test({'field_a': 1}) == {'field_a': 1}
@@ -1165,3 +1195,44 @@ def validate(v, info):
     del cycle
 
     assert_gc(lambda: ref() is None)
+
+
+@pytest.mark.parametrize('config_by_alias', [None, True, False])
+@pytest.mark.parametrize('config_by_name', [None, True, False])
+@pytest.mark.parametrize('runtime_by_alias', [None, True, False])
+@pytest.mark.parametrize('runtime_by_name', [None, True, False])
+def test_by_alias_and_name_config_interaction(
+    config_by_alias: Union[bool, None],
+    config_by_name: Union[bool, None],
+    runtime_by_alias: Union[bool, None],
+    runtime_by_name: Union[bool, None],
+) -> None:
+    """This test reflects the priority that applies for config vs runtime validation alias configuration.
+
+    Runtime values take precedence over config values, when set.
+    By default, by_alias is True and by_name is False.
+    """
+
+    if config_by_alias is False and config_by_name is False and runtime_by_alias is False and runtime_by_name is False:
+        pytest.skip("Can't have both by_alias and by_name as effectively False")
+
+    core_config = {
+        **({'validate_by_alias': config_by_alias} if config_by_alias is not None else {}),
+        **({'validate_by_name': config_by_name} if config_by_name is not None else {}),
+    }
+
+    schema = core_schema.typed_dict_schema(
+        fields={
+            'my_field': core_schema.typed_dict_field(schema=core_schema.int_schema(), validation_alias='my_alias'),
+        },
+        config=core_schema.CoreConfig(**core_config),
+    )
+    s = SchemaValidator(schema)
+
+    alias_allowed = next(x for x in (runtime_by_alias, config_by_alias, True) if x is not None)
+    name_allowed = next(x for x in (runtime_by_name, config_by_name, False) if x is not None)
+
+    if alias_allowed:
+        assert s.validate_python({'my_alias': 1}, by_alias=runtime_by_alias, by_name=runtime_by_name) == {'my_field': 1}
+    if name_allowed:
+        assert s.validate_python({'my_field': 1}, by_alias=runtime_by_alias, by_name=runtime_by_name) == {'my_field': 1}

From 9975030e1f0b8b684c2e113e38c07547b24d353e Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Tue, 25 Feb 2025 15:41:53 -0500
Subject: [PATCH 499/550] Bump version to v2.30.0 (#1648)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 11885ec4e..bd3d51e40 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -424,7 +424,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.29.0"
+version = "2.30.0"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index c7be6ad02..a062f1a23 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.29.0"
+version = "2.30.0"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From 30df641589f494d78a54053be9a74893a197e2e1 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 3 Mar 2025 09:50:29 +0000
Subject: [PATCH 500/550] Bump uraimo/run-on-arch-action from 2.8.1 to 3.0.0
 (#1658)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 72cf0ac9a..7ba7247a2 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -605,7 +605,7 @@ jobs:
           merge-multiple: true
           path: dist
 
-      - uses: uraimo/run-on-arch-action@v2.8.1
+      - uses: uraimo/run-on-arch-action@v3.0.0
         name: install & test
         with:
           arch: ${{ matrix.target }}

From eab183d6dc087ce288083e732e903f6f0721106f Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 3 Mar 2025 09:50:38 +0000
Subject: [PATCH 501/550] Bump serde from 1.0.217 to 1.0.218 (#1657)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 8 ++++----
 Cargo.toml | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index bd3d51e40..3dc3a6a6c 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -579,18 +579,18 @@ checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
 
 [[package]]
 name = "serde"
-version = "1.0.217"
+version = "1.0.218"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "02fc4265df13d6fa1d00ecff087228cc0a2b5f3c0e87e258d8b94a156e984c70"
+checksum = "e8dfc9d19bdbf6d17e22319da49161d5d0108e4188e8b680aef6299eed22df60"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.217"
+version = "1.0.218"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a9bf7cf98d04a2b28aead066b7496853d4779c9cc183c440dbac457641e19a0"
+checksum = "f09503e191f4e797cb8aac08e9a4a4695c5edf6a2e70e376d961ddd5c969f82b"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/Cargo.toml b/Cargo.toml
index a062f1a23..c2fed657f 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -35,7 +35,7 @@ strum = { version = "0.26.3", features = ["derive"] }
 strum_macros = "0.26.4"
 serde_json = {version = "1.0.138", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.13"
-serde = { version = "1.0.217", features = ["derive"] }
+serde = { version = "1.0.218", features = ["derive"] }
 speedate = "0.15.0"
 smallvec = "1.13.2"
 ahash = "0.8.10"

From db340609d3bca4f089aec9a1a178239f41375fcf Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 3 Mar 2025 09:51:19 +0000
Subject: [PATCH 502/550] Bump uuid from 1.12.1 to 1.15.1 (#1655)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 3dc3a6a6c..61101cea0 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -741,9 +741,9 @@ checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
 
 [[package]]
 name = "uuid"
-version = "1.12.1"
+version = "1.15.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b3758f5e68192bb96cc8f9b7e2c2cfdabb435499a28499a42f8f984092adad4b"
+checksum = "e0f540e3240398cce6128b64ba83fdbdd86129c16a3aa1a3a252efd66eb3d587"
 
 [[package]]
 name = "version_check"
diff --git a/Cargo.toml b/Cargo.toml
index c2fed657f..863e63530 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -44,7 +44,7 @@ url = "2.5.4"
 idna = "1.0.3"
 base64 = "0.22.1"
 num-bigint = "0.4.6"
-uuid = "1.12.1"
+uuid = "1.15.1"
 jiter = { version = "0.8.2", features = ["python"] }
 hex = "0.4.3"
 

From 8b7bda65829aac00357a2a70d5ecd4944b2f40cd Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Mon, 3 Mar 2025 09:51:28 +0000
Subject: [PATCH 503/550] Bump smallvec from 1.13.2 to 1.14.0 (#1654)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 61101cea0..5d47d45a6 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -612,9 +612,9 @@ dependencies = [
 
 [[package]]
 name = "smallvec"
-version = "1.13.2"
+version = "1.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "3c5e1a9a646d36c3599cd173a41282daf47c44583ad367b8e6837255952e5c67"
+checksum = "7fcf8323ef1faaee30a44a340193b1ac6814fd9b7b4e88e9d4519a3e4abe1cfd"
 
 [[package]]
 name = "speedate"
diff --git a/Cargo.toml b/Cargo.toml
index 863e63530..580b13c81 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -37,7 +37,7 @@ serde_json = {version = "1.0.138", features = ["arbitrary_precision", "preserve_
 enum_dispatch = "0.3.13"
 serde = { version = "1.0.218", features = ["derive"] }
 speedate = "0.15.0"
-smallvec = "1.13.2"
+smallvec = "1.14.0"
 ahash = "0.8.10"
 url = "2.5.4"
 # idna is already required by url, added here to be explicit

From 66c8c58bb49322627d08a09ceddc84b91fd8c88a Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Mon, 3 Mar 2025 11:22:24 -0500
Subject: [PATCH 504/550] Clean up `PydanticUnexpectedValueError` (#1652)

---
 src/serializers/errors.rs                     | 89 ++++++++++++++++---
 src/serializers/extra.rs                      | 41 +++------
 src/serializers/fields.rs                     | 31 +++----
 .../type_serializers/datetime_etc.rs          |  2 +-
 src/serializers/type_serializers/float.rs     |  2 +-
 src/serializers/type_serializers/function.rs  |  2 +-
 src/serializers/type_serializers/model.rs     |  2 +-
 src/serializers/type_serializers/simple.rs    |  2 +-
 src/serializers/type_serializers/tuple.rs     |  9 +-
 src/serializers/type_serializers/union.rs     | 30 +++++--
 src/tools.rs                                  |  1 +
 tests/serializers/test_any.py                 | 15 ++--
 tests/serializers/test_bytes.py               | 12 ++-
 tests/serializers/test_datetime.py            |  4 +-
 tests/serializers/test_decimal.py             |  6 +-
 tests/serializers/test_enum.py                | 30 ++++---
 tests/serializers/test_functions.py           | 26 ++++--
 tests/serializers/test_generator.py           | 24 +++--
 tests/serializers/test_list_tuple.py          | 88 ++++++++++--------
 tests/serializers/test_model.py               | 21 +++--
 tests/serializers/test_nullable.py            |  3 +-
 tests/serializers/test_other.py               |  3 +-
 tests/serializers/test_set_frozenset.py       | 29 +++---
 tests/serializers/test_simple.py              |  6 +-
 tests/serializers/test_string.py              | 35 +++++---
 tests/serializers/test_timedelta.py           |  4 +-
 tests/serializers/test_union.py               | 22 ++---
 tests/serializers/test_url.py                 |  4 +-
 tests/serializers/test_uuid.py                |  6 +-
 29 files changed, 346 insertions(+), 203 deletions(-)

diff --git a/src/serializers/errors.rs b/src/serializers/errors.rs
index ffd43407f..5f736c11b 100644
--- a/src/serializers/errors.rs
+++ b/src/serializers/errors.rs
@@ -2,6 +2,9 @@ use std::fmt;
 
 use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
+use pyo3::types::PyString;
+
+use crate::tools::truncate_safe_repr;
 
 use serde::ser;
 
@@ -44,9 +47,9 @@ pub(super) fn se_err_py_err(error: PythonSerializerError) -> PyErr {
     let s = error.to_string();
     if let Some(msg) = s.strip_prefix(UNEXPECTED_TYPE_SER_MARKER) {
         if msg.is_empty() {
-            PydanticSerializationUnexpectedValue::new_err(None)
+            PydanticSerializationUnexpectedValue::new_from_msg(None).to_py_err()
         } else {
-            PydanticSerializationUnexpectedValue::new_err(Some(msg.to_string()))
+            PydanticSerializationUnexpectedValue::new_from_msg(Some(msg.to_string())).to_py_err()
         }
     } else if let Some(msg) = s.strip_prefix(SERIALIZATION_ERR_MARKER) {
         PydanticSerializationError::new_err(msg.to_string())
@@ -94,30 +97,90 @@ impl PydanticSerializationError {
 #[derive(Debug, Clone)]
 pub struct PydanticSerializationUnexpectedValue {
     message: Option<String>,
+    field_type: Option<String>,
+    input_value: Option<PyObject>,
 }
 
 impl PydanticSerializationUnexpectedValue {
-    pub(crate) fn new_err(msg: Option<String>) -> PyErr {
-        PyErr::new::<Self, Option<String>>(msg)
+    pub fn new_from_msg(message: Option<String>) -> Self {
+        Self {
+            message,
+            field_type: None,
+            input_value: None,
+        }
+    }
+
+    pub fn new_from_parts(field_type: Option<String>, input_value: Option<PyObject>) -> Self {
+        Self {
+            message: None,
+            field_type,
+            input_value,
+        }
+    }
+
+    pub fn new(message: Option<String>, field_type: Option<String>, input_value: Option<PyObject>) -> Self {
+        Self {
+            message,
+            field_type,
+            input_value,
+        }
+    }
+
+    pub fn to_py_err(&self) -> PyErr {
+        PyErr::new::<Self, (Option<String>, Option<String>, Option<PyObject>)>((
+            self.message.clone(),
+            self.field_type.clone(),
+            self.input_value.clone(),
+        ))
     }
 }
 
 #[pymethods]
 impl PydanticSerializationUnexpectedValue {
     #[new]
-    #[pyo3(signature = (message=None))]
-    fn py_new(message: Option<String>) -> Self {
-        Self { message }
+    #[pyo3(signature = (message=None, field_type=None, input_value=None))]
+    fn py_new(message: Option<String>, field_type: Option<String>, input_value: Option<PyObject>) -> Self {
+        Self {
+            message,
+            field_type,
+            input_value,
+        }
     }
 
-    fn __str__(&self) -> &str {
-        match self.message {
-            Some(ref s) => s,
-            None => "Unexpected Value",
+    pub(crate) fn __str__(&self, py: Python) -> String {
+        let mut message = self.message.as_deref().unwrap_or("").to_string();
+
+        if let Some(field_type) = &self.field_type {
+            if !message.is_empty() {
+                message.push_str(": ");
+            }
+            message.push_str(&format!("Expected `{field_type}`"));
+            if self.input_value.is_some() {
+                message.push_str(" - serialized value may not be as expected");
+            }
+        }
+
+        if let Some(input_value) = &self.input_value {
+            let bound_input = input_value.bind(py);
+            let input_type = bound_input
+                .get_type()
+                .name()
+                .unwrap_or_else(|_| PyString::new(py, "<unknown python object>"))
+                .to_string();
+
+            let value_str = truncate_safe_repr(bound_input, None);
+
+            message.push_str(&format!(" [input_value={value_str}, input_type={input_type}]"));
         }
+
+        if message.is_empty() {
+            message = "Unexpected Value".to_string();
+        }
+
+        message
     }
 
-    pub(crate) fn __repr__(&self) -> String {
-        format!("PydanticSerializationUnexpectedValue({})", self.__str__())
+    pub(crate) fn __repr__(&self, py: Python) -> String {
+        format!("PydanticSerializationUnexpectedValue({})", self.__str__(py))
     }
 }
diff --git a/src/serializers/extra.rs b/src/serializers/extra.rs
index a369859fb..82c432342 100644
--- a/src/serializers/extra.rs
+++ b/src/serializers/extra.rs
@@ -17,7 +17,6 @@ use crate::recursion_guard::ContainsRecursionState;
 use crate::recursion_guard::RecursionError;
 use crate::recursion_guard::RecursionGuard;
 use crate::recursion_guard::RecursionState;
-use crate::tools::truncate_safe_repr;
 use crate::PydanticSerializationError;
 
 /// this is ugly, would be much better if extra could be stored in `SerializationState`
@@ -384,7 +383,7 @@ impl From<bool> for WarningsMode {
 pub(crate) struct CollectWarnings {
     mode: WarningsMode,
     // FIXME: mutex is to satisfy PyO3 0.23, we should be able to refactor this away
-    warnings: Mutex<Vec<String>>,
+    warnings: Mutex<Vec<PydanticSerializationUnexpectedValue>>,
 }
 
 impl Clone for CollectWarnings {
@@ -404,9 +403,9 @@ impl CollectWarnings {
         }
     }
 
-    pub fn custom_warning(&self, warning: String) {
+    pub fn register_warning(&self, warning: PydanticSerializationUnexpectedValue) {
         if self.mode != WarningsMode::None {
-            self.add_warning(warning);
+            self.warnings.lock().expect("lock poisoned").push(warning);
         }
     }
 
@@ -415,15 +414,11 @@ impl CollectWarnings {
         if value.is_none() {
             Ok(())
         } else if extra.check.enabled() {
-            let type_name = value
-                .get_type()
-                .qualname()
-                .unwrap_or_else(|_| PyString::new(value.py(), "<unknown python object>"));
-
-            let value_str = truncate_safe_repr(value, None);
-            Err(PydanticSerializationUnexpectedValue::new_err(Some(format!(
-                "Expected `{field_type}` but got `{type_name}` with value `{value_str}` - serialized value may not be as expected"
-            ))))
+            Err(PydanticSerializationUnexpectedValue::new_from_parts(
+                Some(field_type.to_string()),
+                Some(value.clone().unbind()),
+            )
+            .to_py_err())
         } else {
             self.fallback_warning(field_type, value);
             Ok(())
@@ -452,23 +447,13 @@ impl CollectWarnings {
 
     fn fallback_warning(&self, field_type: &str, value: &Bound<'_, PyAny>) {
         if self.mode != WarningsMode::None {
-            let type_name = value
-                .get_type()
-                .qualname()
-                .unwrap_or_else(|_| PyString::new(value.py(), "<unknown python object>"));
-
-            let value_str = truncate_safe_repr(value, None);
-
-            self.add_warning(format!(
-                "Expected `{field_type}` but got `{type_name}` with value `{value_str}` - serialized value may not be as expected"
+            self.register_warning(PydanticSerializationUnexpectedValue::new_from_parts(
+                Some(field_type.to_string()),
+                Some(value.clone().unbind()),
             ));
         }
     }
 
-    fn add_warning(&self, message: String) {
-        self.warnings.lock().expect("lock poisoned").push(message);
-    }
-
     pub fn final_check(&self, py: Python) -> PyResult<()> {
         if self.mode == WarningsMode::None {
             return Ok(());
@@ -479,7 +464,9 @@ impl CollectWarnings {
             return Ok(());
         }
 
-        let message = format!("Pydantic serializer warnings:\n  {}", warnings.join("\n  "));
+        let formatted_warnings: Vec<String> = warnings.iter().map(|w| w.__repr__(py).to_string()).collect();
+
+        let message = format!("Pydantic serializer warnings:\n  {}", formatted_warnings.join("\n  "));
         if self.mode == WarningsMode::Warn {
             let user_warning_type = PyUserWarning::type_object(py);
             PyErr::warn(py, &user_warning_type, &CString::new(message)?, 0)
diff --git a/src/serializers/fields.rs b/src/serializers/fields.rs
index b0da9ba56..b89468d4e 100644
--- a/src/serializers/fields.rs
+++ b/src/serializers/fields.rs
@@ -9,7 +9,6 @@ use smallvec::SmallVec;
 
 use crate::serializers::extra::SerCheck;
 use crate::serializers::DuckTypingSerMode;
-use crate::tools::truncate_safe_repr;
 use crate::PydanticSerializationUnexpectedValue;
 
 use super::computed_fields::ComputedFields;
@@ -201,15 +200,12 @@ impl GeneralFieldsSerializer {
                     };
                     output_dict.set_item(key, value)?;
                 } else if field_extra.check == SerCheck::Strict {
-                    let type_name = field_extra.model_type_name();
-                    return Err(PydanticSerializationUnexpectedValue::new_err(Some(format!(
-                        "Unexpected field `{key}`{for_type_name}",
-                        for_type_name = if let Some(type_name) = type_name {
-                            format!(" for type `{type_name}`")
-                        } else {
-                            String::new()
-                        },
-                    ))));
+                    return Err(PydanticSerializationUnexpectedValue::new(
+                        Some(format!("Unexpected field `{key}`")),
+                        field_extra.model_type_name().map(|bound| bound.to_string()),
+                        None,
+                    )
+                    .to_py_err());
                 }
             }
         }
@@ -221,16 +217,13 @@ impl GeneralFieldsSerializer {
             && self.required_fields > used_req_fields
         {
             let required_fields = self.required_fields;
-            let type_name = extra.model_type_name();
-            let field_value = match extra.model {
-                Some(model) => truncate_safe_repr(model, Some(100)),
-                None => "<unknown python object>".to_string(),
-            };
 
-            Err(PydanticSerializationUnexpectedValue::new_err(Some(format!(
-                "Expected {required_fields} fields but got {used_req_fields}{for_type_name} with value `{field_value}` - serialized value may not be as expected.",
-                for_type_name = if let Some(type_name) = type_name { format!(" for type `{type_name}`") } else { String::new() },
-            ))))
+            Err(PydanticSerializationUnexpectedValue::new(
+                Some(format!("Expected {required_fields} fields but got {used_req_fields}").to_string()),
+                extra.model_type_name().map(|bound| bound.to_string()),
+                extra.model.map(|bound| bound.clone().unbind()),
+            )
+            .to_py_err())
         } else {
             Ok(output_dict)
         }
diff --git a/src/serializers/type_serializers/datetime_etc.rs b/src/serializers/type_serializers/datetime_etc.rs
index 3486b5999..0b601745a 100644
--- a/src/serializers/type_serializers/datetime_etc.rs
+++ b/src/serializers/type_serializers/datetime_etc.rs
@@ -34,7 +34,7 @@ fn downcast_date_reject_datetime<'a, 'py>(py_date: &'a Bound<'py, PyAny>) -> PyR
         }
     }
 
-    Err(PydanticSerializationUnexpectedValue::new_err(None))
+    Err(PydanticSerializationUnexpectedValue::new_from_msg(None).to_py_err())
 }
 
 macro_rules! build_serializer {
diff --git a/src/serializers/type_serializers/float.rs b/src/serializers/type_serializers/float.rs
index fd79a88b5..41539813b 100644
--- a/src/serializers/type_serializers/float.rs
+++ b/src/serializers/type_serializers/float.rs
@@ -75,7 +75,7 @@ impl TypeSerializer for FloatSerializer {
         match extra.ob_type_lookup.is_type(value, ObType::Float) {
             IsType::Exact => Ok(value.clone().unbind()),
             IsType::Subclass => match extra.check {
-                SerCheck::Strict => Err(PydanticSerializationUnexpectedValue::new_err(None)),
+                SerCheck::Strict => Err(PydanticSerializationUnexpectedValue::new_from_msg(None).to_py_err()),
                 SerCheck::Lax | SerCheck::None => match extra.mode {
                     SerMode::Json => value.extract::<f64>()?.into_py_any(py),
                     _ => infer_to_python(value, include, exclude, extra),
diff --git a/src/serializers/type_serializers/function.rs b/src/serializers/type_serializers/function.rs
index 79317035d..3c66583e2 100644
--- a/src/serializers/type_serializers/function.rs
+++ b/src/serializers/type_serializers/function.rs
@@ -194,7 +194,7 @@ fn on_error(py: Python, err: PyErr, function_name: &str, extra: &Extra) -> PyRes
         if extra.check.enabled() {
             Err(err)
         } else {
-            extra.warnings.custom_warning(ser_err.__repr__());
+            extra.warnings.register_warning(ser_err);
             Ok(())
         }
     } else if let Ok(err) = exception.extract::<PydanticSerializationError>() {
diff --git a/src/serializers/type_serializers/model.rs b/src/serializers/type_serializers/model.rs
index 274fb48a0..4bae243fc 100644
--- a/src/serializers/type_serializers/model.rs
+++ b/src/serializers/type_serializers/model.rs
@@ -190,7 +190,7 @@ impl TypeSerializer for ModelSerializer {
             let py = value.py();
             let root = value.getattr(intern!(py, ROOT_FIELD)).map_err(|original_err| {
                 if root_extra.check.enabled() {
-                    PydanticSerializationUnexpectedValue::new_err(None)
+                    PydanticSerializationUnexpectedValue::new_from_msg(None).to_py_err()
                 } else {
                     original_err
                 }
diff --git a/src/serializers/type_serializers/simple.rs b/src/serializers/type_serializers/simple.rs
index 2cbed2a58..41d69ce75 100644
--- a/src/serializers/type_serializers/simple.rs
+++ b/src/serializers/type_serializers/simple.rs
@@ -123,7 +123,7 @@ macro_rules! build_simple_serializer {
                 match extra.ob_type_lookup.is_type(value, $ob_type) {
                     IsType::Exact => Ok(value.clone().unbind()),
                     IsType::Subclass => match extra.check {
-                        SerCheck::Strict => Err(PydanticSerializationUnexpectedValue::new_err(None)),
+                        SerCheck::Strict => Err(PydanticSerializationUnexpectedValue::new_from_msg(None).to_py_err()),
                         SerCheck::Lax | SerCheck::None => match extra.mode {
                             SerMode::Json => value.extract::<$rust_type>()?.into_py_any(py),
                             _ => infer_to_python(value, include, exclude, extra),
diff --git a/src/serializers/type_serializers/tuple.rs b/src/serializers/type_serializers/tuple.rs
index 1d8057475..e5e3da353 100644
--- a/src/serializers/type_serializers/tuple.rs
+++ b/src/serializers/type_serializers/tuple.rs
@@ -214,11 +214,12 @@ impl TupleSerializer {
                 .chain(self.serializers[variadic_item_index + 1..].iter());
             use_serializers!(serializers_iter);
         } else if extra.check == SerCheck::Strict && n_items != self.serializers.len() {
-            return Err(PydanticSerializationUnexpectedValue::new_err(Some(format!(
+            return Err(PydanticSerializationUnexpectedValue::new_from_msg(Some(format!(
                 "Expected {} items, but got {}",
                 self.serializers.len(),
                 n_items
-            ))));
+            )))
+            .to_py_err());
         } else {
             use_serializers!(self.serializers.iter());
             let mut warned = false;
@@ -226,7 +227,9 @@ impl TupleSerializer {
                 if !warned {
                     extra
                         .warnings
-                        .custom_warning("Unexpected extra items present in tuple".to_string());
+                        .register_warning(PydanticSerializationUnexpectedValue::new_from_msg(Some(
+                            "Unexpected extra items present in tuple".to_string(),
+                        )));
                     warned = true;
                 }
                 let op_next = self
diff --git a/src/serializers/type_serializers/union.rs b/src/serializers/type_serializers/union.rs
index 2c10c1f7b..62779a640 100644
--- a/src/serializers/type_serializers/union.rs
+++ b/src/serializers/type_serializers/union.rs
@@ -9,7 +9,7 @@ use crate::build_tools::py_schema_err;
 use crate::common::union::{Discriminator, SMALL_UNION_THRESHOLD};
 use crate::definitions::DefinitionsBuilder;
 use crate::serializers::PydanticSerializationUnexpectedValue;
-use crate::tools::{truncate_safe_repr, SchemaDict};
+use crate::tools::SchemaDict;
 
 use super::{
     infer_json_key, infer_serialize, infer_to_python, BuildSerializer, CombinedSerializer, Extra, SerCheck,
@@ -78,6 +78,7 @@ fn union_serialize<S>(
     extra: &Extra,
     choices: &[CombinedSerializer],
     retry_with_lax_check: bool,
+    py: Python<'_>,
 ) -> PyResult<Option<S>> {
     // try the serializers in left to right order with error_on fallback=true
     let mut new_extra = extra.clone();
@@ -104,14 +105,23 @@ fn union_serialize<S>(
     // If extra.check is SerCheck::None, we're in a top-level union. We should thus raise the warnings
     if extra.check == SerCheck::None {
         for err in &errors {
-            extra.warnings.custom_warning(err.to_string());
+            if err.is_instance_of::<PydanticSerializationUnexpectedValue>(py) {
+                let pydantic_err: PydanticSerializationUnexpectedValue = err.value(py).extract()?;
+                extra.warnings.register_warning(pydantic_err);
+            } else {
+                extra
+                    .warnings
+                    .register_warning(PydanticSerializationUnexpectedValue::new_from_msg(Some(
+                        err.to_string(),
+                    )));
+            }
         }
     }
     // Otherwise, if we've encountered errors, return them to the parent union, which should take
     // care of the formatting for us
     else if !errors.is_empty() {
         let message = errors.iter().map(ToString::to_string).collect::<Vec<_>>().join("\n");
-        return Err(PydanticSerializationUnexpectedValue::new_err(Some(message)));
+        return Err(PydanticSerializationUnexpectedValue::new_from_msg(Some(message)).to_py_err());
     }
 
     Ok(None)
@@ -130,6 +140,7 @@ impl TypeSerializer for UnionSerializer {
             extra,
             &self.choices,
             self.retry_with_lax_check(),
+            value.py(),
         )?
         .map_or_else(|| infer_to_python(value, include, exclude, extra), Ok)
     }
@@ -140,6 +151,7 @@ impl TypeSerializer for UnionSerializer {
             extra,
             &self.choices,
             self.retry_with_lax_check(),
+            key.py(),
         )?
         .map_or_else(|| infer_json_key(key, extra), Ok)
     }
@@ -157,6 +169,7 @@ impl TypeSerializer for UnionSerializer {
             extra,
             &self.choices,
             self.retry_with_lax_check(),
+            value.py(),
         ) {
             Ok(Some(v)) => infer_serialize(v.bind(value.py()), serializer, None, None, extra),
             Ok(None) => infer_serialize(value, serializer, include, exclude, extra),
@@ -328,10 +341,11 @@ impl TaggedUnionSerializer {
         } else if extra.check == SerCheck::None {
             // If extra.check is SerCheck::None, we're in a top-level union. We should thus raise
             // this warning
-            let value_str = truncate_safe_repr(value, None);
-            extra.warnings.custom_warning(
-                format!(
-                    "Failed to get discriminator value for tagged union serialization with value `{value_str}` - defaulting to left to right union serialization."
+            extra.warnings.register_warning(
+                PydanticSerializationUnexpectedValue::new(
+                    Some("Defaulting to left to right union serialization - failed to get discriminator value for tagged union serialization".to_string()),
+                    None,
+                    Some(value.clone().unbind()),
                 )
             );
         }
@@ -339,6 +353,6 @@ impl TaggedUnionSerializer {
         // if we haven't returned at this point, we should fallback to the union serializer
         // which preserves the historical expectation that we do our best with serialization
         // even if that means we resort to inference
-        union_serialize(selector, extra, &self.choices, self.retry_with_lax_check())
+        union_serialize(selector, extra, &self.choices, self.retry_with_lax_check(), value.py())
     }
 }
diff --git a/src/tools.rs b/src/tools.rs
index 21631b451..96146d30c 100644
--- a/src/tools.rs
+++ b/src/tools.rs
@@ -118,6 +118,7 @@ pub fn safe_repr<'py>(v: &Bound<'py, PyAny>) -> ReprOutput<'py> {
     }
 }
 
+// warning: this function can be incredibly slow, so use with caution
 pub fn truncate_safe_repr(v: &Bound<'_, PyAny>, max_len: Option<usize>) -> String {
     let max_len = max_len.unwrap_or(50); // default to 100 bytes
     let input_str = safe_repr(v);
diff --git a/tests/serializers/test_any.py b/tests/serializers/test_any.py
index c3b3e2f8f..09d492177 100644
--- a/tests/serializers/test_any.py
+++ b/tests/serializers/test_any.py
@@ -163,9 +163,10 @@ def test_any_with_date_serializer():
     with pytest.warns(UserWarning) as warning_info:
         assert s.to_python(b'bang', mode='json') == 'bang'
 
-    assert [w.message.args[0] for w in warning_info.list] == [
-        "Pydantic serializer warnings:\n  Expected `date` but got `bytes` with value `b'bang'` - serialized value may not be as expected"
-    ]
+    assert (
+        "Expected `date` - serialized value may not be as expected [input_value=b'bang', input_type=bytes]"
+        in warning_info.list[0].message.args[0]
+    )
 
 
 def test_any_with_timedelta_serializer():
@@ -177,10 +178,10 @@ def test_any_with_timedelta_serializer():
     with pytest.warns(UserWarning) as warning_info:
         assert s.to_python(b'bang', mode='json') == 'bang'
 
-    assert [w.message.args[0] for w in warning_info.list] == [
-        "Pydantic serializer warnings:\n  Expected `timedelta` but got `bytes` with value `b'bang'` - "
-        'serialized value may not be as expected'
-    ]
+    assert (
+        "Expected `timedelta` - serialized value may not be as expected [input_value=b'bang', input_type=bytes]"
+        in warning_info.list[0].message.args[0]
+    )
 
 
 def test_any_config_timedelta_float():
diff --git a/tests/serializers/test_bytes.py b/tests/serializers/test_bytes.py
index 32c11fac9..b5d22aba0 100644
--- a/tests/serializers/test_bytes.py
+++ b/tests/serializers/test_bytes.py
@@ -47,19 +47,23 @@ def test_bytes_dict_key():
 def test_bytes_fallback():
     s = SchemaSerializer(core_schema.bytes_schema())
     with pytest.warns(
-        UserWarning, match='Expected `bytes` but got `int` with value `123` - serialized value may not be as expected'
+        UserWarning,
+        match=r'Expected `bytes` - serialized value may not be as expected \[input_value=123, input_type=int\]',
     ):
         assert s.to_python(123) == 123
     with pytest.warns(
-        UserWarning, match='Expected `bytes` but got `int` with value `123` - serialized value may not be as expected'
+        UserWarning,
+        match=r'Expected `bytes` - serialized value may not be as expected \[input_value=123, input_type=int\]',
     ):
         assert s.to_python(123, mode='json') == 123
     with pytest.warns(
-        UserWarning, match='Expected `bytes` but got `int` with value `123` - serialized value may not be as expected'
+        UserWarning,
+        match=r'Expected `bytes` - serialized value may not be as expected \[input_value=123, input_type=int\]',
     ):
         assert s.to_json(123) == b'123'
     with pytest.warns(
-        UserWarning, match="Expected `bytes` but got `str` with value `'foo'` - serialized value may not be as expected"
+        UserWarning,
+        match=r"Expected `bytes` - serialized value may not be as expected \[input_value='foo', input_type=str\]",
     ):
         assert s.to_json('foo') == b'"foo"'
 
diff --git a/tests/serializers/test_datetime.py b/tests/serializers/test_datetime.py
index 19d5477f3..e6f71ba0c 100644
--- a/tests/serializers/test_datetime.py
+++ b/tests/serializers/test_datetime.py
@@ -14,13 +14,13 @@ def test_datetime():
 
     with pytest.warns(
         UserWarning,
-        match='Expected `datetime` but got `int` with value `123` - serialized value may not be as expected',
+        match=r'Expected `datetime` - serialized value may not be as expected \[input_value=123, input_type=int\]',
     ):
         assert v.to_python(123, mode='json') == 123
 
     with pytest.warns(
         UserWarning,
-        match='Expected `datetime` but got `int` with value `123` - serialized value may not be as expected',
+        match=r'Expected `datetime` - serialized value may not be as expected \[input_value=123, input_type=int\]',
     ):
         assert v.to_json(123) == b'123'
 
diff --git a/tests/serializers/test_decimal.py b/tests/serializers/test_decimal.py
index 277843aec..e92529b72 100644
--- a/tests/serializers/test_decimal.py
+++ b/tests/serializers/test_decimal.py
@@ -21,12 +21,14 @@ def test_decimal():
     )
 
     with pytest.warns(
-        UserWarning, match='Expected `decimal` but got `int` with value `123` - serialized value may not be as expected'
+        UserWarning,
+        match=r'Expected `decimal` - serialized value may not be as expected \[input_value=123, input_type=int\]',
     ):
         assert v.to_python(123, mode='json') == 123
 
     with pytest.warns(
-        UserWarning, match='Expected `decimal` but got `int` with value `123` - serialized value may not be as expected'
+        UserWarning,
+        match=r'Expected `decimal` - serialized value may not be as expected \[input_value=123, input_type=int\]',
     ):
         assert v.to_json(123) == b'123'
 
diff --git a/tests/serializers/test_enum.py b/tests/serializers/test_enum.py
index 66ab00691..bac3aa406 100644
--- a/tests/serializers/test_enum.py
+++ b/tests/serializers/test_enum.py
@@ -18,11 +18,13 @@ class MyEnum(Enum):
     assert v.to_json(MyEnum.a) == b'1'
 
     with pytest.warns(
-        UserWarning, match='Expected `enum` but got `int` with value `1` - serialized value may not be as expected'
+        UserWarning,
+        match=r'Expected `enum` - serialized value may not be as expected \[input_value=1, input_type=int\]',
     ):
         assert v.to_python(1) == 1
     with pytest.warns(
-        UserWarning, match='Expected `enum` but got `int` with value `1` - serialized value may not be as expected'
+        UserWarning,
+        match=r'Expected `enum` - serialized value may not be as expected \[input_value=1, input_type=int\]',
     ):
         assert v.to_json(1) == b'1'
 
@@ -40,11 +42,13 @@ class MyEnum(int, Enum):
     assert v.to_json(MyEnum.a) == b'1'
 
     with pytest.warns(
-        UserWarning, match='Expected `enum` but got `int` with value `1` - serialized value may not be as expected'
+        UserWarning,
+        match=r'Expected `enum` - serialized value may not be as expected \[input_value=1, input_type=int\]',
     ):
         assert v.to_python(1) == 1
     with pytest.warns(
-        UserWarning, match='Expected `enum` but got `int` with value `1` - serialized value may not be as expected'
+        UserWarning,
+        match=r'Expected `enum` - serialized value may not be as expected \[input_value=1, input_type=int\]',
     ):
         assert v.to_json(1) == b'1'
 
@@ -62,11 +66,13 @@ class MyEnum(str, Enum):
     assert v.to_json(MyEnum.a) == b'"a"'
 
     with pytest.warns(
-        UserWarning, match="Expected `enum` but got `str` with value `'a'` - serialized value may not be as expected"
+        UserWarning,
+        match=r"Expected `enum` - serialized value may not be as expected \[input_value='a', input_type=str\]",
     ):
         assert v.to_python('a') == 'a'
     with pytest.warns(
-        UserWarning, match="Expected `enum` but got `str` with value `'a'` - serialized value may not be as expected"
+        UserWarning,
+        match=r"Expected `enum` - serialized value may not be as expected \[input_value='a', input_type=str\]",
     ):
         assert v.to_json('a') == b'"a"'
 
@@ -89,11 +95,13 @@ class MyEnum(Enum):
     assert v.to_json({MyEnum.a: 'x'}) == b'{"1":"x"}'
 
     with pytest.warns(
-        UserWarning, match="Expected `enum` but got `str` with value `'x'` - serialized value may not be as expected"
+        UserWarning,
+        match=r"Expected `enum` - serialized value may not be as expected \[input_value='x', input_type=str\]",
     ):
         assert v.to_python({'x': 'x'}) == {'x': 'x'}
     with pytest.warns(
-        UserWarning, match="Expected `enum` but got `str` with value `'x'` - serialized value may not be as expected"
+        UserWarning,
+        match=r"Expected `enum` - serialized value may not be as expected \[input_value='x', input_type=str\]",
     ):
         assert v.to_json({'x': 'x'}) == b'{"x":"x"}'
 
@@ -116,10 +124,12 @@ class MyEnum(int, Enum):
     assert v.to_json({MyEnum.a: 'x'}) == b'{"1":"x"}'
 
     with pytest.warns(
-        UserWarning, match="Expected `enum` but got `str` with value `'x'` - serialized value may not be as expected"
+        UserWarning,
+        match=r"Expected `enum` - serialized value may not be as expected \[input_value='x', input_type=str\]",
     ):
         assert v.to_python({'x': 'x'}) == {'x': 'x'}
     with pytest.warns(
-        UserWarning, match="Expected `enum` but got `str` with value `'x'` - serialized value may not be as expected"
+        UserWarning,
+        match=r"Expected `enum` - serialized value may not be as expected \[input_value='x', input_type=str\]",
     ):
         assert v.to_json({'x': 'x'}) == b'{"x":"x"}'
diff --git a/tests/serializers/test_functions.py b/tests/serializers/test_functions.py
index 738e8acc2..926749721 100644
--- a/tests/serializers/test_functions.py
+++ b/tests/serializers/test_functions.py
@@ -207,7 +207,7 @@ def append_42(value, _info):
     assert s.to_python([1, 2, 3], mode='json') == [1, 2, 3, 42]
     assert s.to_json([1, 2, 3]) == b'[1,2,3,42]'
 
-    msg = r"Expected `list\[int\]` but got `str` with value `'abc'` - serialized value may not be as expected"
+    msg = r"Expected `list\[int\]` - serialized value may not be as expected \[input_value='abc', input_type=str\]"
     with pytest.warns(UserWarning, match=msg):
         assert s.to_python('abc') == 'abc'
 
@@ -323,15 +323,18 @@ def test_wrong_return_type():
         )
     )
     with pytest.warns(
-        UserWarning, match="Expected `int` but got `str` with value `'123'` - serialized value may not be as expected"
+        UserWarning,
+        match=r"Expected `int` - serialized value may not be as expected \[input_value='123', input_type=str\]",
     ):
         assert s.to_python(123) == '123'
     with pytest.warns(
-        UserWarning, match="Expected `int` but got `str` with value `'123'` - serialized value may not be as expected"
+        UserWarning,
+        match=r"Expected `int` - serialized value may not be as expected \[input_value='123', input_type=str\]",
     ):
         assert s.to_python(123, mode='json') == '123'
     with pytest.warns(
-        UserWarning, match="Expected `int` but got `str` with value `'123'` - serialized value may not be as expected"
+        UserWarning,
+        match=r"Expected `int` - serialized value may not be as expected \[input_value='123', input_type=str\]",
     ):
         assert s.to_json(123) == b'"123"'
 
@@ -363,15 +366,18 @@ def f(value, serializer):
     assert s.to_python(3, mode='json') == 'result=3'
     assert s.to_json(3) == b'"result=3"'
     with pytest.warns(
-        UserWarning, match='Expected `str` but got `int` with value `42` - serialized value may not be as expected'
+        UserWarning,
+        match=r'Expected `str` - serialized value may not be as expected \[input_value=42, input_type=int\]',
     ):
         assert s.to_python(42) == 42
     with pytest.warns(
-        UserWarning, match='Expected `str` but got `int` with value `42` - serialized value may not be as expected'
+        UserWarning,
+        match=r'Expected `str` - serialized value may not be as expected \[input_value=42, input_type=int\]',
     ):
         assert s.to_python(42, mode='json') == 42
     with pytest.warns(
-        UserWarning, match='Expected `str` but got `int` with value `42` - serialized value may not be as expected'
+        UserWarning,
+        match=r'Expected `str` - serialized value may not be as expected \[input_value=42, input_type=int\]',
     ):
         assert s.to_json(42) == b'42'
 
@@ -624,7 +630,8 @@ def f(value, _info):
 
     s = SchemaSerializer(core_schema.with_info_after_validator_function(f, core_schema.int_schema()))
     with pytest.warns(
-        UserWarning, match="Expected `int` but got `str` with value `'abc'` - serialized value may not be as expected"
+        UserWarning,
+        match=r"Expected `int` - serialized value may not be as expected \[input_value='abc', input_type=str\]",
     ):
         assert s.to_python('abc') == 'abc'
 
@@ -635,7 +642,8 @@ def f(value, handler, _info):
 
     s = SchemaSerializer(core_schema.with_info_wrap_validator_function(f, core_schema.int_schema()))
     with pytest.warns(
-        UserWarning, match="Expected `int` but got `str` with value `'abc'` - serialized value may not be as expected"
+        UserWarning,
+        match=r"Expected `int` - serialized value may not be as expected \[input_value='abc', input_type=str\]",
     ):
         assert s.to_python('abc') == 'abc'
 
diff --git a/tests/serializers/test_generator.py b/tests/serializers/test_generator.py
index cbd72ee8e..b0ddbf0b1 100644
--- a/tests/serializers/test_generator.py
+++ b/tests/serializers/test_generator.py
@@ -54,12 +54,20 @@ def test_generator_any():
     assert s.to_json(iter(['a', b'b', 3])) == b'["a","b",3]'
     assert s.to_json(gen_ok('a', b'b', 3)) == b'["a","b",3]'
 
-    msg = 'Expected `generator` but got `int` with value `4` - serialized value may not be as expected'
-    with pytest.warns(UserWarning, match=msg):
+    with pytest.warns(
+        UserWarning,
+        match=r'Expected `generator` - serialized value may not be as expected \[input_value=4, input_type=int\]',
+    ):
         assert s.to_python(4) == 4
-    with pytest.warns(UserWarning, match="Expected `generator` but got `tuple` with value `\\('a', b'b', 3\\)`"):
+    with pytest.warns(
+        UserWarning,
+        match=r"Expected `generator` - serialized value may not be as expected \[input_value=\('a', b'b', 3\), input_type=tuple\]",
+    ):
         assert s.to_python(('a', b'b', 3)) == ('a', b'b', 3)
-    with pytest.warns(UserWarning, match="Expected `generator` but got `str` with value `'abc'`"):
+    with pytest.warns(
+        UserWarning,
+        match=r"Expected `generator` - serialized value may not be as expected \[input_value='abc', input_type=str\]",
+    ):
         assert s.to_python('abc') == 'abc'
 
     with pytest.raises(ValueError, match='oops'):
@@ -89,19 +97,21 @@ def test_generator_int():
         s.to_json(gen_error(1, 2))
 
     with pytest.warns(
-        UserWarning, match="Expected `int` but got `str` with value `'a'` - serialized value may not be as expected"
+        UserWarning,
+        match=r"Expected `int` - serialized value may not be as expected \[input_value='a', input_type=str\]",
     ):
         s.to_json(gen_ok(1, 'a'))
 
     gen = s.to_python(gen_ok(1, 'a'))
     assert next(gen) == 1
     with pytest.warns(
-        UserWarning, match="Expected `int` but got `str` with value `'a'` - serialized value may not be as expected"
+        UserWarning,
+        match=r"Expected `int` - serialized value may not be as expected \[input_value='a', input_type=str\]",
     ):
         assert next(gen) == 'a'
     with pytest.warns(
         UserWarning,
-        match='Expected `generator` but got `tuple` with value `\\(1, 2, 3\\)` - serialized value may not.+',
+        match=r'Expected `generator` - serialized value may not be as expected \[input_value=\(1, 2, 3\), input_type=tuple\]',
     ):
         s.to_python((1, 2, 3))
 
diff --git a/tests/serializers/test_list_tuple.py b/tests/serializers/test_list_tuple.py
index 5e8443805..7473ee261 100644
--- a/tests/serializers/test_list_tuple.py
+++ b/tests/serializers/test_list_tuple.py
@@ -1,5 +1,4 @@
 import json
-import re
 from functools import partial
 
 import pytest
@@ -24,27 +23,35 @@ def test_list_any():
 
 def test_list_fallback():
     v = SchemaSerializer(core_schema.list_schema(core_schema.any_schema()))
-    msg = "Expected `list[any]` but got `str` with value `'apple'` - serialized value may not be as expected"
-    with pytest.warns(UserWarning, match=re.escape(msg)):
+    with pytest.warns(
+        UserWarning,
+        match=r"Expected `list\[any\]` - serialized value may not be as expected \[input_value='apple', input_type=str\]",
+    ):
         assert v.to_python('apple') == 'apple'
 
     with pytest.warns(UserWarning) as warning_info:
         assert v.to_json('apple') == b'"apple"'
-    assert [w.message.args[0] for w in warning_info.list] == [
-        "Pydantic serializer warnings:\n  Expected `list[any]` but got `str` with value `'apple'` - serialized value may not be as expected"
-    ]
-
-    msg = "Expected `list[any]` but got `bytes` with value `b'apple'` - serialized value may not be as expected"
-    with pytest.warns(UserWarning, match=re.escape(msg)):
+    "Expected `list[any]` - serialized value may not be as expected [input_value='apple', input_type=str]" in warning_info.list[
+        0
+    ].message.args[0]
+
+    with pytest.warns(
+        UserWarning,
+        match=r"Expected `list\[any\]` - serialized value may not be as expected \[input_value=b'apple', input_type=bytes\]",
+    ):
         assert v.to_json(b'apple') == b'"apple"'
 
-    msg = 'Expected `list[any]` but got `tuple` with value `(1, 2, 3)` - serialized value may not be as expected'
-    with pytest.warns(UserWarning, match=re.escape(msg)):
+    with pytest.warns(
+        UserWarning,
+        match=r'Expected `list\[any\]` - serialized value may not be as expected \[input_value=\(1, 2, 3\), input_type=tuple\]',
+    ):
         assert v.to_python((1, 2, 3)) == (1, 2, 3)
 
     # # even though we're in the fallback state, non JSON types should still be converted to JSON here
-    msg = 'Expected `list[any]` but got `tuple` with value `(1, 2, 3)` - serialized value may not be as expected'
-    with pytest.warns(UserWarning, match=re.escape(msg)):
+    with pytest.warns(
+        UserWarning,
+        match=r'Expected `list\[any\]` - serialized value may not be as expected \[input_value=\(1, 2, 3\), input_type=tuple\]',
+    ):
         assert v.to_python((1, 2, 3), mode='json') == [1, 2, 3]
 
 
@@ -52,22 +59,20 @@ def test_list_str_fallback():
     v = SchemaSerializer(core_schema.list_schema(core_schema.str_schema()))
     with pytest.warns(UserWarning) as warning_info:
         assert v.to_json([1, 2, 3]) == b'[1,2,3]'
-    assert [w.message.args[0] for w in warning_info.list] == [
-        'Pydantic serializer warnings:\n'
-        '  Expected `str` but got `int` with value `1` - serialized value may not be as expected\n'
-        '  Expected `str` but got `int` with value `2` - serialized value may not be as expected\n'
-        '  Expected `str` but got `int` with value `3` - serialized value may not be as expected'
+
+    expected_warnings = [
+        'Expected `str` - serialized value may not be as expected [input_value=1, input_type=int]',
+        'Expected `str` - serialized value may not be as expected [input_value=2, input_type=int]',
+        'Expected `str` - serialized value may not be as expected [input_value=3, input_type=int]',
     ]
+
+    all_warnings = ''.join([w.message.args[0] for w in warning_info.list])
+    assert all([x in all_warnings for x in expected_warnings])
+
     with pytest.raises(PydanticSerializationError) as warning_ex:
         v.to_json([1, 2, 3], warnings='error')
-    assert str(warning_ex.value) == ''.join(
-        [
-            'Pydantic serializer warnings:\n'
-            '  Expected `str` but got `int` with value `1` - serialized value may not be as expected\n'
-            '  Expected `str` but got `int` with value `2` - serialized value may not be as expected\n'
-            '  Expected `str` but got `int` with value `3` - serialized value may not be as expected'
-        ]
-    )
+
+    assert all([x in str(warning_ex.value) for x in expected_warnings])
 
 
 def test_tuple_any():
@@ -249,26 +254,33 @@ def test_include_error_call_time(schema_func, seq_f, include, exclude):
 
 def test_tuple_fallback():
     v = SchemaSerializer(core_schema.tuple_variable_schema(core_schema.any_schema()))
-    msg = "Expected `tuple[any, ...]` but got `str` with value `'apple'` - serialized value may not be as expected"
-    with pytest.warns(UserWarning, match=re.escape(msg)):
+    with pytest.warns(
+        UserWarning,
+        match=r"Expected `tuple\[any, ...\]` - serialized value may not be as expected \[input_value='apple', input_type=str\]",
+    ):
         assert v.to_python('apple') == 'apple'
 
     with pytest.warns(UserWarning) as warning_info:
         assert v.to_json([1, 2, 3]) == b'[1,2,3]'
-    assert [w.message.args[0] for w in warning_info.list] == [
-        'Pydantic serializer warnings:\n  Expected `tuple[any, ...]` but got `list` with value `[1, 2, 3]` - '
-        'serialized value may not be as expected'
-    ]
 
-    msg = "Expected `tuple[any, ...]` but got `bytes` with value `b'apple'` - serialized value may not be as expected"
-    with pytest.warns(UserWarning, match=re.escape(msg)):
+    assert (
+        'Expected `tuple[any, ...]` - serialized value may not be as expected [input_value=[1, 2, 3], input_type=list]'
+        in warning_info.list[0].message.args[0]
+    )
+
+    with pytest.warns(
+        UserWarning,
+        match=r"Expected `tuple\[any, ...\]` - serialized value may not be as expected \[input_value=b'apple', input_type=bytes\]",
+    ):
         assert v.to_json(b'apple') == b'"apple"'
 
     assert v.to_python((1, 2, 3)) == (1, 2, 3)
 
     # even though we're in the fallback state, non JSON types should still be converted to JSON here
-    msg = 'Expected `tuple[any, ...]` but got `list` with value `[1, 2, 3]` - serialized value may not be as expected'
-    with pytest.warns(UserWarning, match=re.escape(msg)):
+    with pytest.warns(
+        UserWarning,
+        match=r'Expected `tuple\[any, ...\]` - serialized value may not be as expected \[input_value=\[1, 2, 3\], input_type=list\]',
+    ):
         assert v.to_python([1, 2, 3], mode='json') == [1, 2, 3]
 
 
@@ -398,13 +410,13 @@ def f(prefix, value, _info):
 
 def test_list_dict_key():
     s = SchemaSerializer(core_schema.dict_schema(core_schema.list_schema(), core_schema.int_schema()))
-    with pytest.warns(UserWarning, match=r'Expected `list\[any\]` but got `str`'):
+    with pytest.warns(UserWarning, match=r'Expected `list\[any\]`.+ input_type=str'):
         assert s.to_python({'xx': 1}) == {'xx': 1}
 
 
 def test_tuple_var_dict_key():
     s = SchemaSerializer(core_schema.dict_schema(core_schema.tuple_variable_schema(), core_schema.int_schema()))
-    with pytest.warns(UserWarning, match=r'Expected `tuple\[any, ...\]` but got `str`'):
+    with pytest.warns(UserWarning, match=r'Expected `tuple\[any, ...\]`.+input_type=str'):
         assert s.to_python({'xx': 1}) == {'xx': 1}
 
     assert s.to_python({(1, 2): 1}) == {(1, 2): 1}
diff --git a/tests/serializers/test_model.py b/tests/serializers/test_model.py
index 8786359e8..65871e050 100644
--- a/tests/serializers/test_model.py
+++ b/tests/serializers/test_model.py
@@ -236,16 +236,25 @@ def test_model_wrong_warn():
     assert s.to_python(None, mode='json') is None
     assert s.to_json(None) == b'null'
 
-    with pytest.warns(UserWarning, match='Expected `MyModel` but got `int` with value `123` - serialized value may.+'):
+    with pytest.warns(
+        UserWarning,
+        match=r'Expected `MyModel` - serialized value may not be as expected \[input_value=123, input_type=int\]',
+    ):
         assert s.to_python(123) == 123
-    with pytest.warns(UserWarning, match='Expected `MyModel` but got `int` with value `123` - serialized value may.+'):
+    with pytest.warns(
+        UserWarning,
+        match=r'Expected `MyModel` - serialized value may not be as expected \[input_value=123, input_type=int\]',
+    ):
         assert s.to_python(123, mode='json') == 123
-    with pytest.warns(UserWarning, match='Expected `MyModel` but got `int` with value `123` - serialized value may.+'):
+    with pytest.warns(
+        UserWarning,
+        match=r'Expected `MyModel` - serialized value may not be as expected \[input_value=123, input_type=int\]',
+    ):
         assert s.to_json(123) == b'123'
 
     with pytest.warns(
         UserWarning,
-        match="Expected `MyModel` but got `dict` with value `{'foo': 1, 'bar': b'more'}` - serialized value may.+",
+        match=r"Expected `MyModel` - serialized value may not be as expected \[input_value={'foo': 1, 'bar': b'more'}, input_type=dict\]",
     ):
         assert s.to_python({'foo': 1, 'bar': b'more'}) == {'foo': 1, 'bar': b'more'}
 
@@ -1171,7 +1180,9 @@ class BModel(BasicModel): ...
         )
     )
 
-    with pytest.warns(UserWarning, match='Expected 2 fields but got 1 for type `.*AModel` with value `.*`.+'):
+    with pytest.warns(
+        UserWarning, match='Expected 2 fields but got 1: Expected `AModel` - serialized value may not be as expected .+'
+    ):
         value = BasicModel(root=AModel(type='a'))
         s.to_python(value)
 
diff --git a/tests/serializers/test_nullable.py b/tests/serializers/test_nullable.py
index 86b64a213..0fa00f15a 100644
--- a/tests/serializers/test_nullable.py
+++ b/tests/serializers/test_nullable.py
@@ -12,6 +12,7 @@ def test_nullable():
     assert s.to_json(1) == b'1'
     assert s.to_json(None) == b'null'
     with pytest.warns(
-        UserWarning, match="Expected `int` but got `str` with value `'aaa'` - serialized value may not be as expected"
+        UserWarning,
+        match=r"Expected `int` - serialized value may not be as expected \[input_value='aaa', input_type=str\]",
     ):
         assert s.to_json('aaa') == b'"aaa"'
diff --git a/tests/serializers/test_other.py b/tests/serializers/test_other.py
index 13877d096..d6036db04 100644
--- a/tests/serializers/test_other.py
+++ b/tests/serializers/test_other.py
@@ -45,7 +45,8 @@ def test_lax_or_strict():
 
     assert s.to_json('abc') == b'"abc"'
     with pytest.warns(
-        UserWarning, match='Expected `str` but got `int` with value `123` - serialized value may not be as expected'
+        UserWarning,
+        match=r'Expected `str` - serialized value may not be as expected \[input_value=123, input_type=int\]',
     ):
         assert s.to_json(123) == b'123'
 
diff --git a/tests/serializers/test_set_frozenset.py b/tests/serializers/test_set_frozenset.py
index c2df80f0a..c7be8b69e 100644
--- a/tests/serializers/test_set_frozenset.py
+++ b/tests/serializers/test_set_frozenset.py
@@ -24,28 +24,37 @@ def test_frozenset_any():
 
 
 @pytest.mark.parametrize(
-    'input_value,json_output,warning_type',
+    'input_value,json_output,expected_type',
     [
-        ('apple', 'apple', r"`set\[int\]` but got `str` with value `'apple'`"),
-        ([1, 2, 3], [1, 2, 3], r'`set\[int\]` but got `list` with value `\[1, 2, 3\]`'),
-        ((1, 2, 3), [1, 2, 3], r'`set\[int\]` but got `tuple` with value `\(1, 2, 3\)`'),
+        ('apple', 'apple', r'set\[int\]'),
+        ([1, 2, 3], [1, 2, 3], r'set\[int\]'),
+        ((1, 2, 3), [1, 2, 3], r'set\[int\]'),
         (
             frozenset([1, 2, 3]),
             IsList(1, 2, 3, check_order=False),
-            r'`set\[int\]` but got `frozenset` with value `frozenset\({1, 2, 3}\)`',
+            r'set\[int\]',
         ),
-        ({1, 2, 'a'}, IsList(1, 2, 'a', check_order=False), "`int` but got `str` with value `'a'`"),
+        ({1, 2, 'a'}, IsList(1, 2, 'a', check_order=False), 'int'),
     ],
 )
-def test_set_fallback(input_value, json_output, warning_type):
+def test_set_fallback(input_value, json_output, expected_type):
     v = SchemaSerializer(core_schema.set_schema(core_schema.int_schema()))
     assert v.to_python({1, 2, 3}) == {1, 2, 3}
 
-    with pytest.warns(UserWarning, match=f'Expected {warning_type} - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning,
+        match=f'Expected `{expected_type}` - serialized value may not be as expected',
+    ):
         assert v.to_python(input_value) == input_value
 
-    with pytest.warns(UserWarning, match=f'Expected {warning_type} - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning,
+        match=f'Expected `{expected_type}` - serialized value may not be as expected',
+    ):
         assert v.to_python(input_value, mode='json') == json_output
 
-    with pytest.warns(UserWarning, match=f'Expected {warning_type} - serialized value may not be as expected'):
+    with pytest.warns(
+        UserWarning,
+        match=f'Expected `{expected_type}` - serialized value may not be as expected',
+    ):
         assert json.loads(v.to_json(input_value)) == json_output
diff --git a/tests/serializers/test_simple.py b/tests/serializers/test_simple.py
index 303c23463..cbedcf501 100644
--- a/tests/serializers/test_simple.py
+++ b/tests/serializers/test_simple.py
@@ -110,19 +110,19 @@ def test_simple_serializers_fallback(schema_type):
     s = SchemaSerializer({'type': schema_type})
     with pytest.warns(
         UserWarning,
-        match=f'Expected `{schema_type}` but got `list` with value `\\[1, 2, 3\\]` - serialized value may not be as expected',
+        match=rf'Expected `{schema_type}` - serialized value may not be as expected \[input_value=\[1, 2, 3\], input_type=list\]',
     ):
         assert s.to_python([1, 2, 3]) == [1, 2, 3]
 
     with pytest.warns(
         UserWarning,
-        match=f"Expected `{schema_type}` but got `list` with value `\\[1, 2, b'bytes'\\]` - serialized value may not be as expected",
+        match=rf"Expected `{schema_type}` - serialized value may not be as expected \[input_value=\[1, 2, b'bytes'\], input_type=list\]",
     ):
         assert s.to_python([1, 2, b'bytes'], mode='json') == [1, 2, 'bytes']
 
     with pytest.warns(
         UserWarning,
-        match=f'Expected `{schema_type}` but got `list` with value `\\[1, 2, 3\\]` - serialized value may not be as expected',
+        match=rf'Expected `{schema_type}` - serialized value may not be as expected \[input_value=\[1, 2, 3\], input_type=list\]',
     ):
         assert s.to_json([1, 2, 3]) == b'[1,2,3]'
 
diff --git a/tests/serializers/test_string.py b/tests/serializers/test_string.py
index 074179d8a..f547d49b2 100644
--- a/tests/serializers/test_string.py
+++ b/tests/serializers/test_string.py
@@ -25,7 +25,7 @@ def test_str():
 
 def test_huge_str():
     v = SchemaSerializer(core_schema.int_schema())
-    msg = "Expected `int` but got `str` with value `'123456789012345678901234...89012345678901234567890'` - serialized value may not be as expected"
+    msg = r"Expected `int` - serialized value may not be as expected \[input_value='123456789012345678901234...89012345678901234567890', input_type=str\]"
     with pytest.warns(UserWarning, match=msg):
         v.to_python(
             '12345678901234567890123456789012345678901234567890123456789012345678901234567890\
@@ -41,39 +41,48 @@ def test_str_fallback():
     assert s.to_python(None, mode='json') is None
     assert s.to_json(None) == b'null'
     with pytest.warns(
-        UserWarning, match='Expected `str` but got `int` with value `123` - serialized value may not be as expected'
+        UserWarning,
+        match=r'Expected `str` - serialized value may not be as expected \[input_value=123, input_type=int\]',
     ):
         assert s.to_python(123) == 123
     with pytest.warns(
-        UserWarning, match='Expected `str` but got `int` with value `123` - serialized value may not be as expected'
+        UserWarning,
+        match=r'Expected `str` - serialized value may not be as expected \[input_value=123, input_type=int\]',
     ):
         assert s.to_python(123, mode='json') == 123
     with pytest.warns(
-        UserWarning, match='Expected `str` but got `int` with value `123` - serialized value may not be as expected'
+        UserWarning,
+        match=r'Expected `str` - serialized value may not be as expected \[input_value=123, input_type=int\]',
     ):
         assert s.to_json(123) == b'123'
     with pytest.warns(
-        UserWarning, match='Expected `str` but got `int` with value `123` - serialized value may not be as expected'
+        UserWarning,
+        match=r'Expected `str` - serialized value may not be as expected \[input_value=123, input_type=int\]',
     ):
         assert s.to_python(123, warnings='warn') == 123
     with pytest.warns(
-        UserWarning, match='Expected `str` but got `int` with value `123` - serialized value may not be as expected'
+        UserWarning,
+        match=r'Expected `str` - serialized value may not be as expected \[input_value=123, input_type=int\]',
     ):
         assert s.to_python(123, mode='json', warnings='warn') == 123
     with pytest.warns(
-        UserWarning, match='Expected `str` but got `int` with value `123` - serialized value may not be as expected'
+        UserWarning,
+        match=r'Expected `str` - serialized value may not be as expected \[input_value=123, input_type=int\]',
     ):
         assert s.to_json(123, warnings='warn') == b'123'
     with pytest.warns(
-        UserWarning, match='Expected `str` but got `int` with value `123` - serialized value may not be as expected'
+        UserWarning,
+        match=r'Expected `str` - serialized value may not be as expected \[input_value=123, input_type=int\]',
     ):
         assert s.to_python(123, warnings=True) == 123
     with pytest.warns(
-        UserWarning, match='Expected `str` but got `int` with value `123` - serialized value may not be as expected'
+        UserWarning,
+        match=r'Expected `str` - serialized value may not be as expected \[input_value=123, input_type=int\]',
     ):
         assert s.to_python(123, mode='json', warnings=True) == 123
     with pytest.warns(
-        UserWarning, match='Expected `str` but got `int` with value `123` - serialized value may not be as expected'
+        UserWarning,
+        match=r'Expected `str` - serialized value may not be as expected \[input_value=123, input_type=int\]',
     ):
         assert s.to_json(123, warnings=True) == b'123'
 
@@ -92,17 +101,17 @@ def test_str_errors():
     s = SchemaSerializer(core_schema.str_schema())
     with pytest.raises(
         PydanticSerializationError,
-        match='Expected `str` but got `int` with value `123` - serialized value may not be as expected',
+        match=r'Expected `str` - serialized value may not be as expected \[input_value=123, input_type=int\]',
     ):
         assert s.to_python(123, warnings='error') == 123
     with pytest.raises(
         PydanticSerializationError,
-        match='Expected `str` but got `int` with value `123` - serialized value may not be as expected',
+        match=r'Expected `str` - serialized value may not be as expected \[input_value=123, input_type=int\]',
     ):
         assert s.to_python(123, mode='json', warnings='error') == 123
     with pytest.raises(
         PydanticSerializationError,
-        match='Expected `str` but got `int` with value `123` - serialized value may not be as expected',
+        match=r'Expected `str` - serialized value may not be as expected \[input_value=123, input_type=int\]',
     ):
         assert s.to_json(123, warnings='error') == b'123'
 
diff --git a/tests/serializers/test_timedelta.py b/tests/serializers/test_timedelta.py
index 19abb673d..b5603ee79 100644
--- a/tests/serializers/test_timedelta.py
+++ b/tests/serializers/test_timedelta.py
@@ -19,13 +19,13 @@ def test_timedelta():
 
     with pytest.warns(
         UserWarning,
-        match='Expected `timedelta` but got `int` with value `123` - serialized value may not be as expected',
+        match=r'Expected `timedelta` - serialized value may not be as expected \[input_value=123, input_type=int\]',
     ):
         assert v.to_python(123, mode='json') == 123
 
     with pytest.warns(
         UserWarning,
-        match='Expected `timedelta` but got `int` with value `123` - serialized value may not be as expected',
+        match=r'Expected `timedelta` - serialized value may not be as expected \[input_value=123, input_type=int\]',
     ):
         assert v.to_json(123) == b'123'
 
diff --git a/tests/serializers/test_union.py b/tests/serializers/test_union.py
index 15b9bf2c0..7cf11639a 100644
--- a/tests/serializers/test_union.py
+++ b/tests/serializers/test_union.py
@@ -35,8 +35,8 @@ def test_union_error():
     s = SchemaSerializer(core_schema.union_schema([core_schema.bool_schema(), core_schema.int_schema()]))
 
     messages = [
-        "Expected `bool` but got `str` with value `'a string'` - serialized value may not be as expected",
-        "Expected `int` but got `str` with value `'a string'` - serialized value may not be as expected",
+        "Expected `bool` - serialized value may not be as expected [input_value='a string', input_type=str]",
+        "Expected `int` - serialized value may not be as expected [input_value='a string', input_type=str]",
     ]
 
     with warnings.catch_warnings(record=True) as w:
@@ -916,10 +916,10 @@ def test_union_of_unions_of_models_invalid_variant(union_of_unions_schema: core_
     s = SchemaSerializer(union_of_unions_schema)
     # All warnings should be available
     messages = [
-        'Expected `ModelA` but got `ModelAlien`',
-        'Expected `ModelB` but got `ModelAlien`',
-        'Expected `ModelCat` but got `ModelAlien`',
-        'Expected `ModelDog` but got `ModelAlien`',
+        'Expected `ModelA`',
+        'Expected `ModelB`',
+        'Expected `ModelCat`',
+        'Expected `ModelDog`',
     ]
 
     with warnings.catch_warnings(record=True) as w:
@@ -927,6 +927,7 @@ def test_union_of_unions_of_models_invalid_variant(union_of_unions_schema: core_
         s.to_python(ModelAlien(type_='alien'))
         for m in messages:
             assert m in str(w[0].message)
+            assert 'input_type=ModelAlien' in str(w[0].message)
 
 
 @pytest.fixture
@@ -981,10 +982,10 @@ def test_union_of_unions_of_models_with_tagged_union_invalid_variant(
     s = SchemaSerializer(tagged_union_of_unions_schema)
     # All warnings should be available
     messages = [
-        'Expected `ModelA` but got `ModelAlien`',
-        'Expected `ModelB` but got `ModelAlien`',
-        'Expected `ModelCat` but got `ModelAlien`',
-        'Expected `ModelDog` but got `ModelAlien`',
+        'Expected `ModelA`',
+        'Expected `ModelB`',
+        'Expected `ModelCat`',
+        'Expected `ModelDog`',
     ]
 
     with warnings.catch_warnings(record=True) as w:
@@ -992,6 +993,7 @@ def test_union_of_unions_of_models_with_tagged_union_invalid_variant(
         s.to_python(ModelAlien(type_='alien'))
         for m in messages:
             assert m in str(w[0].message)
+            assert 'input_type=ModelAlien' in str(w[0].message)
 
 
 def test_mixed_union_models_and_other_types() -> None:
diff --git a/tests/serializers/test_url.py b/tests/serializers/test_url.py
index be906c75b..8f826e5df 100644
--- a/tests/serializers/test_url.py
+++ b/tests/serializers/test_url.py
@@ -20,7 +20,7 @@ def test_url():
 
     with pytest.warns(
         UserWarning,
-        match="Expected `url` but got `str` with value `'https://example.com'` - serialized value may not be as expected",
+        match=r"Expected `url` - serialized value may not be as expected \[input_value='https://example.com', input_type=str\]",
     ):
         assert s.to_python('https://example.com', mode='json') == 'https://example.com'
 
@@ -40,7 +40,7 @@ def test_multi_host_url():
 
     with pytest.warns(
         UserWarning,
-        match="Expected `multi-host-url` but got `str` with value `'https://ex.com,ex.org/path'` - serialized value may not be as expected",
+        match=r"Expected `multi-host-url` - serialized value may not be as expected \[input_value='https://ex.com,ex.org/path', input_type=str\]",
     ):
         assert s.to_python('https://ex.com,ex.org/path', mode='json') == 'https://ex.com,ex.org/path'
 
diff --git a/tests/serializers/test_uuid.py b/tests/serializers/test_uuid.py
index fed9cfc98..8aee57763 100644
--- a/tests/serializers/test_uuid.py
+++ b/tests/serializers/test_uuid.py
@@ -15,12 +15,14 @@ def test_uuid():
     assert v.to_json(UUID('12345678-1234-5678-1234-567812345678')) == b'"12345678-1234-5678-1234-567812345678"'
 
     with pytest.warns(
-        UserWarning, match='Expected `uuid` but got `int` with value `123` - serialized value may not be as expected'
+        UserWarning,
+        match=r'Expected `uuid` - serialized value may not be as expected \[input_value=123, input_type=int\]',
     ):
         assert v.to_python(123, mode='json') == 123
 
     with pytest.warns(
-        UserWarning, match='Expected `uuid` but got `int` with value `123` - serialized value may not be as expected'
+        UserWarning,
+        match=r'Expected `uuid` - serialized value may not be as expected \[input_value=123, input_type=int\]',
     ):
         assert v.to_json(123) == b'123'
 

From 72350a1352da43c92a8c4d7ac55924fa6bf6c70e Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Tue, 4 Mar 2025 14:43:29 -0500
Subject: [PATCH 505/550] Skip reusing wrap validators / serializers for
 prebuilt variants (#1660)

---
 src/common/prebuilt.rs      |   4 +-
 src/serializers/prebuilt.rs |   8 +-
 src/validators/prebuilt.rs  |   8 +-
 tests/test_prebuilt.py      | 237 ++++++++++++++++++++++++++++++++++++
 4 files changed, 249 insertions(+), 8 deletions(-)

diff --git a/src/common/prebuilt.rs b/src/common/prebuilt.rs
index f4307064f..e66e2c35b 100644
--- a/src/common/prebuilt.rs
+++ b/src/common/prebuilt.rs
@@ -8,7 +8,7 @@ pub fn get_prebuilt<T>(
     type_: &str,
     schema: &Bound<'_, PyDict>,
     prebuilt_attr_name: &str,
-    extractor: impl FnOnce(Bound<'_, PyAny>) -> PyResult<T>,
+    extractor: impl FnOnce(Bound<'_, PyAny>) -> PyResult<Option<T>>,
 ) -> PyResult<Option<T>> {
     let py = schema.py();
 
@@ -40,5 +40,5 @@ pub fn get_prebuilt<T>(
 
     // Retrieve the prebuilt validator / serializer if available
     let prebuilt: Bound<'_, PyAny> = class_dict.get_item(prebuilt_attr_name)?;
-    extractor(prebuilt).map(Some)
+    extractor(prebuilt)
 }
diff --git a/src/serializers/prebuilt.rs b/src/serializers/prebuilt.rs
index 33d197d9b..3f1cf1c68 100644
--- a/src/serializers/prebuilt.rs
+++ b/src/serializers/prebuilt.rs
@@ -17,9 +17,11 @@ pub struct PrebuiltSerializer {
 impl PrebuiltSerializer {
     pub fn try_get_from_schema(type_: &str, schema: &Bound<'_, PyDict>) -> PyResult<Option<CombinedSerializer>> {
         get_prebuilt(type_, schema, "__pydantic_serializer__", |py_any| {
-            py_any
-                .extract::<Py<SchemaSerializer>>()
-                .map(|schema_serializer| Self { schema_serializer }.into())
+            let schema_serializer = py_any.extract::<Py<SchemaSerializer>>()?;
+            if matches!(schema_serializer.get().serializer, CombinedSerializer::FunctionWrap(_)) {
+                return Ok(None);
+            }
+            Ok(Some(Self { schema_serializer }.into()))
         })
     }
 }
diff --git a/src/validators/prebuilt.rs b/src/validators/prebuilt.rs
index c17acb9f9..54c40f197 100644
--- a/src/validators/prebuilt.rs
+++ b/src/validators/prebuilt.rs
@@ -16,9 +16,11 @@ pub struct PrebuiltValidator {
 impl PrebuiltValidator {
     pub fn try_get_from_schema(type_: &str, schema: &Bound<'_, PyDict>) -> PyResult<Option<CombinedValidator>> {
         get_prebuilt(type_, schema, "__pydantic_validator__", |py_any| {
-            py_any
-                .extract::<Py<SchemaValidator>>()
-                .map(|schema_validator| Self { schema_validator }.into())
+            let schema_validator = py_any.extract::<Py<SchemaValidator>>()?;
+            if matches!(schema_validator.get().validator, CombinedValidator::FunctionWrap(_)) {
+                return Ok(None);
+            }
+            Ok(Some(Self { schema_validator }.into()))
         })
     }
 }
diff --git a/tests/test_prebuilt.py b/tests/test_prebuilt.py
index 9cd5aa325..14a9f288b 100644
--- a/tests/test_prebuilt.py
+++ b/tests/test_prebuilt.py
@@ -1,3 +1,5 @@
+from typing import Union
+
 from pydantic_core import SchemaSerializer, SchemaValidator, core_schema
 
 
@@ -46,3 +48,238 @@ class OuterModel:
     result = outer_validator.validate_python({'inner': {'x': 1}})
     assert result.inner.x == 1
     assert outer_serializer.to_python(result) == {'inner': {'x': 1}}
+
+
+def test_prebuilt_not_used_for_wrap_serializer_functions() -> None:
+    class InnerModel:
+        x: str
+
+        def __init__(self, x: str) -> None:
+            self.x = x
+
+    def serialize_inner(v: InnerModel, serializer) -> Union[dict[str, str], str]:
+        v.x = v.x + ' modified'
+        return serializer(v)
+
+    inner_schema = core_schema.model_schema(
+        InnerModel,
+        schema=core_schema.model_fields_schema(
+            {'x': core_schema.model_field(schema=core_schema.str_schema())},
+        ),
+        serialization=core_schema.wrap_serializer_function_ser_schema(serialize_inner),
+    )
+
+    inner_schema_serializer = SchemaSerializer(inner_schema)
+    InnerModel.__pydantic_complete__ = True  # pyright: ignore[reportAttributeAccessIssue]
+    InnerModel.__pydantic_serializer__ = inner_schema_serializer  # pyright: ignore[reportAttributeAccessIssue]
+
+    class OuterModel:
+        inner: InnerModel
+
+        def __init__(self, inner: InnerModel) -> None:
+            self.inner = inner
+
+    outer_schema = core_schema.model_schema(
+        OuterModel,
+        schema=core_schema.model_fields_schema(
+            {
+                'inner': core_schema.model_field(
+                    schema=core_schema.model_schema(
+                        InnerModel,
+                        schema=core_schema.model_fields_schema(
+                            # note, we use a simple str schema (with no custom serialization)
+                            # in order to verify that the prebuilt serializer from InnerModel is not used
+                            {'x': core_schema.model_field(schema=core_schema.str_schema())},
+                        ),
+                    )
+                )
+            }
+        ),
+    )
+
+    inner_serializer = SchemaSerializer(inner_schema)
+    outer_serializer = SchemaSerializer(outer_schema)
+
+    # the custom serialization function does apply for the inner model
+    inner_instance = InnerModel(x='hello')
+    assert inner_serializer.to_python(inner_instance) == {'x': 'hello modified'}
+
+    # but the outer model doesn't reuse the custom wrap serializer function, so we see simple str ser
+    outer_instance = OuterModel(inner=InnerModel(x='hello'))
+    assert outer_serializer.to_python(outer_instance) == {'inner': {'x': 'hello'}}
+
+
+def test_prebuilt_not_used_for_wrap_validator_functions() -> None:
+    class InnerModel:
+        x: str
+
+        def __init__(self, x: str) -> None:
+            self.x = x
+
+    def validate_inner(data, validator) -> InnerModel:
+        data['x'] = data['x'] + ' modified'
+        return validator(data)
+
+    inner_schema = core_schema.no_info_wrap_validator_function(
+        validate_inner,
+        core_schema.model_schema(
+            InnerModel,
+            schema=core_schema.model_fields_schema(
+                {'x': core_schema.model_field(schema=core_schema.str_schema())},
+            ),
+        ),
+    )
+
+    inner_schema_validator = SchemaValidator(inner_schema)
+    InnerModel.__pydantic_complete__ = True  # pyright: ignore[reportAttributeAccessIssue]
+    InnerModel.__pydantic_validator__ = inner_schema_validator  # pyright: ignore[reportAttributeAccessIssue]
+
+    class OuterModel:
+        inner: InnerModel
+
+        def __init__(self, inner: InnerModel) -> None:
+            self.inner = inner
+
+    outer_schema = core_schema.model_schema(
+        OuterModel,
+        schema=core_schema.model_fields_schema(
+            {
+                'inner': core_schema.model_field(
+                    schema=core_schema.model_schema(
+                        InnerModel,
+                        schema=core_schema.model_fields_schema(
+                            # note, we use a simple str schema (with no custom validation)
+                            # in order to verify that the prebuilt validator from InnerModel is not used
+                            {'x': core_schema.model_field(schema=core_schema.str_schema())},
+                        ),
+                    )
+                )
+            }
+        ),
+    )
+
+    inner_validator = SchemaValidator(inner_schema)
+    outer_validator = SchemaValidator(outer_schema)
+
+    # the custom validation function does apply for the inner model
+    result_inner = inner_validator.validate_python({'x': 'hello'})
+    assert result_inner.x == 'hello modified'
+
+    # but the outer model doesn't reuse the custom wrap validator function, so we see simple str val
+    result_outer = outer_validator.validate_python({'inner': {'x': 'hello'}})
+    assert result_outer.inner.x == 'hello'
+
+
+def test_reuse_plain_serializer_ok() -> None:
+    class InnerModel:
+        x: str
+
+        def __init__(self, x: str) -> None:
+            self.x = x
+
+    def serialize_inner(v: InnerModel) -> str:
+        return v.x + ' modified'
+
+    inner_schema = core_schema.model_schema(
+        InnerModel,
+        schema=core_schema.model_fields_schema(
+            {'x': core_schema.model_field(schema=core_schema.str_schema())},
+        ),
+        serialization=core_schema.plain_serializer_function_ser_schema(serialize_inner),
+    )
+
+    inner_schema_serializer = SchemaSerializer(inner_schema)
+    InnerModel.__pydantic_complete__ = True  # pyright: ignore[reportAttributeAccessIssue]
+    InnerModel.__pydantic_serializer__ = inner_schema_serializer  # pyright: ignore[reportAttributeAccessIssue]
+
+    class OuterModel:
+        inner: InnerModel
+
+        def __init__(self, inner: InnerModel) -> None:
+            self.inner = inner
+
+    outer_schema = core_schema.model_schema(
+        OuterModel,
+        schema=core_schema.model_fields_schema(
+            {
+                'inner': core_schema.model_field(
+                    schema=core_schema.model_schema(
+                        InnerModel,
+                        schema=core_schema.model_fields_schema(
+                            # note, we use a simple str schema (with no custom serialization)
+                            # in order to verify that the prebuilt serializer from InnerModel is used instead
+                            {'x': core_schema.model_field(schema=core_schema.str_schema())},
+                        ),
+                    )
+                )
+            }
+        ),
+    )
+
+    inner_serializer = SchemaSerializer(inner_schema)
+    outer_serializer = SchemaSerializer(outer_schema)
+
+    # the custom serialization function does apply for the inner model
+    inner_instance = InnerModel(x='hello')
+    assert inner_serializer.to_python(inner_instance) == 'hello modified'
+    assert 'FunctionPlainSerializer' in repr(inner_serializer)
+
+    # the custom ser function applies for the outer model as well, a plain serializer is permitted as a prebuilt candidate
+    outer_instance = OuterModel(inner=InnerModel(x='hello'))
+    assert outer_serializer.to_python(outer_instance) == {'inner': 'hello modified'}
+    assert 'PrebuiltSerializer' in repr(outer_serializer)
+
+
+def test_reuse_plain_validator_ok() -> None:
+    class InnerModel:
+        x: str
+
+        def __init__(self, x: str) -> None:
+            self.x = x
+
+    def validate_inner(data) -> InnerModel:
+        data['x'] = data['x'] + ' modified'
+        return InnerModel(**data)
+
+    inner_schema = core_schema.no_info_plain_validator_function(validate_inner)
+
+    inner_schema_validator = SchemaValidator(inner_schema)
+    InnerModel.__pydantic_complete__ = True  # pyright: ignore[reportAttributeAccessIssue]
+    InnerModel.__pydantic_validator__ = inner_schema_validator  # pyright: ignore[reportAttributeAccessIssue]
+
+    class OuterModel:
+        inner: InnerModel
+
+        def __init__(self, inner: InnerModel) -> None:
+            self.inner = inner
+
+    outer_schema = core_schema.model_schema(
+        OuterModel,
+        schema=core_schema.model_fields_schema(
+            {
+                'inner': core_schema.model_field(
+                    schema=core_schema.model_schema(
+                        InnerModel,
+                        schema=core_schema.model_fields_schema(
+                            # note, we use a simple str schema (with no custom validation)
+                            # in order to verify that the prebuilt validator from InnerModel is used instead
+                            {'x': core_schema.model_field(schema=core_schema.str_schema())},
+                        ),
+                    )
+                )
+            }
+        ),
+    )
+
+    inner_validator = SchemaValidator(inner_schema)
+    outer_validator = SchemaValidator(outer_schema)
+
+    # the custom validation function does apply for the inner model
+    result_inner = inner_validator.validate_python({'x': 'hello'})
+    assert result_inner.x == 'hello modified'
+    assert 'FunctionPlainValidator' in repr(inner_validator)
+
+    # the custom validation function does apply for the outer model as well, a plain validator is permitted as a prebuilt candidate
+    result_outer = outer_validator.validate_python({'inner': {'x': 'hello'}})
+    assert result_outer.inner.x == 'hello modified'
+    assert 'PrebuiltValidator' in repr(outer_validator)

From 0761adb45a934d8c8895fb01aebb17672b091709 Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Wed, 5 Mar 2025 09:05:15 +0100
Subject: [PATCH 506/550] Add `cls_name` to `typed-dict` schema (#1659)

This aligns with other schemas, like the dataclass one where the class name is used as the validator name
---
 python/pydantic_core/core_schema.py |  5 +++++
 src/validators/typed_dict.rs        | 14 ++++++++++++--
 2 files changed, 17 insertions(+), 2 deletions(-)

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index c4a26041a..c7ca7cfd8 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -2882,6 +2882,7 @@ class TypedDictSchema(TypedDict, total=False):
     type: Required[Literal['typed-dict']]
     fields: Required[dict[str, TypedDictField]]
     cls: type[Any]
+    cls_name: str
     computed_fields: list[ComputedField]
     strict: bool
     extras_schema: CoreSchema
@@ -2898,6 +2899,7 @@ def typed_dict_schema(
     fields: dict[str, TypedDictField],
     *,
     cls: type[Any] | None = None,
+    cls_name: str | None = None,
     computed_fields: list[ComputedField] | None = None,
     strict: bool | None = None,
     extras_schema: CoreSchema | None = None,
@@ -2929,6 +2931,8 @@ class MyTypedDict(TypedDict):
     Args:
         fields: The fields to use for the typed dict
         cls: The class to use for the typed dict
+        cls_name: The name to use in error locations. Falls back to `cls.__name__`, or the validator name if no class
+            is provided.
         computed_fields: Computed fields to use when serializing the model, only applies when directly inside a model
         strict: Whether the typed dict is strict
         extras_schema: The extra validator to use for the typed dict
@@ -2942,6 +2946,7 @@ class MyTypedDict(TypedDict):
         type='typed-dict',
         fields=fields,
         cls=cls,
+        cls_name=cls_name,
         computed_fields=computed_fields,
         strict=strict,
         extras_schema=extras_schema,
diff --git a/src/validators/typed_dict.rs b/src/validators/typed_dict.rs
index 999926762..013db4d69 100644
--- a/src/validators/typed_dict.rs
+++ b/src/validators/typed_dict.rs
@@ -1,6 +1,6 @@
 use pyo3::intern;
 use pyo3::prelude::*;
-use pyo3::types::{PyDict, PyString};
+use pyo3::types::{PyDict, PyString, PyType};
 
 use crate::build_tools::py_schema_err;
 use crate::build_tools::{is_strict, schema_or_config, ExtraBehavior};
@@ -37,6 +37,7 @@ pub struct TypedDictValidator {
     loc_by_alias: bool,
     validate_by_alias: Option<bool>,
     validate_by_name: Option<bool>,
+    cls_name: Option<String>,
 }
 
 impl BuildValidator for TypedDictValidator {
@@ -69,6 +70,14 @@ impl BuildValidator for TypedDictValidator {
         let fields_dict: Bound<'_, PyDict> = schema.get_as_req(intern!(py, "fields"))?;
         let mut fields: Vec<TypedDictField> = Vec::with_capacity(fields_dict.len());
 
+        let cls_name: Option<String> = match schema.get_as_req::<String>(intern!(py, "cls_name")) {
+            Ok(name) => Some(name),
+            Err(_) => match schema.get_as_req::<Bound<'_, PyType>>(intern!(py, "cls")) {
+                Ok(class) => Some(class.getattr(intern!(py, "__name__"))?.extract()?),
+                Err(_) => None,
+            },
+        };
+
         for (key, value) in fields_dict {
             let field_info = value.downcast::<PyDict>()?;
             let field_name_py = key.downcast_into::<PyString>()?;
@@ -128,6 +137,7 @@ impl BuildValidator for TypedDictValidator {
             loc_by_alias: config.get_as(intern!(py, "loc_by_alias"))?.unwrap_or(true),
             validate_by_alias: config.get_as(intern!(py, "validate_by_alias"))?,
             validate_by_name: config.get_as(intern!(py, "validate_by_name"))?,
+            cls_name,
         }
         .into())
     }
@@ -367,6 +377,6 @@ impl Validator for TypedDictValidator {
     }
 
     fn get_name(&self) -> &str {
-        Self::EXPECTED_TYPE
+        self.cls_name.as_deref().unwrap_or(Self::EXPECTED_TYPE)
     }
 }

From a6f3972866c7276a584af970671b3032b654880b Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Wed, 5 Mar 2025 20:34:59 +0100
Subject: [PATCH 507/550] Coerce validator constraints to their valid type
 (#1661)

---
 src/validators/date.rs            | 14 ++++++---
 src/validators/datetime.rs        | 14 ++++++---
 src/validators/decimal.rs         | 26 ++++++++++++----
 src/validators/int.rs             | 50 +++++++++++++++++++++----------
 tests/validators/test_date.py     |  9 ++++++
 tests/validators/test_datetime.py |  9 ++++++
 tests/validators/test_decimal.py  | 19 +++++++++---
 tests/validators/test_int.py      | 15 ++++++++--
 8 files changed, 119 insertions(+), 37 deletions(-)

diff --git a/src/validators/date.rs b/src/validators/date.rs
index 2b64b71c6..d85af4a13 100644
--- a/src/validators/date.rs
+++ b/src/validators/date.rs
@@ -1,6 +1,7 @@
+use pyo3::exceptions::PyValueError;
 use pyo3::intern;
 use pyo3::prelude::*;
-use pyo3::types::{PyDate, PyDict, PyString};
+use pyo3::types::{PyDict, PyString};
 use speedate::{Date, Time};
 use strum::EnumMessage;
 
@@ -175,9 +176,14 @@ impl DateConstraints {
     }
 }
 
-fn convert_pydate(schema: &Bound<'_, PyDict>, field: &Bound<'_, PyString>) -> PyResult<Option<Date>> {
-    match schema.get_as::<Bound<'_, PyDate>>(field)? {
-        Some(date) => Ok(Some(EitherDate::Py(date).as_raw()?)),
+fn convert_pydate(schema: &Bound<'_, PyDict>, key: &Bound<'_, PyString>) -> PyResult<Option<Date>> {
+    match schema.get_as::<Bound<'_, PyAny>>(key)? {
+        Some(value) => match value.validate_date(false) {
+            Ok(v) => Ok(Some(v.into_inner().as_raw()?)),
+            Err(_) => Err(PyValueError::new_err(format!(
+                "'{key}' must be coercible to a date instance",
+            ))),
+        },
         None => Ok(None),
     }
 }
diff --git a/src/validators/datetime.rs b/src/validators/datetime.rs
index 0d685216f..fad79deff 100644
--- a/src/validators/datetime.rs
+++ b/src/validators/datetime.rs
@@ -1,8 +1,9 @@
+use pyo3::exceptions::PyValueError;
 use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::sync::GILOnceCell;
 use pyo3::types::{PyDict, PyString};
-use speedate::{DateTime, Time};
+use speedate::{DateTime, MicrosecondsPrecisionOverflowBehavior, Time};
 use std::cmp::Ordering;
 use strum::EnumMessage;
 
@@ -208,9 +209,14 @@ impl DateTimeConstraints {
     }
 }
 
-fn py_datetime_as_datetime(schema: &Bound<'_, PyDict>, field: &Bound<'_, PyString>) -> PyResult<Option<DateTime>> {
-    match schema.get_as(field)? {
-        Some(dt) => Ok(Some(EitherDateTime::Py(dt).as_raw()?)),
+fn py_datetime_as_datetime(schema: &Bound<'_, PyDict>, key: &Bound<'_, PyString>) -> PyResult<Option<DateTime>> {
+    match schema.get_as::<Bound<'_, PyAny>>(key)? {
+        Some(value) => match value.validate_datetime(false, MicrosecondsPrecisionOverflowBehavior::Truncate) {
+            Ok(v) => Ok(Some(v.into_inner().as_raw()?)),
+            Err(_) => Err(PyValueError::new_err(format!(
+                "'{key}' must be coercible to a datetime instance",
+            ))),
+        },
         None => Ok(None),
     }
 }
diff --git a/src/validators/decimal.rs b/src/validators/decimal.rs
index 6c2e55806..4f6db8ae8 100644
--- a/src/validators/decimal.rs
+++ b/src/validators/decimal.rs
@@ -1,7 +1,7 @@
 use pyo3::exceptions::{PyTypeError, PyValueError};
 use pyo3::intern;
 use pyo3::sync::GILOnceCell;
-use pyo3::types::{IntoPyDict, PyDict, PyTuple, PyType};
+use pyo3::types::{IntoPyDict, PyDict, PyString, PyTuple, PyType};
 use pyo3::{prelude::*, PyTypeInfo};
 
 use crate::build_tools::{is_strict, schema_or_config_same};
@@ -28,6 +28,18 @@ pub fn get_decimal_type(py: Python) -> &Bound<'_, PyType> {
         .bind(py)
 }
 
+fn validate_as_decimal(py: Python, schema: &Bound<'_, PyDict>, key: &str) -> PyResult<Option<Py<PyAny>>> {
+    match schema.get_as::<Bound<'_, PyAny>>(&PyString::new(py, key))? {
+        Some(value) => match value.validate_decimal(false, py) {
+            Ok(v) => Ok(Some(v.into_inner().unbind())),
+            Err(_) => Err(PyValueError::new_err(format!(
+                "'{key}' must be coercible to a Decimal instance",
+            ))),
+        },
+        None => Ok(None),
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct DecimalValidator {
     strict: bool,
@@ -50,6 +62,7 @@ impl BuildValidator for DecimalValidator {
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
         let py = schema.py();
+
         let allow_inf_nan = schema_or_config_same(schema, config, intern!(py, "allow_inf_nan"))?.unwrap_or(false);
         let decimal_places = schema.get_as(intern!(py, "decimal_places"))?;
         let max_digits = schema.get_as(intern!(py, "max_digits"))?;
@@ -58,16 +71,17 @@ impl BuildValidator for DecimalValidator {
                 "allow_inf_nan=True cannot be used with max_digits or decimal_places",
             ));
         }
+
         Ok(Self {
             strict: is_strict(schema, config)?,
             allow_inf_nan,
             check_digits: decimal_places.is_some() || max_digits.is_some(),
             decimal_places,
-            multiple_of: schema.get_as(intern!(py, "multiple_of"))?,
-            le: schema.get_as(intern!(py, "le"))?,
-            lt: schema.get_as(intern!(py, "lt"))?,
-            ge: schema.get_as(intern!(py, "ge"))?,
-            gt: schema.get_as(intern!(py, "gt"))?,
+            multiple_of: validate_as_decimal(py, schema, "multiple_of")?,
+            le: validate_as_decimal(py, schema, "le")?,
+            lt: validate_as_decimal(py, schema, "lt")?,
+            ge: validate_as_decimal(py, schema, "ge")?,
+            gt: validate_as_decimal(py, schema, "gt")?,
             max_digits,
         }
         .into())
diff --git a/src/validators/int.rs b/src/validators/int.rs
index dd30ef5c3..8d30f215c 100644
--- a/src/validators/int.rs
+++ b/src/validators/int.rs
@@ -1,7 +1,8 @@
 use num_bigint::BigInt;
+use pyo3::exceptions::PyValueError;
 use pyo3::intern;
 use pyo3::prelude::*;
-use pyo3::types::PyDict;
+use pyo3::types::{PyDict, PyString};
 use pyo3::IntoPyObjectExt;
 
 use crate::build_tools::is_strict;
@@ -11,6 +12,23 @@ use crate::tools::SchemaDict;
 
 use super::{BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
 
+fn validate_as_int(py: Python, schema: &Bound<'_, PyDict>, key: &str) -> PyResult<Option<Int>> {
+    match schema.get_as::<Bound<'_, PyAny>>(&PyString::new(py, key))? {
+        Some(value) => match value.validate_int(false) {
+            Ok(v) => match v.into_inner().as_int() {
+                Ok(v) => Ok(Some(v)),
+                Err(_) => Err(PyValueError::new_err(format!(
+                    "'{key}' must be coercible to an integer"
+                ))),
+            },
+            Err(_) => Err(PyValueError::new_err(format!(
+                "'{key}' must be coercible to an integer"
+            ))),
+        },
+        None => Ok(None),
+    }
+}
+
 #[derive(Debug, Clone)]
 pub struct IntValidator {
     strict: bool,
@@ -70,6 +88,21 @@ pub struct ConstrainedIntValidator {
     gt: Option<Int>,
 }
 
+impl ConstrainedIntValidator {
+    fn build(schema: &Bound<'_, PyDict>, config: Option<&Bound<'_, PyDict>>) -> PyResult<CombinedValidator> {
+        let py = schema.py();
+        Ok(Self {
+            strict: is_strict(schema, config)?,
+            multiple_of: validate_as_int(py, schema, "multiple_of")?,
+            le: validate_as_int(py, schema, "le")?,
+            lt: validate_as_int(py, schema, "lt")?,
+            ge: validate_as_int(py, schema, "ge")?,
+            gt: validate_as_int(py, schema, "gt")?,
+        }
+        .into())
+    }
+}
+
 impl_py_gc_traverse!(ConstrainedIntValidator {});
 
 impl Validator for ConstrainedIntValidator {
@@ -144,18 +177,3 @@ impl Validator for ConstrainedIntValidator {
         "constrained-int"
     }
 }
-
-impl ConstrainedIntValidator {
-    fn build(schema: &Bound<'_, PyDict>, config: Option<&Bound<'_, PyDict>>) -> PyResult<CombinedValidator> {
-        let py = schema.py();
-        Ok(Self {
-            strict: is_strict(schema, config)?,
-            multiple_of: schema.get_as(intern!(py, "multiple_of"))?,
-            le: schema.get_as(intern!(py, "le"))?,
-            lt: schema.get_as(intern!(py, "lt"))?,
-            ge: schema.get_as(intern!(py, "ge"))?,
-            gt: schema.get_as(intern!(py, "gt"))?,
-        }
-        .into())
-    }
-}
diff --git a/tests/validators/test_date.py b/tests/validators/test_date.py
index 90cb1d797..202a8f205 100644
--- a/tests/validators/test_date.py
+++ b/tests/validators/test_date.py
@@ -13,6 +13,15 @@
 from ..conftest import Err, PyAndJson
 
 
+@pytest.mark.parametrize(
+    'constraint',
+    ['le', 'lt', 'ge', 'gt'],
+)
+def test_constraints_schema_validation(constraint: str) -> None:
+    with pytest.raises(SchemaError, match=f"'{constraint}' must be coercible to a date instance"):
+        SchemaValidator(cs.date_schema(**{constraint: 'bad_value'}))
+
+
 @pytest.mark.parametrize(
     'input_value,expected',
     [
diff --git a/tests/validators/test_datetime.py b/tests/validators/test_datetime.py
index f9ee69bf4..16ea0b4e0 100644
--- a/tests/validators/test_datetime.py
+++ b/tests/validators/test_datetime.py
@@ -14,6 +14,15 @@
 from ..conftest import Err, PyAndJson
 
 
+@pytest.mark.parametrize(
+    'constraint',
+    ['le', 'lt', 'ge', 'gt'],
+)
+def test_constraints_schema_validation(constraint: str) -> None:
+    with pytest.raises(SchemaError, match=f"'{constraint}' must be coercible to a datetime instance"):
+        SchemaValidator(cs.datetime_schema(**{constraint: 'bad_value'}))
+
+
 @pytest.mark.parametrize(
     'input_value,expected',
     [
diff --git a/tests/validators/test_decimal.py b/tests/validators/test_decimal.py
index 074425b5f..1a8d15871 100644
--- a/tests/validators/test_decimal.py
+++ b/tests/validators/test_decimal.py
@@ -9,7 +9,7 @@
 import pytest
 from dirty_equals import FunctionCheck, IsStr
 
-from pydantic_core import SchemaValidator, ValidationError, core_schema
+from pydantic_core import SchemaError, SchemaValidator, ValidationError
 from pydantic_core import core_schema as cs
 
 from ..conftest import Err, PyAndJson, plain_repr
@@ -19,6 +19,17 @@ class DecimalSubclass(Decimal):
     pass
 
 
+# Note: there's another constraint validation (allow_inf_nan=True cannot be used with max_digits or decimal_places).
+# but it is tested in Pydantic:
+@pytest.mark.parametrize(
+    'constraint',
+    ['multiple_of', 'le', 'lt', 'ge', 'gt'],
+)
+def test_constraints_schema_validation(constraint: str) -> None:
+    with pytest.raises(SchemaError, match=f"'{constraint}' must be coercible to a Decimal instance"):
+        SchemaValidator(cs.decimal_schema(**{constraint: 'bad_value'}))
+
+
 @pytest.mark.parametrize(
     'input_value,expected',
     [
@@ -487,20 +498,20 @@ def test_validate_max_digits_and_decimal_places_edge_case() -> None:
 
 
 def test_str_validation_w_strict() -> None:
-    s = SchemaValidator(core_schema.decimal_schema(strict=True))
+    s = SchemaValidator(cs.decimal_schema(strict=True))
 
     with pytest.raises(ValidationError):
         assert s.validate_python('1.23')
 
 
 def test_str_validation_w_lax() -> None:
-    s = SchemaValidator(core_schema.decimal_schema(strict=False))
+    s = SchemaValidator(cs.decimal_schema(strict=False))
 
     assert s.validate_python('1.23') == Decimal('1.23')
 
 
 def test_union_with_str_prefers_str() -> None:
-    s = SchemaValidator(core_schema.union_schema([core_schema.decimal_schema(), core_schema.str_schema()]))
+    s = SchemaValidator(cs.union_schema([cs.decimal_schema(), cs.str_schema()]))
 
     assert s.validate_python('1.23') == '1.23'
     assert s.validate_python(1.23) == Decimal('1.23')
diff --git a/tests/validators/test_int.py b/tests/validators/test_int.py
index ffd8a85c6..f16bf1377 100644
--- a/tests/validators/test_int.py
+++ b/tests/validators/test_int.py
@@ -6,7 +6,7 @@
 import pytest
 from dirty_equals import IsStr
 
-from pydantic_core import SchemaValidator, ValidationError, core_schema
+from pydantic_core import SchemaError, SchemaValidator, ValidationError
 from pydantic_core import core_schema as cs
 
 from ..conftest import Err, PyAndJson, plain_repr
@@ -14,6 +14,15 @@
 i64_max = 9_223_372_036_854_775_807
 
 
+@pytest.mark.parametrize(
+    'constraint',
+    ['multiple_of', 'le', 'lt', 'ge', 'gt'],
+)
+def test_constraints_schema_validation(constraint: str) -> None:
+    with pytest.raises(SchemaError, match=f"'{constraint}' must be coercible to an integer"):
+        SchemaValidator(cs.int_schema(**{constraint: 'bad_value'}))
+
+
 @pytest.mark.parametrize(
     'input_value,expected',
     [
@@ -532,7 +541,7 @@ class PlainEnum(Enum):
 
 
 def test_allow_inf_nan_true_json() -> None:
-    v = SchemaValidator(core_schema.int_schema(), config=core_schema.CoreConfig(allow_inf_nan=True))
+    v = SchemaValidator(cs.int_schema(), config=cs.CoreConfig(allow_inf_nan=True))
 
     assert v.validate_json('123') == 123
     with pytest.raises(ValidationError, match=r'Input should be a finite number \[type=finite_number'):
@@ -544,7 +553,7 @@ def test_allow_inf_nan_true_json() -> None:
 
 
 def test_allow_inf_nan_false_json() -> None:
-    v = SchemaValidator(core_schema.int_schema(), config=core_schema.CoreConfig(allow_inf_nan=False))
+    v = SchemaValidator(cs.int_schema(), config=cs.CoreConfig(allow_inf_nan=False))
 
     assert v.validate_json('123') == 123
     with pytest.raises(ValidationError, match=r'Input should be a finite number \[type=finite_number'):

From c3be32d786dc4332a1ab44609a5da854208db880 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Wed, 5 Mar 2025 14:44:34 -0500
Subject: [PATCH 508/550] Bump version to v2.31.0 (#1662)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 5d47d45a6..1a721dc58 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -424,7 +424,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.30.0"
+version = "2.31.0"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index 580b13c81..7759387a5 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.30.0"
+version = "2.31.0"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From 94d7985e7b5d19656d8c40616ab1339849942ef9 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Thu, 6 Mar 2025 09:59:40 -0500
Subject: [PATCH 509/550] Skip reusing after validators in prebuilt schemas
 (#1663)

---
 src/validators/prebuilt.rs |   5 +-
 tests/test_prebuilt.py     | 152 +++++++++++++++++++++++++++++++++----
 2 files changed, 140 insertions(+), 17 deletions(-)

diff --git a/src/validators/prebuilt.rs b/src/validators/prebuilt.rs
index 54c40f197..8aead86dd 100644
--- a/src/validators/prebuilt.rs
+++ b/src/validators/prebuilt.rs
@@ -17,7 +17,10 @@ impl PrebuiltValidator {
     pub fn try_get_from_schema(type_: &str, schema: &Bound<'_, PyDict>) -> PyResult<Option<CombinedValidator>> {
         get_prebuilt(type_, schema, "__pydantic_validator__", |py_any| {
             let schema_validator = py_any.extract::<Py<SchemaValidator>>()?;
-            if matches!(schema_validator.get().validator, CombinedValidator::FunctionWrap(_)) {
+            if matches!(
+                schema_validator.get().validator,
+                CombinedValidator::FunctionWrap(_) | CombinedValidator::FunctionAfter(_)
+            ) {
                 return Ok(None);
             }
             Ok(Some(Self { schema_validator }.into()))
diff --git a/tests/test_prebuilt.py b/tests/test_prebuilt.py
index 14a9f288b..c5a795b0f 100644
--- a/tests/test_prebuilt.py
+++ b/tests/test_prebuilt.py
@@ -14,11 +14,11 @@ class InnerModel:
         ),
     )
 
-    inner_schema_validator = SchemaValidator(inner_schema)
-    inner_schema_serializer = SchemaSerializer(inner_schema)
+    inner_validator = SchemaValidator(inner_schema)
+    inner_serializer = SchemaSerializer(inner_schema)
     InnerModel.__pydantic_complete__ = True  # pyright: ignore[reportAttributeAccessIssue]
-    InnerModel.__pydantic_validator__ = inner_schema_validator  # pyright: ignore[reportAttributeAccessIssue]
-    InnerModel.__pydantic_serializer__ = inner_schema_serializer  # pyright: ignore[reportAttributeAccessIssue]
+    InnerModel.__pydantic_validator__ = inner_validator  # pyright: ignore[reportAttributeAccessIssue]
+    InnerModel.__pydantic_serializer__ = inner_serializer  # pyright: ignore[reportAttributeAccessIssue]
 
     class OuterModel:
         inner: InnerModel
@@ -69,9 +69,9 @@ def serialize_inner(v: InnerModel, serializer) -> Union[dict[str, str], str]:
         serialization=core_schema.wrap_serializer_function_ser_schema(serialize_inner),
     )
 
-    inner_schema_serializer = SchemaSerializer(inner_schema)
+    inner_serializer = SchemaSerializer(inner_schema)
     InnerModel.__pydantic_complete__ = True  # pyright: ignore[reportAttributeAccessIssue]
-    InnerModel.__pydantic_serializer__ = inner_schema_serializer  # pyright: ignore[reportAttributeAccessIssue]
+    InnerModel.__pydantic_serializer__ = inner_serializer  # pyright: ignore[reportAttributeAccessIssue]
 
     class OuterModel:
         inner: InnerModel
@@ -97,7 +97,6 @@ def __init__(self, inner: InnerModel) -> None:
         ),
     )
 
-    inner_serializer = SchemaSerializer(inner_schema)
     outer_serializer = SchemaSerializer(outer_schema)
 
     # the custom serialization function does apply for the inner model
@@ -130,9 +129,9 @@ def validate_inner(data, validator) -> InnerModel:
         ),
     )
 
-    inner_schema_validator = SchemaValidator(inner_schema)
+    inner_validator = SchemaValidator(inner_schema)
     InnerModel.__pydantic_complete__ = True  # pyright: ignore[reportAttributeAccessIssue]
-    InnerModel.__pydantic_validator__ = inner_schema_validator  # pyright: ignore[reportAttributeAccessIssue]
+    InnerModel.__pydantic_validator__ = inner_validator  # pyright: ignore[reportAttributeAccessIssue]
 
     class OuterModel:
         inner: InnerModel
@@ -158,7 +157,6 @@ def __init__(self, inner: InnerModel) -> None:
         ),
     )
 
-    inner_validator = SchemaValidator(inner_schema)
     outer_validator = SchemaValidator(outer_schema)
 
     # the custom validation function does apply for the inner model
@@ -170,6 +168,66 @@ def __init__(self, inner: InnerModel) -> None:
     assert result_outer.inner.x == 'hello'
 
 
+def test_prebuilt_not_used_for_after_validator_functions() -> None:
+    class InnerModel:
+        x: str
+
+        def __init__(self, x: str) -> None:
+            self.x = x
+
+    def validate_after(self) -> InnerModel:
+        self.x = self.x + ' modified'
+        return self
+
+    inner_schema = core_schema.no_info_after_validator_function(
+        validate_after,
+        core_schema.model_schema(
+            InnerModel,
+            schema=core_schema.model_fields_schema(
+                {'x': core_schema.model_field(schema=core_schema.str_schema())},
+            ),
+        ),
+    )
+
+    inner_validator = SchemaValidator(inner_schema)
+    InnerModel.__pydantic_complete__ = True  # pyright: ignore[reportAttributeAccessIssue]
+    InnerModel.__pydantic_validator__ = inner_validator  # pyright: ignore[reportAttributeAccessIssue]
+
+    class OuterModel:
+        inner: InnerModel
+
+        def __init__(self, inner: InnerModel) -> None:
+            self.inner = inner
+
+    outer_schema = core_schema.model_schema(
+        OuterModel,
+        schema=core_schema.model_fields_schema(
+            {
+                'inner': core_schema.model_field(
+                    schema=core_schema.model_schema(
+                        InnerModel,
+                        schema=core_schema.model_fields_schema(
+                            # note, we use a simple str schema (with no custom validation)
+                            # in order to verify that the prebuilt validator from InnerModel is not used
+                            {'x': core_schema.model_field(schema=core_schema.str_schema())},
+                        ),
+                    )
+                )
+            }
+        ),
+    )
+
+    outer_validator = SchemaValidator(outer_schema)
+
+    # the custom validation function does apply for the inner model
+    result_inner = inner_validator.validate_python({'x': 'hello'})
+    assert result_inner.x == 'hello modified'
+
+    # but the outer model doesn't reuse the custom after validator function, so we see simple str val
+    result_outer = outer_validator.validate_python({'inner': {'x': 'hello'}})
+    assert result_outer.inner.x == 'hello'
+
+
 def test_reuse_plain_serializer_ok() -> None:
     class InnerModel:
         x: str
@@ -188,9 +246,9 @@ def serialize_inner(v: InnerModel) -> str:
         serialization=core_schema.plain_serializer_function_ser_schema(serialize_inner),
     )
 
-    inner_schema_serializer = SchemaSerializer(inner_schema)
+    inner_serializer = SchemaSerializer(inner_schema)
     InnerModel.__pydantic_complete__ = True  # pyright: ignore[reportAttributeAccessIssue]
-    InnerModel.__pydantic_serializer__ = inner_schema_serializer  # pyright: ignore[reportAttributeAccessIssue]
+    InnerModel.__pydantic_serializer__ = inner_serializer  # pyright: ignore[reportAttributeAccessIssue]
 
     class OuterModel:
         inner: InnerModel
@@ -216,7 +274,6 @@ def __init__(self, inner: InnerModel) -> None:
         ),
     )
 
-    inner_serializer = SchemaSerializer(inner_schema)
     outer_serializer = SchemaSerializer(outer_schema)
 
     # the custom serialization function does apply for the inner model
@@ -243,9 +300,9 @@ def validate_inner(data) -> InnerModel:
 
     inner_schema = core_schema.no_info_plain_validator_function(validate_inner)
 
-    inner_schema_validator = SchemaValidator(inner_schema)
+    inner_validator = SchemaValidator(inner_schema)
     InnerModel.__pydantic_complete__ = True  # pyright: ignore[reportAttributeAccessIssue]
-    InnerModel.__pydantic_validator__ = inner_schema_validator  # pyright: ignore[reportAttributeAccessIssue]
+    InnerModel.__pydantic_validator__ = inner_validator  # pyright: ignore[reportAttributeAccessIssue]
 
     class OuterModel:
         inner: InnerModel
@@ -271,7 +328,6 @@ def __init__(self, inner: InnerModel) -> None:
         ),
     )
 
-    inner_validator = SchemaValidator(inner_schema)
     outer_validator = SchemaValidator(outer_schema)
 
     # the custom validation function does apply for the inner model
@@ -283,3 +339,67 @@ def __init__(self, inner: InnerModel) -> None:
     result_outer = outer_validator.validate_python({'inner': {'x': 'hello'}})
     assert result_outer.inner.x == 'hello modified'
     assert 'PrebuiltValidator' in repr(outer_validator)
+
+
+def test_reuse_before_validator_ok() -> None:
+    class InnerModel:
+        x: str
+
+        def __init__(self, x: str) -> None:
+            self.x = x
+
+    def validate_before(data) -> dict:
+        data['x'] = data['x'] + ' modified'
+        return data
+
+    inner_schema = core_schema.no_info_before_validator_function(
+        validate_before,
+        core_schema.model_schema(
+            InnerModel,
+            schema=core_schema.model_fields_schema(
+                {'x': core_schema.model_field(schema=core_schema.str_schema())},
+            ),
+        ),
+    )
+
+    inner_validator = SchemaValidator(inner_schema)
+    InnerModel.__pydantic_complete__ = True  # pyright: ignore[reportAttributeAccessIssue]
+    InnerModel.__pydantic_validator__ = inner_validator  # pyright: ignore[reportAttributeAccessIssue]
+
+    class OuterModel:
+        inner: InnerModel
+
+        def __init__(self, inner: InnerModel) -> None:
+            self.inner = inner
+
+    outer_schema = core_schema.model_schema(
+        OuterModel,
+        schema=core_schema.model_fields_schema(
+            {
+                'inner': core_schema.model_field(
+                    schema=core_schema.model_schema(
+                        InnerModel,
+                        schema=core_schema.model_fields_schema(
+                            # note, we use a simple str schema (with no custom validation)
+                            # in order to verify that the prebuilt validator from InnerModel is used instead
+                            {'x': core_schema.model_field(schema=core_schema.str_schema())},
+                        ),
+                    )
+                )
+            }
+        ),
+    )
+
+    outer_validator = SchemaValidator(outer_schema)
+    print(inner_validator)
+    print(outer_validator)
+
+    # the custom validation function does apply for the inner model
+    result_inner = inner_validator.validate_python({'x': 'hello'})
+    assert result_inner.x == 'hello modified'
+    assert 'FunctionBeforeValidator' in repr(inner_validator)
+
+    # the custom validation function does apply for the outer model as well, a before validator is permitted as a prebuilt candidate
+    result_outer = outer_validator.validate_python({'inner': {'x': 'hello'}})
+    assert result_outer.inner.x == 'hello modified'
+    assert 'PrebuiltValidator' in repr(outer_validator)

From d8be765fbb66b20b791599b53a2abad2cfe76b13 Mon Sep 17 00:00:00 2001
From: Sydney Runkle <54324534+sydney-runkle@users.noreply.github.com>
Date: Thu, 6 Mar 2025 10:04:21 -0500
Subject: [PATCH 510/550] Bump version to `v2.31.0` (#1664)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 1a721dc58..bf01f4ca4 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -424,7 +424,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.31.0"
+version = "2.31.1"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index 7759387a5..13af5c552 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.31.0"
+version = "2.31.1"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From aa142f94a40d8271aedb61b484e08017de9feea7 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Tue, 11 Mar 2025 12:25:49 +0000
Subject: [PATCH 511/550] bump jiter to 0.9, pyo3 to 0.24 (#1667)

---
 Cargo.lock                  | 40 ++++++++++++++++++-------------------
 Cargo.toml                  |  8 ++++----
 src/input/input_json.rs     | 28 ++++++++++++++++----------
 src/lookup_key.rs           | 27 ++++++++++++++++++++-----
 src/validators/dataclass.rs |  2 +-
 5 files changed, 65 insertions(+), 40 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index bf01f4ca4..0c1035e0f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -296,9 +296,9 @@ checksum = "49f1f14873335454500d59611f1cf4a4b0f786f9ac11f4312a78e4cf2566695b"
 
 [[package]]
 name = "jiter"
-version = "0.8.2"
+version = "0.9.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8243cf2d026264056bfacf305e54f5bee8866fd46b4c1873adcaebf614a0d306"
+checksum = "c024ccb0ed468a474efa325edea34d4198fb601d290c4d1bc24fe31ed11902fc"
 dependencies = [
  "ahash",
  "bitvec",
@@ -312,9 +312,9 @@ dependencies = [
 
 [[package]]
 name = "lexical-parse-float"
-version = "0.8.5"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "683b3a5ebd0130b8fb52ba0bdc718cc56815b6a097e28ae5a6997d0ad17dc05f"
+checksum = "de6f9cb01fb0b08060209a057c048fcbab8717b4c1ecd2eac66ebfe39a65b0f2"
 dependencies = [
  "lexical-parse-integer",
  "lexical-util",
@@ -323,9 +323,9 @@ dependencies = [
 
 [[package]]
 name = "lexical-parse-integer"
-version = "0.8.6"
+version = "1.0.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "6d0994485ed0c312f6d965766754ea177d07f9c00c9b82a5ee62ed5b47945ee9"
+checksum = "72207aae22fc0a121ba7b6d479e42cbfea549af1479c3f3a4f12c70dd66df12e"
 dependencies = [
  "lexical-util",
  "static_assertions",
@@ -333,9 +333,9 @@ dependencies = [
 
 [[package]]
 name = "lexical-util"
-version = "0.8.5"
+version = "1.0.6"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5255b9ff16ff898710eb9eb63cb39248ea8a5bb036bea8085b1a767ff6c4e3fc"
+checksum = "5a82e24bf537fd24c177ffbbdc6ebcc8d54732c35b50a3f28cc3f4e4c949a0b3"
 dependencies = [
  "static_assertions",
 ]
@@ -449,9 +449,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.23.5"
+version = "0.24.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7778bffd85cf38175ac1f545509665d0b9b92a198ca7941f131f85f7a4f9a872"
+checksum = "7f1c6c3591120564d64db2261bec5f910ae454f01def849b9c22835a84695e86"
 dependencies = [
  "cfg-if",
  "indoc",
@@ -468,9 +468,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.23.5"
+version = "0.24.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "94f6cbe86ef3bf18998d9df6e0f3fc1050a8c5efa409bf712e661a4366e010fb"
+checksum = "e9b6c2b34cf71427ea37c7001aefbaeb85886a074795e35f161f5aecc7620a7a"
 dependencies = [
  "once_cell",
  "python3-dll-a",
@@ -479,9 +479,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.23.5"
+version = "0.24.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e9f1b4c431c0bb1c8fb0a338709859eed0d030ff6daa34368d3b152a63dfdd8d"
+checksum = "5507651906a46432cdda02cd02dd0319f6064f1374c9147c45b978621d2c3a9c"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -489,9 +489,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.23.5"
+version = "0.24.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fbc2201328f63c4710f68abdf653c89d8dbc2858b88c5d88b0ff38a75288a9da"
+checksum = "b0d394b5b4fd8d97d48336bb0dd2aebabad39f1d294edd6bcd2cccf2eefe6f42"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -501,9 +501,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.23.5"
+version = "0.24.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fca6726ad0f3da9c9de093d6f116a93c1a38e417ed73bf138472cf4064f72028"
+checksum = "fd72da09cfa943b1080f621f024d2ef7e2773df7badd51aa30a2be1f8caa7c8e"
 dependencies = [
  "heck",
  "proc-macro2",
@@ -690,9 +690,9 @@ checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
 
 [[package]]
 name = "target-lexicon"
-version = "0.12.14"
+version = "0.13.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e1fc403891a21bcfb7c37834ba66a547a8f402146eba7265b5a6d88059c9ff2f"
+checksum = "e502f78cdbb8ba4718f566c418c52bc729126ffd16baee5baa718cf25dd5a69a"
 
 [[package]]
 name = "tinystr"
diff --git a/Cargo.toml b/Cargo.toml
index 13af5c552..16dc843c4 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -29,7 +29,7 @@ rust-version = "1.75"
 [dependencies]
 # TODO it would be very nice to remove the "py-clone" feature as it can panic,
 # but needs a bit of work to make sure it's not used in the codebase
-pyo3 = { version = "0.23.5", features = ["generate-import-lib", "num-bigint", "py-clone"] }
+pyo3 = { version = "0.24", features = ["generate-import-lib", "num-bigint", "py-clone"] }
 regex = "1.11.1"
 strum = { version = "0.26.3", features = ["derive"] }
 strum_macros = "0.26.4"
@@ -45,7 +45,7 @@ idna = "1.0.3"
 base64 = "0.22.1"
 num-bigint = "0.4.6"
 uuid = "1.15.1"
-jiter = { version = "0.8.2", features = ["python"] }
+jiter = { version = "0.9.0", features = ["python"] }
 hex = "0.4.3"
 
 [lib]
@@ -73,12 +73,12 @@ debug = true
 strip = false
 
 [dev-dependencies]
-pyo3 = { version = "0.23.5", features = ["auto-initialize"] }
+pyo3 = { version = "0.24", features = ["auto-initialize"] }
 
 [build-dependencies]
 version_check = "0.9.5"
 # used where logic has to be version/distribution specific, e.g. pypy
-pyo3-build-config = { version = "0.23.5" }
+pyo3-build-config = { version = "0.24" }
 
 [lints.clippy]
 dbg_macro = "warn"
diff --git a/src/input/input_json.rs b/src/input/input_json.rs
index 139c71a25..6479357cc 100644
--- a/src/input/input_json.rs
+++ b/src/input/input_json.rs
@@ -1,9 +1,8 @@
 use std::borrow::Cow;
 
-use jiter::{JsonArray, JsonObject, JsonValue, LazyIndexMap};
+use jiter::{JsonArray, JsonObject, JsonValue};
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList, PyString};
-use smallvec::SmallVec;
 use speedate::MicrosecondsPrecisionOverflowBehavior;
 use strum::EnumMessage;
 
@@ -62,7 +61,9 @@ impl<'py, 'data> Input<'py> for JsonValue<'data> {
         match self {
             JsonValue::Object(object) => {
                 let dict = PyDict::new(py);
-                for (k, v) in LazyIndexMap::iter(object) {
+                for (k, v) in object.as_slice() {
+                    // TODO: jiter doesn't deduplicate keys, so we should probably do that here to
+                    // avoid potential wasted work creating Python objects.
                     dict.set_item(k, v).unwrap();
                 }
                 Some(dict)
@@ -253,7 +254,14 @@ impl<'py, 'data> Input<'py> for JsonValue<'data> {
             JsonValue::Str(s) => Ok(string_to_vec(s).into()),
             JsonValue::Object(object) => {
                 // return keys iterator to match python's behavior
-                let keys: JsonArray = JsonArray::new(object.keys().map(|k| JsonValue::Str(k.clone())).collect());
+                // FIXME jiter doesn't deduplicate keys, should probably do that here before iteration.
+                let keys: JsonArray = JsonArray::new(
+                    object
+                        .as_slice()
+                        .iter()
+                        .map(|(k, _)| JsonValue::Str(k.clone()))
+                        .collect(),
+                );
                 Ok(GenericIterator::from(keys).into_static())
             }
             _ => Err(ValError::new(ErrorTypeDefaults::IterableType, self)),
@@ -543,11 +551,11 @@ impl<'data> ValidatedDict<'_> for &'_ JsonObject<'data> {
         &'a self,
         consumer: impl ConsumeIterator<ValResult<(Self::Key<'a>, Self::Item<'a>)>, Output = R>,
     ) -> ValResult<R> {
-        Ok(consumer.consume_iterator(LazyIndexMap::iter(self).map(|(k, v)| Ok((k.as_ref(), v)))))
+        Ok(consumer.consume_iterator(self.as_slice().iter().map(|(k, v)| Ok((k.as_ref(), v)))))
     }
 
     fn last_key(&self) -> Option<Self::Key<'_>> {
-        self.keys().last().map(AsRef::as_ref)
+        self.last().map(|(k, _)| k.as_ref())
     }
 }
 
@@ -555,7 +563,7 @@ impl<'a, 'py, 'data> ValidatedList<'py> for &'a JsonArray<'data> {
     type Item = &'a JsonValue<'data>;
 
     fn len(&self) -> Option<usize> {
-        Some(SmallVec::len(self))
+        Some(Vec::len(self))
     }
     fn iterate<R>(self, consumer: impl ConsumeIterator<PyResult<Self::Item>, Output = R>) -> ValResult<R> {
         Ok(consumer.consume_iterator(self.iter().map(Ok)))
@@ -569,7 +577,7 @@ impl<'a, 'data> ValidatedTuple<'_> for &'a JsonArray<'data> {
     type Item = &'a JsonValue<'data>;
 
     fn len(&self) -> Option<usize> {
-        Some(SmallVec::len(self))
+        Some(Vec::len(self))
     }
     fn iterate<R>(self, consumer: impl ConsumeIterator<PyResult<Self::Item>, Output = R>) -> ValResult<R> {
         Ok(consumer.consume_iterator(self.iter().map(Ok)))
@@ -637,12 +645,12 @@ impl<'data> KeywordArgs<'_> for JsonObject<'data> {
         Self: 'a;
 
     fn len(&self) -> usize {
-        LazyIndexMap::len(self)
+        Vec::len(self)
     }
     fn get_item<'k>(&self, key: &'k LookupKey) -> ValResult<Option<(&'k LookupPath, Self::Item<'_>)>> {
         key.json_get(self)
     }
     fn iter(&self) -> impl Iterator<Item = ValResult<(Self::Key<'_>, Self::Item<'_>)>> {
-        LazyIndexMap::iter(self).map(|(k, v)| Ok((k.as_ref(), v)))
+        self.as_slice().iter().map(|(k, v)| Ok((k.as_ref(), v)))
     }
 }
diff --git a/src/lookup_key.rs b/src/lookup_key.rs
index 9b06db8fa..db8a4c869 100644
--- a/src/lookup_key.rs
+++ b/src/lookup_key.rs
@@ -262,20 +262,33 @@ impl LookupKey {
         &'s self,
         dict: &'a JsonObject<'data>,
     ) -> ValResult<Option<(&'s LookupPath, &'a JsonValue<'data>)>> {
+        // FIXME: use of find_map in here probably leads to quadratic complexity
         match self {
-            Self::Simple(path) => match dict.get(path.first_key()) {
+            Self::Simple(path) => match dict
+                .iter()
+                .rev()
+                .find_map(|(k, v)| (k == path.first_key()).then_some(v))
+            {
                 Some(value) => {
                     debug_assert!(path.rest.is_empty());
                     Ok(Some((path, value)))
                 }
                 None => Ok(None),
             },
-            Self::Choice { path1, path2 } => match dict.get(path1.first_key()) {
+            Self::Choice { path1, path2 } => match dict
+                .iter()
+                .rev()
+                .find_map(|(k, v)| (k == path1.first_key()).then_some(v))
+            {
                 Some(value) => {
                     debug_assert!(path1.rest.is_empty());
                     Ok(Some((path1, value)))
                 }
-                None => match dict.get(path2.first_key()) {
+                None => match dict
+                    .iter()
+                    .rev()
+                    .find_map(|(k, v)| (k == path2.first_key()).then_some(v))
+                {
                     Some(value) => {
                         debug_assert!(path2.rest.is_empty());
                         Ok(Some((path2, value)))
@@ -287,7 +300,11 @@ impl LookupKey {
                 for path in path_choices {
                     // first step is different from the rest as we already know dict is JsonObject
                     // because of above checks, we know that path should have at least one element, hence unwrap
-                    let v: &JsonValue = match dict.get(path.first_item.key.as_str()) {
+                    let v: &JsonValue = match dict
+                        .iter()
+                        .rev()
+                        .find_map(|(k, v)| (k == path.first_key()).then_some(v))
+                    {
                         Some(v) => v,
                         None => continue,
                     };
@@ -527,7 +544,7 @@ impl PathItem {
 
     pub fn json_obj_get<'a, 'data>(&self, json_obj: &'a JsonObject<'data>) -> Option<&'a JsonValue<'data>> {
         match self {
-            Self::S(PathItemString { key, .. }) => json_obj.get(key.as_str()),
+            Self::S(PathItemString { key, .. }) => json_obj.iter().rev().find_map(|(k, v)| (k == key).then_some(v)),
             _ => None,
         }
     }
diff --git a/src/validators/dataclass.rs b/src/validators/dataclass.rs
index 69c8279ea..0f2cbefc7 100644
--- a/src/validators/dataclass.rs
+++ b/src/validators/dataclass.rs
@@ -668,7 +668,7 @@ impl DataclassValidator {
                 dc.call_method0(post_init)
             } else {
                 let args = post_init_kwargs.downcast::<PyTuple>()?;
-                dc.call_method1(post_init, args)
+                dc.call_method1(post_init, args.clone()) // FIXME should not need clone here
             };
             r.map_err(|e| convert_err(py, e, input))?;
         }

From 53bdfa62abefe061575d51cdb9d59b72000295ee Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Tue, 11 Mar 2025 15:19:26 +0000
Subject: [PATCH 512/550] update authors (#1668)

---
 pyproject.toml | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/pyproject.toml b/pyproject.toml
index db64e0d7a..082f1b647 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -6,7 +6,14 @@ build-backend = 'maturin'
 name = 'pydantic_core'
 description = "Core functionality for Pydantic validation and serialization"
 requires-python = '>=3.9'
-authors = [{ name = 'Samuel Colvin', email = 's@muelcolvin.com' }]
+authors = [
+    { name = 'Samuel Colvin', email = 's@muelcolvin.com' },
+    { name = 'Adrian Garcia Badaracco', email = '1755071+adriangb@users.noreply.github.com' },
+    { name = 'David Montague', email = 'david@pydantic.dev' },
+    { name = 'David Hewitt', email = 'mail@davidhewitt.dev' },
+    { name = 'Sydney Runkle', email = 'sydneymarierunkle@gmail.com' },
+    { name = 'Victorien Plot', email='contact@vctrn.dev' },
+]
 classifiers = [
     'Development Status :: 3 - Alpha',
     'Programming Language :: Python',

From 1defe62942e4ddf4444542040062daa646d51a8e Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Fri, 14 Mar 2025 16:27:20 +0100
Subject: [PATCH 513/550] Add new `arguments-v3` schema (#1641)

---
 python/pydantic_core/core_schema.py           | 116 +++
 src/input/input_abstract.rs                   |   6 +
 src/input/input_json.rs                       |  16 +
 src/input/input_python.rs                     |  23 +-
 src/input/input_string.rs                     |   5 +
 src/validators/arguments_v3.rs                | 782 ++++++++++++++++++
 src/validators/mod.rs                         |   3 +
 tests/conftest.py                             |   8 +-
 tests/test_schema_functions.py                |  18 +
 tests/validators/arguments_v3/__init__.py     |   0
 tests/validators/arguments_v3/test_alias.py   | 158 ++++
 .../arguments_v3/test_build_errors.py         |  87 ++
 tests/validators/arguments_v3/test_extra.py   |  57 ++
 tests/validators/arguments_v3/test_general.py | 131 +++
 .../arguments_v3/test_keyword_only.py         |  99 +++
 .../arguments_v3/test_positional_only.py      | 107 +++
 .../test_positional_or_keyword.py             | 107 +++
 .../validators/arguments_v3/test_var_args.py  | 100 +++
 .../arguments_v3/test_var_kwargs_uniform.py   |  89 ++
 .../test_var_kwargs_unpacked_typed_dict.py    | 120 +++
 20 files changed, 2029 insertions(+), 3 deletions(-)
 create mode 100644 src/validators/arguments_v3.rs
 create mode 100644 tests/validators/arguments_v3/__init__.py
 create mode 100644 tests/validators/arguments_v3/test_alias.py
 create mode 100644 tests/validators/arguments_v3/test_build_errors.py
 create mode 100644 tests/validators/arguments_v3/test_extra.py
 create mode 100644 tests/validators/arguments_v3/test_general.py
 create mode 100644 tests/validators/arguments_v3/test_keyword_only.py
 create mode 100644 tests/validators/arguments_v3/test_positional_only.py
 create mode 100644 tests/validators/arguments_v3/test_positional_or_keyword.py
 create mode 100644 tests/validators/arguments_v3/test_var_args.py
 create mode 100644 tests/validators/arguments_v3/test_var_kwargs_uniform.py
 create mode 100644 tests/validators/arguments_v3/test_var_kwargs_unpacked_typed_dict.py

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index c7ca7cfd8..3fc307ee3 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -3494,6 +3494,120 @@ def arguments_schema(
     )
 
 
+class ArgumentsV3Parameter(TypedDict, total=False):
+    name: Required[str]
+    schema: Required[CoreSchema]
+    mode: Literal[
+        'positional_only',
+        'positional_or_keyword',
+        'keyword_only',
+        'var_args',
+        'var_kwargs_uniform',
+        'var_kwargs_unpacked_typed_dict',
+    ]  # default positional_or_keyword
+    alias: Union[str, list[Union[str, int]], list[list[Union[str, int]]]]
+
+
+def arguments_v3_parameter(
+    name: str,
+    schema: CoreSchema,
+    *,
+    mode: Literal[
+        'positional_only',
+        'positional_or_keyword',
+        'keyword_only',
+        'var_args',
+        'var_kwargs_uniform',
+        'var_kwargs_unpacked_typed_dict',
+    ]
+    | None = None,
+    alias: str | list[str | int] | list[list[str | int]] | None = None,
+) -> ArgumentsV3Parameter:
+    """
+    Returns a schema that matches an argument parameter, e.g.:
+
+    ```py
+    from pydantic_core import SchemaValidator, core_schema
+
+    param = core_schema.arguments_v3_parameter(
+        name='a', schema=core_schema.str_schema(), mode='positional_only'
+    )
+    schema = core_schema.arguments_v3_schema([param])
+    v = SchemaValidator(schema)
+    assert v.validate_python({'a': 'hello'}) == (('hello',), {})
+    ```
+
+    Args:
+        name: The name to use for the argument parameter
+        schema: The schema to use for the argument parameter
+        mode: The mode to use for the argument parameter
+        alias: The alias to use for the argument parameter
+    """
+    return _dict_not_none(name=name, schema=schema, mode=mode, alias=alias)
+
+
+class ArgumentsV3Schema(TypedDict, total=False):
+    type: Required[Literal['arguments-v3']]
+    arguments_schema: Required[list[ArgumentsV3Parameter]]
+    validate_by_name: bool
+    validate_by_alias: bool
+    extra_behavior: Literal['forbid', 'ignore']  # 'allow' doesn't make sense here.
+    ref: str
+    metadata: dict[str, Any]
+    serialization: SerSchema
+
+
+def arguments_v3_schema(
+    arguments: list[ArgumentsV3Parameter],
+    *,
+    validate_by_name: bool | None = None,
+    validate_by_alias: bool | None = None,
+    extra_behavior: Literal['forbid', 'ignore'] | None = None,
+    ref: str | None = None,
+    metadata: dict[str, Any] | None = None,
+    serialization: SerSchema | None = None,
+) -> ArgumentsV3Schema:
+    """
+    Returns a schema that matches an arguments schema, e.g.:
+
+    ```py
+    from pydantic_core import SchemaValidator, core_schema
+
+    param_a = core_schema.arguments_v3_parameter(
+        name='a', schema=core_schema.str_schema(), mode='positional_only'
+    )
+    param_b = core_schema.arguments_v3_parameter(
+        name='kwargs', schema=core_schema.bool_schema(), mode='var_kwargs_uniform'
+    )
+    schema = core_schema.arguments_v3_schema([param_a, param_b])
+    v = SchemaValidator(schema)
+    assert v.validate_python({'a': 'hi', 'kwargs': {'b': True}}) == (('hi',), {'b': True})
+    ```
+
+    This schema is currently not used by other Pydantic components. In V3, it will most likely
+    become the default arguments schema for the `'call'` schema.
+
+    Args:
+        arguments: The arguments to use for the arguments schema.
+        validate_by_name: Whether to populate by the parameter names, defaults to `False`.
+        validate_by_alias: Whether to populate by the parameter aliases, defaults to `True`.
+        extra_behavior: The extra behavior to use.
+        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.
+        serialization: Custom serialization schema.
+    """
+    return _dict_not_none(
+        type='arguments-v3',
+        arguments_schema=arguments,
+        validate_by_name=validate_by_name,
+        validate_by_alias=validate_by_alias,
+        extra_behavior=extra_behavior,
+        ref=ref,
+        metadata=metadata,
+        serialization=serialization,
+    )
+
+
 class CallSchema(TypedDict, total=False):
     type: Required[Literal['call']]
     arguments_schema: Required[CoreSchema]
@@ -3921,6 +4035,7 @@ def definition_reference_schema(
         DataclassArgsSchema,
         DataclassSchema,
         ArgumentsSchema,
+        ArgumentsV3Schema,
         CallSchema,
         CustomErrorSchema,
         JsonSchema,
@@ -3978,6 +4093,7 @@ def definition_reference_schema(
     'dataclass-args',
     'dataclass',
     'arguments',
+    'arguments-v3',
     'call',
     'custom-error',
     'json',
diff --git a/src/input/input_abstract.rs b/src/input/input_abstract.rs
index aa9c6eb16..119c862ac 100644
--- a/src/input/input_abstract.rs
+++ b/src/input/input_abstract.rs
@@ -81,6 +81,8 @@ pub trait Input<'py>: fmt::Debug {
 
     fn validate_args(&self) -> ValResult<Self::Arguments<'_>>;
 
+    fn validate_args_v3(&self) -> ValResult<Self::Arguments<'_>>;
+
     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<'_>>;
@@ -265,6 +267,7 @@ pub trait ValidatedList<'py> {
 pub trait ValidatedTuple<'py> {
     type Item: BorrowInput<'py>;
     fn len(&self) -> Option<usize>;
+    fn try_for_each(self, f: impl FnMut(PyResult<Self::Item>) -> ValResult<()>) -> ValResult<()>;
     fn iterate<R>(self, consumer: impl ConsumeIterator<PyResult<Self::Item>, Output = R>) -> ValResult<R>;
 }
 
@@ -313,6 +316,9 @@ impl<'py> ValidatedTuple<'py> for Never {
     fn len(&self) -> Option<usize> {
         unreachable!()
     }
+    fn try_for_each(self, _f: impl FnMut(PyResult<Self::Item>) -> ValResult<()>) -> ValResult<()> {
+        unreachable!()
+    }
     fn iterate<R>(self, _consumer: impl ConsumeIterator<PyResult<Self::Item>, Output = R>) -> ValResult<R> {
         unreachable!()
     }
diff --git a/src/input/input_json.rs b/src/input/input_json.rs
index 6479357cc..4de3fd4cf 100644
--- a/src/input/input_json.rs
+++ b/src/input/input_json.rs
@@ -85,6 +85,11 @@ impl<'py, 'data> Input<'py> for JsonValue<'data> {
         }
     }
 
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
+    fn validate_args_v3(&self) -> ValResult<Self::Arguments<'_>> {
+        Err(ValError::new(ErrorTypeDefaults::ArgumentsType, self))
+    }
+
     fn validate_dataclass_args<'a>(&'a self, class_name: &str) -> ValResult<JsonArgs<'a, 'data>> {
         match self {
             JsonValue::Object(object) => Ok(JsonArgs::new(None, Some(object))),
@@ -383,6 +388,11 @@ impl<'py> Input<'py> for str {
         Err(ValError::new(ErrorTypeDefaults::ArgumentsType, self))
     }
 
+    #[cfg_attr(has_coverage_attribute, coverage(off))]
+    fn validate_args_v3(&self) -> ValResult<Never> {
+        Err(ValError::new(ErrorTypeDefaults::ArgumentsType, self))
+    }
+
     #[cfg_attr(has_coverage_attribute, coverage(off))]
     fn validate_dataclass_args(&self, class_name: &str) -> ValResult<Never> {
         let class_name = class_name.to_string();
@@ -579,6 +589,12 @@ impl<'a, 'data> ValidatedTuple<'_> for &'a JsonArray<'data> {
     fn len(&self) -> Option<usize> {
         Some(Vec::len(self))
     }
+    fn try_for_each(self, mut f: impl FnMut(PyResult<Self::Item>) -> ValResult<()>) -> ValResult<()> {
+        for item in self.iter() {
+            f(Ok(item))?;
+        }
+        Ok(())
+    }
     fn iterate<R>(self, consumer: impl ConsumeIterator<PyResult<Self::Item>, Output = R>) -> ValResult<R> {
         Ok(consumer.consume_iterator(self.iter().map(Ok)))
     }
diff --git a/src/input/input_python.rs b/src/input/input_python.rs
index ea6eab054..e82cbaed7 100644
--- a/src/input/input_python.rs
+++ b/src/input/input_python.rs
@@ -117,6 +117,16 @@ impl<'py> Input<'py> for Bound<'py, PyAny> {
         }
     }
 
+    fn validate_args_v3(&self) -> ValResult<PyArgs<'py>> {
+        if let Ok(args_kwargs) = self.extract::<ArgsKwargs>() {
+            let args = args_kwargs.args.into_bound(self.py());
+            let kwargs = args_kwargs.kwargs.map(|d| d.into_bound(self.py()));
+            Ok(PyArgs::new(Some(args), kwargs))
+        } else {
+            Err(ValError::new(ErrorTypeDefaults::ArgumentsType, self))
+        }
+    }
+
     fn validate_dataclass_args<'a>(&'a self, class_name: &str) -> ValResult<PyArgs<'py>> {
         if let Ok(dict) = self.downcast::<PyDict>() {
             Ok(PyArgs::new(None, Some(dict.clone())))
@@ -915,7 +925,15 @@ impl<'py> PySequenceIterable<'_, 'py> {
             PySequenceIterable::Iterator(iter) => iter.len().ok(),
         }
     }
-
+    fn generic_try_for_each(self, f: impl FnMut(PyResult<Bound<'py, PyAny>>) -> ValResult<()>) -> ValResult<()> {
+        match self {
+            PySequenceIterable::List(iter) => iter.iter().map(Ok).try_for_each(f),
+            PySequenceIterable::Tuple(iter) => iter.iter().map(Ok).try_for_each(f),
+            PySequenceIterable::Set(iter) => iter.iter().map(Ok).try_for_each(f),
+            PySequenceIterable::FrozenSet(iter) => iter.iter().map(Ok).try_for_each(f),
+            PySequenceIterable::Iterator(mut iter) => iter.try_for_each(f),
+        }
+    }
     fn generic_iterate<R>(
         self,
         consumer: impl ConsumeIterator<PyResult<Bound<'py, PyAny>>, Output = R>,
@@ -951,6 +969,9 @@ impl<'py> ValidatedTuple<'py> for PySequenceIterable<'_, 'py> {
     fn len(&self) -> Option<usize> {
         self.generic_len()
     }
+    fn try_for_each(self, f: impl FnMut(PyResult<Self::Item>) -> ValResult<()>) -> ValResult<()> {
+        self.generic_try_for_each(f)
+    }
     fn iterate<R>(self, consumer: impl ConsumeIterator<PyResult<Self::Item>, Output = R>) -> ValResult<R> {
         self.generic_iterate(consumer)
     }
diff --git a/src/input/input_string.rs b/src/input/input_string.rs
index a50b3cff2..0ab4ad014 100644
--- a/src/input/input_string.rs
+++ b/src/input/input_string.rs
@@ -89,6 +89,11 @@ impl<'py> Input<'py> for StringMapping<'py> {
         Err(ValError::new(ErrorTypeDefaults::ArgumentsType, self))
     }
 
+    fn validate_args_v3(&self) -> ValResult<Self::Arguments<'_>> {
+        // do we want to support this?
+        Err(ValError::new(ErrorTypeDefaults::ArgumentsType, self))
+    }
+
     fn validate_dataclass_args<'a>(&'a self, _dataclass_name: &str) -> ValResult<StringMappingDict<'py>> {
         match self {
             StringMapping::String(_) => Err(ValError::new(ErrorTypeDefaults::ArgumentsType, self)),
diff --git a/src/validators/arguments_v3.rs b/src/validators/arguments_v3.rs
new file mode 100644
index 000000000..22c9c6d0f
--- /dev/null
+++ b/src/validators/arguments_v3.rs
@@ -0,0 +1,782 @@
+use std::str::FromStr;
+
+use pyo3::intern;
+use pyo3::prelude::*;
+use pyo3::types::{PyDict, PyList, PyString, PyTuple};
+
+use ahash::AHashSet;
+use pyo3::IntoPyObjectExt;
+
+use crate::build_tools::py_schema_err;
+use crate::build_tools::{schema_or_config_same, ExtraBehavior};
+use crate::errors::LocItem;
+use crate::errors::{ErrorTypeDefaults, ValError, ValLineError, ValResult};
+use crate::input::ConsumeIterator;
+use crate::input::{
+    Arguments, BorrowInput, Input, KeywordArgs, PositionalArgs, ValidatedDict, ValidatedTuple, ValidationMatch,
+};
+use crate::lookup_key::LookupKeyCollection;
+use crate::tools::SchemaDict;
+
+use super::validation_state::ValidationState;
+use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuilder, Validator};
+
+#[derive(Debug, PartialEq)]
+enum ParameterMode {
+    PositionalOnly,
+    PositionalOrKeyword,
+    VarArgs,
+    KeywordOnly,
+    VarKwargsUniform,
+    VarKwargsUnpackedTypedDict,
+}
+
+impl FromStr for ParameterMode {
+    type Err = PyErr;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s {
+            "positional_only" => Ok(Self::PositionalOnly),
+            "positional_or_keyword" => Ok(Self::PositionalOrKeyword),
+            "var_args" => Ok(Self::VarArgs),
+            "keyword_only" => Ok(Self::KeywordOnly),
+            "var_kwargs_uniform" => Ok(Self::VarKwargsUniform),
+            "var_kwargs_unpacked_typed_dict" => Ok(Self::VarKwargsUnpackedTypedDict),
+            s => py_schema_err!("Invalid var_kwargs mode: `{}`", s),
+        }
+    }
+}
+
+#[derive(Debug)]
+struct Parameter {
+    name: String,
+    mode: ParameterMode,
+    lookup_key_collection: LookupKeyCollection,
+    validator: CombinedValidator,
+}
+
+impl Parameter {
+    fn is_variadic(&self) -> bool {
+        matches!(
+            self.mode,
+            ParameterMode::VarArgs | ParameterMode::VarKwargsUniform | ParameterMode::VarKwargsUnpackedTypedDict
+        )
+    }
+}
+
+#[derive(Debug)]
+pub struct ArgumentsV3Validator {
+    parameters: Vec<Parameter>,
+    positional_params_count: usize,
+    loc_by_alias: bool,
+    extra: ExtraBehavior,
+    validate_by_alias: Option<bool>,
+    validate_by_name: Option<bool>,
+}
+
+impl BuildValidator for ArgumentsV3Validator {
+    const EXPECTED_TYPE: &'static str = "arguments-v3";
+
+    fn build(
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
+        definitions: &mut DefinitionsBuilder<CombinedValidator>,
+    ) -> PyResult<CombinedValidator> {
+        let py = schema.py();
+
+        let arguments_schema: Bound<'_, PyList> = schema.get_as_req(intern!(py, "arguments_schema"))?;
+        let mut parameters: Vec<Parameter> = Vec::with_capacity(arguments_schema.len());
+
+        let mut had_default_arg = false;
+        let mut had_positional_or_keyword = false;
+        let mut had_var_args = false;
+        let mut had_keyword_only = false;
+        let mut had_var_kwargs = false;
+
+        let mut names: AHashSet<String> = AHashSet::with_capacity(arguments_schema.len());
+
+        for arg in arguments_schema.iter() {
+            let arg = arg.downcast::<PyDict>()?;
+
+            let py_name: Bound<PyString> = arg.get_as_req(intern!(py, "name"))?;
+            let name = py_name.to_string();
+            if !names.insert(name.clone()) {
+                return py_schema_err!("Duplicate parameter '{}'", name);
+            }
+
+            let py_mode = arg.get_as::<Bound<'_, PyString>>(intern!(py, "mode"))?;
+            let py_mode = py_mode
+                .as_ref()
+                .map(|py_str| py_str.to_str())
+                .transpose()?
+                .unwrap_or("positional_or_keyword");
+
+            let mode = ParameterMode::from_str(py_mode)?;
+
+            match mode {
+                ParameterMode::PositionalOnly => {
+                    if had_positional_or_keyword || had_var_args || had_keyword_only || had_var_kwargs {
+                        return py_schema_err!(
+                            "Positional only parameter '{}' cannot follow other parameter kinds",
+                            name
+                        );
+                    }
+                }
+                ParameterMode::PositionalOrKeyword => {
+                    if had_var_args || had_keyword_only || had_var_kwargs {
+                        return py_schema_err!(
+                            "Positional or keyword parameter '{}' cannot follow variadic or keyword only parameters",
+                            name
+                        );
+                    }
+                    had_positional_or_keyword = true;
+                }
+                ParameterMode::VarArgs => {
+                    if had_var_args {
+                        return py_schema_err!("Duplicate variadic positional parameter '{}'", name);
+                    }
+                    if had_keyword_only || had_var_kwargs {
+                        return py_schema_err!(
+                            "Variadic positional parameter '{}' cannot follow variadic or keyword only parameters",
+                            name
+                        );
+                    }
+                    had_var_args = true;
+                }
+                ParameterMode::KeywordOnly => {
+                    if had_var_kwargs {
+                        return py_schema_err!(
+                            "Keyword only parameter '{}' cannot follow variadic keyword only parameter",
+                            name
+                        );
+                    }
+                    had_keyword_only = true;
+                }
+                ParameterMode::VarKwargsUniform | ParameterMode::VarKwargsUnpackedTypedDict => {
+                    if had_var_kwargs {
+                        return py_schema_err!("Duplicate variadic keyword parameter '{}'", name);
+                    }
+                    had_var_kwargs = true;
+                }
+            }
+
+            let schema = arg.get_as_req(intern!(py, "schema"))?;
+
+            let validator = match build_validator(&schema, config, definitions) {
+                Ok(v) => v,
+                Err(err) => return py_schema_err!("Parameter '{}':\n  {}", name, err),
+            };
+
+            let has_default = match validator {
+                CombinedValidator::WithDefault(ref v) => {
+                    if v.omit_on_error() {
+                        return py_schema_err!("Parameter '{}': omit_on_error cannot be used with arguments", name);
+                    }
+                    v.has_default()
+                }
+                _ => false,
+            };
+
+            if had_default_arg && !has_default && !had_keyword_only {
+                return py_schema_err!("Required parameter '{}' follows parameter with default", name);
+            } else if has_default {
+                had_default_arg = true;
+            }
+
+            let validation_alias = arg.get_item(intern!(py, "alias"))?;
+            let lookup_key_collection = LookupKeyCollection::new(py, validation_alias, name.as_str())?;
+
+            parameters.push(Parameter {
+                name,
+                mode,
+                lookup_key_collection,
+                validator,
+            });
+        }
+
+        let positional_params_count = parameters
+            .iter()
+            .filter(|p| {
+                matches!(
+                    p.mode,
+                    ParameterMode::PositionalOnly | ParameterMode::PositionalOrKeyword
+                )
+            })
+            .count();
+
+        Ok(Self {
+            parameters,
+            positional_params_count,
+            loc_by_alias: config.get_as(intern!(py, "loc_by_alias"))?.unwrap_or(true),
+            extra: ExtraBehavior::from_schema_or_config(py, schema, config, ExtraBehavior::Forbid)?,
+            validate_by_alias: schema_or_config_same(schema, config, intern!(py, "validate_by_alias"))?,
+            validate_by_name: schema_or_config_same(schema, config, intern!(py, "validate_by_name"))?,
+        }
+        .into())
+    }
+}
+
+impl_py_gc_traverse!(Parameter { validator });
+
+impl_py_gc_traverse!(ArgumentsV3Validator { parameters });
+
+impl ArgumentsV3Validator {
+    /// Validate the arguments from a mapping:
+    /// ```py
+    /// def func(a: int, /, *, b: str, **kwargs: int) -> None:
+    ///     ...
+    ///
+    /// valid_mapping = {'a': 1, 'b': 'test', 'kwargs': {'c': 1, 'd': 2}}
+    /// ```
+    fn validate_from_mapping<'py>(
+        &self,
+        py: Python<'py>,
+        original_input: &(impl Input<'py> + ?Sized),
+        mapping: impl ValidatedDict<'py>,
+        state: &mut ValidationState<'_, 'py>,
+    ) -> ValResult<PyObject> {
+        let mut output_args: Vec<PyObject> = Vec::with_capacity(self.positional_params_count);
+        let output_kwargs = PyDict::new(py);
+        let mut errors: Vec<ValLineError> = Vec::new();
+
+        let validate_by_alias = state.validate_by_alias_or(self.validate_by_alias);
+        let validate_by_name = state.validate_by_name_or(self.validate_by_name);
+
+        // Keep track of used keys for extra behavior:
+        let mut used_keys: Option<AHashSet<&str>> = if self.extra == ExtraBehavior::Ignore || mapping.is_py_get_attr() {
+            None
+        } else {
+            Some(AHashSet::with_capacity(self.parameters.len()))
+        };
+
+        for parameter in &self.parameters {
+            let lookup_key = parameter
+                .lookup_key_collection
+                .select(validate_by_alias, validate_by_name)?;
+
+            // A value is present in the mapping:
+            if let Some((lookup_path, dict_value)) = mapping.get_item(lookup_key)? {
+                if let Some(ref mut used_keys) = used_keys {
+                    // key is "used" whether or not validation passes, since we want to skip this key in
+                    // extra logic either way
+                    used_keys.insert(lookup_path.first_key());
+                }
+
+                match parameter.mode {
+                    ParameterMode::PositionalOnly | ParameterMode::PositionalOrKeyword => {
+                        match parameter.validator.validate(py, dict_value.borrow_input(), state) {
+                            Ok(value) => output_args.push(value),
+                            Err(ValError::LineErrors(line_errors)) => {
+                                errors.extend(
+                                    line_errors.into_iter().map(|err| {
+                                        lookup_path.apply_error_loc(err, self.loc_by_alias, &parameter.name)
+                                    }),
+                                );
+                            }
+                            Err(err) => return Err(err),
+                        }
+                    }
+                    ParameterMode::VarArgs => match dict_value.borrow_input().validate_tuple(false) {
+                        Ok(tuple) => {
+                            let mut i: i64 = 0;
+                            tuple.unpack(state).try_for_each(|v| {
+                                match parameter.validator.validate(py, v.unwrap().borrow_input(), state) {
+                                    Ok(tuple_value) => {
+                                        output_args.push(tuple_value);
+                                        i += 1;
+                                        Ok(())
+                                    }
+                                    Err(ValError::LineErrors(line_errors)) => {
+                                        errors.extend(line_errors.into_iter().map(|err| {
+                                            lookup_path.apply_error_loc(
+                                                err.with_outer_location(i),
+                                                self.loc_by_alias,
+                                                &parameter.name,
+                                            )
+                                        }));
+                                        i += 1;
+                                        Ok(())
+                                    }
+                                    Err(err) => {
+                                        i += 1;
+                                        Err(err)
+                                    }
+                                }
+                            })?;
+                        }
+                        Err(_) => {
+                            let val_error = ValLineError::new(ErrorTypeDefaults::TupleType, dict_value.borrow_input());
+                            errors.push(lookup_path.apply_error_loc(val_error, self.loc_by_alias, &parameter.name));
+                        }
+                    },
+                    ParameterMode::KeywordOnly => {
+                        match parameter.validator.validate(py, dict_value.borrow_input(), state) {
+                            Ok(value) => {
+                                output_kwargs.set_item(PyString::new(py, parameter.name.as_str()).unbind(), value)?;
+                            }
+                            Err(ValError::LineErrors(line_errors)) => {
+                                errors.extend(
+                                    line_errors.into_iter().map(|err| {
+                                        lookup_path.apply_error_loc(err, self.loc_by_alias, &parameter.name)
+                                    }),
+                                );
+                            }
+                            Err(err) => return Err(err),
+                        }
+                    }
+                    ParameterMode::VarKwargsUniform => match dict_value.borrow_input().as_kwargs(py) {
+                        // We will validate that keys are strings, and values match the validator:
+                        Some(value) => {
+                            for (dict_key, dict_value) in value {
+                                // Validate keys are strings:
+                                match dict_key.validate_str(true, false).map(ValidationMatch::into_inner) {
+                                    Ok(_) => (),
+                                    Err(ValError::LineErrors(line_errors)) => {
+                                        for err in line_errors {
+                                            errors.push(
+                                                err.with_outer_location(dict_key.clone())
+                                                    .with_outer_location(&parameter.name)
+                                                    .with_type(ErrorTypeDefaults::InvalidKey),
+                                            );
+                                        }
+                                        continue;
+                                    }
+                                    Err(err) => return Err(err),
+                                }
+                                // Validate values:
+                                match parameter.validator.validate(py, dict_value.borrow_input(), state) {
+                                    Ok(value) => output_kwargs.set_item(dict_key, value)?,
+                                    Err(ValError::LineErrors(line_errors)) => {
+                                        errors.extend(line_errors.into_iter().map(|err| {
+                                            lookup_path.apply_error_loc(
+                                                err.with_outer_location(dict_key.clone()),
+                                                self.loc_by_alias,
+                                                &parameter.name,
+                                            )
+                                        }));
+                                    }
+                                    Err(err) => return Err(err),
+                                }
+                            }
+                        }
+                        None => {
+                            let val_error = ValLineError::new(ErrorTypeDefaults::DictType, dict_value);
+                            errors.push(lookup_path.apply_error_loc(val_error, self.loc_by_alias, &parameter.name));
+                        }
+                    },
+                    ParameterMode::VarKwargsUnpackedTypedDict => {
+                        match parameter.validator.validate(py, dict_value.borrow_input(), state) {
+                            Ok(value) => {
+                                output_kwargs.update(value.downcast_bound::<PyDict>(py).unwrap().as_mapping())?;
+                            }
+                            Err(ValError::LineErrors(line_errors)) => {
+                                errors.extend(
+                                    line_errors.into_iter().map(|err| {
+                                        lookup_path.apply_error_loc(err, self.loc_by_alias, &parameter.name)
+                                    }),
+                                );
+                            }
+                            Err(err) => return Err(err),
+                        }
+                    }
+                }
+            // No value is present in the mapping...
+            } else {
+                match parameter.mode {
+                    // ... fallback to the default value (and error if no default):
+                    ParameterMode::PositionalOnly | ParameterMode::PositionalOrKeyword | ParameterMode::KeywordOnly => {
+                        if let Some(value) =
+                            parameter
+                                .validator
+                                .default_value(py, Some(parameter.name.as_str()), state)?
+                        {
+                            if matches!(
+                                parameter.mode,
+                                ParameterMode::PositionalOnly | ParameterMode::PositionalOrKeyword
+                            ) {
+                                output_args.push(value);
+                            } else {
+                                output_kwargs.set_item(PyString::new(py, parameter.name.as_str()).unbind(), value)?;
+                            }
+                        } else {
+                            let error_type = match parameter.mode {
+                                ParameterMode::PositionalOnly => ErrorTypeDefaults::MissingPositionalOnlyArgument,
+                                ParameterMode::PositionalOrKeyword => ErrorTypeDefaults::MissingArgument,
+                                ParameterMode::KeywordOnly => ErrorTypeDefaults::MissingKeywordOnlyArgument,
+                                _ => unreachable!(),
+                            };
+
+                            errors.push(lookup_key.error(
+                                error_type,
+                                original_input,
+                                self.loc_by_alias,
+                                &parameter.name,
+                            ));
+                        }
+                    }
+                    // ... validate the unpacked kwargs against an empty dict:
+                    ParameterMode::VarKwargsUnpackedTypedDict => {
+                        match parameter.validator.validate(py, PyDict::new(py).borrow_input(), state) {
+                            Ok(value) => {
+                                output_kwargs.update(value.downcast_bound::<PyDict>(py).unwrap().as_mapping())?;
+                            }
+                            Err(ValError::LineErrors(line_errors)) => {
+                                errors.extend(
+                                    line_errors
+                                        .into_iter()
+                                        .map(|err| err.with_outer_location(&parameter.name)),
+                                );
+                            }
+                            Err(err) => return Err(err),
+                        }
+                    }
+                    // Variadic args/uniform kwargs can be empty by definition:
+                    _ => (),
+                }
+            }
+        }
+
+        if let Some(used_keys) = used_keys {
+            struct ValidateExtra<'a> {
+                used_keys: AHashSet<&'a str>,
+                errors: &'a mut Vec<ValLineError>,
+                extra_behavior: ExtraBehavior,
+            }
+
+            impl<'py, Key, Value> ConsumeIterator<ValResult<(Key, Value)>> for ValidateExtra<'_>
+            where
+                Key: BorrowInput<'py> + Clone + Into<LocItem>,
+                Value: BorrowInput<'py>,
+            {
+                type Output = ValResult<()>;
+                fn consume_iterator(self, iterator: impl Iterator<Item = ValResult<(Key, Value)>>) -> Self::Output {
+                    for item_result in iterator {
+                        let (raw_key, value) = item_result?;
+                        let either_str = match raw_key
+                            .borrow_input()
+                            .validate_str(true, false)
+                            .map(ValidationMatch::into_inner)
+                        {
+                            Ok(k) => k,
+                            Err(ValError::LineErrors(line_errors)) => {
+                                for err in line_errors {
+                                    self.errors.push(
+                                        err.with_outer_location(raw_key.clone())
+                                            .with_type(ErrorTypeDefaults::InvalidKey),
+                                    );
+                                }
+                                continue;
+                            }
+                            Err(err) => return Err(err),
+                        };
+                        let cow = either_str.as_cow()?;
+                        if self.used_keys.contains(cow.as_ref()) {
+                            continue;
+                        }
+
+                        let value = value.borrow_input();
+
+                        if self.extra_behavior == ExtraBehavior::Forbid {
+                            self.errors.push(ValLineError::new_with_loc(
+                                ErrorTypeDefaults::ExtraForbidden,
+                                value,
+                                raw_key.clone(),
+                            ));
+                        }
+                    }
+
+                    Ok(())
+                }
+            }
+
+            mapping.iterate(ValidateExtra {
+                used_keys,
+                errors: &mut errors,
+                extra_behavior: self.extra,
+            })??;
+        }
+
+        if !errors.is_empty() {
+            Err(ValError::LineErrors(errors))
+        } else {
+            Ok((PyTuple::new(py, output_args)?, output_kwargs).into_py_any(py)?)
+        }
+    }
+
+    /// Validate the arguments from an [`ArgsKwargs`][crate::argument_markers::ArgsKwargs] instance:
+    /// ```py
+    /// def func(a: int, /, *, b: str, **kwargs: int) -> None:
+    ///     ...
+    ///
+    /// valid_argskwargs = ArgsKwargs((1,), {'b': 'test', 'c': 1, 'd': 2})
+    /// ```
+    fn validate_from_argskwargs<'py>(
+        &self,
+        py: Python<'py>,
+        original_input: &(impl Input<'py> + ?Sized),
+        args_kwargs: impl Arguments<'py>,
+        state: &mut ValidationState<'_, 'py>,
+    ) -> ValResult<PyObject> {
+        let mut output_args: Vec<PyObject> = Vec::with_capacity(self.positional_params_count);
+        let output_kwargs = PyDict::new(py);
+        let mut errors: Vec<ValLineError> = Vec::new();
+        let mut used_kwargs: AHashSet<&str> = AHashSet::with_capacity(self.parameters.len());
+
+        let validate_by_alias = state.validate_by_alias_or(self.validate_by_alias);
+        let validate_by_name = state.validate_by_name_or(self.validate_by_name);
+
+        // go through non variadic parameters, getting the value from args or kwargs and validating it
+        for (index, parameter) in self.parameters.iter().filter(|p| !p.is_variadic()).enumerate() {
+            let lookup_key = parameter
+                .lookup_key_collection
+                .select(validate_by_alias, validate_by_name)?;
+
+            let mut pos_value = None;
+            if let Some(args) = args_kwargs.args() {
+                if matches!(
+                    parameter.mode,
+                    ParameterMode::PositionalOnly | ParameterMode::PositionalOrKeyword
+                ) {
+                    pos_value = args.get_item(index);
+                }
+            }
+
+            let mut kw_value = None;
+            if let Some(kwargs) = args_kwargs.kwargs() {
+                if matches!(
+                    parameter.mode,
+                    ParameterMode::PositionalOrKeyword | ParameterMode::KeywordOnly
+                ) {
+                    if let Some((lookup_path, value)) = kwargs.get_item(lookup_key)? {
+                        used_kwargs.insert(lookup_path.first_key());
+                        kw_value = Some((lookup_path, value));
+                    }
+                }
+            }
+
+            match (pos_value, kw_value) {
+                (Some(_), Some((_, kw_value))) => {
+                    errors.push(ValLineError::new_with_loc(
+                        ErrorTypeDefaults::MultipleArgumentValues,
+                        kw_value.borrow_input(),
+                        parameter.name.clone(),
+                    ));
+                }
+                (Some(pos_value), None) => match parameter.validator.validate(py, pos_value.borrow_input(), state) {
+                    Ok(value) => output_args.push(value),
+                    Err(ValError::LineErrors(line_errors)) => {
+                        errors.extend(line_errors.into_iter().map(|err| err.with_outer_location(index)));
+                    }
+                    Err(err) => return Err(err),
+                },
+                (None, Some((lookup_path, kw_value))) => {
+                    match parameter.validator.validate(py, kw_value.borrow_input(), state) {
+                        Ok(value) => {
+                            output_kwargs.set_item(PyString::new(py, parameter.name.as_str()).unbind(), value)?;
+                        }
+                        Err(ValError::LineErrors(line_errors)) => {
+                            errors.extend(
+                                line_errors
+                                    .into_iter()
+                                    .map(|err| lookup_path.apply_error_loc(err, self.loc_by_alias, &parameter.name)),
+                            );
+                        }
+                        Err(err) => return Err(err),
+                    }
+                }
+                (None, None) => {
+                    if let Some(value) = parameter
+                        .validator
+                        .default_value(py, Some(parameter.name.as_str()), state)?
+                    {
+                        if parameter.mode == ParameterMode::PositionalOnly {
+                            output_args.push(value);
+                        } else {
+                            output_kwargs.set_item(PyString::new(py, parameter.name.as_str()).unbind(), value)?;
+                        }
+                    } else {
+                        // Required and no default, error:
+                        match parameter.mode {
+                            ParameterMode::PositionalOnly => {
+                                errors.push(ValLineError::new_with_loc(
+                                    ErrorTypeDefaults::MissingPositionalOnlyArgument,
+                                    original_input,
+                                    index,
+                                ));
+                            }
+                            ParameterMode::PositionalOrKeyword => {
+                                errors.push(lookup_key.error(
+                                    ErrorTypeDefaults::MissingArgument,
+                                    original_input,
+                                    self.loc_by_alias,
+                                    &parameter.name,
+                                ));
+                            }
+                            ParameterMode::KeywordOnly => {
+                                errors.push(lookup_key.error(
+                                    ErrorTypeDefaults::MissingKeywordOnlyArgument,
+                                    original_input,
+                                    self.loc_by_alias,
+                                    &parameter.name,
+                                ));
+                            }
+                            _ => unreachable!(),
+                        }
+                    }
+                }
+            }
+        }
+
+        // if there are args check any where index > positional_params_count since they won't have been checked yet
+        if let Some(args) = args_kwargs.args() {
+            let len = args.len();
+            if len > self.positional_params_count {
+                if let Some(var_args_param) = self.parameters.iter().find(|p| p.mode == ParameterMode::VarArgs) {
+                    for (index, item) in args.iter().enumerate().skip(self.positional_params_count) {
+                        match var_args_param.validator.validate(py, item.borrow_input(), state) {
+                            Ok(value) => output_args.push(value),
+                            Err(ValError::LineErrors(line_errors)) => {
+                                errors.extend(line_errors.into_iter().map(|err| err.with_outer_location(index)));
+                            }
+                            Err(err) => return Err(err),
+                        }
+                    }
+                } else {
+                    for (index, item) in args.iter().enumerate().skip(self.positional_params_count) {
+                        errors.push(ValLineError::new_with_loc(
+                            ErrorTypeDefaults::UnexpectedPositionalArgument,
+                            item,
+                            index,
+                        ));
+                    }
+                }
+            }
+        }
+
+        let remaining_kwargs = PyDict::new(py);
+
+        // if there are kwargs check any that haven't been processed yet
+        if let Some(kwargs) = args_kwargs.kwargs() {
+            if kwargs.len() > used_kwargs.len() {
+                for result in kwargs.iter() {
+                    let (raw_key, value) = result?;
+                    let either_str = match raw_key
+                        .borrow_input()
+                        .validate_str(true, false)
+                        .map(ValidationMatch::into_inner)
+                    {
+                        Ok(k) => k,
+                        Err(ValError::LineErrors(line_errors)) => {
+                            for err in line_errors {
+                                errors.push(
+                                    err.with_outer_location(raw_key.clone())
+                                        .with_type(ErrorTypeDefaults::InvalidKey),
+                                );
+                            }
+                            continue;
+                        }
+                        Err(err) => return Err(err),
+                    };
+                    if !used_kwargs.contains(either_str.as_cow()?.as_ref()) {
+                        let maybe_var_kwargs_parameter = self.parameters.iter().find(|p| {
+                            matches!(
+                                p.mode,
+                                ParameterMode::VarKwargsUniform | ParameterMode::VarKwargsUnpackedTypedDict
+                            )
+                        });
+
+                        match maybe_var_kwargs_parameter {
+                            None => {
+                                if self.extra == ExtraBehavior::Forbid {
+                                    errors.push(ValLineError::new_with_loc(
+                                        ErrorTypeDefaults::UnexpectedKeywordArgument,
+                                        value,
+                                        raw_key.clone(),
+                                    ));
+                                }
+                            }
+                            Some(var_kwargs_parameter) => {
+                                match var_kwargs_parameter.mode {
+                                    ParameterMode::VarKwargsUniform => {
+                                        match var_kwargs_parameter.validator.validate(py, value.borrow_input(), state) {
+                                            Ok(value) => {
+                                                output_kwargs
+                                                    .set_item(either_str.as_py_string(py, state.cache_str()), value)?;
+                                            }
+                                            Err(ValError::LineErrors(line_errors)) => {
+                                                for err in line_errors {
+                                                    errors.push(err.with_outer_location(raw_key.clone()));
+                                                }
+                                            }
+                                            Err(err) => return Err(err),
+                                        }
+                                    }
+                                    ParameterMode::VarKwargsUnpackedTypedDict => {
+                                        // Save to the remaining kwargs, we will validate as a single dict:
+                                        remaining_kwargs.set_item(
+                                            either_str.as_py_string(py, state.cache_str()),
+                                            value.borrow_input().to_object(py)?,
+                                        )?;
+                                    }
+                                    _ => unreachable!(),
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        let maybe_var_kwargs_parameter = self
+            .parameters
+            .iter()
+            .find(|p| p.mode == ParameterMode::VarKwargsUnpackedTypedDict);
+
+        if let Some(var_kwargs_parameter) = maybe_var_kwargs_parameter {
+            match var_kwargs_parameter
+                .validator
+                .validate(py, remaining_kwargs.as_any(), state)
+            {
+                Ok(value) => {
+                    output_kwargs.update(value.downcast_bound::<PyDict>(py).unwrap().as_mapping())?;
+                }
+                Err(ValError::LineErrors(line_errors)) => {
+                    errors.extend(line_errors);
+                }
+                Err(err) => return Err(err),
+            }
+        }
+
+        if !errors.is_empty() {
+            Err(ValError::LineErrors(errors))
+        } else {
+            Ok((PyTuple::new(py, output_args)?, output_kwargs).into_py_any(py)?)
+        }
+    }
+}
+
+impl Validator for ArgumentsV3Validator {
+    fn validate<'py>(
+        &self,
+        py: Python<'py>,
+        input: &(impl Input<'py> + ?Sized),
+        state: &mut ValidationState<'_, 'py>,
+    ) -> ValResult<PyObject> {
+        // this validator does not yet support partial validation, disable it to avoid incorrect results
+        state.allow_partial = false.into();
+
+        let args_dict = input.validate_dict(false);
+
+        // Validation from a dictionary, mapping parameter names to the values:
+        if let Ok(dict) = args_dict {
+            self.validate_from_mapping(py, input, dict, state)
+        } else {
+            let args = input.validate_args_v3()?;
+            self.validate_from_argskwargs(py, input, args, state)
+        }
+    }
+
+    fn get_name(&self) -> &str {
+        Self::EXPECTED_TYPE
+    }
+}
diff --git a/src/validators/mod.rs b/src/validators/mod.rs
index 4e40bf080..f105e1854 100644
--- a/src/validators/mod.rs
+++ b/src/validators/mod.rs
@@ -21,6 +21,7 @@ pub(crate) use config::ValBytesMode;
 
 mod any;
 mod arguments;
+mod arguments_v3;
 mod bool;
 mod bytes;
 mod call;
@@ -636,6 +637,7 @@ pub fn build_validator(
         callable::CallableValidator,
         // arguments
         arguments::ArgumentsValidator,
+        arguments_v3::ArgumentsV3Validator,
         // default value
         with_default::WithDefaultValidator,
         // chain validators
@@ -802,6 +804,7 @@ pub enum CombinedValidator {
     Callable(callable::CallableValidator),
     // arguments
     Arguments(arguments::ArgumentsValidator),
+    ArgumentsV3(arguments_v3::ArgumentsV3Validator),
     // default value
     WithDefault(with_default::WithDefaultValidator),
     // chain validators
diff --git a/tests/conftest.py b/tests/conftest.py
index 56d94a0c1..226ace018 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -14,7 +14,7 @@
 import hypothesis
 import pytest
 
-from pydantic_core import ArgsKwargs, SchemaValidator, ValidationError, validate_core_schema
+from pydantic_core import ArgsKwargs, CoreSchema, SchemaValidator, ValidationError, validate_core_schema
 from pydantic_core.core_schema import CoreConfig
 
 __all__ = 'Err', 'PyAndJson', 'plain_repr', 'infinite_generator'
@@ -52,7 +52,11 @@ def json_default(obj):
 
 class PyAndJsonValidator:
     def __init__(
-        self, schema, config: CoreConfig | None = None, *, validator_type: Literal['json', 'python'] | None = None
+        self,
+        schema: CoreSchema,
+        config: CoreConfig | None = None,
+        *,
+        validator_type: Literal['json', 'python'] | None = None,
     ):
         self.validator = SchemaValidator(validate_core_schema(schema), config)
         self.validator_type = validator_type
diff --git a/tests/test_schema_functions.py b/tests/test_schema_functions.py
index a15adfca5..a9cb358ff 100644
--- a/tests/test_schema_functions.py
+++ b/tests/test_schema_functions.py
@@ -225,6 +225,24 @@ def args(*args, **kwargs):
             'serialization': {'type': 'format', 'formatting_string': 'd'},
         },
     ),
+    (
+        core_schema.arguments_v3_schema,
+        args(
+            [
+                core_schema.arguments_v3_parameter('foo', core_schema.int_schema()),
+                core_schema.arguments_v3_parameter('bar', core_schema.str_schema()),
+            ],
+            serialization=core_schema.format_ser_schema('d'),
+        ),
+        {
+            'type': 'arguments-v3',
+            'arguments_schema': [
+                {'name': 'foo', 'schema': {'type': 'int'}},
+                {'name': 'bar', 'schema': {'type': 'str'}},
+            ],
+            'serialization': {'type': 'format', 'formatting_string': 'd'},
+        },
+    ),
     (
         core_schema.call_schema,
         args(core_schema.arguments_schema([core_schema.arguments_parameter('foo', {'type': 'int'})]), val_function),
diff --git a/tests/validators/arguments_v3/__init__.py b/tests/validators/arguments_v3/__init__.py
new file mode 100644
index 000000000..e69de29bb
diff --git a/tests/validators/arguments_v3/test_alias.py b/tests/validators/arguments_v3/test_alias.py
new file mode 100644
index 000000000..0f365c353
--- /dev/null
+++ b/tests/validators/arguments_v3/test_alias.py
@@ -0,0 +1,158 @@
+from __future__ import annotations
+
+import re
+
+import pytest
+
+from pydantic_core import ArgsKwargs, SchemaValidator, ValidationError
+from pydantic_core import core_schema as cs
+
+from ...conftest import Err, PyAndJson
+
+
+@pytest.mark.parametrize(
+    ['input_value', 'expected'],
+    (
+        [ArgsKwargs((1,)), ((1,), {})],
+        [ArgsKwargs((), {'Foo': 1}), ((), {'a': 1})],
+        [ArgsKwargs((), {'a': 1}), Err('Foo\n  Missing required argument [type=missing_argument,')],
+        [{'Foo': 1}, ((1,), {})],
+        [{'a': 1}, Err('Foo\n  Missing required argument [type=missing_argument,')],
+    ),
+    ids=repr,
+)
+def test_alias(py_and_json: PyAndJson, input_value, expected) -> None:
+    v = py_and_json(
+        cs.arguments_v3_schema(
+            [
+                cs.arguments_v3_parameter(name='a', schema=cs.int_schema(), alias='Foo', mode='positional_or_keyword'),
+            ]
+        )
+    )
+    if isinstance(expected, Err):
+        with pytest.raises(ValidationError, match=re.escape(expected.message)):
+            v.validate_test(input_value)
+    else:
+        assert v.validate_test(input_value) == expected
+
+
+@pytest.mark.parametrize(
+    ['input_value', 'expected'],
+    (
+        [ArgsKwargs((1,)), ((1,), {})],
+        [ArgsKwargs((), {'Foo': 1}), ((), {'a': 1})],
+        [ArgsKwargs((), {'a': 1}), ((), {'a': 1})],
+        [ArgsKwargs((), {'a': 1, 'b': 2}), Err('b\n  Unexpected keyword argument [type=unexpected_keyword_argument,')],
+        [
+            ArgsKwargs((), {'a': 1, 'Foo': 2}),
+            Err('a\n  Unexpected keyword argument [type=unexpected_keyword_argument,'),
+        ],
+        [{'Foo': 1}, ((1,), {})],
+        [{'a': 1}, ((1,), {})],
+    ),
+    ids=repr,
+)
+def test_alias_validate_by_name(py_and_json: PyAndJson, input_value, expected):
+    v = py_and_json(
+        cs.arguments_v3_schema(
+            [
+                cs.arguments_v3_parameter(name='a', schema=cs.int_schema(), alias='Foo', mode='positional_or_keyword'),
+            ],
+            validate_by_name=True,
+        )
+    )
+    if isinstance(expected, Err):
+        with pytest.raises(ValidationError, match=re.escape(expected.message)):
+            v.validate_test(input_value)
+    else:
+        assert v.validate_test(input_value) == expected
+
+
+def test_only_validate_by_name(py_and_json) -> None:
+    v = py_and_json(
+        cs.arguments_v3_schema(
+            [
+                cs.arguments_v3_parameter(
+                    name='a', schema=cs.str_schema(), alias='FieldA', mode='positional_or_keyword'
+                ),
+            ],
+            validate_by_name=True,
+            validate_by_alias=False,
+        )
+    )
+
+    assert v.validate_test(ArgsKwargs((), {'a': 'hello'})) == ((), {'a': 'hello'})
+    assert v.validate_test({'a': 'hello'}) == (('hello',), {})
+
+    with pytest.raises(ValidationError, match=r'a\n +Missing required argument \[type=missing_argument,'):
+        assert v.validate_test(ArgsKwargs((), {'FieldA': 'hello'}))
+    with pytest.raises(ValidationError, match=r'a\n +Missing required argument \[type=missing_argument,'):
+        assert v.validate_test({'FieldA': 'hello'})
+
+
+def test_only_allow_alias(py_and_json) -> None:
+    v = py_and_json(
+        cs.arguments_v3_schema(
+            [
+                cs.arguments_v3_parameter(
+                    name='a', schema=cs.str_schema(), alias='FieldA', mode='positional_or_keyword'
+                ),
+            ],
+            validate_by_name=False,
+            validate_by_alias=True,
+        )
+    )
+    assert v.validate_test(ArgsKwargs((), {'FieldA': 'hello'})) == ((), {'a': 'hello'})
+    assert v.validate_test({'FieldA': 'hello'}) == (('hello',), {})
+
+    with pytest.raises(ValidationError, match=r'FieldA\n +Missing required argument \[type=missing_argument,'):
+        assert v.validate_test(ArgsKwargs((), {'a': 'hello'}))
+    with pytest.raises(ValidationError, match=r'FieldA\n +Missing required argument \[type=missing_argument,'):
+        assert v.validate_test({'a': 'hello'})
+
+
+@pytest.mark.parametrize('config_by_alias', [None, True, False])
+@pytest.mark.parametrize('config_by_name', [None, True, False])
+@pytest.mark.parametrize('runtime_by_alias', [None, True, False])
+@pytest.mark.parametrize('runtime_by_name', [None, True, False])
+def test_by_alias_and_name_config_interaction(
+    config_by_alias: bool | None,
+    config_by_name: bool | None,
+    runtime_by_alias: bool | None,
+    runtime_by_name: bool | None,
+) -> None:
+    """This test reflects the priority that applies for config vs runtime validation alias configuration.
+
+    Runtime values take precedence over config values, when set.
+    By default, by_alias is True and by_name is False.
+    """
+
+    if config_by_alias is False and config_by_name is False and runtime_by_alias is False and runtime_by_name is False:
+        pytest.skip("Can't have both by_alias and by_name as effectively False")
+
+    schema = cs.arguments_v3_schema(
+        arguments=[
+            cs.arguments_v3_parameter(name='my_field', schema=cs.int_schema(), alias='my_alias'),
+        ],
+        **({'validate_by_alias': config_by_alias} if config_by_alias is not None else {}),
+        **({'validate_by_name': config_by_name} if config_by_name is not None else {}),
+    )
+    s = SchemaValidator(schema)
+
+    alias_allowed = next(x for x in (runtime_by_alias, config_by_alias, True) if x is not None)
+    name_allowed = next(x for x in (runtime_by_name, config_by_name, False) if x is not None)
+
+    if alias_allowed:
+        assert s.validate_python(
+            ArgsKwargs((), {'my_alias': 1}), by_alias=runtime_by_alias, by_name=runtime_by_name
+        ) == (
+            (),
+            {'my_field': 1},
+        )
+    if name_allowed:
+        assert s.validate_python(
+            ArgsKwargs((), {'my_field': 1}), by_alias=runtime_by_alias, by_name=runtime_by_name
+        ) == (
+            (),
+            {'my_field': 1},
+        )
diff --git a/tests/validators/arguments_v3/test_build_errors.py b/tests/validators/arguments_v3/test_build_errors.py
new file mode 100644
index 000000000..a81244577
--- /dev/null
+++ b/tests/validators/arguments_v3/test_build_errors.py
@@ -0,0 +1,87 @@
+import pytest
+
+from pydantic_core import SchemaError, SchemaValidator
+from pydantic_core import core_schema as cs
+
+
+def test_build_non_default_follows_default() -> None:
+    with pytest.raises(SchemaError, match="Required parameter 'b' follows parameter with default"):
+        SchemaValidator(
+            schema=cs.arguments_v3_schema(
+                [
+                    cs.arguments_v3_parameter(
+                        name='a',
+                        schema=cs.with_default_schema(schema=cs.int_schema(), default_factory=lambda: 42),
+                        mode='positional_or_keyword',
+                    ),
+                    cs.arguments_v3_parameter(name='b', schema=cs.int_schema(), mode='positional_or_keyword'),
+                ]
+            )
+        )
+
+
+def test_duplicate_parameter_name() -> None:
+    with pytest.raises(SchemaError, match="Duplicate parameter 'test'"):
+        SchemaValidator(
+            schema=cs.arguments_v3_schema(
+                [
+                    cs.arguments_v3_parameter(name='test', schema=cs.int_schema()),
+                    cs.arguments_v3_parameter(name='a', schema=cs.int_schema()),
+                    cs.arguments_v3_parameter(name='test', schema=cs.int_schema()),
+                ]
+            )
+        )
+
+
+def test_invalid_positional_only_parameter_position() -> None:
+    with pytest.raises(SchemaError, match="Positional only parameter 'test' cannot follow other parameter kinds"):
+        SchemaValidator(
+            schema=cs.arguments_v3_schema(
+                [
+                    cs.arguments_v3_parameter(name='a', schema=cs.int_schema(), mode='var_args'),
+                    cs.arguments_v3_parameter(name='test', schema=cs.int_schema(), mode='positional_only'),
+                ]
+            )
+        )
+
+
+def test_invalid_positional_or_keyword_parameter_position() -> None:
+    with pytest.raises(
+        SchemaError, match="Positional or keyword parameter 'test' cannot follow variadic or keyword only parameters"
+    ):
+        SchemaValidator(
+            schema=cs.arguments_v3_schema(
+                [
+                    cs.arguments_v3_parameter(name='a', schema=cs.int_schema(), mode='var_args'),
+                    cs.arguments_v3_parameter(name='test', schema=cs.int_schema(), mode='positional_or_keyword'),
+                ]
+            )
+        )
+
+
+def test_invalid_var_args_parameter_position() -> None:
+    with pytest.raises(
+        SchemaError, match="Variadic positional parameter 'test' cannot follow variadic or keyword only parameters"
+    ):
+        SchemaValidator(
+            schema=cs.arguments_v3_schema(
+                [
+                    cs.arguments_v3_parameter(name='a', schema=cs.int_schema(), mode='keyword_only'),
+                    cs.arguments_v3_parameter(name='test', schema=cs.int_schema(), mode='var_args'),
+                ]
+            )
+        )
+
+
+def test_invalid_keyword_only_parameter_position() -> None:
+    with pytest.raises(
+        SchemaError, match="Keyword only parameter 'test' cannot follow variadic keyword only parameter"
+    ):
+        SchemaValidator(
+            schema=cs.arguments_v3_schema(
+                [
+                    cs.arguments_v3_parameter(name='a', schema=cs.int_schema(), mode='var_kwargs_uniform'),
+                    cs.arguments_v3_parameter(name='test', schema=cs.int_schema(), mode='keyword_only'),
+                ]
+            )
+        )
diff --git a/tests/validators/arguments_v3/test_extra.py b/tests/validators/arguments_v3/test_extra.py
new file mode 100644
index 000000000..749c3f342
--- /dev/null
+++ b/tests/validators/arguments_v3/test_extra.py
@@ -0,0 +1,57 @@
+import pytest
+
+from pydantic_core import ArgsKwargs, ValidationError
+from pydantic_core import core_schema as cs
+
+from ...conftest import PyAndJson
+
+
+@pytest.mark.parametrize(
+    ['input_value', 'err_type'],
+    (
+        [ArgsKwargs((), {'a': 1, 'b': 2, 'c': 3}), 'unexpected_keyword_argument'],
+        [ArgsKwargs((), {'a': 1, 'c': 3, 'extra': 'value'}), 'unexpected_keyword_argument'],
+        [{'a': 1, 'b': 2, 'c': 3}, 'extra_forbidden'],
+        [{'a': 1, 'c': 3, 'extra': 'value'}, 'extra_forbidden'],
+    ),
+)
+def test_extra_forbid(py_and_json: PyAndJson, input_value, err_type) -> None:
+    v = py_and_json(
+        cs.arguments_v3_schema(
+            [
+                cs.arguments_v3_parameter(name='a', schema=cs.int_schema()),
+                cs.arguments_v3_parameter(name='b', schema=cs.int_schema(), alias='c'),
+            ],
+            extra_behavior='forbid',
+        ),
+    )
+
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_test(input_value)
+
+    error = exc_info.value.errors()[0]
+
+    assert error['type'] == err_type
+
+
+@pytest.mark.parametrize(
+    'input_value',
+    [
+        ArgsKwargs((), {'a': 1, 'b': 2, 'c': 3}),
+        ArgsKwargs((), {'a': 1, 'c': 3, 'extra': 'value'}),
+        {'a': 1, 'b': 2, 'c': 3},
+        {'a': 1, 'c': 3, 'extra': 'value'},
+    ],
+)
+def test_extra_ignore(py_and_json: PyAndJson, input_value) -> None:
+    v = py_and_json(
+        cs.arguments_v3_schema(
+            [
+                cs.arguments_v3_parameter(name='a', schema=cs.int_schema(), mode='keyword_only'),
+                cs.arguments_v3_parameter(name='b', schema=cs.int_schema(), alias='c', mode='keyword_only'),
+            ],
+            extra_behavior='ignore',
+        ),
+    )
+
+    assert v.validate_test(input_value) == ((), {'a': 1, 'b': 3})
diff --git a/tests/validators/arguments_v3/test_general.py b/tests/validators/arguments_v3/test_general.py
new file mode 100644
index 000000000..bc2e91436
--- /dev/null
+++ b/tests/validators/arguments_v3/test_general.py
@@ -0,0 +1,131 @@
+import pytest
+
+from pydantic_core import ArgsKwargs, SchemaValidator, ValidationError
+from pydantic_core import core_schema as cs
+
+from ...conftest import Err, PyAndJson, plain_repr
+
+
+@pytest.mark.parametrize(
+    ['input_value', 'expected'],
+    (
+        [ArgsKwargs(()), ((), {})],
+        [{}, ((), {})],
+        [ArgsKwargs((1,)), Err('', [{'type': 'unexpected_positional_argument'}])],
+        [ArgsKwargs((), {'a': 1}), Err('', [{'type': 'unexpected_keyword_argument'}])],
+    ),
+)
+def test_no_args(py_and_json: PyAndJson, input_value, expected) -> None:
+    v = py_and_json(cs.arguments_v3_schema([]))
+
+    if isinstance(expected, Err):
+        with pytest.raises(ValidationError) as exc_info:
+            v.validate_test(input_value)
+
+        error = exc_info.value.errors()[0]
+
+        assert error['type'] == expected.errors[0]['type']
+    else:
+        assert v.validate_test(input_value) == expected
+
+
+@pytest.mark.parametrize(
+    ['input_value', 'expected'],
+    [
+        [ArgsKwargs((1, 2)), ((1, 2), {})],
+        [ArgsKwargs((1,)), ((1,), {'b': 42})],
+        [ArgsKwargs((1,), {'b': 3}), ((1,), {'b': 3})],
+        [ArgsKwargs((), {'a': 1}), ((), {'a': 1, 'b': 42})],
+        [{'a': 1, 'b': 2}, ((1, 2), {})],
+        [{'a': 1}, ((1, 42), {})],
+    ],
+    ids=repr,
+)
+def test_default_factory(py_and_json: PyAndJson, input_value, expected) -> None:
+    v = py_and_json(
+        cs.arguments_v3_schema(
+            [
+                cs.arguments_v3_parameter(name='a', schema=cs.int_schema(), mode='positional_or_keyword'),
+                cs.arguments_v3_parameter(
+                    name='b',
+                    schema=cs.with_default_schema(schema=cs.int_schema(), default_factory=lambda: 42),
+                    mode='positional_or_keyword',
+                ),
+            ]
+        )
+    )
+
+    assert v.validate_test(input_value) == expected
+
+
+def double_or_bust(input_value):
+    if input_value == 1:
+        raise RuntimeError('bust')
+    return input_value * 2
+
+
+def test_internal_error(py_and_json: PyAndJson) -> None:
+    v = py_and_json(
+        cs.arguments_v3_schema(
+            [
+                cs.arguments_v3_parameter(name='a', schema=cs.int_schema(), mode='positional_only'),
+                cs.arguments_v3_parameter(
+                    name='b', schema=cs.no_info_plain_validator_function(double_or_bust), mode='positional_only'
+                ),
+            ]
+        )
+    )
+
+    assert v.validate_test(ArgsKwargs((1, 2))) == ((1, 4), {})
+    with pytest.raises(RuntimeError, match='bust'):
+        v.validate_test(ArgsKwargs((1, 1)))
+
+
+def test_repr() -> None:
+    v = SchemaValidator(
+        cs.arguments_v3_schema(
+            [
+                cs.arguments_v3_parameter(name='a', schema=cs.int_schema(), mode='positional_or_keyword'),
+                cs.arguments_v3_parameter(
+                    name='b',
+                    schema=cs.with_default_schema(schema=cs.int_schema(), default_factory=lambda: 42),
+                    mode='keyword_only',
+                ),
+            ]
+        )
+    )
+    assert 'positional_params_count:1,' in plain_repr(v)
+
+
+@pytest.mark.parametrize(
+    ['input_value', 'expected'],
+    (
+        [ArgsKwargs((1, 't', 2, 3, 4), {'c': True, 'other': 1}), ((1, 't', 2, 3, 4), {'c': True, 'other': 1})],
+        [
+            {'aa': 1, 'b': 't', 'args': [2, 3, 4], 'c': True, 'kwargs': {'other': 1}},
+            ((1, 't', 2, 3, 4), {'c': True, 'other': 1}),
+        ],
+    ),
+)
+def test_full(py_and_json: PyAndJson, input_value, expected) -> None:
+    """Test inputs against all parameter types:
+
+    ```python
+    def func(a: Annotated[int, Field(alias='aa')], /, b: str, *args: int, c: bool, **kwargs: int):
+        ...
+    ```
+    """
+
+    v = py_and_json(
+        cs.arguments_v3_schema(
+            [
+                cs.arguments_v3_parameter(name='a', schema=cs.int_schema(), alias='aa', mode='positional_only'),
+                cs.arguments_v3_parameter(name='b', schema=cs.str_schema(), mode='positional_or_keyword'),
+                cs.arguments_v3_parameter(name='args', schema=cs.int_schema(), mode='var_args'),
+                cs.arguments_v3_parameter(name='c', schema=cs.bool_schema(), mode='keyword_only'),
+                cs.arguments_v3_parameter(name='kwargs', schema=cs.int_schema(), mode='var_kwargs_uniform'),
+            ]
+        )
+    )
+
+    assert v.validate_test(input_value) == expected
diff --git a/tests/validators/arguments_v3/test_keyword_only.py b/tests/validators/arguments_v3/test_keyword_only.py
new file mode 100644
index 000000000..5a7f00a05
--- /dev/null
+++ b/tests/validators/arguments_v3/test_keyword_only.py
@@ -0,0 +1,99 @@
+import pytest
+
+from pydantic_core import ArgsKwargs, ValidationError
+from pydantic_core import core_schema as cs
+
+from ...conftest import PyAndJson
+
+
+@pytest.mark.parametrize(
+    'input_value',
+    [
+        ArgsKwargs((), {'a': 1, 'b': True}),
+        ArgsKwargs((), {'a': 1}),
+        {'a': 1, 'b': True},
+        {'a': 1},
+    ],
+)
+def test_keyword_only(py_and_json: PyAndJson, input_value) -> None:
+    """Test valid inputs against keyword-only parameters:
+
+    ```python
+    def func(*, a: int, b: bool = True):
+        ...
+    ```
+    """
+    v = py_and_json(
+        cs.arguments_v3_schema(
+            [
+                cs.arguments_v3_parameter(name='a', schema=cs.int_schema(), mode='keyword_only'),
+                cs.arguments_v3_parameter(
+                    name='b', schema=cs.with_default_schema(cs.bool_schema(), default=True), mode='keyword_only'
+                ),
+            ]
+        )
+    )
+
+    assert v.validate_test(input_value) == ((), {'a': 1, 'b': True})
+
+
+@pytest.mark.parametrize(
+    'input_value',
+    [ArgsKwargs((), {'a': 'not_an_int'}), {'a': 'not_an_int'}],
+)
+def test_keyword_only_validation_error(py_and_json: PyAndJson, input_value) -> None:
+    """Test invalid inputs against keyword-only parameters:
+
+    ```python
+    def func(*, a: int):
+        ...
+
+    func('not_an_int')
+    ```
+    """
+    v = py_and_json(
+        cs.arguments_v3_schema(
+            [
+                cs.arguments_v3_parameter(name='a', schema=cs.int_schema(), mode='keyword_only'),
+            ]
+        )
+    )
+
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_test(input_value)
+
+    error = exc_info.value.errors()[0]
+
+    assert error['type'] == 'int_parsing'
+    assert error['loc'] == ('a',)
+
+
+@pytest.mark.parametrize(
+    'input_value',
+    [ArgsKwargs((), {}), {}],
+)
+def test_keyword_only_error_required(py_and_json: PyAndJson, input_value) -> None:
+    """Test missing inputs against keyword-only parameters:
+
+    ```python
+    def func(*, a: int):
+        ...
+
+    func()
+    ```
+    """
+    v = py_and_json(
+        cs.arguments_v3_schema(
+            [
+                cs.arguments_v3_parameter(name='a', schema=cs.int_schema(), mode='keyword_only'),
+            ]
+        )
+    )
+
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_test(input_value)
+
+    error = exc_info.value.errors()[0]
+
+    assert error['type'] == 'missing_keyword_only_argument'
+    assert error['loc'] == ('a',)
diff --git a/tests/validators/arguments_v3/test_positional_only.py b/tests/validators/arguments_v3/test_positional_only.py
new file mode 100644
index 000000000..5f6d4ba95
--- /dev/null
+++ b/tests/validators/arguments_v3/test_positional_only.py
@@ -0,0 +1,107 @@
+import pytest
+
+from pydantic_core import ArgsKwargs, ValidationError
+from pydantic_core import core_schema as cs
+
+from ...conftest import PyAndJson
+
+
+@pytest.mark.parametrize(
+    'input_value',
+    [
+        ArgsKwargs((1, True)),
+        ArgsKwargs((1,)),
+        {'a': 1, 'b': True},
+        {'a': 1},
+    ],
+)
+def test_positional_only(py_and_json: PyAndJson, input_value) -> None:
+    """Test valid inputs against positional-only parameters:
+
+    ```python
+    def func(a: int, b: bool = True, /):
+        ...
+    ```
+    """
+    v = py_and_json(
+        cs.arguments_v3_schema(
+            [
+                cs.arguments_v3_parameter(name='a', schema=cs.int_schema(), mode='positional_only'),
+                cs.arguments_v3_parameter(
+                    name='b', schema=cs.with_default_schema(cs.bool_schema(), default=True), mode='positional_only'
+                ),
+            ]
+        )
+    )
+
+    assert v.validate_test(input_value) == ((1, True), {})
+
+
+def test_positional_only_validation_error(py_and_json: PyAndJson) -> None:
+    """Test invalid inputs against positional-only parameters:
+
+    ```python
+    def func(a: int, /):
+        ...
+
+    func('not_an_int')
+    ```
+    """
+    v = py_and_json(
+        cs.arguments_v3_schema(
+            [
+                cs.arguments_v3_parameter(name='a', schema=cs.int_schema(), mode='positional_only'),
+            ]
+        )
+    )
+
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_test(ArgsKwargs(('not_an_int',), {}))
+
+    error = exc_info.value.errors()[0]
+
+    assert error['type'] == 'int_parsing'
+    assert error['loc'] == (0,)
+
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_test({'a': 'not_an_int'})
+
+    error = exc_info.value.errors()[0]
+
+    assert error['type'] == 'int_parsing'
+    assert error['loc'] == ('a',)
+
+
+def test_positional_only_error_required(py_and_json: PyAndJson) -> None:
+    """Test missing inputs against positional-only parameters:
+
+    ```python
+    def func(a: int, /):
+        ...
+
+    func()
+    ```
+    """
+    v = py_and_json(
+        cs.arguments_v3_schema(
+            [
+                cs.arguments_v3_parameter(name='a', schema=cs.int_schema(), mode='positional_only'),
+            ]
+        )
+    )
+
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_test(ArgsKwargs((), {}))
+
+    error = exc_info.value.errors()[0]
+
+    assert error['type'] == 'missing_positional_only_argument'
+    assert error['loc'] == (0,)
+
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_test({})
+
+    error = exc_info.value.errors()[0]
+
+    assert error['type'] == 'missing_positional_only_argument'
+    assert error['loc'] == ('a',)
diff --git a/tests/validators/arguments_v3/test_positional_or_keyword.py b/tests/validators/arguments_v3/test_positional_or_keyword.py
new file mode 100644
index 000000000..40d0fa55c
--- /dev/null
+++ b/tests/validators/arguments_v3/test_positional_or_keyword.py
@@ -0,0 +1,107 @@
+import pytest
+
+from pydantic_core import ArgsKwargs, ValidationError
+from pydantic_core import core_schema as cs
+
+from ...conftest import PyAndJson
+
+
+@pytest.mark.parametrize(
+    ['input_value', 'expected'],
+    (
+        [ArgsKwargs((1, True)), ((1, True), {})],
+        [ArgsKwargs((1,)), ((1,), {'b': True})],
+        [ArgsKwargs((1,), {'b': True}), ((1,), {'b': True})],
+        [ArgsKwargs((), {'a': 1, 'b': True}), ((), {'a': 1, 'b': True})],
+        [{'a': 1, 'b': True}, ((1, True), {})],
+        [{'a': 1}, ((1, True), {})],
+    ),
+)
+def test_positional_or_keyword(py_and_json: PyAndJson, input_value, expected) -> None:
+    """Test valid inputs against positional-or-keyword parameters:
+
+    ```python
+    def func(a: int, b: bool = True):
+        ...
+    ```
+    """
+    v = py_and_json(
+        cs.arguments_v3_schema(
+            [
+                cs.arguments_v3_parameter(name='a', schema=cs.int_schema(), mode='positional_or_keyword'),
+                cs.arguments_v3_parameter(
+                    name='b',
+                    schema=cs.with_default_schema(cs.bool_schema(), default=True),
+                    mode='positional_or_keyword',
+                ),
+            ]
+        )
+    )
+
+    assert v.validate_test(input_value) == expected
+
+
+@pytest.mark.parametrize(
+    ['input_value', 'err_loc'],
+    (
+        [ArgsKwargs(('not_an_int',), {}), (0,)],
+        [ArgsKwargs((), {'a': 'not_an_int'}), ('a',)],
+        [{'a': 'not_an_int'}, ('a',)],
+    ),
+)
+def test_positional_or_keyword_validation_error(py_and_json: PyAndJson, input_value, err_loc) -> None:
+    """Test invalid inputs against positional-or-keyword parameters:
+
+    ```python
+    def func(a: int):
+        ...
+
+    func('not_an_int')
+    ```
+    """
+    v = py_and_json(
+        cs.arguments_v3_schema(
+            [
+                cs.arguments_v3_parameter(name='a', schema=cs.int_schema(), mode='positional_or_keyword'),
+            ]
+        )
+    )
+
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_test(input_value)
+
+    error = exc_info.value.errors()[0]
+
+    assert error['type'] == 'int_parsing'
+    assert error['loc'] == err_loc
+
+
+@pytest.mark.parametrize(
+    'input_value',
+    [ArgsKwargs((), {}), {}],
+)
+def test_positional_only_error_required(py_and_json: PyAndJson, input_value) -> None:
+    """Test missing inputs against positional-or-keyword parameters:
+
+    ```python
+    def func(a: int):
+        ...
+
+    func()
+    ```
+    """
+    v = py_and_json(
+        cs.arguments_v3_schema(
+            [
+                cs.arguments_v3_parameter(name='a', schema=cs.int_schema(), mode='positional_or_keyword'),
+            ]
+        )
+    )
+
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_test(input_value)
+
+    error = exc_info.value.errors()[0]
+
+    assert error['type'] == 'missing_argument'
+    assert error['loc'] == ('a',)
diff --git a/tests/validators/arguments_v3/test_var_args.py b/tests/validators/arguments_v3/test_var_args.py
new file mode 100644
index 000000000..5fa2a5eb3
--- /dev/null
+++ b/tests/validators/arguments_v3/test_var_args.py
@@ -0,0 +1,100 @@
+import pytest
+
+from pydantic_core import ArgsKwargs, ValidationError
+from pydantic_core import core_schema as cs
+
+from ...conftest import PyAndJson
+
+
+@pytest.mark.parametrize(
+    ['input_value', 'expected'],
+    (
+        [ArgsKwargs(()), ((), {})],
+        [ArgsKwargs((1, 2, 3)), ((1, 2, 3), {})],
+        [{'args': ()}, ((), {})],
+        [{'args': (1, 2, 3)}, ((1, 2, 3), {})],
+        # Also validates against other sequence types, as long as it is
+        # possible to validate it as a tuple:
+        [{'args': [1, 2, 3]}, ((1, 2, 3), {})],
+    ),
+)
+def test_var_args(py_and_json: PyAndJson, input_value, expected) -> None:
+    """Test valid inputs against var-args parameters:
+
+    ```python
+    def func(*args: int):
+        ...
+    ```
+    """
+    v = py_and_json(
+        cs.arguments_v3_schema(
+            [
+                cs.arguments_v3_parameter(name='args', schema=cs.int_schema(), mode='var_args'),
+            ]
+        )
+    )
+
+    assert v.validate_test(input_value) == expected
+
+
+@pytest.mark.parametrize(
+    ['input_value', 'err_loc'],
+    (
+        [ArgsKwargs(('not_an_int',)), (0,)],
+        [
+            ArgsKwargs(
+                (
+                    1,
+                    'not_an_int',
+                )
+            ),
+            (1,),
+        ],
+        [{'args': ['not_an_int']}, ('args', 0)],
+        [{'args': [1, 'not_an_int']}, ('args', 1)],
+    ),
+)
+def test_var_args_validation_error(py_and_json: PyAndJson, input_value, err_loc) -> None:
+    """Test invalid inputs against var-args parameters:
+
+    ```python
+    def func(*args: int):
+        ...
+
+    func(1, 'not_an_int')
+    ```
+    """
+    v = py_and_json(
+        cs.arguments_v3_schema(
+            [
+                cs.arguments_v3_parameter(name='args', schema=cs.int_schema(), mode='var_args'),
+            ]
+        )
+    )
+
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_test(input_value)
+
+    error = exc_info.value.errors()[0]
+
+    assert error['type'] == 'int_parsing'
+    assert error['loc'] == err_loc
+
+
+def test_var_args_invalid_tuple(py_and_json: PyAndJson) -> None:
+    """Test invalid tuple-like input against var-args parameters in mapping validation mode."""
+    v = py_and_json(
+        cs.arguments_v3_schema(
+            [
+                cs.arguments_v3_parameter(name='args', schema=cs.int_schema(), mode='var_args'),
+            ]
+        )
+    )
+
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_test({'args': 'not_a_tuple'})
+
+    error = exc_info.value.errors()[0]
+
+    assert error['type'] == 'tuple_type'
+    assert error['loc'] == ('args',)
diff --git a/tests/validators/arguments_v3/test_var_kwargs_uniform.py b/tests/validators/arguments_v3/test_var_kwargs_uniform.py
new file mode 100644
index 000000000..ed44721d6
--- /dev/null
+++ b/tests/validators/arguments_v3/test_var_kwargs_uniform.py
@@ -0,0 +1,89 @@
+import pytest
+
+from pydantic_core import ArgsKwargs, ValidationError
+from pydantic_core import core_schema as cs
+
+from ...conftest import PyAndJson
+
+
+@pytest.mark.parametrize(
+    ['input_value', 'expected'],
+    (
+        [ArgsKwargs(()), ((), {})],
+        [ArgsKwargs((), {'a': 1, 'b': 2}), ((), {'a': 1, 'b': 2})],
+        [{}, ((), {})],
+        [{'kwargs': {'a': 1, 'b': 2}}, ((), {'a': 1, 'b': 2})],
+    ),
+)
+def test_var_kwargs(py_and_json: PyAndJson, input_value, expected) -> None:
+    """Test valid inputs against var-args parameters (uniform):
+
+    ```python
+    def func(**kwargs: int):
+        ...
+    ```
+    """
+    v = py_and_json(
+        cs.arguments_v3_schema(
+            [
+                cs.arguments_v3_parameter(name='kwargs', schema=cs.int_schema(), mode='var_kwargs_uniform'),
+            ]
+        )
+    )
+
+    assert v.validate_test(input_value) == expected
+
+
+@pytest.mark.parametrize(
+    ['input_value', 'err_loc'],
+    (
+        [ArgsKwargs((), {'a': 'not_an_int'}), ('a',)],
+        [ArgsKwargs((), {'a': 1, 'b': 'not_an_int'}), ('b',)],
+        [{'kwargs': {'a': 'not_an_int'}}, ('kwargs', 'a')],
+        [{'kwargs': {'a': 1, 'b': 'not_an_int'}}, ('kwargs', 'b')],
+    ),
+)
+def test_var_kwargs_validation_error(py_and_json: PyAndJson, input_value, err_loc) -> None:
+    """Test invalid inputs against var-args parameters (uniform):
+
+    ```python
+    def func(**kwargs: int):
+        ...
+
+    func(a='not_an_int')
+    ```
+    """
+    v = py_and_json(
+        cs.arguments_v3_schema(
+            [
+                cs.arguments_v3_parameter(name='kwargs', schema=cs.int_schema(), mode='var_kwargs_uniform'),
+            ]
+        )
+    )
+
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_test(input_value)
+
+    error = exc_info.value.errors()[0]
+
+    assert error['type'] == 'int_parsing'
+    assert error['loc'] == err_loc
+
+
+def test_var_kwargs_invalid_dict(py_and_json: PyAndJson) -> None:
+    """Test invalid dict-like input against var-kwargs parameters in mapping validation mode."""
+    v = py_and_json(
+        cs.arguments_v3_schema(
+            [
+                cs.arguments_v3_parameter(name='kwargs', schema=cs.int_schema(), mode='var_kwargs_uniform'),
+            ]
+        )
+    )
+
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_test({'kwargs': 'not_a_dict'})
+
+    error = exc_info.value.errors()[0]
+
+    assert error['type'] == 'dict_type'
+    assert error['loc'] == ('kwargs',)
diff --git a/tests/validators/arguments_v3/test_var_kwargs_unpacked_typed_dict.py b/tests/validators/arguments_v3/test_var_kwargs_unpacked_typed_dict.py
new file mode 100644
index 000000000..6ffb90a1e
--- /dev/null
+++ b/tests/validators/arguments_v3/test_var_kwargs_unpacked_typed_dict.py
@@ -0,0 +1,120 @@
+import pytest
+
+from pydantic_core import ArgsKwargs, ValidationError
+from pydantic_core import core_schema as cs
+
+from ...conftest import Err, PyAndJson
+
+
+@pytest.mark.parametrize(
+    ['input_value', 'expected'],
+    (
+        [ArgsKwargs((), {'x': 1}), ((), {'x': 1})],
+        [ArgsKwargs((), {'x': 1, 'z': True}), ((), {'x': 1, 'y': True})],
+        [ArgsKwargs((), {}), Err('', [{'type': 'missing', 'loc': ('x',)}])],
+        [ArgsKwargs((), {'x': 'not_an_int'}), Err('', [{'type': 'int_parsing', 'loc': ('x',)}])],
+        [ArgsKwargs((), {'x': 1, 'y': True}), Err('', [{'type': 'extra_forbidden', 'loc': ('y',)}])],
+        [{'kwargs': {'x': 1}}, ((), {'x': 1})],
+        [{'kwargs': {'x': 1, 'z': True}}, ((), {'x': 1, 'y': True})],
+        [{'kwargs': {}}, Err('', [{'type': 'missing', 'loc': ('kwargs', 'x')}])],
+        [{}, Err('', [{'type': 'missing', 'loc': ('kwargs', 'x')}])],
+        [
+            {'kwargs': {'x': 'not_an_int'}},
+            Err(
+                '',
+                [
+                    {
+                        'type': 'int_parsing',
+                        'loc': (
+                            'kwargs',
+                            'x',
+                        ),
+                    }
+                ],
+            ),
+        ],
+        [
+            {'kwargs': {'x': 1, 'y': True}},
+            Err(
+                '',
+                [
+                    {
+                        'type': 'extra_forbidden',
+                        'loc': (
+                            'kwargs',
+                            'y',
+                        ),
+                    }
+                ],
+            ),
+        ],
+    ),
+)
+def test_var_kwargs(py_and_json: PyAndJson, input_value, expected) -> None:
+    """Test (in)valid inputs against var-args parameters (unpacked typed dict):
+
+    ```python
+    class TD(TypedDict, total=false):
+        x: Required[int]
+        y: Annotated[bool, Field(validation_alias='z')]
+
+    def func(**kwargs: Unpack[TD]):
+        ...
+    ```
+    """
+    v = py_and_json(
+        cs.arguments_v3_schema(
+            [
+                cs.arguments_v3_parameter(
+                    name='kwargs',
+                    schema=cs.typed_dict_schema(
+                        {
+                            'x': cs.typed_dict_field(
+                                schema=cs.int_schema(),
+                                required=True,
+                            ),
+                            'y': cs.typed_dict_field(
+                                schema=cs.bool_schema(),
+                                required=False,
+                                validation_alias='z',
+                            ),
+                        },
+                        extra_behavior='forbid',
+                    ),
+                    mode='var_kwargs_unpacked_typed_dict',
+                ),
+            ]
+        )
+    )
+
+    if isinstance(expected, Err):
+        with pytest.raises(ValidationError) as exc_info:
+            v.validate_test(input_value)
+
+        error = exc_info.value.errors()[0]
+
+        assert error['type'] == expected.errors[0]['type']
+        assert error['loc'] == expected.errors[0]['loc']
+    else:
+        assert v.validate_test(input_value) == expected
+
+
+def test_var_kwargs_invalid_dict(py_and_json: PyAndJson) -> None:
+    """Test invalid dict-like input against var-kwargs parameters in mapping validation mode."""
+    v = py_and_json(
+        cs.arguments_v3_schema(
+            [
+                cs.arguments_v3_parameter(
+                    name='kwargs', schema=cs.typed_dict_schema({}), mode='var_kwargs_unpacked_typed_dict'
+                ),
+            ]
+        )
+    )
+
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_test({'kwargs': 'not_a_dict'})
+
+    error = exc_info.value.errors()[0]
+
+    assert error['type'] == 'dict_type'
+    assert error['loc'] == ('kwargs',)

From f3fa016e94ac4f3746a01cc8f7a392e1b37dd55d Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Fri, 14 Mar 2025 16:43:15 +0100
Subject: [PATCH 514/550] Add `TzInfo.__new__` stub method (#1611)

---
 python/pydantic_core/_pydantic_core.pyi | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index 3220b3ef8..a3e8117eb 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -993,7 +993,9 @@ def list_all_errors() -> list[ErrorTypeInfo]:
     """
 @final
 class TzInfo(datetime.tzinfo):
-    """An `pydantic-core` implementation of the abstract [`datetime.tzinfo`] class."""
+    """An `pydantic-core` implementation of the abstract [`datetime.tzinfo`][] class."""
+
+    # def __new__(cls, seconds: float) -> Self: ...
 
     # Docstrings for attributes sourced from the abstract base class, [`datetime.tzinfo`](https://docs.python.org/3/library/datetime.html#datetime.tzinfo).
 

From ac17f0c92f1d8fe0cad895dce08f87b9103ba06a Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Fri, 14 Mar 2025 18:27:23 +0100
Subject: [PATCH 515/550] Bump version to v2.32.0 (#1670)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 0c1035e0f..d1d3aadec 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -424,7 +424,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.31.1"
+version = "2.32.0"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index 16dc843c4..c444ddc91 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.31.1"
+version = "2.32.0"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From f256531791399f30645fdceade4d22f65d64de91 Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Thu, 20 Mar 2025 14:35:43 +0100
Subject: [PATCH 516/550] Add support for extra keys validation for model
 fields (#1671)

This is only implemented for model fields but this could be done for dataclass/typed dict as well. I only went with models for now as it is the only data type where extra validation can be customized through `__pydantic_extra__`.

This also only implements validation support. Extra values can have serialization customized but I don't think we should also allow serialization customization for extra keys as we don't have such a concept for "normal" field names.
---
 python/pydantic_core/core_schema.py   | 16 ++++++++++------
 src/validators/model_fields.rs        | 26 +++++++++++++++++++++++++-
 tests/validators/test_model_fields.py | 25 +++++++++++++++++++++++++
 3 files changed, 60 insertions(+), 7 deletions(-)

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index 3fc307ee3..0ab3dd947 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -3013,6 +3013,7 @@ class ModelFieldsSchema(TypedDict, total=False):
     computed_fields: list[ComputedField]
     strict: bool
     extras_schema: CoreSchema
+    extras_keys_schema: CoreSchema
     extra_behavior: ExtraBehavior
     from_attributes: bool
     ref: str
@@ -3027,6 +3028,7 @@ def model_fields_schema(
     computed_fields: list[ComputedField] | None = None,
     strict: bool | None = None,
     extras_schema: CoreSchema | None = None,
+    extras_keys_schema: CoreSchema | None = None,
     extra_behavior: ExtraBehavior | None = None,
     from_attributes: bool | None = None,
     ref: str | None = None,
@@ -3034,7 +3036,7 @@ def model_fields_schema(
     serialization: SerSchema | None = None,
 ) -> ModelFieldsSchema:
     """
-    Returns a schema that matches a typed dict, e.g.:
+    Returns a schema that matches the fields of a Pydantic model, e.g.:
 
     ```py
     from pydantic_core import SchemaValidator, core_schema
@@ -3048,15 +3050,16 @@ def model_fields_schema(
     ```
 
     Args:
-        fields: The fields to use for the typed dict
+        fields: The fields of the model
         model_name: The name of the model, used for error messages, defaults to "Model"
         computed_fields: Computed fields to use when serializing the model, only applies when directly inside a model
-        strict: Whether the typed dict is strict
-        extras_schema: The extra validator to use for the typed dict
+        strict: Whether the model is strict
+        extras_schema: The schema to use when validating extra input data
+        extras_keys_schema: The schema to use when validating the keys of extra input data
         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
-        extra_behavior: The extra behavior to use for the typed dict
-        from_attributes: Whether the typed dict should be populated from attributes
+        extra_behavior: The extra behavior to use for the model fields
+        from_attributes: Whether the model fields should be populated from attributes
         serialization: Custom serialization schema
     """
     return _dict_not_none(
@@ -3066,6 +3069,7 @@ def model_fields_schema(
         computed_fields=computed_fields,
         strict=strict,
         extras_schema=extras_schema,
+        extras_keys_schema=extras_keys_schema,
         extra_behavior=extra_behavior,
         from_attributes=from_attributes,
         ref=ref,
diff --git a/src/validators/model_fields.rs b/src/validators/model_fields.rs
index 1ef684890..ba1f7d1ba 100644
--- a/src/validators/model_fields.rs
+++ b/src/validators/model_fields.rs
@@ -34,6 +34,7 @@ pub struct ModelFieldsValidator {
     model_name: String,
     extra_behavior: ExtraBehavior,
     extras_validator: Option<Box<CombinedValidator>>,
+    extras_keys_validator: Option<Box<CombinedValidator>>,
     strict: bool,
     from_attributes: bool,
     loc_by_alias: bool,
@@ -62,6 +63,11 @@ impl BuildValidator for ModelFieldsValidator {
             (Some(_), _) => return py_schema_err!("extras_schema can only be used if extra_behavior=allow"),
             (_, _) => None,
         };
+        let extras_keys_validator = match (schema.get_item(intern!(py, "extras_keys_schema"))?, &extra_behavior) {
+            (Some(v), ExtraBehavior::Allow) => Some(Box::new(build_validator(&v, config, definitions)?)),
+            (Some(_), _) => return py_schema_err!("extras_keys_schema can only be used if extra_behavior=allow"),
+            (_, _) => None,
+        };
         let model_name: String = schema
             .get_as(intern!(py, "model_name"))?
             .unwrap_or_else(|| "Model".to_string());
@@ -98,6 +104,7 @@ impl BuildValidator for ModelFieldsValidator {
             model_name,
             extra_behavior,
             extras_validator,
+            extras_keys_validator,
             strict,
             from_attributes,
             loc_by_alias: config.get_as(intern!(py, "loc_by_alias"))?.unwrap_or(true),
@@ -244,6 +251,7 @@ impl Validator for ModelFieldsValidator {
                 fields_set_vec: &'a mut Vec<Py<PyString>>,
                 extra_behavior: ExtraBehavior,
                 extras_validator: Option<&'a CombinedValidator>,
+                extras_keys_validator: Option<&'a CombinedValidator>,
                 state: &'a mut ValidationState<'s, 'py>,
             }
 
@@ -294,7 +302,22 @@ impl Validator for ModelFieldsValidator {
                             }
                             ExtraBehavior::Ignore => {}
                             ExtraBehavior::Allow => {
-                                let py_key = either_str.as_py_string(self.py, self.state.cache_str());
+                                let py_key = match self.extras_keys_validator {
+                                    Some(validator) => {
+                                        match validator.validate(self.py, raw_key.borrow_input(), self.state) {
+                                            Ok(value) => value.downcast_bound::<PyString>(self.py)?.clone(),
+                                            Err(ValError::LineErrors(line_errors)) => {
+                                                for err in line_errors {
+                                                    self.errors.push(err.with_outer_location(raw_key.clone()));
+                                                }
+                                                continue;
+                                            }
+                                            Err(err) => return Err(err),
+                                        }
+                                    }
+                                    None => either_str.as_py_string(self.py, self.state.cache_str()),
+                                };
+
                                 if let Some(validator) = self.extras_validator {
                                     match validator.validate(self.py, value, self.state) {
                                         Ok(value) => {
@@ -326,6 +349,7 @@ impl Validator for ModelFieldsValidator {
                 fields_set_vec: &mut fields_set_vec,
                 extra_behavior: self.extra_behavior,
                 extras_validator: self.extras_validator.as_deref(),
+                extras_keys_validator: self.extras_keys_validator.as_deref(),
                 state,
             })??;
 
diff --git a/tests/validators/test_model_fields.py b/tests/validators/test_model_fields.py
index 22b8620a8..cc04f07c1 100644
--- a/tests/validators/test_model_fields.py
+++ b/tests/validators/test_model_fields.py
@@ -213,6 +213,13 @@ def test_allow_extra_invalid():
             )
         )
 
+    with pytest.raises(SchemaError, match='extras_keys_schema can only be used if extra_behavior=allow'):
+        SchemaValidator(
+            schema=core_schema.model_fields_schema(
+                fields={}, extras_keys_schema=core_schema.int_schema(), extra_behavior='ignore'
+            )
+        )
+
 
 def test_allow_extra_wrong():
     with pytest.raises(SchemaError, match='Invalid extra_behavior: `wrong`'):
@@ -1758,6 +1765,24 @@ def test_extra_behavior_ignore(config: Union[core_schema.CoreConfig, None], sche
     assert 'not_f' not in m
 
 
+def test_extra_behavior_allow_keys_validation() -> None:
+    v = SchemaValidator(
+        core_schema.model_fields_schema(
+            {}, extra_behavior='allow', extras_keys_schema=core_schema.str_schema(max_length=3)
+        )
+    )
+
+    m, model_extra, fields_set = v.validate_python({'ext': 123})
+    assert m == {}
+    assert model_extra == {'ext': 123}
+    assert fields_set == {'ext'}
+
+    with pytest.raises(ValidationError) as exc_info:
+        v.validate_python({'extra_too_long': 123})
+
+    assert exc_info.value.errors()[0]['type'] == 'string_too_long'
+
+
 @pytest.mark.parametrize('config_by_alias', [None, True, False])
 @pytest.mark.parametrize('config_by_name', [None, True, False])
 @pytest.mark.parametrize('runtime_by_alias', [None, True, False])

From f977516d5af94d2d3ef7fa99e4528276f3a3a747 Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Thu, 20 Mar 2025 14:36:03 +0100
Subject: [PATCH 517/550] Revert `by_alias` default value change for
 `to_json()` and `to_jsonable_python()` (#1672)

---
 python/pydantic_core/_pydantic_core.pyi | 10 ++++++++--
 src/serializers/mod.rs                  | 12 ++++++------
 2 files changed, 14 insertions(+), 8 deletions(-)

diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index a3e8117eb..17098cca5 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -392,7 +392,10 @@ def to_json(
     indent: int | None = None,
     include: _IncEx | None = None,
     exclude: _IncEx | None = None,
-    by_alias: bool | None = None,
+    # Note: In Pydantic 2.11, the default value of `by_alias` on `SchemaSerializer` was changed from `True` to `None`,
+    # to be consistent with the Pydantic "dump" methods. However, the default of `True` was kept here for
+    # backwards compatibility. In Pydantic V3, `by_alias` is expected to default to `True` everywhere:
+    by_alias: bool = True,
     exclude_none: bool = False,
     round_trip: bool = False,
     timedelta_mode: Literal['iso8601', 'float'] = 'iso8601',
@@ -468,7 +471,10 @@ def to_jsonable_python(
     *,
     include: _IncEx | None = None,
     exclude: _IncEx | None = None,
-    by_alias: bool | None = None,
+    # Note: In Pydantic 2.11, the default value of `by_alias` on `SchemaSerializer` was changed from `True` to `None`,
+    # to be consistent with the Pydantic "dump" methods. However, the default of `True` was kept here for
+    # backwards compatibility. In Pydantic V3, `by_alias` is expected to default to `True` everywhere:
+    by_alias: bool = True,
     exclude_none: bool = False,
     round_trip: bool = False,
     timedelta_mode: Literal['iso8601', 'float'] = 'iso8601',
diff --git a/src/serializers/mod.rs b/src/serializers/mod.rs
index 6ed496aab..434b43c53 100644
--- a/src/serializers/mod.rs
+++ b/src/serializers/mod.rs
@@ -239,7 +239,7 @@ impl SchemaSerializer {
 
 #[allow(clippy::too_many_arguments)]
 #[pyfunction]
-#[pyo3(signature = (value, *, indent = None, include = None, exclude = None, by_alias = None,
+#[pyo3(signature = (value, *, indent = None, include = None, exclude = None, by_alias = true,
     exclude_none = false, round_trip = false, timedelta_mode = "iso8601", bytes_mode = "utf8",
     inf_nan_mode = "constants", serialize_unknown = false, fallback = None, serialize_as_any = false,
     context = None))]
@@ -249,7 +249,7 @@ pub fn to_json(
     indent: Option<usize>,
     include: Option<&Bound<'_, PyAny>>,
     exclude: Option<&Bound<'_, PyAny>>,
-    by_alias: Option<bool>,
+    by_alias: bool,
     exclude_none: bool,
     round_trip: bool,
     timedelta_mode: &str,
@@ -265,7 +265,7 @@ pub fn to_json(
     let extra = state.extra(
         py,
         &SerMode::Json,
-        by_alias,
+        Some(by_alias),
         exclude_none,
         round_trip,
         serialize_unknown,
@@ -282,7 +282,7 @@ pub fn to_json(
 
 #[allow(clippy::too_many_arguments)]
 #[pyfunction]
-#[pyo3(signature = (value, *, include = None, exclude = None, by_alias = None, exclude_none = false, round_trip = false,
+#[pyo3(signature = (value, *, include = None, exclude = None, by_alias = true, exclude_none = false, round_trip = false,
     timedelta_mode = "iso8601", bytes_mode = "utf8", inf_nan_mode = "constants", serialize_unknown = false, fallback = None,
     serialize_as_any = false, context = None))]
 pub fn to_jsonable_python(
@@ -290,7 +290,7 @@ pub fn to_jsonable_python(
     value: &Bound<'_, PyAny>,
     include: Option<&Bound<'_, PyAny>>,
     exclude: Option<&Bound<'_, PyAny>>,
-    by_alias: Option<bool>,
+    by_alias: bool,
     exclude_none: bool,
     round_trip: bool,
     timedelta_mode: &str,
@@ -306,7 +306,7 @@ pub fn to_jsonable_python(
     let extra = state.extra(
         py,
         &SerMode::Json,
-        by_alias,
+        Some(by_alias),
         exclude_none,
         round_trip,
         serialize_unknown,

From 6c936de5a8d4d69fc3a13bc975dc73c0de2b8310 Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Wed, 26 Mar 2025 21:03:39 +0100
Subject: [PATCH 518/550] Bump version to v2.33.0 (#1673)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index d1d3aadec..a599d7c0e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -424,7 +424,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.32.0"
+version = "2.33.0"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index c444ddc91..c2054b2d7 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.32.0"
+version = "2.33.0"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From 104d39889499119cf5e632605eec293dbc17f3ac Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Tue, 1 Apr 2025 17:01:06 +0200
Subject: [PATCH 519/550] Coerce `'timedelta'` schema constraints (#1676)

---
 .github/workflows/ci.yml           |  3 ++-
 src/validators/date.rs             |  3 +--
 src/validators/datetime.rs         |  2 +-
 src/validators/decimal.rs          | 18 +++++++++++-------
 src/validators/int.rs              | 15 +++++++--------
 src/validators/timedelta.rs        | 29 +++++++++++++++++------------
 tests/validators/test_date.py      |  8 +++++++-
 tests/validators/test_datetime.py  |  8 +++++++-
 tests/validators/test_decimal.py   |  8 +++++++-
 tests/validators/test_int.py       |  8 +++++++-
 tests/validators/test_timedelta.py | 15 +++++++++++++++
 11 files changed, 82 insertions(+), 35 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 7ba7247a2..01176881b 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -362,7 +362,8 @@ jobs:
   # https://github.com/marketplace/actions/alls-green#why used for branch protection checks
   check:
     if: always()
-    needs: [coverage, test-python, test-os, test-debug, lint, bench, build-wasm-emscripten]
+    # TODO: add build-wasm-emscripten back when CI installation failures are solved:
+    needs: [coverage, test-python, test-os, test-debug, lint, bench]
     runs-on: ubuntu-latest
     steps:
       - name: Decide whether the needed jobs succeeded or failed
diff --git a/src/validators/date.rs b/src/validators/date.rs
index d85af4a13..6fec1f89e 100644
--- a/src/validators/date.rs
+++ b/src/validators/date.rs
@@ -9,7 +9,6 @@ use crate::build_tools::{is_strict, py_schema_error_type};
 use crate::errors::{ErrorType, ErrorTypeDefaults, ValError, ValResult};
 use crate::input::{EitherDate, Input};
 
-use crate::tools::SchemaDict;
 use crate::validators::datetime::{NowConstraint, NowOp};
 
 use super::Exactness;
@@ -177,7 +176,7 @@ impl DateConstraints {
 }
 
 fn convert_pydate(schema: &Bound<'_, PyDict>, key: &Bound<'_, PyString>) -> PyResult<Option<Date>> {
-    match schema.get_as::<Bound<'_, PyAny>>(key)? {
+    match schema.get_item(key)? {
         Some(value) => match value.validate_date(false) {
             Ok(v) => Ok(Some(v.into_inner().as_raw()?)),
             Err(_) => Err(PyValueError::new_err(format!(
diff --git a/src/validators/datetime.rs b/src/validators/datetime.rs
index fad79deff..d82a3dd6c 100644
--- a/src/validators/datetime.rs
+++ b/src/validators/datetime.rs
@@ -210,7 +210,7 @@ impl DateTimeConstraints {
 }
 
 fn py_datetime_as_datetime(schema: &Bound<'_, PyDict>, key: &Bound<'_, PyString>) -> PyResult<Option<DateTime>> {
-    match schema.get_as::<Bound<'_, PyAny>>(key)? {
+    match schema.get_item(key)? {
         Some(value) => match value.validate_datetime(false, MicrosecondsPrecisionOverflowBehavior::Truncate) {
             Ok(v) => Ok(Some(v.into_inner().as_raw()?)),
             Err(_) => Err(PyValueError::new_err(format!(
diff --git a/src/validators/decimal.rs b/src/validators/decimal.rs
index 4f6db8ae8..3d8c90c6e 100644
--- a/src/validators/decimal.rs
+++ b/src/validators/decimal.rs
@@ -28,8 +28,12 @@ pub fn get_decimal_type(py: Python) -> &Bound<'_, PyType> {
         .bind(py)
 }
 
-fn validate_as_decimal(py: Python, schema: &Bound<'_, PyDict>, key: &str) -> PyResult<Option<Py<PyAny>>> {
-    match schema.get_as::<Bound<'_, PyAny>>(&PyString::new(py, key))? {
+fn validate_as_decimal(
+    py: Python,
+    schema: &Bound<'_, PyDict>,
+    key: &Bound<'_, PyString>,
+) -> PyResult<Option<Py<PyAny>>> {
+    match schema.get_item(key)? {
         Some(value) => match value.validate_decimal(false, py) {
             Ok(v) => Ok(Some(v.into_inner().unbind())),
             Err(_) => Err(PyValueError::new_err(format!(
@@ -77,11 +81,11 @@ impl BuildValidator for DecimalValidator {
             allow_inf_nan,
             check_digits: decimal_places.is_some() || max_digits.is_some(),
             decimal_places,
-            multiple_of: validate_as_decimal(py, schema, "multiple_of")?,
-            le: validate_as_decimal(py, schema, "le")?,
-            lt: validate_as_decimal(py, schema, "lt")?,
-            ge: validate_as_decimal(py, schema, "ge")?,
-            gt: validate_as_decimal(py, schema, "gt")?,
+            multiple_of: validate_as_decimal(py, schema, intern!(py, "multiple_of"))?,
+            le: validate_as_decimal(py, schema, intern!(py, "le"))?,
+            lt: validate_as_decimal(py, schema, intern!(py, "lt"))?,
+            ge: validate_as_decimal(py, schema, intern!(py, "ge"))?,
+            gt: validate_as_decimal(py, schema, intern!(py, "gt"))?,
             max_digits,
         }
         .into())
diff --git a/src/validators/int.rs b/src/validators/int.rs
index 8d30f215c..28d068c21 100644
--- a/src/validators/int.rs
+++ b/src/validators/int.rs
@@ -8,12 +8,11 @@ use pyo3::IntoPyObjectExt;
 use crate::build_tools::is_strict;
 use crate::errors::{ErrorType, ValError, ValResult};
 use crate::input::{Input, Int};
-use crate::tools::SchemaDict;
 
 use super::{BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
 
-fn validate_as_int(py: Python, schema: &Bound<'_, PyDict>, key: &str) -> PyResult<Option<Int>> {
-    match schema.get_as::<Bound<'_, PyAny>>(&PyString::new(py, key))? {
+fn validate_as_int(schema: &Bound<'_, PyDict>, key: &Bound<'_, PyString>) -> PyResult<Option<Int>> {
+    match schema.get_item(key)? {
         Some(value) => match value.validate_int(false) {
             Ok(v) => match v.into_inner().as_int() {
                 Ok(v) => Ok(Some(v)),
@@ -93,11 +92,11 @@ impl ConstrainedIntValidator {
         let py = schema.py();
         Ok(Self {
             strict: is_strict(schema, config)?,
-            multiple_of: validate_as_int(py, schema, "multiple_of")?,
-            le: validate_as_int(py, schema, "le")?,
-            lt: validate_as_int(py, schema, "lt")?,
-            ge: validate_as_int(py, schema, "ge")?,
-            gt: validate_as_int(py, schema, "gt")?,
+            multiple_of: validate_as_int(schema, intern!(py, "multiple_of"))?,
+            le: validate_as_int(schema, intern!(py, "le"))?,
+            lt: validate_as_int(schema, intern!(py, "lt"))?,
+            ge: validate_as_int(schema, intern!(py, "ge"))?,
+            gt: validate_as_int(schema, intern!(py, "gt"))?,
         }
         .into())
     }
diff --git a/src/validators/timedelta.rs b/src/validators/timedelta.rs
index a4c755f8a..d1d6ff3b8 100644
--- a/src/validators/timedelta.rs
+++ b/src/validators/timedelta.rs
@@ -1,10 +1,12 @@
+use pyo3::exceptions::PyValueError;
+use pyo3::intern;
 use pyo3::prelude::*;
-use pyo3::types::{PyDelta, PyDeltaAccess, PyDict};
-use speedate::Duration;
+use pyo3::types::{PyDelta, PyDeltaAccess, PyDict, PyString};
+use speedate::{Duration, MicrosecondsPrecisionOverflowBehavior};
 
 use crate::build_tools::is_strict;
 use crate::errors::{ErrorType, ValError, ValResult};
-use crate::input::{duration_as_pytimedelta, EitherTimedelta, Input};
+use crate::input::{duration_as_pytimedelta, Input};
 
 use super::datetime::extract_microseconds_precision;
 use super::{BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationState, Validator};
@@ -24,12 +26,14 @@ struct TimedeltaConstraints {
     gt: Option<Duration>,
 }
 
-fn get_constraint(schema: &Bound<'_, PyDict>, key: &str) -> PyResult<Option<Duration>> {
+fn get_constraint(schema: &Bound<'_, PyDict>, key: &Bound<'_, PyString>) -> PyResult<Option<Duration>> {
     match schema.get_item(key)? {
-        Some(value) => {
-            let either_timedelta = EitherTimedelta::try_from(&value)?;
-            Ok(Some(either_timedelta.to_duration()?))
-        }
+        Some(value) => match value.validate_timedelta(false, MicrosecondsPrecisionOverflowBehavior::default()) {
+            Ok(v) => Ok(Some(v.into_inner().to_duration()?)),
+            Err(_) => Err(PyValueError::new_err(format!(
+                "'{key}' must be coercible to a timedelta instance"
+            ))),
+        },
         None => Ok(None),
     }
 }
@@ -42,11 +46,12 @@ impl BuildValidator for TimeDeltaValidator {
         config: Option<&Bound<'_, PyDict>>,
         _definitions: &mut DefinitionsBuilder<CombinedValidator>,
     ) -> PyResult<CombinedValidator> {
+        let py = schema.py();
         let constraints = TimedeltaConstraints {
-            le: get_constraint(schema, "le")?,
-            lt: get_constraint(schema, "lt")?,
-            ge: get_constraint(schema, "ge")?,
-            gt: get_constraint(schema, "gt")?,
+            le: get_constraint(schema, intern!(py, "le"))?,
+            lt: get_constraint(schema, intern!(py, "lt"))?,
+            ge: get_constraint(schema, intern!(py, "ge"))?,
+            gt: get_constraint(schema, intern!(py, "gt"))?,
         };
 
         Ok(Self {
diff --git a/tests/validators/test_date.py b/tests/validators/test_date.py
index 202a8f205..161f115d9 100644
--- a/tests/validators/test_date.py
+++ b/tests/validators/test_date.py
@@ -17,11 +17,17 @@
     'constraint',
     ['le', 'lt', 'ge', 'gt'],
 )
-def test_constraints_schema_validation(constraint: str) -> None:
+def test_constraints_schema_validation_error(constraint: str) -> None:
     with pytest.raises(SchemaError, match=f"'{constraint}' must be coercible to a date instance"):
         SchemaValidator(cs.date_schema(**{constraint: 'bad_value'}))
 
 
+def test_constraints_schema_validation() -> None:
+    val = SchemaValidator(cs.date_schema(gt='2020-01-01'))
+    with pytest.raises(ValidationError):
+        val.validate_python('2019-01-01')
+
+
 @pytest.mark.parametrize(
     'input_value,expected',
     [
diff --git a/tests/validators/test_datetime.py b/tests/validators/test_datetime.py
index 16ea0b4e0..21b0db61e 100644
--- a/tests/validators/test_datetime.py
+++ b/tests/validators/test_datetime.py
@@ -18,11 +18,17 @@
     'constraint',
     ['le', 'lt', 'ge', 'gt'],
 )
-def test_constraints_schema_validation(constraint: str) -> None:
+def test_constraints_schema_validation_error(constraint: str) -> None:
     with pytest.raises(SchemaError, match=f"'{constraint}' must be coercible to a datetime instance"):
         SchemaValidator(cs.datetime_schema(**{constraint: 'bad_value'}))
 
 
+def test_constraints_schema_validation() -> None:
+    val = SchemaValidator(cs.datetime_schema(gt='2020-01-01T00:00:00'))
+    with pytest.raises(ValidationError):
+        val.validate_python('2019-01-01T00:00:00')
+
+
 @pytest.mark.parametrize(
     'input_value,expected',
     [
diff --git a/tests/validators/test_decimal.py b/tests/validators/test_decimal.py
index 1a8d15871..64d34ba18 100644
--- a/tests/validators/test_decimal.py
+++ b/tests/validators/test_decimal.py
@@ -25,11 +25,17 @@ class DecimalSubclass(Decimal):
     'constraint',
     ['multiple_of', 'le', 'lt', 'ge', 'gt'],
 )
-def test_constraints_schema_validation(constraint: str) -> None:
+def test_constraints_schema_validation_error(constraint: str) -> None:
     with pytest.raises(SchemaError, match=f"'{constraint}' must be coercible to a Decimal instance"):
         SchemaValidator(cs.decimal_schema(**{constraint: 'bad_value'}))
 
 
+def test_constraints_schema_validation() -> None:
+    val = SchemaValidator(cs.decimal_schema(gt='1'))
+    with pytest.raises(ValidationError):
+        val.validate_python('0')
+
+
 @pytest.mark.parametrize(
     'input_value,expected',
     [
diff --git a/tests/validators/test_int.py b/tests/validators/test_int.py
index f16bf1377..4db426032 100644
--- a/tests/validators/test_int.py
+++ b/tests/validators/test_int.py
@@ -18,11 +18,17 @@
     'constraint',
     ['multiple_of', 'le', 'lt', 'ge', 'gt'],
 )
-def test_constraints_schema_validation(constraint: str) -> None:
+def test_constraints_schema_validation_error(constraint: str) -> None:
     with pytest.raises(SchemaError, match=f"'{constraint}' must be coercible to an integer"):
         SchemaValidator(cs.int_schema(**{constraint: 'bad_value'}))
 
 
+def test_constraints_schema_validation() -> None:
+    val = SchemaValidator(cs.int_schema(gt='1'))
+    with pytest.raises(ValidationError):
+        val.validate_python('0')
+
+
 @pytest.mark.parametrize(
     'input_value,expected',
     [
diff --git a/tests/validators/test_timedelta.py b/tests/validators/test_timedelta.py
index e9b885481..c10a2d592 100644
--- a/tests/validators/test_timedelta.py
+++ b/tests/validators/test_timedelta.py
@@ -15,6 +15,21 @@
     pandas = None
 
 
+@pytest.mark.parametrize(
+    'constraint',
+    ['le', 'lt', 'ge', 'gt'],
+)
+def test_constraints_schema_validation_error(constraint: str) -> None:
+    with pytest.raises(SchemaError, match=f"'{constraint}' must be coercible to a timedelta instance"):
+        SchemaValidator(core_schema.timedelta_schema(**{constraint: 'bad_value'}))
+
+
+def test_constraints_schema_validation() -> None:
+    val = SchemaValidator(core_schema.timedelta_schema(gt=3))
+    with pytest.raises(ValidationError):
+        val.validate_python(1)
+
+
 @pytest.mark.parametrize(
     'input_value,expected',
     [

From f6ded645fb27cb2f387bab481d610e98860e56cc Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Wed, 2 Apr 2025 09:34:17 +0100
Subject: [PATCH 520/550] Pin `inline-snapshot` with an upper bound to fix wasm
 build (#1680)

---
 .github/workflows/ci.yml   | 3 +--
 tests/emscripten_runner.js | 3 ++-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 01176881b..7ba7247a2 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -362,8 +362,7 @@ jobs:
   # https://github.com/marketplace/actions/alls-green#why used for branch protection checks
   check:
     if: always()
-    # TODO: add build-wasm-emscripten back when CI installation failures are solved:
-    needs: [coverage, test-python, test-os, test-debug, lint, bench]
+    needs: [coverage, test-python, test-os, test-debug, lint, bench, build-wasm-emscripten]
     runs-on: ubuntu-latest
     steps:
       - name: Decide whether the needed jobs succeeded or failed
diff --git a/tests/emscripten_runner.js b/tests/emscripten_runner.js
index a49c1b6ad..ab1583da3 100644
--- a/tests/emscripten_runner.js
+++ b/tests/emscripten_runner.js
@@ -98,7 +98,8 @@ import importlib
 
 await micropip.install([
     'dirty-equals',
-    'inline-snapshot',
+    # inline-snapshot 0.21 requires pytest 8.3.4, pyodide 0.26 ships with 8.1.1
+    'inline-snapshot < 0.21',
     'hypothesis',
     'pytest-speed',
     'pytest-mock',

From baa8cbf4d5d54ec217f61b45d09873c07fc20159 Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Wed, 2 Apr 2025 11:24:24 +0200
Subject: [PATCH 521/550] Bump version to v2.33.1 (#1681)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index a599d7c0e..870459ac1 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -424,7 +424,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.33.0"
+version = "2.33.1"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index c2054b2d7..278149ac8 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.33.0"
+version = "2.33.1"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From ee8c173f3d1832a5187152a67a802336564a0065 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Thu, 3 Apr 2025 15:35:12 +0100
Subject: [PATCH 522/550] fix clippy lints for Rust 1.86 (#1682)

---
 src/errors/location.rs                        | 2 +-
 src/input/datetime.rs                         | 7 ++++---
 src/input/shared.rs                           | 2 +-
 src/serializers/errors.rs                     | 6 ++++--
 src/serializers/type_serializers/generator.rs | 5 +----
 src/serializers/type_serializers/tuple.rs     | 4 ++--
 src/url.rs                                    | 4 ++--
 src/validators/arguments.rs                   | 2 +-
 src/validators/dataclass.rs                   | 6 +++---
 src/validators/decimal.rs                     | 2 +-
 src/validators/literal.rs                     | 6 +++---
 src/validators/model_fields.rs                | 6 +++---
 src/validators/typed_dict.rs                  | 4 ++--
 src/validators/union.rs                       | 2 +-
 src/validators/url.rs                         | 2 +-
 src/validators/uuid.rs                        | 2 +-
 16 files changed, 31 insertions(+), 31 deletions(-)

diff --git a/src/errors/location.rs b/src/errors/location.rs
index d020519e7..3d3e90849 100644
--- a/src/errors/location.rs
+++ b/src/errors/location.rs
@@ -147,7 +147,7 @@ impl Location {
             Self::Empty => {
                 *self = Self::new_some(loc_item);
             }
-        };
+        }
     }
 }
 
diff --git a/src/input/datetime.rs b/src/input/datetime.rs
index 9afe49a0a..e1b3b3792 100644
--- a/src/input/datetime.rs
+++ b/src/input/datetime.rs
@@ -10,6 +10,7 @@ use speedate::MicrosecondsPrecisionOverflowBehavior;
 use speedate::{Date, DateTime, Duration, ParseError, Time, TimeConfig};
 use std::borrow::Cow;
 use std::collections::hash_map::DefaultHasher;
+use std::fmt::Write;
 use std::hash::Hash;
 use std::hash::Hasher;
 
@@ -59,7 +60,7 @@ impl<'py> EitherDate<'py> {
                         },
                         input,
                     ));
-                };
+                }
                 let py_date = PyDate::new(py, date.year.into(), date.month, date.day)?;
                 Ok(py_date.into())
             }
@@ -296,7 +297,7 @@ impl<'py> EitherDateTime<'py> {
                         },
                         input,
                     ));
-                };
+                }
                 let py_dt = PyDateTime::new(
                     py,
                     dt.date.year.into(),
@@ -590,7 +591,7 @@ impl TzInfo {
         );
 
         if seconds != 0 {
-            result.push_str(&format!(":{:02}", seconds.abs()));
+            write!(result, ":{:02}", seconds.abs()).expect("writing to string should never fail");
         }
 
         result
diff --git a/src/input/shared.rs b/src/input/shared.rs
index f3d8a3b9f..1a90b4142 100644
--- a/src/input/shared.rs
+++ b/src/input/shared.rs
@@ -181,7 +181,7 @@ fn strip_leading_zeros(s: &str) -> Option<&str> {
         Some((_, c)) if ('1'..='9').contains(&c) || c == '-' => return Some(s),
         // anything else is invalid, we return None
         _ => return None,
-    };
+    }
     for (i, c) in char_iter {
         match c {
             // continue on more leading zeros or if we get an underscore we continue - we're "within the number"
diff --git a/src/serializers/errors.rs b/src/serializers/errors.rs
index 5f736c11b..d9ba85682 100644
--- a/src/serializers/errors.rs
+++ b/src/serializers/errors.rs
@@ -1,4 +1,5 @@
 use std::fmt;
+use std::fmt::Write;
 
 use pyo3::exceptions::PyValueError;
 use pyo3::prelude::*;
@@ -154,7 +155,7 @@ impl PydanticSerializationUnexpectedValue {
             if !message.is_empty() {
                 message.push_str(": ");
             }
-            message.push_str(&format!("Expected `{field_type}`"));
+            write!(message, "Expected `{field_type}`").expect("writing to string should never fail");
             if self.input_value.is_some() {
                 message.push_str(" - serialized value may not be as expected");
             }
@@ -170,7 +171,8 @@ impl PydanticSerializationUnexpectedValue {
 
             let value_str = truncate_safe_repr(bound_input, None);
 
-            message.push_str(&format!(" [input_value={value_str}, input_type={input_type}]"));
+            write!(message, " [input_value={value_str}, input_type={input_type}]")
+                .expect("writing to string should never fail");
         }
 
         if message.is_empty() {
diff --git a/src/serializers/type_serializers/generator.rs b/src/serializers/type_serializers/generator.rs
index 86379bade..0e5050c64 100644
--- a/src/serializers/type_serializers/generator.rs
+++ b/src/serializers/type_serializers/generator.rs
@@ -115,10 +115,7 @@ impl TypeSerializer for GeneratorSerializer {
     ) -> Result<S::Ok, S::Error> {
         match value.downcast::<PyIterator>() {
             Ok(py_iter) => {
-                let len = match value.len() {
-                    Ok(len) => Some(len),
-                    Err(_) => None,
-                };
+                let len = value.len().ok();
                 let mut seq = serializer.serialize_seq(len)?;
                 let item_serializer = self.item_serializer.as_ref();
 
diff --git a/src/serializers/type_serializers/tuple.rs b/src/serializers/type_serializers/tuple.rs
index e5e3da353..e6bc6d2f0 100644
--- a/src/serializers/type_serializers/tuple.rs
+++ b/src/serializers/type_serializers/tuple.rs
@@ -243,10 +243,10 @@ impl TupleSerializer {
                         serializer: &CombinedSerializer::Any(AnySerializer),
                     }) {
                         return Ok(Err(e));
-                    };
+                    }
                 }
             }
-        };
+        }
         Ok(Ok(()))
     }
 }
diff --git a/src/url.rs b/src/url.rs
index 8d31fb27e..da63be5af 100644
--- a/src/url.rs
+++ b/src/url.rs
@@ -392,7 +392,7 @@ impl PyMultiHostUrl {
                     multi_url.push_str(&single_host.to_string());
                     if index != hosts.len() - 1 {
                         multi_url.push(',');
-                    };
+                    }
                 }
                 multi_url
             } else if host.is_some() {
@@ -456,7 +456,7 @@ impl fmt::Display for UrlHostParts {
             (None, Some(password)) => write!(f, ":{password}@")?,
             (Some(username), Some(password)) => write!(f, "{username}:{password}@")?,
             (None, None) => {}
-        };
+        }
         if let Some(host) = &self.host {
             write!(f, "{host}")?;
         }
diff --git a/src/validators/arguments.rs b/src/validators/arguments.rs
index 7c397d69f..2da3bbfcb 100644
--- a/src/validators/arguments.rs
+++ b/src/validators/arguments.rs
@@ -280,7 +280,7 @@ impl Validator for ArgumentsValidator {
                             input,
                             index,
                         ));
-                    };
+                    }
                 }
             }
         }
diff --git a/src/validators/dataclass.rs b/src/validators/dataclass.rs
index 0f2cbefc7..e518757f2 100644
--- a/src/validators/dataclass.rs
+++ b/src/validators/dataclass.rs
@@ -190,9 +190,9 @@ impl Validator for DataclassArgsValidator {
                     // We could try to "fix" this in the future if desired.
                     Err(ValError::LineErrors(line_errors)) => errors.extend(line_errors),
                     Err(err) => return Err(err),
-                };
+                }
                 continue;
-            };
+            }
 
             let mut pos_value = None;
             if let Some(args) = args.args() {
@@ -265,7 +265,7 @@ impl Validator for DataclassArgsValidator {
                                 &field.name,
                             ));
                         }
-                        Err(ValError::Omit) => continue,
+                        Err(ValError::Omit) => {}
                         Err(ValError::LineErrors(line_errors)) => {
                             for err in line_errors {
                                 // Note: this will always use the field name even if there is an alias
diff --git a/src/validators/decimal.rs b/src/validators/decimal.rs
index 3d8c90c6e..a2a9e0b5b 100644
--- a/src/validators/decimal.rs
+++ b/src/validators/decimal.rs
@@ -194,7 +194,7 @@ impl Validator for DecimalValidator {
                             }
                         }
                     }
-                };
+                }
             }
         }
 
diff --git a/src/validators/literal.rs b/src/validators/literal.rs
index ffe615fe3..3da5e9d47 100644
--- a/src/validators/literal.rs
+++ b/src/validators/literal.rs
@@ -158,7 +158,7 @@ impl<T: Debug> LiteralLookup<T> {
                 let id: usize = v.extract().unwrap();
                 return Ok(Some((input, &self.values[id])));
             }
-        };
+        }
         if let Some(expected_py_values) = &self.expected_py_values {
             let py_input = get_py_input()?;
             for (k, id) in expected_py_values {
@@ -166,7 +166,7 @@ impl<T: Debug> LiteralLookup<T> {
                     return Ok(Some((input, &self.values[*id])));
                 }
             }
-        };
+        }
 
         // this one must be last to avoid conflicts with the other lookups, think of this
         // almost as a lax fallback
@@ -179,7 +179,7 @@ impl<T: Debug> LiteralLookup<T> {
                 let id: usize = v.extract().unwrap();
                 return Ok(Some((input, &self.values[id])));
             }
-        };
+        }
         Ok(None)
     }
 
diff --git a/src/validators/model_fields.rs b/src/validators/model_fields.rs
index ba1f7d1ba..b87f671ab 100644
--- a/src/validators/model_fields.rs
+++ b/src/validators/model_fields.rs
@@ -228,7 +228,7 @@ impl Validator for ModelFieldsValidator {
                             &field.name,
                         ));
                     }
-                    Err(ValError::Omit) => continue,
+                    Err(ValError::Omit) => {}
                     Err(ValError::LineErrors(line_errors)) => {
                         for err in line_errors {
                             // Note: this will always use the field name even if there is an alias
@@ -334,7 +334,7 @@ impl Validator for ModelFieldsValidator {
                                 } else {
                                     model_extra_dict.set_item(&py_key, value.to_object(self.py)?)?;
                                     self.fields_set_vec.push(py_key.into());
-                                };
+                                }
                             }
                         }
                     }
@@ -368,7 +368,7 @@ impl Validator for ModelFieldsValidator {
             // from attributes, set it now so __pydantic_extra__ is always a dict if extra=allow
             if matches!(self.extra_behavior, ExtraBehavior::Allow) && model_extra_dict_op.is_none() {
                 model_extra_dict_op = Some(PyDict::new(py));
-            };
+            }
 
             Ok((model_dict, model_extra_dict_op, fields_set).into_py_any(py)?)
         }
diff --git a/src/validators/typed_dict.rs b/src/validators/typed_dict.rs
index 013db4d69..c9c122791 100644
--- a/src/validators/typed_dict.rs
+++ b/src/validators/typed_dict.rs
@@ -252,7 +252,7 @@ impl Validator for TypedDictValidator {
                             ));
                         }
                     }
-                    Err(ValError::Omit) => continue,
+                    Err(ValError::Omit) => {}
                     Err(ValError::LineErrors(line_errors)) => {
                         for err in line_errors {
                             // Note: this will always use the field name even if there is an alias
@@ -347,7 +347,7 @@ impl Validator for TypedDictValidator {
                                     }
                                 } else {
                                     self.output_dict.set_item(py_key, value.to_object(self.py)?)?;
-                                };
+                                }
                             }
                         }
                     }
diff --git a/src/validators/union.rs b/src/validators/union.rs
index dccc09ce7..f293a9976 100644
--- a/src/validators/union.rs
+++ b/src/validators/union.rs
@@ -193,7 +193,7 @@ impl UnionValidator {
             match validator.validate(py, input, state) {
                 Err(ValError::LineErrors(lines)) => errors.push(validator, label.as_deref(), lines),
                 otherwise => return otherwise,
-            };
+            }
         }
 
         Err(errors.into_val_error(input))
diff --git a/src/validators/url.rs b/src/validators/url.rs
index fd386074f..d220d60ed 100644
--- a/src/validators/url.rs
+++ b/src/validators/url.rs
@@ -392,7 +392,7 @@ fn parse_multihost_url<'py>(
                 '\t' | '\n' | '\r' => (),
                 c if c <= &' ' => (),
                 _ => break,
-            };
+            }
             chars.next();
         } else {
             break;
diff --git a/src/validators/uuid.rs b/src/validators/uuid.rs
index 995f2d183..9ad4eb3b9 100644
--- a/src/validators/uuid.rs
+++ b/src/validators/uuid.rs
@@ -215,7 +215,7 @@ impl UuidValidator {
                     input,
                 ));
             }
-        };
+        }
         Ok(uuid)
     }
 

From 5a32b4f1300194df6ec78114fd14821fc3cf3b79 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 3 Apr 2025 15:09:49 +0000
Subject: [PATCH 523/550] Bump uuid from 1.15.1 to 1.16.0 (#1678)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 870459ac1..30d1a9158 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -741,9 +741,9 @@ checksum = "b6c140620e7ffbb22c2dee59cafe6084a59b5ffc27a8859a5f0d494b5d52b6be"
 
 [[package]]
 name = "uuid"
-version = "1.15.1"
+version = "1.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e0f540e3240398cce6128b64ba83fdbdd86129c16a3aa1a3a252efd66eb3d587"
+checksum = "458f7a779bf54acc9f347480ac654f68407d3aab21269a6e3c9f922acd9e2da9"
 
 [[package]]
 name = "version_check"
diff --git a/Cargo.toml b/Cargo.toml
index 278149ac8..66b2a6b37 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -44,7 +44,7 @@ url = "2.5.4"
 idna = "1.0.3"
 base64 = "0.22.1"
 num-bigint = "0.4.6"
-uuid = "1.15.1"
+uuid = "1.16.0"
 jiter = { version = "0.9.0", features = ["python"] }
 hex = "0.4.3"
 

From 59e655ef3a4d861c7d576c9e9f380a42cb83c5b7 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 3 Apr 2025 16:25:10 +0100
Subject: [PATCH 524/550] Bump serde_json from 1.0.138 to 1.0.140 (#1679)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 30d1a9158..bb804210e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -599,9 +599,9 @@ dependencies = [
 
 [[package]]
 name = "serde_json"
-version = "1.0.138"
+version = "1.0.140"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d434192e7da787e94a6ea7e9670b26a036d0ca41e0b7efb2676dd32bae872949"
+checksum = "20068b6e96dc6c9bd23e01df8827e6c7e1f2fddd43c21810382803c136b99373"
 dependencies = [
  "indexmap",
  "itoa",
diff --git a/Cargo.toml b/Cargo.toml
index 66b2a6b37..4bc99e6ff 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -33,7 +33,7 @@ pyo3 = { version = "0.24", features = ["generate-import-lib", "num-bigint", "py-
 regex = "1.11.1"
 strum = { version = "0.26.3", features = ["derive"] }
 strum_macros = "0.26.4"
-serde_json = {version = "1.0.138", features = ["arbitrary_precision", "preserve_order"]}
+serde_json = {version = "1.0.140", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.13"
 serde = { version = "1.0.218", features = ["derive"] }
 speedate = "0.15.0"

From 0a5bbfc116c1659ce476fac56a44cda96673dfa8 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Thu, 3 Apr 2025 16:25:25 +0100
Subject: [PATCH 525/550] Bump pyo3 from 0.24.0 to 0.24.1 (#1677)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index bb804210e..e645e120e 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -449,9 +449,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.24.0"
+version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f1c6c3591120564d64db2261bec5f910ae454f01def849b9c22835a84695e86"
+checksum = "17da310086b068fbdcefbba30aeb3721d5bb9af8db4987d6735b2183ca567229"
 dependencies = [
  "cfg-if",
  "indoc",
@@ -468,9 +468,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.24.0"
+version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e9b6c2b34cf71427ea37c7001aefbaeb85886a074795e35f161f5aecc7620a7a"
+checksum = "e27165889bd793000a098bb966adc4300c312497ea25cf7a690a9f0ac5aa5fc1"
 dependencies = [
  "once_cell",
  "python3-dll-a",
@@ -479,9 +479,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.24.0"
+version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5507651906a46432cdda02cd02dd0319f6064f1374c9147c45b978621d2c3a9c"
+checksum = "05280526e1dbf6b420062f3ef228b78c0c54ba94e157f5cb724a609d0f2faabc"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -489,9 +489,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.24.0"
+version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b0d394b5b4fd8d97d48336bb0dd2aebabad39f1d294edd6bcd2cccf2eefe6f42"
+checksum = "5c3ce5686aa4d3f63359a5100c62a127c9f15e8398e5fdeb5deef1fed5cd5f44"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -501,9 +501,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.24.0"
+version = "0.24.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "fd72da09cfa943b1080f621f024d2ef7e2773df7badd51aa30a2be1f8caa7c8e"
+checksum = "f4cf6faa0cbfb0ed08e89beb8103ae9724eb4750e3a78084ba4017cbe94f3855"
 dependencies = [
  "heck",
  "proc-macro2",

From 9a25aa69f88183d06c484775c8cb2c4329368251 Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Wed, 9 Apr 2025 12:19:07 +0200
Subject: [PATCH 526/550] Allow JSON `BigInt` to validate against `float`
 schema (#1685)

---
 Cargo.lock                     | 1 +
 Cargo.toml                     | 1 +
 src/input/input_json.rs        | 4 ++++
 tests/validators/test_float.py | 6 +++++-
 tests/validators/test_int.py   | 2 +-
 5 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index e645e120e..bbfc4f5b8 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -433,6 +433,7 @@ dependencies = [
  "idna",
  "jiter",
  "num-bigint",
+ "num-traits",
  "pyo3",
  "pyo3-build-config",
  "regex",
diff --git a/Cargo.toml b/Cargo.toml
index 4bc99e6ff..91fefc4ef 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -44,6 +44,7 @@ url = "2.5.4"
 idna = "1.0.3"
 base64 = "0.22.1"
 num-bigint = "0.4.6"
+num-traits = "0.2.19"
 uuid = "1.16.0"
 jiter = { version = "0.9.0", features = ["python"] }
 hex = "0.4.3"
diff --git a/src/input/input_json.rs b/src/input/input_json.rs
index 4de3fd4cf..6828f5927 100644
--- a/src/input/input_json.rs
+++ b/src/input/input_json.rs
@@ -1,6 +1,7 @@
 use std::borrow::Cow;
 
 use jiter::{JsonArray, JsonObject, JsonValue};
+use num_traits::cast::ToPrimitive;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList, PyString};
 use speedate::MicrosecondsPrecisionOverflowBehavior;
@@ -173,6 +174,9 @@ impl<'py, 'data> Input<'py> for JsonValue<'data> {
         match self {
             JsonValue::Float(f) => Ok(ValidationMatch::exact(EitherFloat::F64(*f))),
             JsonValue::Int(i) => Ok(ValidationMatch::strict(EitherFloat::F64(*i as f64))),
+            JsonValue::BigInt(b) => Ok(ValidationMatch::strict(EitherFloat::F64(
+                b.to_f64().expect("BigInt should always return some value"),
+            ))),
             JsonValue::Bool(b) if !strict => Ok(ValidationMatch::lax(EitherFloat::F64(if *b { 1.0 } else { 0.0 }))),
             JsonValue::Str(str) if !strict => str_as_float(self, str).map(ValidationMatch::lax),
             _ => Err(ValError::new(ErrorTypeDefaults::FloatType, self)),
diff --git a/tests/validators/test_float.py b/tests/validators/test_float.py
index 8a0235ed5..dd78e8499 100644
--- a/tests/validators/test_float.py
+++ b/tests/validators/test_float.py
@@ -1,5 +1,6 @@
 import math
 import re
+import sys
 from decimal import Decimal
 from typing import Any
 
@@ -11,7 +12,8 @@
 
 from ..conftest import Err, PyAndJson, plain_repr
 
-f64_max = 1.7976931348623157e308
+i64_max = (2**63) - 1
+f64_max = sys.float_info.max
 
 
 @pytest.mark.parametrize(
@@ -20,6 +22,8 @@
         (0, 0),
         (1, 1),
         (42, 42),
+        (i64_max + 1, i64_max + 1),
+        (f64_max, f64_max),
         ('42', 42),
         ('  42.1  ', 42.1),
         ('42.123', 42.123),
diff --git a/tests/validators/test_int.py b/tests/validators/test_int.py
index 4db426032..1de2e0f0a 100644
--- a/tests/validators/test_int.py
+++ b/tests/validators/test_int.py
@@ -11,7 +11,7 @@
 
 from ..conftest import Err, PyAndJson, plain_repr
 
-i64_max = 9_223_372_036_854_775_807
+i64_max = (2**63) - 1
 
 
 @pytest.mark.parametrize(

From 4760f383a037e5fe91b854f9d883c7475b0f53f5 Mon Sep 17 00:00:00 2001
From: Douwe Maan <me@douwe.me>
Date: Thu, 17 Apr 2025 06:17:40 -0600
Subject: [PATCH 527/550] Ensure `ValidationInfo.field_name` is correct on
 validator reuse (#1692)

---
 python/pydantic_core/core_schema.py       |  44 ++++--
 src/validators/arguments.rs               |   3 +
 src/validators/dataclass.rs               |  25 ++--
 src/validators/function.rs                |  32 ++++-
 src/validators/generator.rs               |   2 +
 src/validators/mod.rs                     |   6 +
 src/validators/model.rs                   |  14 +-
 src/validators/model_fields.rs            |   6 +
 src/validators/typed_dict.rs              |   3 +
 tests/benchmarks/test_micro_benchmarks.py |   2 +-
 tests/validators/test_dataclasses.py      |  42 ++----
 tests/validators/test_function.py         | 160 +++++++++++++++-------
 tests/validators/test_model.py            |  10 +-
 tests/validators/test_model_init.py       |  12 +-
 tests/validators/test_model_root.py       |   2 +-
 15 files changed, 242 insertions(+), 121 deletions(-)

diff --git a/python/pydantic_core/core_schema.py b/python/pydantic_core/core_schema.py
index 0ab3dd947..f03daac36 100644
--- a/python/pydantic_core/core_schema.py
+++ b/python/pydantic_core/core_schema.py
@@ -1954,7 +1954,7 @@ class NoInfoValidatorFunctionSchema(TypedDict):
 class WithInfoValidatorFunctionSchema(TypedDict, total=False):
     type: Required[Literal['with-info']]
     function: Required[WithInfoValidatorFunction]
-    field_name: str
+    field_name: str  # deprecated
 
 
 ValidationFunction = Union[NoInfoValidatorFunctionSchema, WithInfoValidatorFunctionSchema]
@@ -2042,7 +2042,7 @@ def fn(v: bytes, info: core_schema.ValidationInfo) -> str:
         return v.decode() + 'world'
 
     func_schema = core_schema.with_info_before_validator_function(
-        function=fn, schema=core_schema.str_schema(), field_name='a'
+        function=fn, schema=core_schema.str_schema()
     )
     schema = core_schema.typed_dict_schema({'a': core_schema.typed_dict_field(func_schema)})
 
@@ -2052,13 +2052,20 @@ def fn(v: bytes, info: core_schema.ValidationInfo) -> str:
 
     Args:
         function: The validator function to call
-        field_name: The name of the field
+        field_name: The name of the field this validator is applied to, if any (deprecated)
         schema: The schema to validate the output of the validator function
         ref: optional unique identifier of the schema, used to reference the schema in other places
         json_schema_input_schema: The core schema to be used to generate the corresponding JSON Schema input type
         metadata: Any other information you want to include with the schema, not used by pydantic-core
         serialization: Custom serialization schema
     """
+    if field_name is not None:
+        warnings.warn(
+            'The `field_name` argument on `with_info_before_validator_function` is deprecated, it will be passed to the function through `ValidationState` instead.',
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
     return _dict_not_none(
         type='function-before',
         function=_dict_not_none(type='with-info', function=function, field_name=field_name),
@@ -2140,7 +2147,7 @@ def fn(v: str, info: core_schema.ValidationInfo) -> str:
         return v + 'world'
 
     func_schema = core_schema.with_info_after_validator_function(
-        function=fn, schema=core_schema.str_schema(), field_name='a'
+        function=fn, schema=core_schema.str_schema()
     )
     schema = core_schema.typed_dict_schema({'a': core_schema.typed_dict_field(func_schema)})
 
@@ -2151,11 +2158,18 @@ def fn(v: str, info: core_schema.ValidationInfo) -> str:
     Args:
         function: The validator function to call after the schema is validated
         schema: The schema to validate before the validator function
-        field_name: The name of the field this validators is applied to, if any
+        field_name: The name of the field this validator is applied to, if any (deprecated)
         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
         serialization: Custom serialization schema
     """
+    if field_name is not None:
+        warnings.warn(
+            'The `field_name` argument on `with_info_after_validator_function` is deprecated, it will be passed to the function through `ValidationState` instead.',
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
     return _dict_not_none(
         type='function-after',
         function=_dict_not_none(type='with-info', function=function, field_name=field_name),
@@ -2187,7 +2201,7 @@ class NoInfoWrapValidatorFunctionSchema(TypedDict):
 class WithInfoWrapValidatorFunctionSchema(TypedDict, total=False):
     type: Required[Literal['with-info']]
     function: Required[WithInfoWrapValidatorFunction]
-    field_name: str
+    field_name: str  # deprecated
 
 
 WrapValidatorFunction = Union[NoInfoWrapValidatorFunctionSchema, WithInfoWrapValidatorFunctionSchema]
@@ -2287,12 +2301,19 @@ def fn(
     Args:
         function: The validator function to call
         schema: The schema to validate the output of the validator function
-        field_name: The name of the field this validators is applied to, if any
+        field_name: The name of the field this validator is applied to, if any (deprecated)
         json_schema_input_schema: The core schema to be used to generate the corresponding JSON Schema input type
         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
         serialization: Custom serialization schema
     """
+    if field_name is not None:
+        warnings.warn(
+            'The `field_name` argument on `with_info_wrap_validator_function` is deprecated, it will be passed to the function through `ValidationState` instead.',
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
     return _dict_not_none(
         type='function-wrap',
         function=_dict_not_none(type='with-info', function=function, field_name=field_name),
@@ -2379,12 +2400,19 @@ def fn(v: str, info: core_schema.ValidationInfo) -> str:
 
     Args:
         function: The validator function to call
-        field_name: The name of the field this validators is applied to, if any
+        field_name: The name of the field this validator is applied to, if any (deprecated)
         ref: optional unique identifier of the schema, used to reference the schema in other places
         json_schema_input_schema: The core schema to be used to generate the corresponding JSON Schema input type
         metadata: Any other information you want to include with the schema, not used by pydantic-core
         serialization: Custom serialization schema
     """
+    if field_name is not None:
+        warnings.warn(
+            'The `field_name` argument on `with_info_plain_validator_function` is deprecated, it will be passed to the function through `ValidationState` instead.',
+            DeprecationWarning,
+            stacklevel=2,
+        )
+
     return _dict_not_none(
         type='function-plain',
         function=_dict_not_none(type='with-info', function=function, field_name=field_name),
diff --git a/src/validators/arguments.rs b/src/validators/arguments.rs
index 2da3bbfcb..2ca3ba5f6 100644
--- a/src/validators/arguments.rs
+++ b/src/validators/arguments.rs
@@ -229,6 +229,9 @@ impl Validator for ArgumentsValidator {
                 }
             }
 
+            let state =
+                &mut state.rebind_extra(|extra| extra.field_name = Some(PyString::new(py, parameter.name.as_str())));
+
             match (pos_value, kw_value) {
                 (Some(_), Some((_, kw_value))) => {
                     errors.push(ValLineError::new_with_loc(
diff --git a/src/validators/dataclass.rs b/src/validators/dataclass.rs
index e518757f2..c74d789ec 100644
--- a/src/validators/dataclass.rs
+++ b/src/validators/dataclass.rs
@@ -24,7 +24,7 @@ use super::{build_validator, BuildValidator, CombinedValidator, DefinitionsBuild
 struct Field {
     kw_only: bool,
     name: String,
-    py_name: Py<PyString>,
+    name_py: Py<PyString>,
     init: bool,
     init_only: bool,
     lookup_key_collection: LookupKeyCollection,
@@ -72,8 +72,8 @@ impl BuildValidator for DataclassArgsValidator {
         for field in fields_schema {
             let field = field.downcast::<PyDict>()?;
 
-            let py_name: Bound<'_, PyString> = field.get_as_req(intern!(py, "name"))?;
-            let name: String = py_name.extract()?;
+            let name_py: Bound<'_, PyString> = field.get_as_req(intern!(py, "name"))?;
+            let name: String = name_py.extract()?;
 
             let schema = field.get_as_req(intern!(py, "schema"))?;
 
@@ -99,7 +99,7 @@ impl BuildValidator for DataclassArgsValidator {
             fields.push(Field {
                 kw_only,
                 name,
-                py_name: py_name.into(),
+                name_py: name_py.into(),
                 lookup_key_collection,
                 validator,
                 init: field.get_as(intern!(py, "init"))?.unwrap_or(true),
@@ -163,13 +163,13 @@ impl Validator for DataclassArgsValidator {
 
         macro_rules! set_item {
             ($field:ident, $value:expr) => {{
-                let py_name = $field.py_name.bind(py);
+                let name_py = $field.name_py.bind(py);
                 if $field.init_only {
                     if let Some(ref mut init_only_args) = init_only_args {
                         init_only_args.push($value);
                     }
                 } else {
-                    output_dict.set_item(py_name, $value)?;
+                    output_dict.set_item(name_py, $value)?;
                 }
             }};
         }
@@ -214,6 +214,8 @@ impl Validator for DataclassArgsValidator {
             }
             let kw_value = kw_value.as_ref().map(|(path, value)| (path, value.borrow_input()));
 
+            let state = &mut state.rebind_extra(|extra| extra.field_name = Some(field.name_py.bind(py).clone()));
+
             match (pos_value, kw_value) {
                 // found both positional and keyword arguments, error
                 (Some(_), Some((_, kw_value))) => {
@@ -404,11 +406,12 @@ impl Validator for DataclassArgsValidator {
                 }
             }
 
-            match field.validator.validate(
-                py,
-                field_value,
-                &mut state.rebind_extra(|extra| extra.data = Some(data_dict.clone())),
-            ) {
+            let state = &mut state.rebind_extra(|extra| {
+                extra.data = Some(data_dict.clone());
+                extra.field_name = Some(field.name_py.bind(py).clone());
+            });
+
+            match field.validator.validate(py, field_value, state) {
                 Ok(output) => ok(output),
                 Err(ValError::LineErrors(line_errors)) => {
                     let errors = line_errors
diff --git a/src/validators/function.rs b/src/validators/function.rs
index 6f0eea7f4..e65ff79c3 100644
--- a/src/validators/function.rs
+++ b/src/validators/function.rs
@@ -100,7 +100,13 @@ impl FunctionBeforeValidator {
         state: &'s mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let r = if self.info_arg {
-            let info = ValidationInfo::new(py, state.extra(), &self.config, self.field_name.clone());
+            let field_name = state
+                .extra()
+                .field_name
+                .clone()
+                .map(Bound::unbind)
+                .or_else(|| self.field_name.clone());
+            let info = ValidationInfo::new(py, state.extra(), &self.config, field_name);
             self.func.call1(py, (input.to_object(py)?, info))
         } else {
             self.func.call1(py, (input.to_object(py)?,))
@@ -169,7 +175,13 @@ impl FunctionAfterValidator {
     ) -> ValResult<PyObject> {
         let v = call(input, state)?;
         let r = if self.info_arg {
-            let info = ValidationInfo::new(py, state.extra(), &self.config, self.field_name.clone());
+            let field_name = state
+                .extra()
+                .field_name
+                .clone()
+                .map(Bound::unbind)
+                .or_else(|| self.field_name.clone());
+            let info = ValidationInfo::new(py, state.extra(), &self.config, field_name);
             self.func.call1(py, (v, info))
         } else {
             self.func.call1(py, (v,))
@@ -258,7 +270,13 @@ impl Validator for FunctionPlainValidator {
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let r = if self.info_arg {
-            let info = ValidationInfo::new(py, state.extra(), &self.config, self.field_name.clone());
+            let field_name = state
+                .extra()
+                .field_name
+                .clone()
+                .map(Bound::unbind)
+                .or_else(|| self.field_name.clone());
+            let info = ValidationInfo::new(py, state.extra(), &self.config, field_name);
             self.func.call1(py, (input.to_object(py)?, info))
         } else {
             self.func.call1(py, (input.to_object(py)?,))
@@ -322,7 +340,13 @@ impl FunctionWrapValidator {
         state: &mut ValidationState<'_, 'py>,
     ) -> ValResult<PyObject> {
         let r = if self.info_arg {
-            let info = ValidationInfo::new(py, state.extra(), &self.config, self.field_name.clone());
+            let field_name = state
+                .extra()
+                .field_name
+                .clone()
+                .map(Bound::unbind)
+                .or_else(|| self.field_name.clone());
+            let info = ValidationInfo::new(py, state.extra(), &self.config, field_name);
             self.func.call1(py, (input.to_object(py)?, handler, info))
         } else {
             self.func.call1(py, (input.to_object(py)?, handler))
diff --git a/src/validators/generator.rs b/src/validators/generator.rs
index bc0cbd82a..12d76b3be 100644
--- a/src/validators/generator.rs
+++ b/src/validators/generator.rs
@@ -276,6 +276,7 @@ impl InternalValidator {
             data: self.data.as_ref().map(|data| data.bind(py).clone()),
             strict: self.strict,
             from_attributes: self.from_attributes,
+            field_name: Some(PyString::new(py, field_name)),
             context: self.context.as_ref().map(|data| data.bind(py)),
             self_instance: self.self_instance.as_ref().map(|data| data.bind(py)),
             cache_str: self.cache_str,
@@ -313,6 +314,7 @@ impl InternalValidator {
             data: self.data.as_ref().map(|data| data.bind(py).clone()),
             strict: self.strict,
             from_attributes: self.from_attributes,
+            field_name: None,
             context: self.context.as_ref().map(|data| data.bind(py)),
             self_instance: self.self_instance.as_ref().map(|data| data.bind(py)),
             cache_str: self.cache_str,
diff --git a/src/validators/mod.rs b/src/validators/mod.rs
index f105e1854..cd166b61b 100644
--- a/src/validators/mod.rs
+++ b/src/validators/mod.rs
@@ -311,6 +311,7 @@ impl SchemaValidator {
             data: None,
             strict,
             from_attributes,
+            field_name: Some(PyString::new(py, field_name)),
             context,
             self_instance: None,
             cache_str: self.cache_str,
@@ -337,6 +338,7 @@ impl SchemaValidator {
             data: None,
             strict,
             from_attributes: None,
+            field_name: None,
             context,
             self_instance: None,
             cache_str: self.cache_str,
@@ -678,6 +680,8 @@ pub struct Extra<'a, 'py> {
     pub from_attributes: Option<bool>,
     /// context used in validator functions
     pub context: Option<&'a Bound<'py, PyAny>>,
+    /// The name of the field being validated, if applicable
+    pub field_name: Option<Bound<'py, PyString>>,
     /// This is an instance of the model or dataclass being validated, when validation is performed from `__init__`
     self_instance: Option<&'a Bound<'py, PyAny>>,
     /// Whether to use a cache of short strings to accelerate python string construction
@@ -705,6 +709,7 @@ impl<'a, 'py> Extra<'a, 'py> {
             data: None,
             strict,
             from_attributes,
+            field_name: None,
             context,
             self_instance,
             cache_str,
@@ -721,6 +726,7 @@ impl Extra<'_, '_> {
             data: self.data.clone(),
             strict: Some(true),
             from_attributes: self.from_attributes,
+            field_name: self.field_name.clone(),
             context: self.context,
             self_instance: self.self_instance,
             cache_str: self.cache_str,
diff --git a/src/validators/model.rs b/src/validators/model.rs
index 6c93c209c..f2c3658e8 100644
--- a/src/validators/model.rs
+++ b/src/validators/model.rs
@@ -202,6 +202,7 @@ impl Validator for ModelValidator {
                     field_name.to_string(),
                 ))
             } else {
+                let state = &mut state.rebind_extra(|extra| extra.field_name = Some(PyString::new(py, ROOT_FIELD)));
                 let output = self.validator.validate(py, field_value, state)?;
 
                 force_setattr(py, model, intern!(py, ROOT_FIELD), output)?;
@@ -255,9 +256,11 @@ impl ModelValidator {
         // we need to set `self_instance` to None for nested validators as we don't want to operate on self_instance
         // anymore
         let state = &mut state.rebind_extra(|extra| extra.self_instance = None);
-        let output = self.validator.validate(py, input, state)?;
 
         if self.root_model {
+            let state = &mut state.rebind_extra(|extra| extra.field_name = Some(PyString::new(py, ROOT_FIELD)));
+            let output = self.validator.validate(py, input, state)?;
+
             let fields_set = if input.as_python().is_some_and(|py_input| py_input.is(&self.undefined)) {
                 PySet::empty(py)?
             } else {
@@ -266,6 +269,8 @@ impl ModelValidator {
             force_setattr(py, self_instance, intern!(py, DUNDER_FIELDS_SET_KEY), &fields_set)?;
             force_setattr(py, self_instance, intern!(py, ROOT_FIELD), &output)?;
         } else {
+            let output = self.validator.validate(py, input, state)?;
+
             let (model_dict, model_extra, fields_set): (Bound<PyAny>, Bound<PyAny>, Bound<PyAny>) =
                 output.extract(py)?;
             set_model_attrs(self_instance, &model_dict, &model_extra, &fields_set)?;
@@ -294,11 +299,12 @@ impl ModelValidator {
             }
         }
 
-        let output = self.validator.validate(py, input, state)?;
-
         let instance = create_class(self.class.bind(py))?;
 
         if self.root_model {
+            let state = &mut state.rebind_extra(|extra| extra.field_name = Some(PyString::new(py, ROOT_FIELD)));
+            let output = self.validator.validate(py, input, state)?;
+
             let fields_set = if input.as_python().is_some_and(|py_input| py_input.is(&self.undefined)) {
                 PySet::empty(py)?
             } else {
@@ -307,6 +313,8 @@ impl ModelValidator {
             force_setattr(py, &instance, intern!(py, DUNDER_FIELDS_SET_KEY), &fields_set)?;
             force_setattr(py, &instance, intern!(py, ROOT_FIELD), output)?;
         } else {
+            let output = self.validator.validate(py, input, state)?;
+
             let (model_dict, model_extra, val_fields_set): (Bound<PyAny>, Bound<PyAny>, Bound<PyAny>) =
                 output.extract(py)?;
             let fields_set = existing_fields_set.unwrap_or(&val_fields_set);
diff --git a/src/validators/model_fields.rs b/src/validators/model_fields.rs
index b87f671ab..10d13d7b8 100644
--- a/src/validators/model_fields.rs
+++ b/src/validators/model_fields.rs
@@ -197,6 +197,10 @@ impl Validator for ModelFieldsValidator {
                         // extra logic either way
                         used_keys.insert(lookup_path.first_key());
                     }
+
+                    let state =
+                        &mut state.rebind_extra(|extra| extra.field_name = Some(field.name_py.bind(py).clone()));
+
                     match field.validator.validate(py, value.borrow_input(), state) {
                         Ok(value) => {
                             model_dict.set_item(&field.name_py, value)?;
@@ -422,6 +426,8 @@ impl Validator for ModelFieldsValidator {
                     ));
                 }
 
+                let state = &mut state.rebind_extra(|extra| extra.field_name = Some(field.name_py.bind(py).clone()));
+
                 prepare_result(field.validator.validate(py, field_value, state))?
             } else {
                 // Handle extra (unknown) field
diff --git a/src/validators/typed_dict.rs b/src/validators/typed_dict.rs
index c9c122791..eb4394e39 100644
--- a/src/validators/typed_dict.rs
+++ b/src/validators/typed_dict.rs
@@ -218,6 +218,9 @@ impl Validator for TypedDictValidator {
                         true => allow_partial,
                         false => false.into(),
                     };
+                    let state =
+                        &mut state.rebind_extra(|extra| extra.field_name = Some(field.name_py.bind(py).clone()));
+
                     match field.validator.validate(py, value.borrow_input(), state) {
                         Ok(value) => {
                             output_dict.set_item(&field.name_py, value)?;
diff --git a/tests/benchmarks/test_micro_benchmarks.py b/tests/benchmarks/test_micro_benchmarks.py
index 5640431ae..6d36ffa8d 100644
--- a/tests/benchmarks/test_micro_benchmarks.py
+++ b/tests/benchmarks/test_micro_benchmarks.py
@@ -1348,7 +1348,7 @@ def f(v: int, info: core_schema.ValidationInfo) -> int:
     limit = pydantic_core._pydantic_core._recursion_limit - 3
 
     for _ in range(limit):
-        schema = core_schema.with_info_after_validator_function(f, schema, field_name='x')
+        schema = core_schema.with_info_after_validator_function(f, schema)
 
     schema = core_schema.typed_dict_schema({'x': core_schema.typed_dict_field(schema)})
 
diff --git a/tests/validators/test_dataclasses.py b/tests/validators/test_dataclasses.py
index cfead4423..6ae9f54f9 100644
--- a/tests/validators/test_dataclasses.py
+++ b/tests/validators/test_dataclasses.py
@@ -506,9 +506,7 @@ def validate_b(cls, v: str, info: core_schema.ValidationInfo) -> str:
                 core_schema.dataclass_field(name='a', schema=core_schema.int_schema()),
                 core_schema.dataclass_field(
                     name='b',
-                    schema=core_schema.with_info_after_validator_function(
-                        Foo.validate_b, core_schema.str_schema(), field_name='b'
-                    ),
+                    schema=core_schema.with_info_after_validator_function(Foo.validate_b, core_schema.str_schema()),
                 ),
             ],
         ),
@@ -540,7 +538,7 @@ def validate_b(cls, v: bytes, info: core_schema.ValidationInfo) -> str:
             [
                 core_schema.dataclass_field(name='a', schema=core_schema.int_schema()),
                 core_schema.dataclass_field(
-                    name='b', schema=core_schema.with_info_plain_validator_function(Foo.validate_b, field_name='b')
+                    name='b', schema=core_schema.with_info_plain_validator_function(Foo.validate_b)
                 ),
             ],
         ),
@@ -573,9 +571,7 @@ def validate_b(cls, v: bytes, info: core_schema.ValidationInfo) -> bytes:
                 core_schema.dataclass_field(name='a', schema=core_schema.int_schema()),
                 core_schema.dataclass_field(
                     name='b',
-                    schema=core_schema.with_info_before_validator_function(
-                        Foo.validate_b, core_schema.str_schema(), field_name='b'
-                    ),
+                    schema=core_schema.with_info_before_validator_function(Foo.validate_b, core_schema.str_schema()),
                 ),
             ],
         ),
@@ -612,9 +608,7 @@ def validate_b(
                 core_schema.dataclass_field(name='a', schema=core_schema.int_schema()),
                 core_schema.dataclass_field(
                     name='b',
-                    schema=core_schema.with_info_wrap_validator_function(
-                        Foo.validate_b, core_schema.str_schema(), field_name='b'
-                    ),
+                    schema=core_schema.with_info_wrap_validator_function(Foo.validate_b, core_schema.str_schema()),
                 ),
             ],
         ),
@@ -649,9 +643,7 @@ def validate_b(
                 core_schema.dataclass_field(name='a', schema=core_schema.int_schema()),
                 core_schema.dataclass_field(
                     name='b',
-                    schema=core_schema.with_info_wrap_validator_function(
-                        Foo.validate_b, core_schema.str_schema(), field_name='b'
-                    ),
+                    schema=core_schema.with_info_wrap_validator_function(Foo.validate_b, core_schema.str_schema()),
                 ),
             ],
         ),
@@ -878,9 +870,7 @@ def func(x, info):
                     core_schema.dataclass_field('field_a', core_schema.str_schema()),
                     core_schema.dataclass_field(
                         'field_b',
-                        core_schema.with_info_after_validator_function(
-                            func, core_schema.int_schema(), field_name='field_b'
-                        ),
+                        core_schema.with_info_after_validator_function(func, core_schema.int_schema()),
                     ),
                     core_schema.dataclass_field('field_c', core_schema.int_schema()),
                 ],
@@ -1295,9 +1285,7 @@ def validate_b(cls, v: bytes, info: core_schema.ValidationInfo) -> bytes:
                 core_schema.dataclass_field(name='a', schema=core_schema.int_schema()),
                 core_schema.dataclass_field(
                     name='b',
-                    schema=core_schema.with_info_before_validator_function(
-                        Foo.validate_b, core_schema.str_schema(), field_name='b'
-                    ),
+                    schema=core_schema.with_info_before_validator_function(Foo.validate_b, core_schema.str_schema()),
                 ),
             ],
         ),
@@ -1332,9 +1320,7 @@ def validate_b(cls, v: str, info: core_schema.ValidationInfo) -> str:
                 core_schema.dataclass_field(name='a', schema=core_schema.int_schema()),
                 core_schema.dataclass_field(
                     name='b',
-                    schema=core_schema.with_info_after_validator_function(
-                        Foo.validate_b, core_schema.str_schema(), field_name='b'
-                    ),
+                    schema=core_schema.with_info_after_validator_function(Foo.validate_b, core_schema.str_schema()),
                 ),
             ],
         ),
@@ -1550,15 +1536,9 @@ def _wrap_validator(cls, v, validator, info):
 
         field_schema = core_schema.int_schema()
         if validator == 'field':
-            field_schema = core_schema.with_info_before_validator_function(
-                Dataclass._validator, field_schema, field_name='a'
-            )
-            field_schema = core_schema.with_info_wrap_validator_function(
-                Dataclass._wrap_validator, field_schema, field_name='a'
-            )
-            field_schema = core_schema.with_info_after_validator_function(
-                Dataclass._validator, field_schema, field_name='a'
-            )
+            field_schema = core_schema.with_info_before_validator_function(Dataclass._validator, field_schema)
+            field_schema = core_schema.with_info_wrap_validator_function(Dataclass._wrap_validator, field_schema)
+            field_schema = core_schema.with_info_after_validator_function(Dataclass._validator, field_schema)
 
         dataclass_schema = core_schema.dataclass_schema(
             Dataclass,
diff --git a/tests/validators/test_function.py b/tests/validators/test_function.py
index 562687268..09ef7c74f 100644
--- a/tests/validators/test_function.py
+++ b/tests/validators/test_function.py
@@ -2,6 +2,7 @@
 import platform
 import re
 from copy import deepcopy
+from dataclasses import dataclass
 from typing import Any
 
 import pytest
@@ -604,7 +605,7 @@ def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
             core_schema.model_fields_schema(
                 {
                     'x': core_schema.model_field(
-                        core_schema.with_info_before_validator_function(f, core_schema.str_schema(), field_name='x')
+                        core_schema.with_info_before_validator_function(f, core_schema.str_schema())
                     )
                 }
             ),
@@ -630,7 +631,7 @@ def f(input_value: str, info: core_schema.ValidationInfo) -> Any:
             core_schema.model_fields_schema(
                 {
                     'x': core_schema.model_field(
-                        core_schema.with_info_after_validator_function(f, core_schema.str_schema(), field_name='x')
+                        core_schema.with_info_after_validator_function(f, core_schema.str_schema())
                     )
                 }
             ),
@@ -654,7 +655,7 @@ def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
         core_schema.model_schema(
             Model,
             core_schema.model_fields_schema(
-                {'x': core_schema.model_field(core_schema.with_info_plain_validator_function(f, field_name='x'))}
+                {'x': core_schema.model_field(core_schema.with_info_plain_validator_function(f))}
             ),
         )
     )
@@ -662,6 +663,39 @@ def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
     assert v.validate_python({'x': b'foo'}).x == 'input: foo'
 
 
+def test_model_field_validator_reuse() -> None:
+    class Model:
+        x: str
+        y: str
+
+    def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
+        return f'{info.field_name}: {input_value}'
+
+    # When a type alias with a validator function is used on multiple fields,
+    # its core schema is only generated once (with the first field_name) and reused.
+    # See https://github.com/pydantic/pydantic/issues/11737
+    with pytest.warns(
+        DeprecationWarning, match='`field_name` argument on `with_info_plain_validator_function` is deprecated'
+    ):
+        validator = core_schema.with_info_plain_validator_function(f, field_name='x')
+
+    v = SchemaValidator(
+        core_schema.model_schema(
+            Model,
+            core_schema.model_fields_schema(
+                {
+                    'x': core_schema.model_field(validator),
+                    'y': core_schema.model_field(validator),
+                }
+            ),
+        )
+    )
+
+    m = v.validate_python({'x': 'foo', 'y': 'bar'})
+    assert m.x == 'x: foo'
+    assert m.y == 'y: bar'
+
+
 def test_model_field_wrap_validator() -> None:
     class Model:
         x: str
@@ -678,7 +712,7 @@ def f(input_value: Any, val: core_schema.ValidatorFunctionWrapHandler, info: cor
             core_schema.model_fields_schema(
                 {
                     'x': core_schema.model_field(
-                        core_schema.with_info_wrap_validator_function(f, core_schema.str_schema(), field_name='x')
+                        core_schema.with_info_wrap_validator_function(f, core_schema.str_schema())
                     )
                 }
             ),
@@ -688,17 +722,13 @@ def f(input_value: Any, val: core_schema.ValidatorFunctionWrapHandler, info: cor
     assert v.validate_python({'x': b'foo'}).x == 'input: foo'
 
 
-def check_info_field_name_none(info: core_schema.ValidationInfo) -> None:
-    assert info.field_name is None
-    assert info.data == {}
-
-
-def test_non_model_field_before_validator_tries_to_access_field_info() -> None:
+def test_non_model_field_before_validator_field_info() -> None:
     class Model:
         x: str
 
     def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
-        check_info_field_name_none(info)
+        assert info.field_name == 'x'
+        assert info.data == {}
         assert isinstance(input_value, bytes)
         return f'input: {input_value.decode()}'
 
@@ -718,12 +748,13 @@ def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
     assert v.validate_python({'x': b'foo'}).x == 'input: foo'
 
 
-def test_non_model_field_after_validator_tries_to_access_field_info() -> None:
+def test_non_model_field_after_validator_field_info() -> None:
     class Model:
         x: str
 
     def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
-        check_info_field_name_none(info)
+        assert info.field_name == 'x'
+        assert info.data == {}
         return f'input: {input_value}'
 
     v = SchemaValidator(
@@ -742,12 +773,13 @@ def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
     assert v.validate_python({'x': b'foo'}).x == 'input: foo'
 
 
-def test_non_model_field_plain_validator_tries_to_access_field_info() -> None:
+def test_non_model_field_plain_validator_field_info() -> None:
     class Model:
         x: str
 
     def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
-        check_info_field_name_none(info)
+        assert info.field_name == 'x'
+        assert info.data == {}
         assert isinstance(input_value, bytes)
         return f'input: {input_value.decode()}'
 
@@ -763,13 +795,14 @@ def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
     assert v.validate_python({'x': b'foo'}).x == 'input: foo'
 
 
-def test_non_model_field_wrap_validator_tries_to_access_field_info() -> None:
+def test_non_model_field_wrap_validator_field_info() -> None:
     class Model:
         __slots__ = '__dict__', '__pydantic_fields_set__', '__pydantic_extra__', '__pydantic_private__'
         x: str
 
     def f(input_value: Any, val: core_schema.ValidatorFunctionWrapHandler, info: core_schema.ValidationInfo) -> Any:
-        check_info_field_name_none(info)
+        assert info.field_name == 'x'
+        assert info.data == {}
         return f'input: {val(input_value)}'
 
     v = SchemaValidator(
@@ -803,7 +836,7 @@ def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
                 'a': core_schema.typed_dict_field(core_schema.int_schema()),
                 'b': core_schema.typed_dict_field(core_schema.int_schema()),
                 'c': core_schema.typed_dict_field(
-                    core_schema.with_info_after_validator_function(f, core_schema.str_schema(), field_name='c')
+                    core_schema.with_info_after_validator_function(f, core_schema.str_schema())
                 ),
             }
         )
@@ -821,6 +854,68 @@ def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
     assert info_stuff == {'field_name': 'c', 'data': {'a': 1}}
 
 
+def test_typed_dict_validator_reuse() -> None:
+    def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
+        return f'{info.field_name}: {input_value}'
+
+    # When a type alias with a validator function is used on multiple fields,
+    # its core schema is only generated once (with the first field_name) and reused.
+    # See https://github.com/pydantic/pydantic/issues/11737
+    with pytest.warns(
+        DeprecationWarning, match='`field_name` argument on `with_info_plain_validator_function` is deprecated'
+    ):
+        validator = core_schema.with_info_plain_validator_function(f, field_name='x')
+
+    v = SchemaValidator(
+        core_schema.typed_dict_schema(
+            {
+                'x': core_schema.model_field(validator),
+                'y': core_schema.model_field(validator),
+            }
+        )
+    )
+
+    data = v.validate_python({'x': 'foo', 'y': 'bar'})
+    assert data['x'] == 'x: foo'
+    assert data['y'] == 'y: bar'
+
+
+def test_dataclass_validator_reuse() -> None:
+    @dataclass
+    class Model:
+        x: str
+        y: str
+
+    def f(input_value: Any, info: core_schema.ValidationInfo) -> Any:
+        return f'{info.field_name}: {input_value}'
+
+    # When a type alias with a validator function is used on multiple fields,
+    # its core schema is only generated once (with the first field_name) and reused.
+    # See https://github.com/pydantic/pydantic/issues/11737
+    with pytest.warns(
+        DeprecationWarning, match='`field_name` argument on `with_info_plain_validator_function` is deprecated'
+    ):
+        validator = core_schema.with_info_plain_validator_function(f, field_name='x')
+
+    v = SchemaValidator(
+        core_schema.dataclass_schema(
+            Model,
+            core_schema.dataclass_args_schema(
+                'Model',
+                [
+                    core_schema.dataclass_field(name='x', schema=validator),
+                    core_schema.dataclass_field(name='y', schema=validator),
+                ],
+            ),
+            ['x', 'y'],
+        )
+    )
+
+    m = v.validate_python({'x': 'foo', 'y': 'bar'})
+    assert m.x == 'x: foo'
+    assert m.y == 'y: bar'
+
+
 @pytest.mark.parametrize(
     'mode,calls1,calls2',
     [
@@ -916,35 +1011,6 @@ def f_w(v: Any, handler: core_schema.ValidatorFunctionWrapHandler, info: core_sc
     calls.clear()
 
 
-def test_reprs() -> None:
-    reprs: list[str] = []
-
-    def sample_repr(v: Any, info: core_schema.ValidationInfo) -> Any:
-        reprs.append(repr(info))
-        return v
-
-    v = SchemaValidator(
-        core_schema.chain_schema(
-            [
-                core_schema.with_info_plain_validator_function(sample_repr),
-                core_schema.with_info_plain_validator_function(sample_repr, field_name='x'),
-            ]
-        )
-    )
-
-    class Foo:
-        def __repr__(self) -> str:
-            return 'This is Foo!'
-
-    v.validate_python(Foo())
-
-    # insert_assert(reprs)
-    assert reprs == [
-        'ValidationInfo(config=None, context=None, data=None, field_name=None)',
-        "ValidationInfo(config=None, context=None, data=None, field_name='x')",
-    ]
-
-
 def test_function_after_doesnt_change_mode() -> None:
     # https://github.com/pydantic/pydantic/issues/7468 - function-after was
     # incorrectly forcing Python validation mode
diff --git a/tests/validators/test_model.py b/tests/validators/test_model.py
index 2ce2c0a56..253b8a734 100644
--- a/tests/validators/test_model.py
+++ b/tests/validators/test_model.py
@@ -1054,9 +1054,7 @@ def func(x, info):
                 {
                     'field_a': core_schema.model_field(core_schema.str_schema()),
                     'field_b': core_schema.model_field(
-                        core_schema.with_info_after_validator_function(
-                            func, core_schema.int_schema(), field_name='field_b'
-                        )
+                        core_schema.with_info_after_validator_function(func, core_schema.int_schema())
                     ),
                     'field_c': core_schema.model_field(core_schema.int_schema()),
                 }
@@ -1145,17 +1143,17 @@ class MyModel:
         (
             core_schema.with_info_after_validator_function,
             (({'a': 1, 'b': 2}, None, {'b'}), 'ValidationInfo(config=None, context=None, data=None, field_name=None)'),
-            (({'a': 10, 'b': 2}, None, {'a'}), 'ValidationInfo(config=None, context=None, data=None, field_name=None)'),
+            (({'a': 10, 'b': 2}, None, {'a'}), "ValidationInfo(config=None, context=None, data=None, field_name='a')"),
         ),
         (
             core_schema.with_info_before_validator_function,
             ({'b': 2}, 'ValidationInfo(config=None, context=None, data=None, field_name=None)'),
-            ({'a': 10, 'b': 2}, 'ValidationInfo(config=None, context=None, data=None, field_name=None)'),
+            ({'a': 10, 'b': 2}, "ValidationInfo(config=None, context=None, data=None, field_name='a')"),
         ),
         (
             core_schema.with_info_wrap_validator_function,
             ({'b': 2}, 'ValidationInfo(config=None, context=None, data=None, field_name=None)'),
-            ({'a': 10, 'b': 2}, 'ValidationInfo(config=None, context=None, data=None, field_name=None)'),
+            ({'a': 10, 'b': 2}, "ValidationInfo(config=None, context=None, data=None, field_name='a')"),
         ),
     ],
 )
diff --git a/tests/validators/test_model_init.py b/tests/validators/test_model_init.py
index 08f13ac54..463a9a48a 100644
--- a/tests/validators/test_model_init.py
+++ b/tests/validators/test_model_init.py
@@ -430,15 +430,9 @@ def _wrap_validator(cls, v, validator, info):
 
         field_schema = core_schema.int_schema()
         if validator == 'field':
-            field_schema = core_schema.with_info_before_validator_function(
-                Model._validator, field_schema, field_name='a'
-            )
-            field_schema = core_schema.with_info_wrap_validator_function(
-                Model._wrap_validator, field_schema, field_name='a'
-            )
-            field_schema = core_schema.with_info_after_validator_function(
-                Model._validator, field_schema, field_name='a'
-            )
+            field_schema = core_schema.with_info_before_validator_function(Model._validator, field_schema)
+            field_schema = core_schema.with_info_wrap_validator_function(Model._wrap_validator, field_schema)
+            field_schema = core_schema.with_info_after_validator_function(Model._validator, field_schema)
 
         model_schema = core_schema.model_schema(
             Model, core_schema.model_fields_schema({'a': core_schema.model_field(field_schema)})
diff --git a/tests/validators/test_model_root.py b/tests/validators/test_model_root.py
index 4e0a55048..96e492c4d 100644
--- a/tests/validators/test_model_root.py
+++ b/tests/validators/test_model_root.py
@@ -138,7 +138,7 @@ def f(input_value: str, info):
     v = SchemaValidator(
         core_schema.model_schema(
             RootModel,
-            core_schema.with_info_after_validator_function(f, core_schema.str_schema(), field_name='root'),
+            core_schema.with_info_after_validator_function(f, core_schema.str_schema()),
             root_model=True,
         )
     )

From 60bccf17b1c147875adacd8f6eea85dfe4dff4e8 Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Thu, 17 Apr 2025 16:22:49 +0200
Subject: [PATCH 528/550] Bump version to v2.34.0 (#1694)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index bbfc4f5b8..e1d351596 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -424,7 +424,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.33.1"
+version = "2.34.0"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index 91fefc4ef..b5d0a1bb1 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.33.1"
+version = "2.34.0"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From 0d034502ab205649c509b72258c5ff8417d389c5 Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Thu, 17 Apr 2025 18:06:13 +0200
Subject: [PATCH 529/550] Fix CI condition for `release` job (#1695)

---
 .github/workflows/ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 7ba7247a2..5b359a799 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -660,7 +660,7 @@ jobs:
 
   release:
     needs: [test-builds-arch, test-builds-os, build-sdist, check]
-    if: success() && startsWith(github.ref, 'refs/tags/')
+    if: startsWith(github.ref, 'refs/tags/')
     runs-on: ubuntu-latest
 
     steps:

From 2bcce9fca3d1fede5e62cd14af5b737ab706dc45 Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Thu, 17 Apr 2025 18:41:14 +0200
Subject: [PATCH 530/550] Fix CI condition for `release` job x2 (#1696)

---
 .github/workflows/ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 5b359a799..e6758d61b 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -660,7 +660,7 @@ jobs:
 
   release:
     needs: [test-builds-arch, test-builds-os, build-sdist, check]
-    if: startsWith(github.ref, 'refs/tags/')
+    if: always() && startsWith(github.ref, 'refs/tags/')
     runs-on: ubuntu-latest
 
     steps:

From 5bb2d6273df3a25a0fefe476fe400c3ef3afcb11 Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Thu, 17 Apr 2025 21:59:07 +0200
Subject: [PATCH 531/550] Mark some tests as xfailing on free-threaded (#1697)

---
 tests/conftest.py                     | 8 +++++++-
 tests/test_garbage_collection.py      | 4 +++-
 tests/validators/test_dataclasses.py  | 3 ++-
 tests/validators/test_model_init.py   | 3 ++-
 tests/validators/test_with_default.py | 3 ++-
 5 files changed, 16 insertions(+), 5 deletions(-)

diff --git a/tests/conftest.py b/tests/conftest.py
index 226ace018..e9079c8ba 100644
--- a/tests/conftest.py
+++ b/tests/conftest.py
@@ -6,6 +6,7 @@
 import json
 import os
 import re
+import sys
 from dataclasses import dataclass
 from pathlib import Path
 from time import sleep, time
@@ -17,12 +18,17 @@
 from pydantic_core import ArgsKwargs, CoreSchema, SchemaValidator, ValidationError, validate_core_schema
 from pydantic_core.core_schema import CoreConfig
 
-__all__ = 'Err', 'PyAndJson', 'plain_repr', 'infinite_generator'
+__all__ = 'Err', 'PyAndJson', 'assert_gc', 'is_free_threaded', 'plain_repr', 'infinite_generator'
 
 hypothesis.settings.register_profile('fast', max_examples=2)
 hypothesis.settings.register_profile('slow', max_examples=1_000)
 hypothesis.settings.load_profile(os.getenv('HYPOTHESIS_PROFILE', 'fast'))
 
+try:
+    is_free_threaded = not sys._is_gil_enabled()
+except AttributeError:
+    is_free_threaded = False
+
 
 def plain_repr(obj):
     r = repr(obj)
diff --git a/tests/test_garbage_collection.py b/tests/test_garbage_collection.py
index 2213f7cfb..c129c0e34 100644
--- a/tests/test_garbage_collection.py
+++ b/tests/test_garbage_collection.py
@@ -7,7 +7,7 @@
 
 from pydantic_core import SchemaSerializer, SchemaValidator, core_schema
 
-from .conftest import assert_gc
+from .conftest import assert_gc, is_free_threaded
 
 GC_TEST_SCHEMA_INNER = core_schema.definitions_schema(
     core_schema.definition_reference_schema(schema_ref='model'),
@@ -20,6 +20,7 @@
 )
 
 
+@pytest.mark.xfail(is_free_threaded, reason='GC leaks on free-threaded')
 @pytest.mark.xfail(
     condition=platform.python_implementation() == 'PyPy', reason='https://foss.heptapod.net/pypy/pypy/-/issues/3899'
 )
@@ -47,6 +48,7 @@ class MyModel(BaseModel):
     assert_gc(lambda: len(cache) == 0)
 
 
+@pytest.mark.xfail(is_free_threaded, reason='GC leaks on free-threaded')
 @pytest.mark.xfail(
     condition=platform.python_implementation() == 'PyPy', reason='https://foss.heptapod.net/pypy/pypy/-/issues/3899'
 )
diff --git a/tests/validators/test_dataclasses.py b/tests/validators/test_dataclasses.py
index 6ae9f54f9..da4105a55 100644
--- a/tests/validators/test_dataclasses.py
+++ b/tests/validators/test_dataclasses.py
@@ -10,7 +10,7 @@
 
 from pydantic_core import ArgsKwargs, SchemaValidator, ValidationError, core_schema
 
-from ..conftest import Err, PyAndJson, assert_gc
+from ..conftest import Err, PyAndJson, assert_gc, is_free_threaded
 
 
 @pytest.mark.parametrize(
@@ -1516,6 +1516,7 @@ def test_dataclass_wrap_json():
     assert v.validate_json('{"a": "hello", "b": true}', strict=True) == FooDataclass(a='hello', b=True)
 
 
+@pytest.mark.xfail(is_free_threaded, reason='GC leaks on free-threaded')
 @pytest.mark.xfail(
     condition=platform.python_implementation() == 'PyPy', reason='https://foss.heptapod.net/pypy/pypy/-/issues/3899'
 )
diff --git a/tests/validators/test_model_init.py b/tests/validators/test_model_init.py
index 463a9a48a..ccc427800 100644
--- a/tests/validators/test_model_init.py
+++ b/tests/validators/test_model_init.py
@@ -6,7 +6,7 @@
 
 from pydantic_core import CoreConfig, SchemaValidator, core_schema
 
-from ..conftest import assert_gc
+from ..conftest import assert_gc, is_free_threaded
 
 
 class MyModel:
@@ -411,6 +411,7 @@ def __init__(self, **kwargs):
     assert calls == ["{'a': '1'}", "{'a': '1', 'x': 4}"]
 
 
+@pytest.mark.xfail(is_free_threaded, reason='GC leaks on free-threaded')
 @pytest.mark.xfail(
     condition=platform.python_implementation() == 'PyPy', reason='https://foss.heptapod.net/pypy/pypy/-/issues/3899'
 )
diff --git a/tests/validators/test_with_default.py b/tests/validators/test_with_default.py
index 2b092d066..ca9b5802d 100644
--- a/tests/validators/test_with_default.py
+++ b/tests/validators/test_with_default.py
@@ -16,7 +16,7 @@
     core_schema,
 )
 
-from ..conftest import PyAndJson, assert_gc
+from ..conftest import PyAndJson, assert_gc, is_free_threaded
 
 
 def test_typed_dict_default():
@@ -636,6 +636,7 @@ def val_func(v: Any, handler: core_schema.ValidatorFunctionWrapHandler) -> Any:
         validator.validate_python('')
 
 
+@pytest.mark.xfail(is_free_threaded, reason='GC leaks on free-threaded')
 @pytest.mark.xfail(
     condition=platform.python_implementation() == 'PyPy', reason='https://foss.heptapod.net/pypy/pypy/-/issues/3899'
 )

From 34147034f64bff6bd7a240e1475c4faacc3c9b4e Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Thu, 17 Apr 2025 22:08:18 +0200
Subject: [PATCH 532/550] Bump version to v2.34.1 (#1698)

---
 Cargo.lock | 2 +-
 Cargo.toml | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index e1d351596..3bbb1c03f 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -424,7 +424,7 @@ dependencies = [
 
 [[package]]
 name = "pydantic-core"
-version = "2.34.0"
+version = "2.34.1"
 dependencies = [
  "ahash",
  "base64",
diff --git a/Cargo.toml b/Cargo.toml
index b5d0a1bb1..40d1fe90d 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -1,6 +1,6 @@
 [package]
 name = "pydantic-core"
-version = "2.34.0"
+version = "2.34.1"
 edition = "2021"
 license = "MIT"
 homepage = "https://github.com/pydantic/pydantic-core"

From 334a9b0f302b6eeca9f808496ae2a095aeb20dc9 Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Wed, 23 Apr 2025 19:44:39 +0200
Subject: [PATCH 533/550] Do not reuse validator and serializer when unpickling
 (#1693)

---
 src/serializers/mod.rs             |  4 +--
 src/serializers/shared.rs          | 23 +++++++++++++++---
 src/validators/mod.rs              | 39 +++++++++++++++++++++++-------
 tests/serializers/test_pickling.py | 23 ++++++++++++++++++
 tests/validators/test_pickling.py  | 23 ++++++++++++++++++
 5 files changed, 97 insertions(+), 15 deletions(-)

diff --git a/src/serializers/mod.rs b/src/serializers/mod.rs
index 434b43c53..5516f81e1 100644
--- a/src/serializers/mod.rs
+++ b/src/serializers/mod.rs
@@ -14,7 +14,7 @@ pub use errors::{PydanticSerializationError, PydanticSerializationUnexpectedValu
 use extra::{CollectWarnings, SerRecursionState, WarningsMode};
 pub(crate) use extra::{DuckTypingSerMode, Extra, SerMode, SerializationState};
 pub use shared::CombinedSerializer;
-use shared::{to_json_bytes, BuildSerializer, TypeSerializer};
+use shared::{to_json_bytes, TypeSerializer};
 
 mod computed_fields;
 mod config;
@@ -91,7 +91,7 @@ impl SchemaSerializer {
     #[pyo3(signature = (schema, config=None))]
     pub fn py_new(schema: Bound<'_, PyDict>, config: Option<&Bound<'_, PyDict>>) -> PyResult<Self> {
         let mut definitions_builder = DefinitionsBuilder::new();
-        let serializer = CombinedSerializer::build(schema.downcast()?, config, &mut definitions_builder)?;
+        let serializer = CombinedSerializer::build_base(schema.downcast()?, config, &mut definitions_builder)?;
         Ok(Self {
             serializer,
             definitions: definitions_builder.finish()?,
diff --git a/src/serializers/shared.rs b/src/serializers/shared.rs
index f7a018749..e28ae9cee 100644
--- a/src/serializers/shared.rs
+++ b/src/serializers/shared.rs
@@ -149,10 +149,21 @@ combined_serializer! {
 }
 
 impl CombinedSerializer {
+    // Used when creating the base serializer instance, to avoid reusing the instance
+    // when unpickling:
+    pub fn build_base(
+        schema: &Bound<'_, PyDict>,
+        config: Option<&Bound<'_, PyDict>>,
+        definitions: &mut DefinitionsBuilder<CombinedSerializer>,
+    ) -> PyResult<CombinedSerializer> {
+        Self::_build(schema, config, definitions, false)
+    }
+
     fn _build(
         schema: &Bound<'_, PyDict>,
         config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
+        use_prebuilt: bool,
     ) -> PyResult<CombinedSerializer> {
         let py = schema.py();
         let type_key = intern!(py, "type");
@@ -199,9 +210,13 @@ impl CombinedSerializer {
         let type_: Bound<'_, PyString> = schema.get_as_req(type_key)?;
         let type_ = type_.to_str()?;
 
-        // if we have a SchemaValidator on the type already, use it
-        if let Ok(Some(prebuilt_serializer)) = super::prebuilt::PrebuiltSerializer::try_get_from_schema(type_, schema) {
-            return Ok(prebuilt_serializer);
+        if use_prebuilt {
+            // if we have a SchemaValidator on the type already, use it
+            if let Ok(Some(prebuilt_serializer)) =
+                super::prebuilt::PrebuiltSerializer::try_get_from_schema(type_, schema)
+            {
+                return Ok(prebuilt_serializer);
+            }
         }
 
         Self::find_serializer(type_, schema, config, definitions)
@@ -217,7 +232,7 @@ impl BuildSerializer for CombinedSerializer {
         config: Option<&Bound<'_, PyDict>>,
         definitions: &mut DefinitionsBuilder<CombinedSerializer>,
     ) -> PyResult<CombinedSerializer> {
-        Self::_build(schema, config, definitions)
+        Self::_build(schema, config, definitions, true)
     }
 }
 
diff --git a/src/validators/mod.rs b/src/validators/mod.rs
index cd166b61b..0e497f634 100644
--- a/src/validators/mod.rs
+++ b/src/validators/mod.rs
@@ -127,7 +127,7 @@ impl SchemaValidator {
     pub fn py_new(py: Python, schema: &Bound<'_, PyAny>, config: Option<&Bound<'_, PyDict>>) -> PyResult<Self> {
         let mut definitions_builder = DefinitionsBuilder::new();
 
-        let validator = build_validator(schema, config, &mut definitions_builder)?;
+        let validator = build_validator_base(schema, config, &mut definitions_builder)?;
         let definitions = definitions_builder.finish()?;
         let py_schema = schema.clone().unbind();
         let py_config = match config {
@@ -159,11 +159,6 @@ impl SchemaValidator {
         })
     }
 
-    pub fn __reduce__<'py>(slf: &Bound<'py, Self>) -> PyResult<(Bound<'py, PyType>, Bound<'py, PyTuple>)> {
-        let init_args = (&slf.get().py_schema, &slf.get().py_config).into_pyobject(slf.py())?;
-        Ok((slf.get_type(), init_args))
-    }
-
     #[allow(clippy::too_many_arguments)]
     #[pyo3(signature = (input, *, strict=None, from_attributes=None, context=None, self_instance=None, allow_partial=PartialMode::Off, by_alias=None, by_name=None))]
     pub fn validate_python(
@@ -357,6 +352,11 @@ impl SchemaValidator {
         }
     }
 
+    pub fn __reduce__<'py>(slf: &Bound<'py, Self>) -> PyResult<(Bound<'py, PyType>, Bound<'py, PyTuple>)> {
+        let init_args = (&slf.get().py_schema, &slf.get().py_config).into_pyobject(slf.py())?;
+        Ok((slf.get_type(), init_args))
+    }
+
     pub fn __repr__(&self, py: Python) -> String {
         format!(
             "SchemaValidator(title={:?}, validator={:#?}, definitions={:#?}, cache_strings={})",
@@ -555,19 +555,40 @@ macro_rules! validator_match {
     };
 }
 
+// Used when creating the base validator instance, to avoid reusing the instance
+// when unpickling:
+pub fn build_validator_base(
+    schema: &Bound<'_, PyAny>,
+    config: Option<&Bound<'_, PyDict>>,
+    definitions: &mut DefinitionsBuilder<CombinedValidator>,
+) -> PyResult<CombinedValidator> {
+    build_validator_inner(schema, config, definitions, false)
+}
+
 pub fn build_validator(
     schema: &Bound<'_, PyAny>,
     config: Option<&Bound<'_, PyDict>>,
     definitions: &mut DefinitionsBuilder<CombinedValidator>,
+) -> PyResult<CombinedValidator> {
+    build_validator_inner(schema, config, definitions, true)
+}
+
+fn build_validator_inner(
+    schema: &Bound<'_, PyAny>,
+    config: Option<&Bound<'_, PyDict>>,
+    definitions: &mut DefinitionsBuilder<CombinedValidator>,
+    use_prebuilt: bool,
 ) -> PyResult<CombinedValidator> {
     let dict = schema.downcast::<PyDict>()?;
     let py = schema.py();
     let type_: Bound<'_, PyString> = dict.get_as_req(intern!(py, "type"))?;
     let type_ = type_.to_str()?;
 
-    // if we have a SchemaValidator on the type already, use it
-    if let Ok(Some(prebuilt_validator)) = prebuilt::PrebuiltValidator::try_get_from_schema(type_, dict) {
-        return Ok(prebuilt_validator);
+    if use_prebuilt {
+        // if we have a SchemaValidator on the type already, use it
+        if let Ok(Some(prebuilt_validator)) = prebuilt::PrebuiltValidator::try_get_from_schema(type_, dict) {
+            return Ok(prebuilt_validator);
+        }
     }
 
     validator_match!(
diff --git a/tests/serializers/test_pickling.py b/tests/serializers/test_pickling.py
index 2ca230313..208cafbd9 100644
--- a/tests/serializers/test_pickling.py
+++ b/tests/serializers/test_pickling.py
@@ -48,3 +48,26 @@ def test_schema_serializer_containing_config():
     assert s.to_python(timedelta(seconds=4, microseconds=500_000)) == timedelta(seconds=4, microseconds=500_000)
     assert s.to_python(timedelta(seconds=4, microseconds=500_000), mode='json') == 4.5
     assert s.to_json(timedelta(seconds=4, microseconds=500_000)) == b'4.5'
+
+
+# Should be defined at the module level for pickling to work:
+class Model:
+    __pydantic_serializer__: SchemaSerializer
+    __pydantic_complete__ = True
+
+
+def test_schema_serializer_not_reused_when_unpickling() -> None:
+    s = SchemaSerializer(
+        core_schema.model_schema(
+            cls=Model,
+            schema=core_schema.model_fields_schema(fields={}, model_name='Model'),
+            config={'title': 'Model'},
+            ref='Model:123',
+        )
+    )
+
+    Model.__pydantic_serializer__ = s
+    assert 'Prebuilt' not in str(Model.__pydantic_serializer__)
+
+    reconstructed = pickle.loads(pickle.dumps(Model.__pydantic_serializer__))
+    assert 'Prebuilt' not in str(reconstructed)
diff --git a/tests/validators/test_pickling.py b/tests/validators/test_pickling.py
index 2037ab8c9..b46c57029 100644
--- a/tests/validators/test_pickling.py
+++ b/tests/validators/test_pickling.py
@@ -51,3 +51,26 @@ def test_schema_validator_tz_pickle() -> None:
     validated = v.validate_python('2022-06-08T12:13:14-12:15')
     assert validated == original
     assert pickle.loads(pickle.dumps(validated)) == validated == original
+
+
+# Should be defined at the module level for pickling to work:
+class Model:
+    __pydantic_validator__: SchemaValidator
+    __pydantic_complete__ = True
+
+
+def test_schema_validator_not_reused_when_unpickling() -> None:
+    s = SchemaValidator(
+        core_schema.model_schema(
+            cls=Model,
+            schema=core_schema.model_fields_schema(fields={}, model_name='Model'),
+            config={'title': 'Model'},
+            ref='Model:123',
+        )
+    )
+
+    Model.__pydantic_validator__ = s
+    assert 'Prebuilt' not in str(Model.__pydantic_validator__)
+
+    reconstructed = pickle.loads(pickle.dumps(Model.__pydantic_validator__))
+    assert 'Prebuilt' not in str(reconstructed)

From fc2d1e3e9ae9a9acd3fd7aaf225ac6a7cfd7dc77 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 2 May 2025 09:48:43 +0200
Subject: [PATCH 534/550] Bump serde from 1.0.218 to 1.0.219 (#1703)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 8 ++++----
 Cargo.toml | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index 3bbb1c03f..cc89583ec 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -580,18 +580,18 @@ checksum = "f3cb5ba0dc43242ce17de99c180e96db90b235b8a9fdc9543c96d2209116bd9f"
 
 [[package]]
 name = "serde"
-version = "1.0.218"
+version = "1.0.219"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e8dfc9d19bdbf6d17e22319da49161d5d0108e4188e8b680aef6299eed22df60"
+checksum = "5f0e2c6ed6606019b4e29e69dbaba95b11854410e5347d525002456dbbb786b6"
 dependencies = [
  "serde_derive",
 ]
 
 [[package]]
 name = "serde_derive"
-version = "1.0.218"
+version = "1.0.219"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f09503e191f4e797cb8aac08e9a4a4695c5edf6a2e70e376d961ddd5c969f82b"
+checksum = "5b0276cf7f2c73365f7157c8123c21cd9a50fbbd844757af28ca1f5925fc2a00"
 dependencies = [
  "proc-macro2",
  "quote",
diff --git a/Cargo.toml b/Cargo.toml
index 40d1fe90d..9ceb062b7 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -35,7 +35,7 @@ strum = { version = "0.26.3", features = ["derive"] }
 strum_macros = "0.26.4"
 serde_json = {version = "1.0.140", features = ["arbitrary_precision", "preserve_order"]}
 enum_dispatch = "0.3.13"
-serde = { version = "1.0.218", features = ["derive"] }
+serde = { version = "1.0.219", features = ["derive"] }
 speedate = "0.15.0"
 smallvec = "1.14.0"
 ahash = "0.8.10"

From e8ee342b3b7e64e732bd2bd2d04e1c107c6c1c8b Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 2 May 2025 09:49:01 +0200
Subject: [PATCH 535/550] Bump pyo3 from 0.24.1 to 0.24.2 (#1704)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index cc89583ec..bb7b726fc 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -450,9 +450,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.24.1"
+version = "0.24.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "17da310086b068fbdcefbba30aeb3721d5bb9af8db4987d6735b2183ca567229"
+checksum = "e5203598f366b11a02b13aa20cab591229ff0a89fd121a308a5df751d5fc9219"
 dependencies = [
  "cfg-if",
  "indoc",
@@ -469,9 +469,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.24.1"
+version = "0.24.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e27165889bd793000a098bb966adc4300c312497ea25cf7a690a9f0ac5aa5fc1"
+checksum = "99636d423fa2ca130fa5acde3059308006d46f98caac629418e53f7ebb1e9999"
 dependencies = [
  "once_cell",
  "python3-dll-a",
@@ -480,9 +480,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.24.1"
+version = "0.24.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "05280526e1dbf6b420062f3ef228b78c0c54ba94e157f5cb724a609d0f2faabc"
+checksum = "78f9cf92ba9c409279bc3305b5409d90db2d2c22392d443a87df3a1adad59e33"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -490,9 +490,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.24.1"
+version = "0.24.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5c3ce5686aa4d3f63359a5100c62a127c9f15e8398e5fdeb5deef1fed5cd5f44"
+checksum = "0b999cb1a6ce21f9a6b147dcf1be9ffedf02e0043aec74dc390f3007047cecd9"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -502,9 +502,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.24.1"
+version = "0.24.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "f4cf6faa0cbfb0ed08e89beb8103ae9724eb4750e3a78084ba4017cbe94f3855"
+checksum = "822ece1c7e1012745607d5cf0bcb2874769f0f7cb34c4cde03b9358eb9ef911a"
 dependencies = [
  "heck",
  "proc-macro2",

From 7347eb4d15d0d1e5fc6ea69af02c4b5740a375ac Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 2 May 2025 09:49:13 +0200
Subject: [PATCH 536/550] Bump smallvec from 1.14.0 to 1.15.0 (#1705)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 Cargo.lock | 4 ++--
 Cargo.toml | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index bb7b726fc..db9b19775 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -613,9 +613,9 @@ dependencies = [
 
 [[package]]
 name = "smallvec"
-version = "1.14.0"
+version = "1.15.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7fcf8323ef1faaee30a44a340193b1ac6814fd9b7b4e88e9d4519a3e4abe1cfd"
+checksum = "8917285742e9f3e1683f0a9c4e6b57960b7314d0b08d30d1ecd426713ee2eee9"
 
 [[package]]
 name = "speedate"
diff --git a/Cargo.toml b/Cargo.toml
index 9ceb062b7..57cc42d6b 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -37,7 +37,7 @@ serde_json = {version = "1.0.140", features = ["arbitrary_precision", "preserve_
 enum_dispatch = "0.3.13"
 serde = { version = "1.0.219", features = ["derive"] }
 speedate = "0.15.0"
-smallvec = "1.14.0"
+smallvec = "1.15.0"
 ahash = "0.8.10"
 url = "2.5.4"
 # idna is already required by url, added here to be explicit

From bc2f98cb8c63d79986ec515f8c09019cc533c03e Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 2 May 2025 09:50:58 +0200
Subject: [PATCH 537/550] Bump astral-sh/setup-uv from 5 to 6 (#1706)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/ci.yml       | 20 ++++++++++----------
 .github/workflows/codspeed.yml |  2 +-
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index e6758d61b..6a1b376e8 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -32,7 +32,7 @@ jobs:
       - run: rustup component add llvm-tools-preview
 
       - name: install uv
-        uses: astral-sh/setup-uv@v5
+        uses: astral-sh/setup-uv@v6
 
       - name: install deps
         run: uv sync --group testing
@@ -89,7 +89,7 @@ jobs:
           key: test-v3
 
       - name: install uv
-        uses: astral-sh/setup-uv@v5
+        uses: astral-sh/setup-uv@v6
         with:
           python-version: ${{ matrix.python-version }}
 
@@ -127,7 +127,7 @@ jobs:
         uses: Swatinem/rust-cache@v2
 
       - name: install uv
-        uses: astral-sh/setup-uv@v5
+        uses: astral-sh/setup-uv@v6
 
       - name: install deps
         run: uv sync --group testing
@@ -150,7 +150,7 @@ jobs:
       - uses: actions/checkout@v4
 
       - name: install uv
-        uses: astral-sh/setup-uv@v5
+        uses: astral-sh/setup-uv@v6
 
       - name: install deps
         run: uv sync --group testing
@@ -193,7 +193,7 @@ jobs:
       - uses: actions/checkout@v4
 
       - name: install uv
-        uses: astral-sh/setup-uv@v5
+        uses: astral-sh/setup-uv@v6
         with:
           python-version: ${{ matrix.python-version }}
 
@@ -232,7 +232,7 @@ jobs:
         uses: Swatinem/rust-cache@v2
 
       - name: install uv
-        uses: astral-sh/setup-uv@v5
+        uses: astral-sh/setup-uv@v6
 
       - name: install deps
         run: |
@@ -274,7 +274,7 @@ jobs:
           node-version: '18'
 
       - name: install uv
-        uses: astral-sh/setup-uv@v5
+        uses: astral-sh/setup-uv@v6
 
       - name: install deps
         run: |
@@ -334,7 +334,7 @@ jobs:
           actions-cache-folder: emsdk-cache
 
       - name: install uv
-        uses: astral-sh/setup-uv@v5
+        uses: astral-sh/setup-uv@v6
 
       - name: install deps
         run: uv sync --group wasm
@@ -525,7 +525,7 @@ jobs:
       - uses: actions/checkout@v4
 
       - name: install uv
-        uses: astral-sh/setup-uv@v5
+        uses: astral-sh/setup-uv@v6
         with:
           python-version: ${{ matrix.interpreter }}
 
@@ -645,7 +645,7 @@ jobs:
       - uses: actions/checkout@v4
 
       - name: install uv
-        uses: astral-sh/setup-uv@v5
+        uses: astral-sh/setup-uv@v6
 
       - name: get dist artifacts
         uses: actions/download-artifact@v4
diff --git a/.github/workflows/codspeed.yml b/.github/workflows/codspeed.yml
index 3a4f2302a..03ba7a657 100644
--- a/.github/workflows/codspeed.yml
+++ b/.github/workflows/codspeed.yml
@@ -26,7 +26,7 @@ jobs:
           python-version: ${{ env.UV_PYTHON}}
 
       - name: install uv
-        uses: astral-sh/setup-uv@v5
+        uses: astral-sh/setup-uv@v6
         with:
           enable-cache: true
 

From d03bf4a01ca3b378cc8590bd481f307e82115bc6 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Fri, 2 May 2025 09:51:13 +0200
Subject: [PATCH 538/550] Bump uraimo/run-on-arch-action from 3.0.0 to 3.0.1
 (#1707)

Signed-off-by: dependabot[bot] <support@github.com>
Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com>
---
 .github/workflows/ci.yml | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 6a1b376e8..6392972cb 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -605,7 +605,7 @@ jobs:
           merge-multiple: true
           path: dist
 
-      - uses: uraimo/run-on-arch-action@v3.0.0
+      - uses: uraimo/run-on-arch-action@v3.0.1
         name: install & test
         with:
           arch: ${{ matrix.target }}

From f0106b913c5f2e3873ea27a552ff581e3ff4fb6c Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Fri, 16 May 2025 15:08:30 +0200
Subject: [PATCH 539/550] Remove unecessary required fields count when
 `exclude_none` is set (#1708)

---
 src/serializers/fields.rs | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/src/serializers/fields.rs b/src/serializers/fields.rs
index b89468d4e..d4bc8bb67 100644
--- a/src/serializers/fields.rs
+++ b/src/serializers/fields.rs
@@ -162,11 +162,6 @@ impl GeneralFieldsSerializer {
             let key_str = key_str(&key)?;
             let op_field = self.fields.get(key_str);
             if extra.exclude_none && value.is_none() {
-                if let Some(field) = op_field {
-                    if field.required {
-                        used_req_fields += 1;
-                    }
-                }
                 continue;
             }
             let field_extra = Extra {

From bd24ed00f698f6ba710408011923bf117a56df07 Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Fri, 16 May 2025 15:26:59 +0200
Subject: [PATCH 540/550] Update test dependencies after 3.8 dropped support
 (#1710)

---
 pyproject.toml |   5 +-
 uv.lock        | 817 ++++++++++++++++++++++++-------------------------
 2 files changed, 410 insertions(+), 412 deletions(-)

diff --git a/pyproject.toml b/pyproject.toml
index 082f1b647..d09c62a10 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -46,13 +46,12 @@ Source = 'https://github.com/pydantic/pydantic-core'
 dev = ["maturin"]
 testing = [
     { include-group = "dev" },
-    'backports.zoneinfo; python_version < "3.9"',
     'coverage',
     'dirty-equals',
     'inline-snapshot',
     'hypothesis',
     # pandas doesn't offer prebuilt wheels for all versions and platforms we test in CI e.g. aarch64 musllinux
-    'pandas; python_version >= "3.9" and python_version < "3.13" and implementation_name == "cpython" and platform_machine == "x86_64"',
+    'pandas; python_version < "3.13" and implementation_name == "cpython" and platform_machine == "x86_64"',
     'pytest',
     # pytest-examples currently depends on aiohttp via black; we don't want to build it on platforms like aarch64 musllinux in CI
     'pytest-examples; implementation_name == "cpython" and platform_machine == "x86_64"',
@@ -63,7 +62,7 @@ testing = [
     'pytest-timeout',
     'python-dateutil',
     # numpy doesn't offer prebuilt wheels for all versions and platforms we test in CI e.g. aarch64 musllinux
-    'numpy; python_version >= "3.9" and python_version < "3.13" and implementation_name == "cpython" and platform_machine == "x86_64"',
+    'numpy; python_version < "3.13" and implementation_name == "cpython" and platform_machine == "x86_64"',
     'exceptiongroup; python_version < "3.11"',
     'tzdata',
     'typing_extensions',
diff --git a/uv.lock b/uv.lock
index 7ad8e1c5a..717abdced 100644
--- a/uv.lock
+++ b/uv.lock
@@ -1,4 +1,5 @@
 version = 1
+revision = 2
 requires-python = ">=3.9"
 resolution-markers = [
     "python_full_version == '3.13.*' and implementation_name == 'cpython'",
@@ -12,18 +13,18 @@ resolution-markers = [
 name = "asttokens"
 version = "3.0.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/4a/e7/82da0a03e7ba5141f05cce0d302e6eed121ae055e0456ca228bf693984bc/asttokens-3.0.0.tar.gz", hash = "sha256:0dcd8baa8d62b0c1d118b399b2ddba3c4aff271d0d7a9e0d4c1681c79035bbc7", size = 61978 }
+sdist = { url = "https://files.pythonhosted.org/packages/4a/e7/82da0a03e7ba5141f05cce0d302e6eed121ae055e0456ca228bf693984bc/asttokens-3.0.0.tar.gz", hash = "sha256:0dcd8baa8d62b0c1d118b399b2ddba3c4aff271d0d7a9e0d4c1681c79035bbc7", size = 61978, upload-time = "2024-11-30T04:30:14.439Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/25/8a/c46dcc25341b5bce5472c718902eb3d38600a903b14fa6aeecef3f21a46f/asttokens-3.0.0-py3-none-any.whl", hash = "sha256:e3078351a059199dd5138cb1c706e6430c05eff2ff136af5eb4790f9d28932e2", size = 26918 },
+    { url = "https://files.pythonhosted.org/packages/25/8a/c46dcc25341b5bce5472c718902eb3d38600a903b14fa6aeecef3f21a46f/asttokens-3.0.0-py3-none-any.whl", hash = "sha256:e3078351a059199dd5138cb1c706e6430c05eff2ff136af5eb4790f9d28932e2", size = 26918, upload-time = "2024-11-30T04:30:10.946Z" },
 ]
 
 [[package]]
 name = "attrs"
 version = "24.3.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/48/c8/6260f8ccc11f0917360fc0da435c5c9c7504e3db174d5a12a1494887b045/attrs-24.3.0.tar.gz", hash = "sha256:8f5c07333d543103541ba7be0e2ce16eeee8130cb0b3f9238ab904ce1e85baff", size = 805984 }
+sdist = { url = "https://files.pythonhosted.org/packages/48/c8/6260f8ccc11f0917360fc0da435c5c9c7504e3db174d5a12a1494887b045/attrs-24.3.0.tar.gz", hash = "sha256:8f5c07333d543103541ba7be0e2ce16eeee8130cb0b3f9238ab904ce1e85baff", size = 805984, upload-time = "2024-12-16T06:59:29.899Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/89/aa/ab0f7891a01eeb2d2e338ae8fecbe57fcebea1a24dbb64d45801bfab481d/attrs-24.3.0-py3-none-any.whl", hash = "sha256:ac96cd038792094f438ad1f6ff80837353805ac950cd2aa0e0625ef19850c308", size = 63397 },
+    { url = "https://files.pythonhosted.org/packages/89/aa/ab0f7891a01eeb2d2e338ae8fecbe57fcebea1a24dbb64d45801bfab481d/attrs-24.3.0-py3-none-any.whl", hash = "sha256:ac96cd038792094f438ad1f6ff80837353805ac950cd2aa0e0625ef19850c308", size = 63397, upload-time = "2024-12-16T06:59:26.977Z" },
 ]
 
 [[package]]
@@ -39,24 +40,24 @@ dependencies = [
     { name = "tomli", marker = "python_full_version < '3.11'" },
     { name = "typing-extensions", marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/d8/0d/cc2fb42b8c50d80143221515dd7e4766995bd07c56c9a3ed30baf080b6dc/black-24.10.0.tar.gz", hash = "sha256:846ea64c97afe3bc677b761787993be4991810ecc7a4a937816dd6bddedc4875", size = 645813 }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/0d/cc2fb42b8c50d80143221515dd7e4766995bd07c56c9a3ed30baf080b6dc/black-24.10.0.tar.gz", hash = "sha256:846ea64c97afe3bc677b761787993be4991810ecc7a4a937816dd6bddedc4875", size = 645813, upload-time = "2024-10-07T19:20:50.361Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a3/f3/465c0eb5cddf7dbbfe1fecd9b875d1dcf51b88923cd2c1d7e9ab95c6336b/black-24.10.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e6668650ea4b685440857138e5fe40cde4d652633b1bdffc62933d0db4ed9812", size = 1623211 },
-    { url = "https://files.pythonhosted.org/packages/6e/c5/9023b7673904a5188f9be81f5e129fff69f51f5515655fbd1d5a4e80a47b/black-24.10.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:649fff99a20bd06c6f727d2a27f401331dc0cc861fb69cde910fe95b01b5928f", size = 1753774 },
-    { url = "https://files.pythonhosted.org/packages/e1/32/df7f18bd0e724e0d9748829765455d6643ec847b3f87e77456fc99d0edab/black-24.10.0-cp310-cp310-win_amd64.whl", hash = "sha256:fe4d6476887de70546212c99ac9bd803d90b42fc4767f058a0baa895013fbb3e", size = 1414209 },
-    { url = "https://files.pythonhosted.org/packages/c2/cc/7496bb63a9b06a954d3d0ac9fe7a73f3bf1cd92d7a58877c27f4ad1e9d41/black-24.10.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5a2221696a8224e335c28816a9d331a6c2ae15a2ee34ec857dcf3e45dbfa99ad", size = 1607468 },
-    { url = "https://files.pythonhosted.org/packages/c9/9b/2db8045b45844665c720dcfe292fdaf2e49825810c0103e1191515fc101a/black-24.10.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4007b1393d902b48b36958a216c20c4482f601569d19ed1df294a496eb366392", size = 1737061 },
-    { url = "https://files.pythonhosted.org/packages/a3/95/17d4a09a5be5f8c65aa4a361444d95edc45def0de887810f508d3f65db7a/black-24.10.0-cp311-cp311-win_amd64.whl", hash = "sha256:394d4ddc64782e51153eadcaaca95144ac4c35e27ef9b0a42e121ae7e57a9175", size = 1423293 },
-    { url = "https://files.pythonhosted.org/packages/90/04/bf74c71f592bcd761610bbf67e23e6a3cff824780761f536512437f1e655/black-24.10.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b5e39e0fae001df40f95bd8cc36b9165c5e2ea88900167bddf258bacef9bbdc3", size = 1644256 },
-    { url = "https://files.pythonhosted.org/packages/4e/3e/443ef8bc1fbda78e61f79157f303893f3fddf19ca3c8989b163eb3469a12/black-24.10.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:14b3502784f09ce2443830e3133dacf2c0110d45191ed470ecb04d0f5f6fcb0f", size = 1761892 },
-    { url = "https://files.pythonhosted.org/packages/52/93/eac95ff229049a6901bc84fec6908a5124b8a0b7c26ea766b3b8a5debd22/black-24.10.0-cp312-cp312-win_amd64.whl", hash = "sha256:30d2c30dc5139211dda799758559d1b049f7f14c580c409d6ad925b74a4208a8", size = 1434796 },
-    { url = "https://files.pythonhosted.org/packages/d0/a0/a993f58d4ecfba035e61fca4e9f64a2ecae838fc9f33ab798c62173ed75c/black-24.10.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1cbacacb19e922a1d75ef2b6ccaefcd6e93a2c05ede32f06a21386a04cedb981", size = 1643986 },
-    { url = "https://files.pythonhosted.org/packages/47/6d/a3a239e938960df1a662b93d6230d4f3e9b4a22982d060fc38c42f45a56b/black-24.10.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ddacb691cdcdf77b96f549cf9591701d8db36b2f19519373d60d31746068dbf2", size = 1760928 },
-    { url = "https://files.pythonhosted.org/packages/dd/cf/af018e13b0eddfb434df4d9cd1b2b7892bab119f7a20123e93f6910982e8/black-24.10.0-cp313-cp313-win_amd64.whl", hash = "sha256:680359d932801c76d2e9c9068d05c6b107f2584b2a5b88831c83962eb9984c1b", size = 1436875 },
-    { url = "https://files.pythonhosted.org/packages/fe/02/f408c804e0ee78c367dcea0a01aedde4f1712af93b8b6e60df981e0228c7/black-24.10.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:17374989640fbca88b6a448129cd1745c5eb8d9547b464f281b251dd00155ccd", size = 1622516 },
-    { url = "https://files.pythonhosted.org/packages/0a/1c/314d7f17434a5375682ad097f6f4cc0e3f414f3c95a9b1bb4df14a0f11f9/black-24.10.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfa1d0cb6200857f1923b602f978386a3a2758a65b52e0950299ea014be6800", size = 1752801 },
-    { url = "https://files.pythonhosted.org/packages/39/a7/20e5cd9237d28ad0b31438de5d9f01c8b99814576f4c0cda1edd62caf4b0/black-24.10.0-cp39-cp39-win_amd64.whl", hash = "sha256:2cd9c95431d94adc56600710f8813ee27eea544dd118d45896bb734e9d7a0dc7", size = 1413626 },
-    { url = "https://files.pythonhosted.org/packages/8d/a7/4b27c50537ebca8bec139b872861f9d2bf501c5ec51fcf897cb924d9e264/black-24.10.0-py3-none-any.whl", hash = "sha256:3bb2b7a1f7b685f85b11fed1ef10f8a9148bceb49853e47a294a3dd963c1dd7d", size = 206898 },
+    { url = "https://files.pythonhosted.org/packages/a3/f3/465c0eb5cddf7dbbfe1fecd9b875d1dcf51b88923cd2c1d7e9ab95c6336b/black-24.10.0-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:e6668650ea4b685440857138e5fe40cde4d652633b1bdffc62933d0db4ed9812", size = 1623211, upload-time = "2024-10-07T19:26:12.43Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/c5/9023b7673904a5188f9be81f5e129fff69f51f5515655fbd1d5a4e80a47b/black-24.10.0-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:649fff99a20bd06c6f727d2a27f401331dc0cc861fb69cde910fe95b01b5928f", size = 1753774, upload-time = "2024-10-07T19:23:58.47Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/32/df7f18bd0e724e0d9748829765455d6643ec847b3f87e77456fc99d0edab/black-24.10.0-cp310-cp310-win_amd64.whl", hash = "sha256:fe4d6476887de70546212c99ac9bd803d90b42fc4767f058a0baa895013fbb3e", size = 1414209, upload-time = "2024-10-07T19:24:42.54Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/cc/7496bb63a9b06a954d3d0ac9fe7a73f3bf1cd92d7a58877c27f4ad1e9d41/black-24.10.0-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:5a2221696a8224e335c28816a9d331a6c2ae15a2ee34ec857dcf3e45dbfa99ad", size = 1607468, upload-time = "2024-10-07T19:26:14.966Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/9b/2db8045b45844665c720dcfe292fdaf2e49825810c0103e1191515fc101a/black-24.10.0-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:4007b1393d902b48b36958a216c20c4482f601569d19ed1df294a496eb366392", size = 1737061, upload-time = "2024-10-07T19:23:52.18Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/95/17d4a09a5be5f8c65aa4a361444d95edc45def0de887810f508d3f65db7a/black-24.10.0-cp311-cp311-win_amd64.whl", hash = "sha256:394d4ddc64782e51153eadcaaca95144ac4c35e27ef9b0a42e121ae7e57a9175", size = 1423293, upload-time = "2024-10-07T19:24:41.7Z" },
+    { url = "https://files.pythonhosted.org/packages/90/04/bf74c71f592bcd761610bbf67e23e6a3cff824780761f536512437f1e655/black-24.10.0-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:b5e39e0fae001df40f95bd8cc36b9165c5e2ea88900167bddf258bacef9bbdc3", size = 1644256, upload-time = "2024-10-07T19:27:53.355Z" },
+    { url = "https://files.pythonhosted.org/packages/4e/3e/443ef8bc1fbda78e61f79157f303893f3fddf19ca3c8989b163eb3469a12/black-24.10.0-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:14b3502784f09ce2443830e3133dacf2c0110d45191ed470ecb04d0f5f6fcb0f", size = 1761892, upload-time = "2024-10-07T19:24:10.264Z" },
+    { url = "https://files.pythonhosted.org/packages/52/93/eac95ff229049a6901bc84fec6908a5124b8a0b7c26ea766b3b8a5debd22/black-24.10.0-cp312-cp312-win_amd64.whl", hash = "sha256:30d2c30dc5139211dda799758559d1b049f7f14c580c409d6ad925b74a4208a8", size = 1434796, upload-time = "2024-10-07T19:25:06.239Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/a0/a993f58d4ecfba035e61fca4e9f64a2ecae838fc9f33ab798c62173ed75c/black-24.10.0-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:1cbacacb19e922a1d75ef2b6ccaefcd6e93a2c05ede32f06a21386a04cedb981", size = 1643986, upload-time = "2024-10-07T19:28:50.684Z" },
+    { url = "https://files.pythonhosted.org/packages/47/6d/a3a239e938960df1a662b93d6230d4f3e9b4a22982d060fc38c42f45a56b/black-24.10.0-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ddacb691cdcdf77b96f549cf9591701d8db36b2f19519373d60d31746068dbf2", size = 1760928, upload-time = "2024-10-07T19:24:15.233Z" },
+    { url = "https://files.pythonhosted.org/packages/dd/cf/af018e13b0eddfb434df4d9cd1b2b7892bab119f7a20123e93f6910982e8/black-24.10.0-cp313-cp313-win_amd64.whl", hash = "sha256:680359d932801c76d2e9c9068d05c6b107f2584b2a5b88831c83962eb9984c1b", size = 1436875, upload-time = "2024-10-07T19:24:42.762Z" },
+    { url = "https://files.pythonhosted.org/packages/fe/02/f408c804e0ee78c367dcea0a01aedde4f1712af93b8b6e60df981e0228c7/black-24.10.0-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:17374989640fbca88b6a448129cd1745c5eb8d9547b464f281b251dd00155ccd", size = 1622516, upload-time = "2024-10-07T19:29:40.629Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/1c/314d7f17434a5375682ad097f6f4cc0e3f414f3c95a9b1bb4df14a0f11f9/black-24.10.0-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ccfa1d0cb6200857f1923b602f978386a3a2758a65b52e0950299ea014be6800", size = 1752801, upload-time = "2024-10-07T19:23:56.594Z" },
+    { url = "https://files.pythonhosted.org/packages/39/a7/20e5cd9237d28ad0b31438de5d9f01c8b99814576f4c0cda1edd62caf4b0/black-24.10.0-cp39-cp39-win_amd64.whl", hash = "sha256:2cd9c95431d94adc56600710f8813ee27eea544dd118d45896bb734e9d7a0dc7", size = 1413626, upload-time = "2024-10-07T19:24:46.133Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/a7/4b27c50537ebca8bec139b872861f9d2bf501c5ec51fcf897cb924d9e264/black-24.10.0-py3-none-any.whl", hash = "sha256:3bb2b7a1f7b685f85b11fed1ef10f8a9148bceb49853e47a294a3dd963c1dd7d", size = 206898, upload-time = "2024-10-07T19:20:48.317Z" },
 ]
 
 [[package]]
@@ -66,66 +67,66 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "pycparser", marker = "python_full_version == '3.13.*' and implementation_name == 'cpython'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/fc/97/c783634659c2920c3fc70419e3af40972dbaf758daa229a7d6ea6135c90d/cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824", size = 516621 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/90/07/f44ca684db4e4f08a3fdc6eeb9a0d15dc6883efc7b8c90357fdbf74e186c/cffi-1.17.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:df8b1c11f177bc2313ec4b2d46baec87a5f3e71fc8b45dab2ee7cae86d9aba14", size = 182191 },
-    { url = "https://files.pythonhosted.org/packages/08/fd/cc2fedbd887223f9f5d170c96e57cbf655df9831a6546c1727ae13fa977a/cffi-1.17.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8f2cdc858323644ab277e9bb925ad72ae0e67f69e804f4898c070998d50b1a67", size = 178592 },
-    { url = "https://files.pythonhosted.org/packages/de/cc/4635c320081c78d6ffc2cab0a76025b691a91204f4aa317d568ff9280a2d/cffi-1.17.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:edae79245293e15384b51f88b00613ba9f7198016a5948b5dddf4917d4d26382", size = 426024 },
-    { url = "https://files.pythonhosted.org/packages/b6/7b/3b2b250f3aab91abe5f8a51ada1b717935fdaec53f790ad4100fe2ec64d1/cffi-1.17.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:45398b671ac6d70e67da8e4224a065cec6a93541bb7aebe1b198a61b58c7b702", size = 448188 },
-    { url = "https://files.pythonhosted.org/packages/d3/48/1b9283ebbf0ec065148d8de05d647a986c5f22586b18120020452fff8f5d/cffi-1.17.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ad9413ccdeda48c5afdae7e4fa2192157e991ff761e7ab8fdd8926f40b160cc3", size = 455571 },
-    { url = "https://files.pythonhosted.org/packages/40/87/3b8452525437b40f39ca7ff70276679772ee7e8b394934ff60e63b7b090c/cffi-1.17.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5da5719280082ac6bd9aa7becb3938dc9f9cbd57fac7d2871717b1feb0902ab6", size = 436687 },
-    { url = "https://files.pythonhosted.org/packages/8d/fb/4da72871d177d63649ac449aec2e8a29efe0274035880c7af59101ca2232/cffi-1.17.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2bb1a08b8008b281856e5971307cc386a8e9c5b625ac297e853d36da6efe9c17", size = 446211 },
-    { url = "https://files.pythonhosted.org/packages/ab/a0/62f00bcb411332106c02b663b26f3545a9ef136f80d5df746c05878f8c4b/cffi-1.17.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:045d61c734659cc045141be4bae381a41d89b741f795af1dd018bfb532fd0df8", size = 461325 },
-    { url = "https://files.pythonhosted.org/packages/36/83/76127035ed2e7e27b0787604d99da630ac3123bfb02d8e80c633f218a11d/cffi-1.17.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:6883e737d7d9e4899a8a695e00ec36bd4e5e4f18fabe0aca0efe0a4b44cdb13e", size = 438784 },
-    { url = "https://files.pythonhosted.org/packages/21/81/a6cd025db2f08ac88b901b745c163d884641909641f9b826e8cb87645942/cffi-1.17.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:6b8b4a92e1c65048ff98cfe1f735ef8f1ceb72e3d5f0c25fdb12087a23da22be", size = 461564 },
-    { url = "https://files.pythonhosted.org/packages/f8/fe/4d41c2f200c4a457933dbd98d3cf4e911870877bd94d9656cc0fcb390681/cffi-1.17.1-cp310-cp310-win32.whl", hash = "sha256:c9c3d058ebabb74db66e431095118094d06abf53284d9c81f27300d0e0d8bc7c", size = 171804 },
-    { url = "https://files.pythonhosted.org/packages/d1/b6/0b0f5ab93b0df4acc49cae758c81fe4e5ef26c3ae2e10cc69249dfd8b3ab/cffi-1.17.1-cp310-cp310-win_amd64.whl", hash = "sha256:0f048dcf80db46f0098ccac01132761580d28e28bc0f78ae0d58048063317e15", size = 181299 },
-    { url = "https://files.pythonhosted.org/packages/6b/f4/927e3a8899e52a27fa57a48607ff7dc91a9ebe97399b357b85a0c7892e00/cffi-1.17.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a45e3c6913c5b87b3ff120dcdc03f6131fa0065027d0ed7ee6190736a74cd401", size = 182264 },
-    { url = "https://files.pythonhosted.org/packages/6c/f5/6c3a8efe5f503175aaddcbea6ad0d2c96dad6f5abb205750d1b3df44ef29/cffi-1.17.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:30c5e0cb5ae493c04c8b42916e52ca38079f1b235c2f8ae5f4527b963c401caf", size = 178651 },
-    { url = "https://files.pythonhosted.org/packages/94/dd/a3f0118e688d1b1a57553da23b16bdade96d2f9bcda4d32e7d2838047ff7/cffi-1.17.1-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f75c7ab1f9e4aca5414ed4d8e5c0e303a34f4421f8a0d47a4d019ceff0ab6af4", size = 445259 },
-    { url = "https://files.pythonhosted.org/packages/2e/ea/70ce63780f096e16ce8588efe039d3c4f91deb1dc01e9c73a287939c79a6/cffi-1.17.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a1ed2dd2972641495a3ec98445e09766f077aee98a1c896dcb4ad0d303628e41", size = 469200 },
-    { url = "https://files.pythonhosted.org/packages/1c/a0/a4fa9f4f781bda074c3ddd57a572b060fa0df7655d2a4247bbe277200146/cffi-1.17.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:46bf43160c1a35f7ec506d254e5c890f3c03648a4dbac12d624e4490a7046cd1", size = 477235 },
-    { url = "https://files.pythonhosted.org/packages/62/12/ce8710b5b8affbcdd5c6e367217c242524ad17a02fe5beec3ee339f69f85/cffi-1.17.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a24ed04c8ffd54b0729c07cee15a81d964e6fee0e3d4d342a27b020d22959dc6", size = 459721 },
-    { url = "https://files.pythonhosted.org/packages/ff/6b/d45873c5e0242196f042d555526f92aa9e0c32355a1be1ff8c27f077fd37/cffi-1.17.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:610faea79c43e44c71e1ec53a554553fa22321b65fae24889706c0a84d4ad86d", size = 467242 },
-    { url = "https://files.pythonhosted.org/packages/1a/52/d9a0e523a572fbccf2955f5abe883cfa8bcc570d7faeee06336fbd50c9fc/cffi-1.17.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:a9b15d491f3ad5d692e11f6b71f7857e7835eb677955c00cc0aefcd0669adaf6", size = 477999 },
-    { url = "https://files.pythonhosted.org/packages/44/74/f2a2460684a1a2d00ca799ad880d54652841a780c4c97b87754f660c7603/cffi-1.17.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:de2ea4b5833625383e464549fec1bc395c1bdeeb5f25c4a3a82b5a8c756ec22f", size = 454242 },
-    { url = "https://files.pythonhosted.org/packages/f8/4a/34599cac7dfcd888ff54e801afe06a19c17787dfd94495ab0c8d35fe99fb/cffi-1.17.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:fc48c783f9c87e60831201f2cce7f3b2e4846bf4d8728eabe54d60700b318a0b", size = 478604 },
-    { url = "https://files.pythonhosted.org/packages/34/33/e1b8a1ba29025adbdcda5fb3a36f94c03d771c1b7b12f726ff7fef2ebe36/cffi-1.17.1-cp311-cp311-win32.whl", hash = "sha256:85a950a4ac9c359340d5963966e3e0a94a676bd6245a4b55bc43949eee26a655", size = 171727 },
-    { url = "https://files.pythonhosted.org/packages/3d/97/50228be003bb2802627d28ec0627837ac0bf35c90cf769812056f235b2d1/cffi-1.17.1-cp311-cp311-win_amd64.whl", hash = "sha256:caaf0640ef5f5517f49bc275eca1406b0ffa6aa184892812030f04c2abf589a0", size = 181400 },
-    { url = "https://files.pythonhosted.org/packages/5a/84/e94227139ee5fb4d600a7a4927f322e1d4aea6fdc50bd3fca8493caba23f/cffi-1.17.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:805b4371bf7197c329fcb3ead37e710d1bca9da5d583f5073b799d5c5bd1eee4", size = 183178 },
-    { url = "https://files.pythonhosted.org/packages/da/ee/fb72c2b48656111c4ef27f0f91da355e130a923473bf5ee75c5643d00cca/cffi-1.17.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:733e99bc2df47476e3848417c5a4540522f234dfd4ef3ab7fafdf555b082ec0c", size = 178840 },
-    { url = "https://files.pythonhosted.org/packages/cc/b6/db007700f67d151abadf508cbfd6a1884f57eab90b1bb985c4c8c02b0f28/cffi-1.17.1-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1257bdabf294dceb59f5e70c64a3e2f462c30c7ad68092d01bbbfb1c16b1ba36", size = 454803 },
-    { url = "https://files.pythonhosted.org/packages/1a/df/f8d151540d8c200eb1c6fba8cd0dfd40904f1b0682ea705c36e6c2e97ab3/cffi-1.17.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da95af8214998d77a98cc14e3a3bd00aa191526343078b530ceb0bd710fb48a5", size = 478850 },
-    { url = "https://files.pythonhosted.org/packages/28/c0/b31116332a547fd2677ae5b78a2ef662dfc8023d67f41b2a83f7c2aa78b1/cffi-1.17.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d63afe322132c194cf832bfec0dc69a99fb9bb6bbd550f161a49e9e855cc78ff", size = 485729 },
-    { url = "https://files.pythonhosted.org/packages/91/2b/9a1ddfa5c7f13cab007a2c9cc295b70fbbda7cb10a286aa6810338e60ea1/cffi-1.17.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f79fc4fc25f1c8698ff97788206bb3c2598949bfe0fef03d299eb1b5356ada99", size = 471256 },
-    { url = "https://files.pythonhosted.org/packages/b2/d5/da47df7004cb17e4955df6a43d14b3b4ae77737dff8bf7f8f333196717bf/cffi-1.17.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b62ce867176a75d03a665bad002af8e6d54644fad99a3c70905c543130e39d93", size = 479424 },
-    { url = "https://files.pythonhosted.org/packages/0b/ac/2a28bcf513e93a219c8a4e8e125534f4f6db03e3179ba1c45e949b76212c/cffi-1.17.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:386c8bf53c502fff58903061338ce4f4950cbdcb23e2902d86c0f722b786bbe3", size = 484568 },
-    { url = "https://files.pythonhosted.org/packages/d4/38/ca8a4f639065f14ae0f1d9751e70447a261f1a30fa7547a828ae08142465/cffi-1.17.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4ceb10419a9adf4460ea14cfd6bc43d08701f0835e979bf821052f1805850fe8", size = 488736 },
-    { url = "https://files.pythonhosted.org/packages/86/c5/28b2d6f799ec0bdecf44dced2ec5ed43e0eb63097b0f58c293583b406582/cffi-1.17.1-cp312-cp312-win32.whl", hash = "sha256:a08d7e755f8ed21095a310a693525137cfe756ce62d066e53f502a83dc550f65", size = 172448 },
-    { url = "https://files.pythonhosted.org/packages/50/b9/db34c4755a7bd1cb2d1603ac3863f22bcecbd1ba29e5ee841a4bc510b294/cffi-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:51392eae71afec0d0c8fb1a53b204dbb3bcabcb3c9b807eedf3e1e6ccf2de903", size = 181976 },
-    { url = "https://files.pythonhosted.org/packages/8d/f8/dd6c246b148639254dad4d6803eb6a54e8c85c6e11ec9df2cffa87571dbe/cffi-1.17.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f3a2b4222ce6b60e2e8b337bb9596923045681d71e5a082783484d845390938e", size = 182989 },
-    { url = "https://files.pythonhosted.org/packages/8b/f1/672d303ddf17c24fc83afd712316fda78dc6fce1cd53011b839483e1ecc8/cffi-1.17.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0984a4925a435b1da406122d4d7968dd861c1385afe3b45ba82b750f229811e2", size = 178802 },
-    { url = "https://files.pythonhosted.org/packages/0e/2d/eab2e858a91fdff70533cab61dcff4a1f55ec60425832ddfdc9cd36bc8af/cffi-1.17.1-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d01b12eeeb4427d3110de311e1774046ad344f5b1a7403101878976ecd7a10f3", size = 454792 },
-    { url = "https://files.pythonhosted.org/packages/75/b2/fbaec7c4455c604e29388d55599b99ebcc250a60050610fadde58932b7ee/cffi-1.17.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:706510fe141c86a69c8ddc029c7910003a17353970cff3b904ff0686a5927683", size = 478893 },
-    { url = "https://files.pythonhosted.org/packages/4f/b7/6e4a2162178bf1935c336d4da8a9352cccab4d3a5d7914065490f08c0690/cffi-1.17.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de55b766c7aa2e2a3092c51e0483d700341182f08e67c63630d5b6f200bb28e5", size = 485810 },
-    { url = "https://files.pythonhosted.org/packages/c7/8a/1d0e4a9c26e54746dc08c2c6c037889124d4f59dffd853a659fa545f1b40/cffi-1.17.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c59d6e989d07460165cc5ad3c61f9fd8f1b4796eacbd81cee78957842b834af4", size = 471200 },
-    { url = "https://files.pythonhosted.org/packages/26/9f/1aab65a6c0db35f43c4d1b4f580e8df53914310afc10ae0397d29d697af4/cffi-1.17.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd398dbc6773384a17fe0d3e7eeb8d1a21c2200473ee6806bb5e6a8e62bb73dd", size = 479447 },
-    { url = "https://files.pythonhosted.org/packages/5f/e4/fb8b3dd8dc0e98edf1135ff067ae070bb32ef9d509d6cb0f538cd6f7483f/cffi-1.17.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:3edc8d958eb099c634dace3c7e16560ae474aa3803a5df240542b305d14e14ed", size = 484358 },
-    { url = "https://files.pythonhosted.org/packages/f1/47/d7145bf2dc04684935d57d67dff9d6d795b2ba2796806bb109864be3a151/cffi-1.17.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:72e72408cad3d5419375fc87d289076ee319835bdfa2caad331e377589aebba9", size = 488469 },
-    { url = "https://files.pythonhosted.org/packages/bf/ee/f94057fa6426481d663b88637a9a10e859e492c73d0384514a17d78ee205/cffi-1.17.1-cp313-cp313-win32.whl", hash = "sha256:e03eab0a8677fa80d646b5ddece1cbeaf556c313dcfac435ba11f107ba117b5d", size = 172475 },
-    { url = "https://files.pythonhosted.org/packages/7c/fc/6a8cb64e5f0324877d503c854da15d76c1e50eb722e320b15345c4d0c6de/cffi-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:f6a16c31041f09ead72d69f583767292f750d24913dadacf5756b966aacb3f1a", size = 182009 },
-    { url = "https://files.pythonhosted.org/packages/b9/ea/8bb50596b8ffbc49ddd7a1ad305035daa770202a6b782fc164647c2673ad/cffi-1.17.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:b2ab587605f4ba0bf81dc0cb08a41bd1c0a5906bd59243d56bad7668a6fc6c16", size = 182220 },
-    { url = "https://files.pythonhosted.org/packages/ae/11/e77c8cd24f58285a82c23af484cf5b124a376b32644e445960d1a4654c3a/cffi-1.17.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:28b16024becceed8c6dfbc75629e27788d8a3f9030691a1dbf9821a128b22c36", size = 178605 },
-    { url = "https://files.pythonhosted.org/packages/ed/65/25a8dc32c53bf5b7b6c2686b42ae2ad58743f7ff644844af7cdb29b49361/cffi-1.17.1-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1d599671f396c4723d016dbddb72fe8e0397082b0a77a4fab8028923bec050e8", size = 424910 },
-    { url = "https://files.pythonhosted.org/packages/42/7a/9d086fab7c66bd7c4d0f27c57a1b6b068ced810afc498cc8c49e0088661c/cffi-1.17.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca74b8dbe6e8e8263c0ffd60277de77dcee6c837a3d0881d8c1ead7268c9e576", size = 447200 },
-    { url = "https://files.pythonhosted.org/packages/da/63/1785ced118ce92a993b0ec9e0d0ac8dc3e5dbfbcaa81135be56c69cabbb6/cffi-1.17.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f7f5baafcc48261359e14bcd6d9bff6d4b28d9103847c9e136694cb0501aef87", size = 454565 },
-    { url = "https://files.pythonhosted.org/packages/74/06/90b8a44abf3556599cdec107f7290277ae8901a58f75e6fe8f970cd72418/cffi-1.17.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:98e3969bcff97cae1b2def8ba499ea3d6f31ddfdb7635374834cf89a1a08ecf0", size = 435635 },
-    { url = "https://files.pythonhosted.org/packages/bd/62/a1f468e5708a70b1d86ead5bab5520861d9c7eacce4a885ded9faa7729c3/cffi-1.17.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cdf5ce3acdfd1661132f2a9c19cac174758dc2352bfe37d98aa7512c6b7178b3", size = 445218 },
-    { url = "https://files.pythonhosted.org/packages/5b/95/b34462f3ccb09c2594aa782d90a90b045de4ff1f70148ee79c69d37a0a5a/cffi-1.17.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:9755e4345d1ec879e3849e62222a18c7174d65a6a92d5b346b1863912168b595", size = 460486 },
-    { url = "https://files.pythonhosted.org/packages/fc/fc/a1e4bebd8d680febd29cf6c8a40067182b64f00c7d105f8f26b5bc54317b/cffi-1.17.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:f1e22e8c4419538cb197e4dd60acc919d7696e5ef98ee4da4e01d3f8cfa4cc5a", size = 437911 },
-    { url = "https://files.pythonhosted.org/packages/e6/c3/21cab7a6154b6a5ea330ae80de386e7665254835b9e98ecc1340b3a7de9a/cffi-1.17.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:c03e868a0b3bc35839ba98e74211ed2b05d2119be4e8a0f224fba9384f1fe02e", size = 460632 },
-    { url = "https://files.pythonhosted.org/packages/cb/b5/fd9f8b5a84010ca169ee49f4e4ad6f8c05f4e3545b72ee041dbbcb159882/cffi-1.17.1-cp39-cp39-win32.whl", hash = "sha256:e31ae45bc2e29f6b2abd0de1cc3b9d5205aa847cafaecb8af1476a609a2f6eb7", size = 171820 },
-    { url = "https://files.pythonhosted.org/packages/8c/52/b08750ce0bce45c143e1b5d7357ee8c55341b52bdef4b0f081af1eb248c2/cffi-1.17.1-cp39-cp39-win_amd64.whl", hash = "sha256:d016c76bdd850f3c626af19b0542c9677ba156e4ee4fccfdd7848803533ef662", size = 181290 },
+sdist = { url = "https://files.pythonhosted.org/packages/fc/97/c783634659c2920c3fc70419e3af40972dbaf758daa229a7d6ea6135c90d/cffi-1.17.1.tar.gz", hash = "sha256:1c39c6016c32bc48dd54561950ebd6836e1670f2ae46128f67cf49e789c52824", size = 516621, upload-time = "2024-09-04T20:45:21.852Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/90/07/f44ca684db4e4f08a3fdc6eeb9a0d15dc6883efc7b8c90357fdbf74e186c/cffi-1.17.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:df8b1c11f177bc2313ec4b2d46baec87a5f3e71fc8b45dab2ee7cae86d9aba14", size = 182191, upload-time = "2024-09-04T20:43:30.027Z" },
+    { url = "https://files.pythonhosted.org/packages/08/fd/cc2fedbd887223f9f5d170c96e57cbf655df9831a6546c1727ae13fa977a/cffi-1.17.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:8f2cdc858323644ab277e9bb925ad72ae0e67f69e804f4898c070998d50b1a67", size = 178592, upload-time = "2024-09-04T20:43:32.108Z" },
+    { url = "https://files.pythonhosted.org/packages/de/cc/4635c320081c78d6ffc2cab0a76025b691a91204f4aa317d568ff9280a2d/cffi-1.17.1-cp310-cp310-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:edae79245293e15384b51f88b00613ba9f7198016a5948b5dddf4917d4d26382", size = 426024, upload-time = "2024-09-04T20:43:34.186Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/7b/3b2b250f3aab91abe5f8a51ada1b717935fdaec53f790ad4100fe2ec64d1/cffi-1.17.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:45398b671ac6d70e67da8e4224a065cec6a93541bb7aebe1b198a61b58c7b702", size = 448188, upload-time = "2024-09-04T20:43:36.286Z" },
+    { url = "https://files.pythonhosted.org/packages/d3/48/1b9283ebbf0ec065148d8de05d647a986c5f22586b18120020452fff8f5d/cffi-1.17.1-cp310-cp310-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:ad9413ccdeda48c5afdae7e4fa2192157e991ff761e7ab8fdd8926f40b160cc3", size = 455571, upload-time = "2024-09-04T20:43:38.586Z" },
+    { url = "https://files.pythonhosted.org/packages/40/87/3b8452525437b40f39ca7ff70276679772ee7e8b394934ff60e63b7b090c/cffi-1.17.1-cp310-cp310-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:5da5719280082ac6bd9aa7becb3938dc9f9cbd57fac7d2871717b1feb0902ab6", size = 436687, upload-time = "2024-09-04T20:43:40.084Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/fb/4da72871d177d63649ac449aec2e8a29efe0274035880c7af59101ca2232/cffi-1.17.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:2bb1a08b8008b281856e5971307cc386a8e9c5b625ac297e853d36da6efe9c17", size = 446211, upload-time = "2024-09-04T20:43:41.526Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/a0/62f00bcb411332106c02b663b26f3545a9ef136f80d5df746c05878f8c4b/cffi-1.17.1-cp310-cp310-musllinux_1_1_aarch64.whl", hash = "sha256:045d61c734659cc045141be4bae381a41d89b741f795af1dd018bfb532fd0df8", size = 461325, upload-time = "2024-09-04T20:43:43.117Z" },
+    { url = "https://files.pythonhosted.org/packages/36/83/76127035ed2e7e27b0787604d99da630ac3123bfb02d8e80c633f218a11d/cffi-1.17.1-cp310-cp310-musllinux_1_1_i686.whl", hash = "sha256:6883e737d7d9e4899a8a695e00ec36bd4e5e4f18fabe0aca0efe0a4b44cdb13e", size = 438784, upload-time = "2024-09-04T20:43:45.256Z" },
+    { url = "https://files.pythonhosted.org/packages/21/81/a6cd025db2f08ac88b901b745c163d884641909641f9b826e8cb87645942/cffi-1.17.1-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:6b8b4a92e1c65048ff98cfe1f735ef8f1ceb72e3d5f0c25fdb12087a23da22be", size = 461564, upload-time = "2024-09-04T20:43:46.779Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/fe/4d41c2f200c4a457933dbd98d3cf4e911870877bd94d9656cc0fcb390681/cffi-1.17.1-cp310-cp310-win32.whl", hash = "sha256:c9c3d058ebabb74db66e431095118094d06abf53284d9c81f27300d0e0d8bc7c", size = 171804, upload-time = "2024-09-04T20:43:48.186Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/b6/0b0f5ab93b0df4acc49cae758c81fe4e5ef26c3ae2e10cc69249dfd8b3ab/cffi-1.17.1-cp310-cp310-win_amd64.whl", hash = "sha256:0f048dcf80db46f0098ccac01132761580d28e28bc0f78ae0d58048063317e15", size = 181299, upload-time = "2024-09-04T20:43:49.812Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/f4/927e3a8899e52a27fa57a48607ff7dc91a9ebe97399b357b85a0c7892e00/cffi-1.17.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:a45e3c6913c5b87b3ff120dcdc03f6131fa0065027d0ed7ee6190736a74cd401", size = 182264, upload-time = "2024-09-04T20:43:51.124Z" },
+    { url = "https://files.pythonhosted.org/packages/6c/f5/6c3a8efe5f503175aaddcbea6ad0d2c96dad6f5abb205750d1b3df44ef29/cffi-1.17.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:30c5e0cb5ae493c04c8b42916e52ca38079f1b235c2f8ae5f4527b963c401caf", size = 178651, upload-time = "2024-09-04T20:43:52.872Z" },
+    { url = "https://files.pythonhosted.org/packages/94/dd/a3f0118e688d1b1a57553da23b16bdade96d2f9bcda4d32e7d2838047ff7/cffi-1.17.1-cp311-cp311-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:f75c7ab1f9e4aca5414ed4d8e5c0e303a34f4421f8a0d47a4d019ceff0ab6af4", size = 445259, upload-time = "2024-09-04T20:43:56.123Z" },
+    { url = "https://files.pythonhosted.org/packages/2e/ea/70ce63780f096e16ce8588efe039d3c4f91deb1dc01e9c73a287939c79a6/cffi-1.17.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a1ed2dd2972641495a3ec98445e09766f077aee98a1c896dcb4ad0d303628e41", size = 469200, upload-time = "2024-09-04T20:43:57.891Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/a0/a4fa9f4f781bda074c3ddd57a572b060fa0df7655d2a4247bbe277200146/cffi-1.17.1-cp311-cp311-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:46bf43160c1a35f7ec506d254e5c890f3c03648a4dbac12d624e4490a7046cd1", size = 477235, upload-time = "2024-09-04T20:44:00.18Z" },
+    { url = "https://files.pythonhosted.org/packages/62/12/ce8710b5b8affbcdd5c6e367217c242524ad17a02fe5beec3ee339f69f85/cffi-1.17.1-cp311-cp311-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:a24ed04c8ffd54b0729c07cee15a81d964e6fee0e3d4d342a27b020d22959dc6", size = 459721, upload-time = "2024-09-04T20:44:01.585Z" },
+    { url = "https://files.pythonhosted.org/packages/ff/6b/d45873c5e0242196f042d555526f92aa9e0c32355a1be1ff8c27f077fd37/cffi-1.17.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:610faea79c43e44c71e1ec53a554553fa22321b65fae24889706c0a84d4ad86d", size = 467242, upload-time = "2024-09-04T20:44:03.467Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/52/d9a0e523a572fbccf2955f5abe883cfa8bcc570d7faeee06336fbd50c9fc/cffi-1.17.1-cp311-cp311-musllinux_1_1_aarch64.whl", hash = "sha256:a9b15d491f3ad5d692e11f6b71f7857e7835eb677955c00cc0aefcd0669adaf6", size = 477999, upload-time = "2024-09-04T20:44:05.023Z" },
+    { url = "https://files.pythonhosted.org/packages/44/74/f2a2460684a1a2d00ca799ad880d54652841a780c4c97b87754f660c7603/cffi-1.17.1-cp311-cp311-musllinux_1_1_i686.whl", hash = "sha256:de2ea4b5833625383e464549fec1bc395c1bdeeb5f25c4a3a82b5a8c756ec22f", size = 454242, upload-time = "2024-09-04T20:44:06.444Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/4a/34599cac7dfcd888ff54e801afe06a19c17787dfd94495ab0c8d35fe99fb/cffi-1.17.1-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:fc48c783f9c87e60831201f2cce7f3b2e4846bf4d8728eabe54d60700b318a0b", size = 478604, upload-time = "2024-09-04T20:44:08.206Z" },
+    { url = "https://files.pythonhosted.org/packages/34/33/e1b8a1ba29025adbdcda5fb3a36f94c03d771c1b7b12f726ff7fef2ebe36/cffi-1.17.1-cp311-cp311-win32.whl", hash = "sha256:85a950a4ac9c359340d5963966e3e0a94a676bd6245a4b55bc43949eee26a655", size = 171727, upload-time = "2024-09-04T20:44:09.481Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/97/50228be003bb2802627d28ec0627837ac0bf35c90cf769812056f235b2d1/cffi-1.17.1-cp311-cp311-win_amd64.whl", hash = "sha256:caaf0640ef5f5517f49bc275eca1406b0ffa6aa184892812030f04c2abf589a0", size = 181400, upload-time = "2024-09-04T20:44:10.873Z" },
+    { url = "https://files.pythonhosted.org/packages/5a/84/e94227139ee5fb4d600a7a4927f322e1d4aea6fdc50bd3fca8493caba23f/cffi-1.17.1-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:805b4371bf7197c329fcb3ead37e710d1bca9da5d583f5073b799d5c5bd1eee4", size = 183178, upload-time = "2024-09-04T20:44:12.232Z" },
+    { url = "https://files.pythonhosted.org/packages/da/ee/fb72c2b48656111c4ef27f0f91da355e130a923473bf5ee75c5643d00cca/cffi-1.17.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:733e99bc2df47476e3848417c5a4540522f234dfd4ef3ab7fafdf555b082ec0c", size = 178840, upload-time = "2024-09-04T20:44:13.739Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/b6/db007700f67d151abadf508cbfd6a1884f57eab90b1bb985c4c8c02b0f28/cffi-1.17.1-cp312-cp312-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1257bdabf294dceb59f5e70c64a3e2f462c30c7ad68092d01bbbfb1c16b1ba36", size = 454803, upload-time = "2024-09-04T20:44:15.231Z" },
+    { url = "https://files.pythonhosted.org/packages/1a/df/f8d151540d8c200eb1c6fba8cd0dfd40904f1b0682ea705c36e6c2e97ab3/cffi-1.17.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:da95af8214998d77a98cc14e3a3bd00aa191526343078b530ceb0bd710fb48a5", size = 478850, upload-time = "2024-09-04T20:44:17.188Z" },
+    { url = "https://files.pythonhosted.org/packages/28/c0/b31116332a547fd2677ae5b78a2ef662dfc8023d67f41b2a83f7c2aa78b1/cffi-1.17.1-cp312-cp312-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:d63afe322132c194cf832bfec0dc69a99fb9bb6bbd550f161a49e9e855cc78ff", size = 485729, upload-time = "2024-09-04T20:44:18.688Z" },
+    { url = "https://files.pythonhosted.org/packages/91/2b/9a1ddfa5c7f13cab007a2c9cc295b70fbbda7cb10a286aa6810338e60ea1/cffi-1.17.1-cp312-cp312-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:f79fc4fc25f1c8698ff97788206bb3c2598949bfe0fef03d299eb1b5356ada99", size = 471256, upload-time = "2024-09-04T20:44:20.248Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/d5/da47df7004cb17e4955df6a43d14b3b4ae77737dff8bf7f8f333196717bf/cffi-1.17.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:b62ce867176a75d03a665bad002af8e6d54644fad99a3c70905c543130e39d93", size = 479424, upload-time = "2024-09-04T20:44:21.673Z" },
+    { url = "https://files.pythonhosted.org/packages/0b/ac/2a28bcf513e93a219c8a4e8e125534f4f6db03e3179ba1c45e949b76212c/cffi-1.17.1-cp312-cp312-musllinux_1_1_aarch64.whl", hash = "sha256:386c8bf53c502fff58903061338ce4f4950cbdcb23e2902d86c0f722b786bbe3", size = 484568, upload-time = "2024-09-04T20:44:23.245Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/38/ca8a4f639065f14ae0f1d9751e70447a261f1a30fa7547a828ae08142465/cffi-1.17.1-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:4ceb10419a9adf4460ea14cfd6bc43d08701f0835e979bf821052f1805850fe8", size = 488736, upload-time = "2024-09-04T20:44:24.757Z" },
+    { url = "https://files.pythonhosted.org/packages/86/c5/28b2d6f799ec0bdecf44dced2ec5ed43e0eb63097b0f58c293583b406582/cffi-1.17.1-cp312-cp312-win32.whl", hash = "sha256:a08d7e755f8ed21095a310a693525137cfe756ce62d066e53f502a83dc550f65", size = 172448, upload-time = "2024-09-04T20:44:26.208Z" },
+    { url = "https://files.pythonhosted.org/packages/50/b9/db34c4755a7bd1cb2d1603ac3863f22bcecbd1ba29e5ee841a4bc510b294/cffi-1.17.1-cp312-cp312-win_amd64.whl", hash = "sha256:51392eae71afec0d0c8fb1a53b204dbb3bcabcb3c9b807eedf3e1e6ccf2de903", size = 181976, upload-time = "2024-09-04T20:44:27.578Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/f8/dd6c246b148639254dad4d6803eb6a54e8c85c6e11ec9df2cffa87571dbe/cffi-1.17.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f3a2b4222ce6b60e2e8b337bb9596923045681d71e5a082783484d845390938e", size = 182989, upload-time = "2024-09-04T20:44:28.956Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/f1/672d303ddf17c24fc83afd712316fda78dc6fce1cd53011b839483e1ecc8/cffi-1.17.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:0984a4925a435b1da406122d4d7968dd861c1385afe3b45ba82b750f229811e2", size = 178802, upload-time = "2024-09-04T20:44:30.289Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/2d/eab2e858a91fdff70533cab61dcff4a1f55ec60425832ddfdc9cd36bc8af/cffi-1.17.1-cp313-cp313-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:d01b12eeeb4427d3110de311e1774046ad344f5b1a7403101878976ecd7a10f3", size = 454792, upload-time = "2024-09-04T20:44:32.01Z" },
+    { url = "https://files.pythonhosted.org/packages/75/b2/fbaec7c4455c604e29388d55599b99ebcc250a60050610fadde58932b7ee/cffi-1.17.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:706510fe141c86a69c8ddc029c7910003a17353970cff3b904ff0686a5927683", size = 478893, upload-time = "2024-09-04T20:44:33.606Z" },
+    { url = "https://files.pythonhosted.org/packages/4f/b7/6e4a2162178bf1935c336d4da8a9352cccab4d3a5d7914065490f08c0690/cffi-1.17.1-cp313-cp313-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:de55b766c7aa2e2a3092c51e0483d700341182f08e67c63630d5b6f200bb28e5", size = 485810, upload-time = "2024-09-04T20:44:35.191Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/8a/1d0e4a9c26e54746dc08c2c6c037889124d4f59dffd853a659fa545f1b40/cffi-1.17.1-cp313-cp313-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c59d6e989d07460165cc5ad3c61f9fd8f1b4796eacbd81cee78957842b834af4", size = 471200, upload-time = "2024-09-04T20:44:36.743Z" },
+    { url = "https://files.pythonhosted.org/packages/26/9f/1aab65a6c0db35f43c4d1b4f580e8df53914310afc10ae0397d29d697af4/cffi-1.17.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:dd398dbc6773384a17fe0d3e7eeb8d1a21c2200473ee6806bb5e6a8e62bb73dd", size = 479447, upload-time = "2024-09-04T20:44:38.492Z" },
+    { url = "https://files.pythonhosted.org/packages/5f/e4/fb8b3dd8dc0e98edf1135ff067ae070bb32ef9d509d6cb0f538cd6f7483f/cffi-1.17.1-cp313-cp313-musllinux_1_1_aarch64.whl", hash = "sha256:3edc8d958eb099c634dace3c7e16560ae474aa3803a5df240542b305d14e14ed", size = 484358, upload-time = "2024-09-04T20:44:40.046Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/47/d7145bf2dc04684935d57d67dff9d6d795b2ba2796806bb109864be3a151/cffi-1.17.1-cp313-cp313-musllinux_1_1_x86_64.whl", hash = "sha256:72e72408cad3d5419375fc87d289076ee319835bdfa2caad331e377589aebba9", size = 488469, upload-time = "2024-09-04T20:44:41.616Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/ee/f94057fa6426481d663b88637a9a10e859e492c73d0384514a17d78ee205/cffi-1.17.1-cp313-cp313-win32.whl", hash = "sha256:e03eab0a8677fa80d646b5ddece1cbeaf556c313dcfac435ba11f107ba117b5d", size = 172475, upload-time = "2024-09-04T20:44:43.733Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/fc/6a8cb64e5f0324877d503c854da15d76c1e50eb722e320b15345c4d0c6de/cffi-1.17.1-cp313-cp313-win_amd64.whl", hash = "sha256:f6a16c31041f09ead72d69f583767292f750d24913dadacf5756b966aacb3f1a", size = 182009, upload-time = "2024-09-04T20:44:45.309Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/ea/8bb50596b8ffbc49ddd7a1ad305035daa770202a6b782fc164647c2673ad/cffi-1.17.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:b2ab587605f4ba0bf81dc0cb08a41bd1c0a5906bd59243d56bad7668a6fc6c16", size = 182220, upload-time = "2024-09-04T20:45:01.577Z" },
+    { url = "https://files.pythonhosted.org/packages/ae/11/e77c8cd24f58285a82c23af484cf5b124a376b32644e445960d1a4654c3a/cffi-1.17.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:28b16024becceed8c6dfbc75629e27788d8a3f9030691a1dbf9821a128b22c36", size = 178605, upload-time = "2024-09-04T20:45:03.837Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/65/25a8dc32c53bf5b7b6c2686b42ae2ad58743f7ff644844af7cdb29b49361/cffi-1.17.1-cp39-cp39-manylinux_2_12_i686.manylinux2010_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:1d599671f396c4723d016dbddb72fe8e0397082b0a77a4fab8028923bec050e8", size = 424910, upload-time = "2024-09-04T20:45:05.315Z" },
+    { url = "https://files.pythonhosted.org/packages/42/7a/9d086fab7c66bd7c4d0f27c57a1b6b068ced810afc498cc8c49e0088661c/cffi-1.17.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ca74b8dbe6e8e8263c0ffd60277de77dcee6c837a3d0881d8c1ead7268c9e576", size = 447200, upload-time = "2024-09-04T20:45:06.903Z" },
+    { url = "https://files.pythonhosted.org/packages/da/63/1785ced118ce92a993b0ec9e0d0ac8dc3e5dbfbcaa81135be56c69cabbb6/cffi-1.17.1-cp39-cp39-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:f7f5baafcc48261359e14bcd6d9bff6d4b28d9103847c9e136694cb0501aef87", size = 454565, upload-time = "2024-09-04T20:45:08.975Z" },
+    { url = "https://files.pythonhosted.org/packages/74/06/90b8a44abf3556599cdec107f7290277ae8901a58f75e6fe8f970cd72418/cffi-1.17.1-cp39-cp39-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:98e3969bcff97cae1b2def8ba499ea3d6f31ddfdb7635374834cf89a1a08ecf0", size = 435635, upload-time = "2024-09-04T20:45:10.64Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/62/a1f468e5708a70b1d86ead5bab5520861d9c7eacce4a885ded9faa7729c3/cffi-1.17.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:cdf5ce3acdfd1661132f2a9c19cac174758dc2352bfe37d98aa7512c6b7178b3", size = 445218, upload-time = "2024-09-04T20:45:12.366Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/95/b34462f3ccb09c2594aa782d90a90b045de4ff1f70148ee79c69d37a0a5a/cffi-1.17.1-cp39-cp39-musllinux_1_1_aarch64.whl", hash = "sha256:9755e4345d1ec879e3849e62222a18c7174d65a6a92d5b346b1863912168b595", size = 460486, upload-time = "2024-09-04T20:45:13.935Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/fc/a1e4bebd8d680febd29cf6c8a40067182b64f00c7d105f8f26b5bc54317b/cffi-1.17.1-cp39-cp39-musllinux_1_1_i686.whl", hash = "sha256:f1e22e8c4419538cb197e4dd60acc919d7696e5ef98ee4da4e01d3f8cfa4cc5a", size = 437911, upload-time = "2024-09-04T20:45:15.696Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/c3/21cab7a6154b6a5ea330ae80de386e7665254835b9e98ecc1340b3a7de9a/cffi-1.17.1-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:c03e868a0b3bc35839ba98e74211ed2b05d2119be4e8a0f224fba9384f1fe02e", size = 460632, upload-time = "2024-09-04T20:45:17.284Z" },
+    { url = "https://files.pythonhosted.org/packages/cb/b5/fd9f8b5a84010ca169ee49f4e4ad6f8c05f4e3545b72ee041dbbcb159882/cffi-1.17.1-cp39-cp39-win32.whl", hash = "sha256:e31ae45bc2e29f6b2abd0de1cc3b9d5205aa847cafaecb8af1476a609a2f6eb7", size = 171820, upload-time = "2024-09-04T20:45:18.762Z" },
+    { url = "https://files.pythonhosted.org/packages/8c/52/b08750ce0bce45c143e1b5d7357ee8c55341b52bdef4b0f081af1eb248c2/cffi-1.17.1-cp39-cp39-win_amd64.whl", hash = "sha256:d016c76bdd850f3c626af19b0542c9677ba156e4ee4fccfdd7848803533ef662", size = 181290, upload-time = "2024-09-04T20:45:20.226Z" },
 ]
 
 [[package]]
@@ -135,114 +136,114 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "colorama", marker = "sys_platform == 'win32'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/b9/2e/0090cbf739cee7d23781ad4b89a9894a41538e4fcf4c31dcdd705b78eb8b/click-8.1.8.tar.gz", hash = "sha256:ed53c9d8990d83c2a27deae68e4ee337473f6330c040a31d4225c9574d16096a", size = 226593 }
+sdist = { url = "https://files.pythonhosted.org/packages/b9/2e/0090cbf739cee7d23781ad4b89a9894a41538e4fcf4c31dcdd705b78eb8b/click-8.1.8.tar.gz", hash = "sha256:ed53c9d8990d83c2a27deae68e4ee337473f6330c040a31d4225c9574d16096a", size = 226593, upload-time = "2024-12-21T18:38:44.339Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/7e/d4/7ebdbd03970677812aac39c869717059dbb71a4cfc033ca6e5221787892c/click-8.1.8-py3-none-any.whl", hash = "sha256:63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2", size = 98188 },
+    { url = "https://files.pythonhosted.org/packages/7e/d4/7ebdbd03970677812aac39c869717059dbb71a4cfc033ca6e5221787892c/click-8.1.8-py3-none-any.whl", hash = "sha256:63c132bbbed01578a06712a2d1f497bb62d9c1c0d329b7903a866228027263b2", size = 98188, upload-time = "2024-12-21T18:38:41.666Z" },
 ]
 
 [[package]]
 name = "colorama"
 version = "0.4.6"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697 }
+sdist = { url = "https://files.pythonhosted.org/packages/d8/53/6f443c9a4a8358a93a6792e2acffb9d9d5cb0a5cfd8802644b7b1c9a02e4/colorama-0.4.6.tar.gz", hash = "sha256:08695f5cb7ed6e0531a20572697297273c47b8cae5a63ffc6d6ed5c201be6e44", size = 27697, upload-time = "2022-10-25T02:36:22.414Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335 },
+    { url = "https://files.pythonhosted.org/packages/d1/d6/3965ed04c63042e047cb6a3e6ed1a63a35087b6a609aa3a15ed8ac56c221/colorama-0.4.6-py2.py3-none-any.whl", hash = "sha256:4f1d9991f5acc0ca119f9d443620b77f9d6b33703e51011c16baf57afb285fc6", size = 25335, upload-time = "2022-10-25T02:36:20.889Z" },
 ]
 
 [[package]]
 name = "coverage"
 version = "7.6.10"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/84/ba/ac14d281f80aab516275012e8875991bb06203957aa1e19950139238d658/coverage-7.6.10.tar.gz", hash = "sha256:7fb105327c8f8f0682e29843e2ff96af9dcbe5bab8eeb4b398c6a33a16d80a23", size = 803868 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/c5/12/2a2a923edf4ddabdffed7ad6da50d96a5c126dae7b80a33df7310e329a1e/coverage-7.6.10-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:5c912978f7fbf47ef99cec50c4401340436d200d41d714c7a4766f377c5b7b78", size = 207982 },
-    { url = "https://files.pythonhosted.org/packages/ca/49/6985dbca9c7be3f3cb62a2e6e492a0c88b65bf40579e16c71ae9c33c6b23/coverage-7.6.10-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a01ec4af7dfeb96ff0078ad9a48810bb0cc8abcb0115180c6013a6b26237626c", size = 208414 },
-    { url = "https://files.pythonhosted.org/packages/35/93/287e8f1d1ed2646f4e0b2605d14616c9a8a2697d0d1b453815eb5c6cebdb/coverage-7.6.10-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a3b204c11e2b2d883946fe1d97f89403aa1811df28ce0447439178cc7463448a", size = 236860 },
-    { url = "https://files.pythonhosted.org/packages/de/e1/cfdb5627a03567a10031acc629b75d45a4ca1616e54f7133ca1fa366050a/coverage-7.6.10-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:32ee6d8491fcfc82652a37109f69dee9a830e9379166cb73c16d8dc5c2915165", size = 234758 },
-    { url = "https://files.pythonhosted.org/packages/6d/85/fc0de2bcda3f97c2ee9fe8568f7d48f7279e91068958e5b2cc19e0e5f600/coverage-7.6.10-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:675cefc4c06e3b4c876b85bfb7c59c5e2218167bbd4da5075cbe3b5790a28988", size = 235920 },
-    { url = "https://files.pythonhosted.org/packages/79/73/ef4ea0105531506a6f4cf4ba571a214b14a884630b567ed65b3d9c1975e1/coverage-7.6.10-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:f4f620668dbc6f5e909a0946a877310fb3d57aea8198bde792aae369ee1c23b5", size = 234986 },
-    { url = "https://files.pythonhosted.org/packages/c6/4d/75afcfe4432e2ad0405c6f27adeb109ff8976c5e636af8604f94f29fa3fc/coverage-7.6.10-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:4eea95ef275de7abaef630c9b2c002ffbc01918b726a39f5a4353916ec72d2f3", size = 233446 },
-    { url = "https://files.pythonhosted.org/packages/86/5b/efee56a89c16171288cafff022e8af44f8f94075c2d8da563c3935212871/coverage-7.6.10-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:e2f0280519e42b0a17550072861e0bc8a80a0870de260f9796157d3fca2733c5", size = 234566 },
-    { url = "https://files.pythonhosted.org/packages/f2/db/67770cceb4a64d3198bf2aa49946f411b85ec6b0a9b489e61c8467a4253b/coverage-7.6.10-cp310-cp310-win32.whl", hash = "sha256:bc67deb76bc3717f22e765ab3e07ee9c7a5e26b9019ca19a3b063d9f4b874244", size = 210675 },
-    { url = "https://files.pythonhosted.org/packages/8d/27/e8bfc43f5345ec2c27bc8a1fa77cdc5ce9dcf954445e11f14bb70b889d14/coverage-7.6.10-cp310-cp310-win_amd64.whl", hash = "sha256:0f460286cb94036455e703c66988851d970fdfd8acc2a1122ab7f4f904e4029e", size = 211518 },
-    { url = "https://files.pythonhosted.org/packages/85/d2/5e175fcf6766cf7501a8541d81778fd2f52f4870100e791f5327fd23270b/coverage-7.6.10-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ea3c8f04b3e4af80e17bab607c386a830ffc2fb88a5484e1df756478cf70d1d3", size = 208088 },
-    { url = "https://files.pythonhosted.org/packages/4b/6f/06db4dc8fca33c13b673986e20e466fd936235a6ec1f0045c3853ac1b593/coverage-7.6.10-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:507a20fc863cae1d5720797761b42d2d87a04b3e5aeb682ef3b7332e90598f43", size = 208536 },
-    { url = "https://files.pythonhosted.org/packages/0d/62/c6a0cf80318c1c1af376d52df444da3608eafc913b82c84a4600d8349472/coverage-7.6.10-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d37a84878285b903c0fe21ac8794c6dab58150e9359f1aaebbeddd6412d53132", size = 240474 },
-    { url = "https://files.pythonhosted.org/packages/a3/59/750adafc2e57786d2e8739a46b680d4fb0fbc2d57fbcb161290a9f1ecf23/coverage-7.6.10-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a534738b47b0de1995f85f582d983d94031dffb48ab86c95bdf88dc62212142f", size = 237880 },
-    { url = "https://files.pythonhosted.org/packages/2c/f8/ef009b3b98e9f7033c19deb40d629354aab1d8b2d7f9cfec284dbedf5096/coverage-7.6.10-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0d7a2bf79378d8fb8afaa994f91bfd8215134f8631d27eba3e0e2c13546ce994", size = 239750 },
-    { url = "https://files.pythonhosted.org/packages/a6/e2/6622f3b70f5f5b59f705e680dae6db64421af05a5d1e389afd24dae62e5b/coverage-7.6.10-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6713ba4b4ebc330f3def51df1d5d38fad60b66720948112f114968feb52d3f99", size = 238642 },
-    { url = "https://files.pythonhosted.org/packages/2d/10/57ac3f191a3c95c67844099514ff44e6e19b2915cd1c22269fb27f9b17b6/coverage-7.6.10-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:ab32947f481f7e8c763fa2c92fd9f44eeb143e7610c4ca9ecd6a36adab4081bd", size = 237266 },
-    { url = "https://files.pythonhosted.org/packages/ee/2d/7016f4ad9d553cabcb7333ed78ff9d27248ec4eba8dd21fa488254dff894/coverage-7.6.10-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:7bbd8c8f1b115b892e34ba66a097b915d3871db7ce0e6b9901f462ff3a975377", size = 238045 },
-    { url = "https://files.pythonhosted.org/packages/a7/fe/45af5c82389a71e0cae4546413266d2195c3744849669b0bab4b5f2c75da/coverage-7.6.10-cp311-cp311-win32.whl", hash = "sha256:299e91b274c5c9cdb64cbdf1b3e4a8fe538a7a86acdd08fae52301b28ba297f8", size = 210647 },
-    { url = "https://files.pythonhosted.org/packages/db/11/3f8e803a43b79bc534c6a506674da9d614e990e37118b4506faf70d46ed6/coverage-7.6.10-cp311-cp311-win_amd64.whl", hash = "sha256:489a01f94aa581dbd961f306e37d75d4ba16104bbfa2b0edb21d29b73be83609", size = 211508 },
-    { url = "https://files.pythonhosted.org/packages/86/77/19d09ea06f92fdf0487499283b1b7af06bc422ea94534c8fe3a4cd023641/coverage-7.6.10-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:27c6e64726b307782fa5cbe531e7647aee385a29b2107cd87ba7c0105a5d3853", size = 208281 },
-    { url = "https://files.pythonhosted.org/packages/b6/67/5479b9f2f99fcfb49c0d5cf61912a5255ef80b6e80a3cddba39c38146cf4/coverage-7.6.10-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c56e097019e72c373bae32d946ecf9858fda841e48d82df7e81c63ac25554078", size = 208514 },
-    { url = "https://files.pythonhosted.org/packages/15/d1/febf59030ce1c83b7331c3546d7317e5120c5966471727aa7ac157729c4b/coverage-7.6.10-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c7827a5bc7bdb197b9e066cdf650b2887597ad124dd99777332776f7b7c7d0d0", size = 241537 },
-    { url = "https://files.pythonhosted.org/packages/4b/7e/5ac4c90192130e7cf8b63153fe620c8bfd9068f89a6d9b5f26f1550f7a26/coverage-7.6.10-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:204a8238afe787323a8b47d8be4df89772d5c1e4651b9ffa808552bdf20e1d50", size = 238572 },
-    { url = "https://files.pythonhosted.org/packages/dc/03/0334a79b26ecf59958f2fe9dd1f5ab3e2f88db876f5071933de39af09647/coverage-7.6.10-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e67926f51821b8e9deb6426ff3164870976fe414d033ad90ea75e7ed0c2e5022", size = 240639 },
-    { url = "https://files.pythonhosted.org/packages/d7/45/8a707f23c202208d7b286d78ad6233f50dcf929319b664b6cc18a03c1aae/coverage-7.6.10-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e78b270eadb5702938c3dbe9367f878249b5ef9a2fcc5360ac7bff694310d17b", size = 240072 },
-    { url = "https://files.pythonhosted.org/packages/66/02/603ce0ac2d02bc7b393279ef618940b4a0535b0868ee791140bda9ecfa40/coverage-7.6.10-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:714f942b9c15c3a7a5fe6876ce30af831c2ad4ce902410b7466b662358c852c0", size = 238386 },
-    { url = "https://files.pythonhosted.org/packages/04/62/4e6887e9be060f5d18f1dd58c2838b2d9646faf353232dec4e2d4b1c8644/coverage-7.6.10-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:abb02e2f5a3187b2ac4cd46b8ced85a0858230b577ccb2c62c81482ca7d18852", size = 240054 },
-    { url = "https://files.pythonhosted.org/packages/5c/74/83ae4151c170d8bd071924f212add22a0e62a7fe2b149edf016aeecad17c/coverage-7.6.10-cp312-cp312-win32.whl", hash = "sha256:55b201b97286cf61f5e76063f9e2a1d8d2972fc2fcfd2c1272530172fd28c359", size = 210904 },
-    { url = "https://files.pythonhosted.org/packages/c3/54/de0893186a221478f5880283119fc40483bc460b27c4c71d1b8bba3474b9/coverage-7.6.10-cp312-cp312-win_amd64.whl", hash = "sha256:e4ae5ac5e0d1e4edfc9b4b57b4cbecd5bc266a6915c500f358817a8496739247", size = 211692 },
-    { url = "https://files.pythonhosted.org/packages/25/6d/31883d78865529257bf847df5789e2ae80e99de8a460c3453dbfbe0db069/coverage-7.6.10-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:05fca8ba6a87aabdd2d30d0b6c838b50510b56cdcfc604d40760dae7153b73d9", size = 208308 },
-    { url = "https://files.pythonhosted.org/packages/70/22/3f2b129cc08de00c83b0ad6252e034320946abfc3e4235c009e57cfeee05/coverage-7.6.10-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:9e80eba8801c386f72e0712a0453431259c45c3249f0009aff537a517b52942b", size = 208565 },
-    { url = "https://files.pythonhosted.org/packages/97/0a/d89bc2d1cc61d3a8dfe9e9d75217b2be85f6c73ebf1b9e3c2f4e797f4531/coverage-7.6.10-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a372c89c939d57abe09e08c0578c1d212e7a678135d53aa16eec4430adc5e690", size = 241083 },
-    { url = "https://files.pythonhosted.org/packages/4c/81/6d64b88a00c7a7aaed3a657b8eaa0931f37a6395fcef61e53ff742b49c97/coverage-7.6.10-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ec22b5e7fe7a0fa8509181c4aac1db48f3dd4d3a566131b313d1efc102892c18", size = 238235 },
-    { url = "https://files.pythonhosted.org/packages/9a/0b/7797d4193f5adb4b837207ed87fecf5fc38f7cc612b369a8e8e12d9fa114/coverage-7.6.10-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:26bcf5c4df41cad1b19c84af71c22cbc9ea9a547fc973f1f2cc9a290002c8b3c", size = 240220 },
-    { url = "https://files.pythonhosted.org/packages/65/4d/6f83ca1bddcf8e51bf8ff71572f39a1c73c34cf50e752a952c34f24d0a60/coverage-7.6.10-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4e4630c26b6084c9b3cb53b15bd488f30ceb50b73c35c5ad7871b869cb7365fd", size = 239847 },
-    { url = "https://files.pythonhosted.org/packages/30/9d/2470df6aa146aff4c65fee0f87f58d2164a67533c771c9cc12ffcdb865d5/coverage-7.6.10-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:2396e8116db77789f819d2bc8a7e200232b7a282c66e0ae2d2cd84581a89757e", size = 237922 },
-    { url = "https://files.pythonhosted.org/packages/08/dd/723fef5d901e6a89f2507094db66c091449c8ba03272861eaefa773ad95c/coverage-7.6.10-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:79109c70cc0882e4d2d002fe69a24aa504dec0cc17169b3c7f41a1d341a73694", size = 239783 },
-    { url = "https://files.pythonhosted.org/packages/3d/f7/64d3298b2baf261cb35466000628706ce20a82d42faf9b771af447cd2b76/coverage-7.6.10-cp313-cp313-win32.whl", hash = "sha256:9e1747bab246d6ff2c4f28b4d186b205adced9f7bd9dc362051cc37c4a0c7bd6", size = 210965 },
-    { url = "https://files.pythonhosted.org/packages/d5/58/ec43499a7fc681212fe7742fe90b2bc361cdb72e3181ace1604247a5b24d/coverage-7.6.10-cp313-cp313-win_amd64.whl", hash = "sha256:254f1a3b1eef5f7ed23ef265eaa89c65c8c5b6b257327c149db1ca9d4a35f25e", size = 211719 },
-    { url = "https://files.pythonhosted.org/packages/ab/c9/f2857a135bcff4330c1e90e7d03446b036b2363d4ad37eb5e3a47bbac8a6/coverage-7.6.10-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:2ccf240eb719789cedbb9fd1338055de2761088202a9a0b73032857e53f612fe", size = 209050 },
-    { url = "https://files.pythonhosted.org/packages/aa/b3/f840e5bd777d8433caa9e4a1eb20503495709f697341ac1a8ee6a3c906ad/coverage-7.6.10-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:0c807ca74d5a5e64427c8805de15b9ca140bba13572d6d74e262f46f50b13273", size = 209321 },
-    { url = "https://files.pythonhosted.org/packages/85/7d/125a5362180fcc1c03d91850fc020f3831d5cda09319522bcfa6b2b70be7/coverage-7.6.10-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2bcfa46d7709b5a7ffe089075799b902020b62e7ee56ebaed2f4bdac04c508d8", size = 252039 },
-    { url = "https://files.pythonhosted.org/packages/a9/9c/4358bf3c74baf1f9bddd2baf3756b54c07f2cfd2535f0a47f1e7757e54b3/coverage-7.6.10-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4e0de1e902669dccbf80b0415fb6b43d27edca2fbd48c74da378923b05316098", size = 247758 },
-    { url = "https://files.pythonhosted.org/packages/cf/c7/de3eb6fc5263b26fab5cda3de7a0f80e317597a4bad4781859f72885f300/coverage-7.6.10-cp313-cp313t-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3f7b444c42bbc533aaae6b5a2166fd1a797cdb5eb58ee51a92bee1eb94a1e1cb", size = 250119 },
-    { url = "https://files.pythonhosted.org/packages/3e/e6/43de91f8ba2ec9140c6a4af1102141712949903dc732cf739167cfa7a3bc/coverage-7.6.10-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:b330368cb99ef72fcd2dc3ed260adf67b31499584dc8a20225e85bfe6f6cfed0", size = 249597 },
-    { url = "https://files.pythonhosted.org/packages/08/40/61158b5499aa2adf9e37bc6d0117e8f6788625b283d51e7e0c53cf340530/coverage-7.6.10-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:9a7cfb50515f87f7ed30bc882f68812fd98bc2852957df69f3003d22a2aa0abf", size = 247473 },
-    { url = "https://files.pythonhosted.org/packages/50/69/b3f2416725621e9f112e74e8470793d5b5995f146f596f133678a633b77e/coverage-7.6.10-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6f93531882a5f68c28090f901b1d135de61b56331bba82028489bc51bdd818d2", size = 248737 },
-    { url = "https://files.pythonhosted.org/packages/3c/6e/fe899fb937657db6df31cc3e61c6968cb56d36d7326361847440a430152e/coverage-7.6.10-cp313-cp313t-win32.whl", hash = "sha256:89d76815a26197c858f53c7f6a656686ec392b25991f9e409bcef020cd532312", size = 211611 },
-    { url = "https://files.pythonhosted.org/packages/1c/55/52f5e66142a9d7bc93a15192eba7a78513d2abf6b3558d77b4ca32f5f424/coverage-7.6.10-cp313-cp313t-win_amd64.whl", hash = "sha256:54a5f0f43950a36312155dae55c505a76cd7f2b12d26abeebbe7a0b36dbc868d", size = 212781 },
-    { url = "https://files.pythonhosted.org/packages/40/41/473617aadf9a1c15bc2d56be65d90d7c29bfa50a957a67ef96462f7ebf8e/coverage-7.6.10-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:656c82b8a0ead8bba147de9a89bda95064874c91a3ed43a00e687f23cc19d53a", size = 207978 },
-    { url = "https://files.pythonhosted.org/packages/10/f6/480586607768b39a30e6910a3c4522139094ac0f1677028e1f4823688957/coverage-7.6.10-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:ccc2b70a7ed475c68ceb548bf69cec1e27305c1c2606a5eb7c3afff56a1b3b27", size = 208415 },
-    { url = "https://files.pythonhosted.org/packages/f1/af/439bb760f817deff6f4d38fe7da08d9dd7874a560241f1945bc3b4446550/coverage-7.6.10-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a5e37dc41d57ceba70956fa2fc5b63c26dba863c946ace9705f8eca99daecdc4", size = 236452 },
-    { url = "https://files.pythonhosted.org/packages/d0/13/481f4ceffcabe29ee2332e60efb52e4694f54a402f3ada2bcec10bb32e43/coverage-7.6.10-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0aa9692b4fdd83a4647eeb7db46410ea1322b5ed94cd1715ef09d1d5922ba87f", size = 234374 },
-    { url = "https://files.pythonhosted.org/packages/c5/59/4607ea9d6b1b73e905c7656da08d0b00cdf6e59f2293ec259e8914160025/coverage-7.6.10-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aa744da1820678b475e4ba3dfd994c321c5b13381d1041fe9c608620e6676e25", size = 235505 },
-    { url = "https://files.pythonhosted.org/packages/85/60/d66365723b9b7f29464b11d024248ed3523ce5aab958e4ad8c43f3f4148b/coverage-7.6.10-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:c0b1818063dc9e9d838c09e3a473c1422f517889436dd980f5d721899e66f315", size = 234616 },
-    { url = "https://files.pythonhosted.org/packages/74/f8/2cf7a38e7d81b266f47dfcf137fecd8fa66c7bdbd4228d611628d8ca3437/coverage-7.6.10-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:59af35558ba08b758aec4d56182b222976330ef8d2feacbb93964f576a7e7a90", size = 233099 },
-    { url = "https://files.pythonhosted.org/packages/50/2b/bff6c1c6b63c4396ea7ecdbf8db1788b46046c681b8fcc6ec77db9f4ea49/coverage-7.6.10-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:7ed2f37cfce1ce101e6dffdfd1c99e729dd2ffc291d02d3e2d0af8b53d13840d", size = 234089 },
-    { url = "https://files.pythonhosted.org/packages/bf/b5/baace1c754d546a67779358341aa8d2f7118baf58cac235db457e1001d1b/coverage-7.6.10-cp39-cp39-win32.whl", hash = "sha256:4bcc276261505d82f0ad426870c3b12cb177752834a633e737ec5ee79bbdff18", size = 210701 },
-    { url = "https://files.pythonhosted.org/packages/b1/bf/9e1e95b8b20817398ecc5a1e8d3e05ff404e1b9fb2185cd71561698fe2a2/coverage-7.6.10-cp39-cp39-win_amd64.whl", hash = "sha256:457574f4599d2b00f7f637a0700a6422243b3565509457b2dbd3f50703e11f59", size = 211482 },
-    { url = "https://files.pythonhosted.org/packages/a1/70/de81bfec9ed38a64fc44a77c7665e20ca507fc3265597c28b0d989e4082e/coverage-7.6.10-pp39.pp310-none-any.whl", hash = "sha256:fd34e7b3405f0cc7ab03d54a334c17a9e802897580d964bd8c2001f4b9fd488f", size = 200223 },
+sdist = { url = "https://files.pythonhosted.org/packages/84/ba/ac14d281f80aab516275012e8875991bb06203957aa1e19950139238d658/coverage-7.6.10.tar.gz", hash = "sha256:7fb105327c8f8f0682e29843e2ff96af9dcbe5bab8eeb4b398c6a33a16d80a23", size = 803868, upload-time = "2024-12-26T16:59:18.734Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/c5/12/2a2a923edf4ddabdffed7ad6da50d96a5c126dae7b80a33df7310e329a1e/coverage-7.6.10-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:5c912978f7fbf47ef99cec50c4401340436d200d41d714c7a4766f377c5b7b78", size = 207982, upload-time = "2024-12-26T16:57:00.767Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/49/6985dbca9c7be3f3cb62a2e6e492a0c88b65bf40579e16c71ae9c33c6b23/coverage-7.6.10-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:a01ec4af7dfeb96ff0078ad9a48810bb0cc8abcb0115180c6013a6b26237626c", size = 208414, upload-time = "2024-12-26T16:57:03.826Z" },
+    { url = "https://files.pythonhosted.org/packages/35/93/287e8f1d1ed2646f4e0b2605d14616c9a8a2697d0d1b453815eb5c6cebdb/coverage-7.6.10-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a3b204c11e2b2d883946fe1d97f89403aa1811df28ce0447439178cc7463448a", size = 236860, upload-time = "2024-12-26T16:57:06.509Z" },
+    { url = "https://files.pythonhosted.org/packages/de/e1/cfdb5627a03567a10031acc629b75d45a4ca1616e54f7133ca1fa366050a/coverage-7.6.10-cp310-cp310-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:32ee6d8491fcfc82652a37109f69dee9a830e9379166cb73c16d8dc5c2915165", size = 234758, upload-time = "2024-12-26T16:57:09.089Z" },
+    { url = "https://files.pythonhosted.org/packages/6d/85/fc0de2bcda3f97c2ee9fe8568f7d48f7279e91068958e5b2cc19e0e5f600/coverage-7.6.10-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:675cefc4c06e3b4c876b85bfb7c59c5e2218167bbd4da5075cbe3b5790a28988", size = 235920, upload-time = "2024-12-26T16:57:10.445Z" },
+    { url = "https://files.pythonhosted.org/packages/79/73/ef4ea0105531506a6f4cf4ba571a214b14a884630b567ed65b3d9c1975e1/coverage-7.6.10-cp310-cp310-musllinux_1_2_aarch64.whl", hash = "sha256:f4f620668dbc6f5e909a0946a877310fb3d57aea8198bde792aae369ee1c23b5", size = 234986, upload-time = "2024-12-26T16:57:13.298Z" },
+    { url = "https://files.pythonhosted.org/packages/c6/4d/75afcfe4432e2ad0405c6f27adeb109ff8976c5e636af8604f94f29fa3fc/coverage-7.6.10-cp310-cp310-musllinux_1_2_i686.whl", hash = "sha256:4eea95ef275de7abaef630c9b2c002ffbc01918b726a39f5a4353916ec72d2f3", size = 233446, upload-time = "2024-12-26T16:57:14.742Z" },
+    { url = "https://files.pythonhosted.org/packages/86/5b/efee56a89c16171288cafff022e8af44f8f94075c2d8da563c3935212871/coverage-7.6.10-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:e2f0280519e42b0a17550072861e0bc8a80a0870de260f9796157d3fca2733c5", size = 234566, upload-time = "2024-12-26T16:57:17.368Z" },
+    { url = "https://files.pythonhosted.org/packages/f2/db/67770cceb4a64d3198bf2aa49946f411b85ec6b0a9b489e61c8467a4253b/coverage-7.6.10-cp310-cp310-win32.whl", hash = "sha256:bc67deb76bc3717f22e765ab3e07ee9c7a5e26b9019ca19a3b063d9f4b874244", size = 210675, upload-time = "2024-12-26T16:57:18.775Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/27/e8bfc43f5345ec2c27bc8a1fa77cdc5ce9dcf954445e11f14bb70b889d14/coverage-7.6.10-cp310-cp310-win_amd64.whl", hash = "sha256:0f460286cb94036455e703c66988851d970fdfd8acc2a1122ab7f4f904e4029e", size = 211518, upload-time = "2024-12-26T16:57:21.415Z" },
+    { url = "https://files.pythonhosted.org/packages/85/d2/5e175fcf6766cf7501a8541d81778fd2f52f4870100e791f5327fd23270b/coverage-7.6.10-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:ea3c8f04b3e4af80e17bab607c386a830ffc2fb88a5484e1df756478cf70d1d3", size = 208088, upload-time = "2024-12-26T16:57:22.833Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/6f/06db4dc8fca33c13b673986e20e466fd936235a6ec1f0045c3853ac1b593/coverage-7.6.10-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:507a20fc863cae1d5720797761b42d2d87a04b3e5aeb682ef3b7332e90598f43", size = 208536, upload-time = "2024-12-26T16:57:25.578Z" },
+    { url = "https://files.pythonhosted.org/packages/0d/62/c6a0cf80318c1c1af376d52df444da3608eafc913b82c84a4600d8349472/coverage-7.6.10-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:d37a84878285b903c0fe21ac8794c6dab58150e9359f1aaebbeddd6412d53132", size = 240474, upload-time = "2024-12-26T16:57:28.659Z" },
+    { url = "https://files.pythonhosted.org/packages/a3/59/750adafc2e57786d2e8739a46b680d4fb0fbc2d57fbcb161290a9f1ecf23/coverage-7.6.10-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:a534738b47b0de1995f85f582d983d94031dffb48ab86c95bdf88dc62212142f", size = 237880, upload-time = "2024-12-26T16:57:30.095Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/f8/ef009b3b98e9f7033c19deb40d629354aab1d8b2d7f9cfec284dbedf5096/coverage-7.6.10-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0d7a2bf79378d8fb8afaa994f91bfd8215134f8631d27eba3e0e2c13546ce994", size = 239750, upload-time = "2024-12-26T16:57:31.48Z" },
+    { url = "https://files.pythonhosted.org/packages/a6/e2/6622f3b70f5f5b59f705e680dae6db64421af05a5d1e389afd24dae62e5b/coverage-7.6.10-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:6713ba4b4ebc330f3def51df1d5d38fad60b66720948112f114968feb52d3f99", size = 238642, upload-time = "2024-12-26T16:57:34.09Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/10/57ac3f191a3c95c67844099514ff44e6e19b2915cd1c22269fb27f9b17b6/coverage-7.6.10-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:ab32947f481f7e8c763fa2c92fd9f44eeb143e7610c4ca9ecd6a36adab4081bd", size = 237266, upload-time = "2024-12-26T16:57:35.48Z" },
+    { url = "https://files.pythonhosted.org/packages/ee/2d/7016f4ad9d553cabcb7333ed78ff9d27248ec4eba8dd21fa488254dff894/coverage-7.6.10-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:7bbd8c8f1b115b892e34ba66a097b915d3871db7ce0e6b9901f462ff3a975377", size = 238045, upload-time = "2024-12-26T16:57:36.952Z" },
+    { url = "https://files.pythonhosted.org/packages/a7/fe/45af5c82389a71e0cae4546413266d2195c3744849669b0bab4b5f2c75da/coverage-7.6.10-cp311-cp311-win32.whl", hash = "sha256:299e91b274c5c9cdb64cbdf1b3e4a8fe538a7a86acdd08fae52301b28ba297f8", size = 210647, upload-time = "2024-12-26T16:57:39.84Z" },
+    { url = "https://files.pythonhosted.org/packages/db/11/3f8e803a43b79bc534c6a506674da9d614e990e37118b4506faf70d46ed6/coverage-7.6.10-cp311-cp311-win_amd64.whl", hash = "sha256:489a01f94aa581dbd961f306e37d75d4ba16104bbfa2b0edb21d29b73be83609", size = 211508, upload-time = "2024-12-26T16:57:41.234Z" },
+    { url = "https://files.pythonhosted.org/packages/86/77/19d09ea06f92fdf0487499283b1b7af06bc422ea94534c8fe3a4cd023641/coverage-7.6.10-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:27c6e64726b307782fa5cbe531e7647aee385a29b2107cd87ba7c0105a5d3853", size = 208281, upload-time = "2024-12-26T16:57:42.968Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/67/5479b9f2f99fcfb49c0d5cf61912a5255ef80b6e80a3cddba39c38146cf4/coverage-7.6.10-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:c56e097019e72c373bae32d946ecf9858fda841e48d82df7e81c63ac25554078", size = 208514, upload-time = "2024-12-26T16:57:45.747Z" },
+    { url = "https://files.pythonhosted.org/packages/15/d1/febf59030ce1c83b7331c3546d7317e5120c5966471727aa7ac157729c4b/coverage-7.6.10-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:c7827a5bc7bdb197b9e066cdf650b2887597ad124dd99777332776f7b7c7d0d0", size = 241537, upload-time = "2024-12-26T16:57:48.647Z" },
+    { url = "https://files.pythonhosted.org/packages/4b/7e/5ac4c90192130e7cf8b63153fe620c8bfd9068f89a6d9b5f26f1550f7a26/coverage-7.6.10-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:204a8238afe787323a8b47d8be4df89772d5c1e4651b9ffa808552bdf20e1d50", size = 238572, upload-time = "2024-12-26T16:57:51.668Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/03/0334a79b26ecf59958f2fe9dd1f5ab3e2f88db876f5071933de39af09647/coverage-7.6.10-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e67926f51821b8e9deb6426ff3164870976fe414d033ad90ea75e7ed0c2e5022", size = 240639, upload-time = "2024-12-26T16:57:53.175Z" },
+    { url = "https://files.pythonhosted.org/packages/d7/45/8a707f23c202208d7b286d78ad6233f50dcf929319b664b6cc18a03c1aae/coverage-7.6.10-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:e78b270eadb5702938c3dbe9367f878249b5ef9a2fcc5360ac7bff694310d17b", size = 240072, upload-time = "2024-12-26T16:57:56.087Z" },
+    { url = "https://files.pythonhosted.org/packages/66/02/603ce0ac2d02bc7b393279ef618940b4a0535b0868ee791140bda9ecfa40/coverage-7.6.10-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:714f942b9c15c3a7a5fe6876ce30af831c2ad4ce902410b7466b662358c852c0", size = 238386, upload-time = "2024-12-26T16:57:57.572Z" },
+    { url = "https://files.pythonhosted.org/packages/04/62/4e6887e9be060f5d18f1dd58c2838b2d9646faf353232dec4e2d4b1c8644/coverage-7.6.10-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:abb02e2f5a3187b2ac4cd46b8ced85a0858230b577ccb2c62c81482ca7d18852", size = 240054, upload-time = "2024-12-26T16:57:58.967Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/74/83ae4151c170d8bd071924f212add22a0e62a7fe2b149edf016aeecad17c/coverage-7.6.10-cp312-cp312-win32.whl", hash = "sha256:55b201b97286cf61f5e76063f9e2a1d8d2972fc2fcfd2c1272530172fd28c359", size = 210904, upload-time = "2024-12-26T16:58:00.688Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/54/de0893186a221478f5880283119fc40483bc460b27c4c71d1b8bba3474b9/coverage-7.6.10-cp312-cp312-win_amd64.whl", hash = "sha256:e4ae5ac5e0d1e4edfc9b4b57b4cbecd5bc266a6915c500f358817a8496739247", size = 211692, upload-time = "2024-12-26T16:58:02.35Z" },
+    { url = "https://files.pythonhosted.org/packages/25/6d/31883d78865529257bf847df5789e2ae80e99de8a460c3453dbfbe0db069/coverage-7.6.10-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:05fca8ba6a87aabdd2d30d0b6c838b50510b56cdcfc604d40760dae7153b73d9", size = 208308, upload-time = "2024-12-26T16:58:04.487Z" },
+    { url = "https://files.pythonhosted.org/packages/70/22/3f2b129cc08de00c83b0ad6252e034320946abfc3e4235c009e57cfeee05/coverage-7.6.10-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:9e80eba8801c386f72e0712a0453431259c45c3249f0009aff537a517b52942b", size = 208565, upload-time = "2024-12-26T16:58:06.774Z" },
+    { url = "https://files.pythonhosted.org/packages/97/0a/d89bc2d1cc61d3a8dfe9e9d75217b2be85f6c73ebf1b9e3c2f4e797f4531/coverage-7.6.10-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a372c89c939d57abe09e08c0578c1d212e7a678135d53aa16eec4430adc5e690", size = 241083, upload-time = "2024-12-26T16:58:10.27Z" },
+    { url = "https://files.pythonhosted.org/packages/4c/81/6d64b88a00c7a7aaed3a657b8eaa0931f37a6395fcef61e53ff742b49c97/coverage-7.6.10-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:ec22b5e7fe7a0fa8509181c4aac1db48f3dd4d3a566131b313d1efc102892c18", size = 238235, upload-time = "2024-12-26T16:58:12.497Z" },
+    { url = "https://files.pythonhosted.org/packages/9a/0b/7797d4193f5adb4b837207ed87fecf5fc38f7cc612b369a8e8e12d9fa114/coverage-7.6.10-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:26bcf5c4df41cad1b19c84af71c22cbc9ea9a547fc973f1f2cc9a290002c8b3c", size = 240220, upload-time = "2024-12-26T16:58:15.619Z" },
+    { url = "https://files.pythonhosted.org/packages/65/4d/6f83ca1bddcf8e51bf8ff71572f39a1c73c34cf50e752a952c34f24d0a60/coverage-7.6.10-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4e4630c26b6084c9b3cb53b15bd488f30ceb50b73c35c5ad7871b869cb7365fd", size = 239847, upload-time = "2024-12-26T16:58:17.126Z" },
+    { url = "https://files.pythonhosted.org/packages/30/9d/2470df6aa146aff4c65fee0f87f58d2164a67533c771c9cc12ffcdb865d5/coverage-7.6.10-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:2396e8116db77789f819d2bc8a7e200232b7a282c66e0ae2d2cd84581a89757e", size = 237922, upload-time = "2024-12-26T16:58:20.198Z" },
+    { url = "https://files.pythonhosted.org/packages/08/dd/723fef5d901e6a89f2507094db66c091449c8ba03272861eaefa773ad95c/coverage-7.6.10-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:79109c70cc0882e4d2d002fe69a24aa504dec0cc17169b3c7f41a1d341a73694", size = 239783, upload-time = "2024-12-26T16:58:23.614Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/f7/64d3298b2baf261cb35466000628706ce20a82d42faf9b771af447cd2b76/coverage-7.6.10-cp313-cp313-win32.whl", hash = "sha256:9e1747bab246d6ff2c4f28b4d186b205adced9f7bd9dc362051cc37c4a0c7bd6", size = 210965, upload-time = "2024-12-26T16:58:26.765Z" },
+    { url = "https://files.pythonhosted.org/packages/d5/58/ec43499a7fc681212fe7742fe90b2bc361cdb72e3181ace1604247a5b24d/coverage-7.6.10-cp313-cp313-win_amd64.whl", hash = "sha256:254f1a3b1eef5f7ed23ef265eaa89c65c8c5b6b257327c149db1ca9d4a35f25e", size = 211719, upload-time = "2024-12-26T16:58:28.781Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/c9/f2857a135bcff4330c1e90e7d03446b036b2363d4ad37eb5e3a47bbac8a6/coverage-7.6.10-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:2ccf240eb719789cedbb9fd1338055de2761088202a9a0b73032857e53f612fe", size = 209050, upload-time = "2024-12-26T16:58:31.616Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/b3/f840e5bd777d8433caa9e4a1eb20503495709f697341ac1a8ee6a3c906ad/coverage-7.6.10-cp313-cp313t-macosx_11_0_arm64.whl", hash = "sha256:0c807ca74d5a5e64427c8805de15b9ca140bba13572d6d74e262f46f50b13273", size = 209321, upload-time = "2024-12-26T16:58:34.509Z" },
+    { url = "https://files.pythonhosted.org/packages/85/7d/125a5362180fcc1c03d91850fc020f3831d5cda09319522bcfa6b2b70be7/coverage-7.6.10-cp313-cp313t-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:2bcfa46d7709b5a7ffe089075799b902020b62e7ee56ebaed2f4bdac04c508d8", size = 252039, upload-time = "2024-12-26T16:58:36.072Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/9c/4358bf3c74baf1f9bddd2baf3756b54c07f2cfd2535f0a47f1e7757e54b3/coverage-7.6.10-cp313-cp313t-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:4e0de1e902669dccbf80b0415fb6b43d27edca2fbd48c74da378923b05316098", size = 247758, upload-time = "2024-12-26T16:58:39.458Z" },
+    { url = "https://files.pythonhosted.org/packages/cf/c7/de3eb6fc5263b26fab5cda3de7a0f80e317597a4bad4781859f72885f300/coverage-7.6.10-cp313-cp313t-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3f7b444c42bbc533aaae6b5a2166fd1a797cdb5eb58ee51a92bee1eb94a1e1cb", size = 250119, upload-time = "2024-12-26T16:58:41.018Z" },
+    { url = "https://files.pythonhosted.org/packages/3e/e6/43de91f8ba2ec9140c6a4af1102141712949903dc732cf739167cfa7a3bc/coverage-7.6.10-cp313-cp313t-musllinux_1_2_aarch64.whl", hash = "sha256:b330368cb99ef72fcd2dc3ed260adf67b31499584dc8a20225e85bfe6f6cfed0", size = 249597, upload-time = "2024-12-26T16:58:42.827Z" },
+    { url = "https://files.pythonhosted.org/packages/08/40/61158b5499aa2adf9e37bc6d0117e8f6788625b283d51e7e0c53cf340530/coverage-7.6.10-cp313-cp313t-musllinux_1_2_i686.whl", hash = "sha256:9a7cfb50515f87f7ed30bc882f68812fd98bc2852957df69f3003d22a2aa0abf", size = 247473, upload-time = "2024-12-26T16:58:44.486Z" },
+    { url = "https://files.pythonhosted.org/packages/50/69/b3f2416725621e9f112e74e8470793d5b5995f146f596f133678a633b77e/coverage-7.6.10-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:6f93531882a5f68c28090f901b1d135de61b56331bba82028489bc51bdd818d2", size = 248737, upload-time = "2024-12-26T16:58:45.919Z" },
+    { url = "https://files.pythonhosted.org/packages/3c/6e/fe899fb937657db6df31cc3e61c6968cb56d36d7326361847440a430152e/coverage-7.6.10-cp313-cp313t-win32.whl", hash = "sha256:89d76815a26197c858f53c7f6a656686ec392b25991f9e409bcef020cd532312", size = 211611, upload-time = "2024-12-26T16:58:47.883Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/55/52f5e66142a9d7bc93a15192eba7a78513d2abf6b3558d77b4ca32f5f424/coverage-7.6.10-cp313-cp313t-win_amd64.whl", hash = "sha256:54a5f0f43950a36312155dae55c505a76cd7f2b12d26abeebbe7a0b36dbc868d", size = 212781, upload-time = "2024-12-26T16:58:50.822Z" },
+    { url = "https://files.pythonhosted.org/packages/40/41/473617aadf9a1c15bc2d56be65d90d7c29bfa50a957a67ef96462f7ebf8e/coverage-7.6.10-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:656c82b8a0ead8bba147de9a89bda95064874c91a3ed43a00e687f23cc19d53a", size = 207978, upload-time = "2024-12-26T16:58:52.834Z" },
+    { url = "https://files.pythonhosted.org/packages/10/f6/480586607768b39a30e6910a3c4522139094ac0f1677028e1f4823688957/coverage-7.6.10-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:ccc2b70a7ed475c68ceb548bf69cec1e27305c1c2606a5eb7c3afff56a1b3b27", size = 208415, upload-time = "2024-12-26T16:58:56.317Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/af/439bb760f817deff6f4d38fe7da08d9dd7874a560241f1945bc3b4446550/coverage-7.6.10-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a5e37dc41d57ceba70956fa2fc5b63c26dba863c946ace9705f8eca99daecdc4", size = 236452, upload-time = "2024-12-26T16:58:59.158Z" },
+    { url = "https://files.pythonhosted.org/packages/d0/13/481f4ceffcabe29ee2332e60efb52e4694f54a402f3ada2bcec10bb32e43/coverage-7.6.10-cp39-cp39-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:0aa9692b4fdd83a4647eeb7db46410ea1322b5ed94cd1715ef09d1d5922ba87f", size = 234374, upload-time = "2024-12-26T16:59:00.809Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/59/4607ea9d6b1b73e905c7656da08d0b00cdf6e59f2293ec259e8914160025/coverage-7.6.10-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:aa744da1820678b475e4ba3dfd994c321c5b13381d1041fe9c608620e6676e25", size = 235505, upload-time = "2024-12-26T16:59:03.869Z" },
+    { url = "https://files.pythonhosted.org/packages/85/60/d66365723b9b7f29464b11d024248ed3523ce5aab958e4ad8c43f3f4148b/coverage-7.6.10-cp39-cp39-musllinux_1_2_aarch64.whl", hash = "sha256:c0b1818063dc9e9d838c09e3a473c1422f517889436dd980f5d721899e66f315", size = 234616, upload-time = "2024-12-26T16:59:05.876Z" },
+    { url = "https://files.pythonhosted.org/packages/74/f8/2cf7a38e7d81b266f47dfcf137fecd8fa66c7bdbd4228d611628d8ca3437/coverage-7.6.10-cp39-cp39-musllinux_1_2_i686.whl", hash = "sha256:59af35558ba08b758aec4d56182b222976330ef8d2feacbb93964f576a7e7a90", size = 233099, upload-time = "2024-12-26T16:59:08.927Z" },
+    { url = "https://files.pythonhosted.org/packages/50/2b/bff6c1c6b63c4396ea7ecdbf8db1788b46046c681b8fcc6ec77db9f4ea49/coverage-7.6.10-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:7ed2f37cfce1ce101e6dffdfd1c99e729dd2ffc291d02d3e2d0af8b53d13840d", size = 234089, upload-time = "2024-12-26T16:59:10.574Z" },
+    { url = "https://files.pythonhosted.org/packages/bf/b5/baace1c754d546a67779358341aa8d2f7118baf58cac235db457e1001d1b/coverage-7.6.10-cp39-cp39-win32.whl", hash = "sha256:4bcc276261505d82f0ad426870c3b12cb177752834a633e737ec5ee79bbdff18", size = 210701, upload-time = "2024-12-26T16:59:12.212Z" },
+    { url = "https://files.pythonhosted.org/packages/b1/bf/9e1e95b8b20817398ecc5a1e8d3e05ff404e1b9fb2185cd71561698fe2a2/coverage-7.6.10-cp39-cp39-win_amd64.whl", hash = "sha256:457574f4599d2b00f7f637a0700a6422243b3565509457b2dbd3f50703e11f59", size = 211482, upload-time = "2024-12-26T16:59:15.165Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/70/de81bfec9ed38a64fc44a77c7665e20ca507fc3265597c28b0d989e4082e/coverage-7.6.10-pp39.pp310-none-any.whl", hash = "sha256:fd34e7b3405f0cc7ab03d54a334c17a9e802897580d964bd8c2001f4b9fd488f", size = 200223, upload-time = "2024-12-26T16:59:16.968Z" },
 ]
 
 [[package]]
 name = "dirty-equals"
 version = "0.9.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/b0/99/133892f401ced5a27e641a473c547d5fbdb39af8f85dac8a9d633ea3e7a7/dirty_equals-0.9.0.tar.gz", hash = "sha256:17f515970b04ed7900b733c95fd8091f4f85e52f1fb5f268757f25c858eb1f7b", size = 50412 }
+sdist = { url = "https://files.pythonhosted.org/packages/b0/99/133892f401ced5a27e641a473c547d5fbdb39af8f85dac8a9d633ea3e7a7/dirty_equals-0.9.0.tar.gz", hash = "sha256:17f515970b04ed7900b733c95fd8091f4f85e52f1fb5f268757f25c858eb1f7b", size = 50412, upload-time = "2025-01-11T23:23:40.491Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/77/0c/03cc99bf3b6328604b10829de3460f2b2ad3373200c45665c38508e550c6/dirty_equals-0.9.0-py3-none-any.whl", hash = "sha256:ff4d027f5cfa1b69573af00f7ba9043ea652dbdce3fe5cbe828e478c7346db9c", size = 28226 },
+    { url = "https://files.pythonhosted.org/packages/77/0c/03cc99bf3b6328604b10829de3460f2b2ad3373200c45665c38508e550c6/dirty_equals-0.9.0-py3-none-any.whl", hash = "sha256:ff4d027f5cfa1b69573af00f7ba9043ea652dbdce3fe5cbe828e478c7346db9c", size = 28226, upload-time = "2025-01-11T23:23:37.489Z" },
 ]
 
 [[package]]
 name = "exceptiongroup"
 version = "1.2.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/09/35/2495c4ac46b980e4ca1f6ad6db102322ef3ad2410b79fdde159a4b0f3b92/exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc", size = 28883 }
+sdist = { url = "https://files.pythonhosted.org/packages/09/35/2495c4ac46b980e4ca1f6ad6db102322ef3ad2410b79fdde159a4b0f3b92/exceptiongroup-1.2.2.tar.gz", hash = "sha256:47c2edf7c6738fafb49fd34290706d1a1a2f4d1c6df275526b62cbb4aa5393cc", size = 28883, upload-time = "2024-07-12T22:26:00.161Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/02/cc/b7e31358aac6ed1ef2bb790a9746ac2c69bcb3c8588b41616914eb106eaf/exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b", size = 16453 },
+    { url = "https://files.pythonhosted.org/packages/02/cc/b7e31358aac6ed1ef2bb790a9746ac2c69bcb3c8588b41616914eb106eaf/exceptiongroup-1.2.2-py3-none-any.whl", hash = "sha256:3111b9d131c238bec2f8f516e123e14ba243563fb135d3fe885990585aa7795b", size = 16453, upload-time = "2024-07-12T22:25:58.476Z" },
 ]
 
 [[package]]
 name = "executing"
 version = "2.2.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/91/50/a9d80c47ff289c611ff12e63f7c5d13942c65d68125160cefd768c73e6e4/executing-2.2.0.tar.gz", hash = "sha256:5d108c028108fe2551d1a7b2e8b713341e2cb4fc0aa7dcf966fa4327a5226755", size = 978693 }
+sdist = { url = "https://files.pythonhosted.org/packages/91/50/a9d80c47ff289c611ff12e63f7c5d13942c65d68125160cefd768c73e6e4/executing-2.2.0.tar.gz", hash = "sha256:5d108c028108fe2551d1a7b2e8b713341e2cb4fc0aa7dcf966fa4327a5226755", size = 978693, upload-time = "2025-01-22T15:41:29.403Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/7b/8f/c4d9bafc34ad7ad5d8dc16dd1347ee0e507a52c3adb6bfa8887e1c6a26ba/executing-2.2.0-py2.py3-none-any.whl", hash = "sha256:11387150cad388d62750327a53d3339fad4888b39a6fe233c3afbb54ecffd3aa", size = 26702 },
+    { url = "https://files.pythonhosted.org/packages/7b/8f/c4d9bafc34ad7ad5d8dc16dd1347ee0e507a52c3adb6bfa8887e1c6a26ba/executing-2.2.0-py2.py3-none-any.whl", hash = "sha256:11387150cad388d62750327a53d3339fad4888b39a6fe233c3afbb54ecffd3aa", size = 26702, upload-time = "2025-01-22T15:41:25.929Z" },
 ]
 
 [[package]]
@@ -252,9 +253,9 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "colorama" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/5c/74/cd35a98cb11f79de0581e8e1e6fbd738aeeed1f2d90e9b5106728b63f5f7/griffe-1.5.5.tar.gz", hash = "sha256:35ee5b38b93d6a839098aad0f92207e6ad6b70c3e8866c08ca669275b8cba585", size = 391124 }
+sdist = { url = "https://files.pythonhosted.org/packages/5c/74/cd35a98cb11f79de0581e8e1e6fbd738aeeed1f2d90e9b5106728b63f5f7/griffe-1.5.5.tar.gz", hash = "sha256:35ee5b38b93d6a839098aad0f92207e6ad6b70c3e8866c08ca669275b8cba585", size = 391124, upload-time = "2025-01-16T20:18:18.934Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/1f/88/52c9422bc853cd7c2b6122090e887d17b5fad29b67f930e4277c9c557357/griffe-1.5.5-py3-none-any.whl", hash = "sha256:2761b1e8876c6f1f9ab1af274df93ea6bbadd65090de5f38f4cb5cc84897c7dd", size = 128221 },
+    { url = "https://files.pythonhosted.org/packages/1f/88/52c9422bc853cd7c2b6122090e887d17b5fad29b67f930e4277c9c557357/griffe-1.5.5-py3-none-any.whl", hash = "sha256:2761b1e8876c6f1f9ab1af274df93ea6bbadd65090de5f38f4cb5cc84897c7dd", size = 128221, upload-time = "2025-01-16T20:18:15.887Z" },
 ]
 
 [[package]]
@@ -266,18 +267,18 @@ dependencies = [
     { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
     { name = "sortedcontainers" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/e6/3b/3a7cf8973b0424c6af0b2b5fe30f89ab738616bad2a16aafcc49ff069ed4/hypothesis-6.124.2.tar.gz", hash = "sha256:c98823fc1323f23399e5f2251982fd1f38259f84cf627aaaea1b3f0a0d4d2b03", size = 419462 }
+sdist = { url = "https://files.pythonhosted.org/packages/e6/3b/3a7cf8973b0424c6af0b2b5fe30f89ab738616bad2a16aafcc49ff069ed4/hypothesis-6.124.2.tar.gz", hash = "sha256:c98823fc1323f23399e5f2251982fd1f38259f84cf627aaaea1b3f0a0d4d2b03", size = 419462, upload-time = "2025-01-21T18:45:00.461Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a3/e1/80f1819e65a9a0b1b744b453cd26803764fc192cff8eaea202e76f6f5a65/hypothesis-6.124.2-py3-none-any.whl", hash = "sha256:fef7709a404929a9cd3e785f60a6e026089aab986e288b1fdced13091574d474", size = 482180 },
+    { url = "https://files.pythonhosted.org/packages/a3/e1/80f1819e65a9a0b1b744b453cd26803764fc192cff8eaea202e76f6f5a65/hypothesis-6.124.2-py3-none-any.whl", hash = "sha256:fef7709a404929a9cd3e785f60a6e026089aab986e288b1fdced13091574d474", size = 482180, upload-time = "2025-01-21T18:44:55.288Z" },
 ]
 
 [[package]]
 name = "iniconfig"
 version = "2.0.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d7/4b/cbd8e699e64a6f16ca3a8220661b5f83792b3017d0f79807cb8708d33913/iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3", size = 4646 }
+sdist = { url = "https://files.pythonhosted.org/packages/d7/4b/cbd8e699e64a6f16ca3a8220661b5f83792b3017d0f79807cb8708d33913/iniconfig-2.0.0.tar.gz", hash = "sha256:2d91e135bf72d31a410b17c16da610a82cb55f6b0477d1a902134b24a455b8b3", size = 4646, upload-time = "2023-01-07T11:08:11.254Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ef/a6/62565a6e1cf69e10f5727360368e451d4b7f58beeac6173dc9db836a5b46/iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374", size = 5892 },
+    { url = "https://files.pythonhosted.org/packages/ef/a6/62565a6e1cf69e10f5727360368e451d4b7f58beeac6173dc9db836a5b46/iniconfig-2.0.0-py3-none-any.whl", hash = "sha256:b6a85871a79d2e3b22d2d1b94ac2824226a63c6b741c88f7ae975f18b6778374", size = 5892, upload-time = "2023-01-07T11:08:09.864Z" },
 ]
 
 [[package]]
@@ -290,9 +291,9 @@ dependencies = [
     { name = "rich" },
     { name = "tomli", marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/42/bc/bbba2efb2ab0c8cf3d43fb0a7a1d3dfd8533d3bf18df9662ee4c09af7cac/inline_snapshot-0.19.3.tar.gz", hash = "sha256:1e40f34da64fe2406c6bba3f473905e22386da43e16c85060610692325aa94d7", size = 88636 }
+sdist = { url = "https://files.pythonhosted.org/packages/42/bc/bbba2efb2ab0c8cf3d43fb0a7a1d3dfd8533d3bf18df9662ee4c09af7cac/inline_snapshot-0.19.3.tar.gz", hash = "sha256:1e40f34da64fe2406c6bba3f473905e22386da43e16c85060610692325aa94d7", size = 88636, upload-time = "2025-01-15T18:48:55.515Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/fd/fc/d99b8983af46c0adbe10ad369ab929eb35cb32635526a9de4fe06ffd612f/inline_snapshot-0.19.3-py3-none-any.whl", hash = "sha256:81ed10eedb593aee630d2fc0cfe5d10a843c4bd507c2d96ea058c28413985452", size = 43627 },
+    { url = "https://files.pythonhosted.org/packages/fd/fc/d99b8983af46c0adbe10ad369ab929eb35cb32635526a9de4fe06ffd612f/inline_snapshot-0.19.3-py3-none-any.whl", hash = "sha256:81ed10eedb593aee630d2fc0cfe5d10a843c4bd507c2d96ea058c28413985452", size = 43627, upload-time = "2025-01-15T18:48:52.199Z" },
 ]
 
 [[package]]
@@ -302,9 +303,9 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "mdurl" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/38/71/3b932df36c1a044d397a1f92d1cf91ee0a503d91e470cbd670aa66b07ed0/markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb", size = 74596 }
+sdist = { url = "https://files.pythonhosted.org/packages/38/71/3b932df36c1a044d397a1f92d1cf91ee0a503d91e470cbd670aa66b07ed0/markdown-it-py-3.0.0.tar.gz", hash = "sha256:e3f60a94fa066dc52ec76661e37c851cb232d92f9886b15cb560aaada2df8feb", size = 74596, upload-time = "2023-06-03T06:41:14.443Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", size = 87528 },
+    { url = "https://files.pythonhosted.org/packages/42/d7/1ec15b46af6af88f19b8e5ffea08fa375d433c998b8a7639e76935c14f1f/markdown_it_py-3.0.0-py3-none-any.whl", hash = "sha256:355216845c60bd96232cd8d8c40e8f9765cc86f46880e43a8fd22dc1a1a8cab1", size = 87528, upload-time = "2023-06-03T06:41:11.019Z" },
 ]
 
 [[package]]
@@ -314,29 +315,29 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "tomli", marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/9a/08/ccb0f917722a35ab0d758be9bb5edaf645c3a3d6170061f10d396ecd273f/maturin-1.8.1.tar.gz", hash = "sha256:49cd964aabf59f8b0a6969f9860d2cdf194ac331529caae14c884f5659568857", size = 197397 }
+sdist = { url = "https://files.pythonhosted.org/packages/9a/08/ccb0f917722a35ab0d758be9bb5edaf645c3a3d6170061f10d396ecd273f/maturin-1.8.1.tar.gz", hash = "sha256:49cd964aabf59f8b0a6969f9860d2cdf194ac331529caae14c884f5659568857", size = 197397, upload-time = "2024-12-30T14:03:48.109Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/4c/00/f34077315f34db8ad2ccf6bfe11b864ca27baab3a1320634da8e3cf89a48/maturin-1.8.1-py3-none-linux_armv6l.whl", hash = "sha256:7e590a23d9076b8a994f2e67bc63dc9a2d1c9a41b1e7b45ac354ba8275254e89", size = 7568415 },
-    { url = "https://files.pythonhosted.org/packages/5c/07/9219976135ce0cb32d2fa6ea5c6d0ad709013d9a17967312e149b98153a6/maturin-1.8.1-py3-none-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:8d8251a95682c83ea60988c804b620c181911cd824aa107b4a49ac5333c92968", size = 14527816 },
-    { url = "https://files.pythonhosted.org/packages/e6/04/fa009a00903acdd1785d58322193140bfe358595347c39f315112dabdf9e/maturin-1.8.1-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:b9fc1a4354cac5e32c190410208039812ea88c4a36bd2b6499268ec49ef5de00", size = 7580446 },
-    { url = "https://files.pythonhosted.org/packages/9b/d4/414b2aab9bbfe88182b734d3aa1b4fef7d7701e50f6be48500378b8c8721/maturin-1.8.1-py3-none-manylinux_2_12_i686.manylinux2010_i686.musllinux_1_1_i686.whl", hash = "sha256:621e171c6b39f95f1d0df69a118416034fbd59c0f89dcaea8c2ea62019deecba", size = 7650535 },
-    { url = "https://files.pythonhosted.org/packages/f0/64/879418a8a0196013ec1fb19eada0781c04a30e8d6d9227e80f91275a4f5b/maturin-1.8.1-py3-none-manylinux_2_12_x86_64.manylinux2010_x86_64.musllinux_1_1_x86_64.whl", hash = "sha256:98f638739a5132962347871b85c91f525c9246ef4d99796ae98a2031e3df029f", size = 8006702 },
-    { url = "https://files.pythonhosted.org/packages/39/c2/605829324f8371294f70303aca130682df75318958efed246873d3d604ab/maturin-1.8.1-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64.whl", hash = "sha256:f9f5c47521924b6e515cbc652a042fe5f17f8747445be9d931048e5d8ddb50a4", size = 7368164 },
-    { url = "https://files.pythonhosted.org/packages/be/6c/30e136d397bb146b94b628c0ef7f17708281611b97849e2cf37847025ac7/maturin-1.8.1-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.musllinux_1_1_armv7l.whl", hash = "sha256:0f4407c7353c31bfbb8cdeb82bc2170e474cbfb97b5ba27568f440c9d6c1fdd4", size = 7450889 },
-    { url = "https://files.pythonhosted.org/packages/1b/50/e1f5023512696d4e56096f702e2f68d6d9a30afe0a4eec82b0e27b8eb4e4/maturin-1.8.1-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.musllinux_1_1_ppc64le.whl", hash = "sha256:ec49cd70cad3c389946c6e2bc0bd50772a7fcb463040dd800720345897eec9bf", size = 9585819 },
-    { url = "https://files.pythonhosted.org/packages/b7/80/b24b5248d89d2e5982553900237a337ea098ca9297b8369ca2aa95549e0f/maturin-1.8.1-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c08767d794de8f8a11c5c8b1b47a4ff9fb6ae2d2d97679e27030f2f509c8c2a0", size = 10920801 },
-    { url = "https://files.pythonhosted.org/packages/6e/f4/8ede7a662fabf93456b44390a5ad22630e25fb5ddaecf787251071b2e143/maturin-1.8.1-py3-none-win32.whl", hash = "sha256:d678407713f3e10df33c5b3d7a343ec0551eb7f14d8ad9ba6febeb96f4e4c75c", size = 6873556 },
-    { url = "https://files.pythonhosted.org/packages/9c/22/757f093ed0e319e9648155b8c9d716765442bea5bc98ebc58ad4ad5b0524/maturin-1.8.1-py3-none-win_amd64.whl", hash = "sha256:a526f90fe0e5cb59ffb81f4ff547ddc42e823bbdeae4a31012c0893ca6dcaf46", size = 7823153 },
-    { url = "https://files.pythonhosted.org/packages/a4/f5/051413e04f6da25069db5e76759ecdb8cd2a8ab4a94045b5a3bf548c66fa/maturin-1.8.1-py3-none-win_arm64.whl", hash = "sha256:e95f077fd2ddd2f048182880eed458c308571a534be3eb2add4d3dac55bf57f4", size = 6552131 },
+    { url = "https://files.pythonhosted.org/packages/4c/00/f34077315f34db8ad2ccf6bfe11b864ca27baab3a1320634da8e3cf89a48/maturin-1.8.1-py3-none-linux_armv6l.whl", hash = "sha256:7e590a23d9076b8a994f2e67bc63dc9a2d1c9a41b1e7b45ac354ba8275254e89", size = 7568415, upload-time = "2024-12-30T14:03:07.939Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/07/9219976135ce0cb32d2fa6ea5c6d0ad709013d9a17967312e149b98153a6/maturin-1.8.1-py3-none-macosx_10_12_x86_64.macosx_11_0_arm64.macosx_10_12_universal2.whl", hash = "sha256:8d8251a95682c83ea60988c804b620c181911cd824aa107b4a49ac5333c92968", size = 14527816, upload-time = "2024-12-30T14:03:13.851Z" },
+    { url = "https://files.pythonhosted.org/packages/e6/04/fa009a00903acdd1785d58322193140bfe358595347c39f315112dabdf9e/maturin-1.8.1-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:b9fc1a4354cac5e32c190410208039812ea88c4a36bd2b6499268ec49ef5de00", size = 7580446, upload-time = "2024-12-30T14:03:17.64Z" },
+    { url = "https://files.pythonhosted.org/packages/9b/d4/414b2aab9bbfe88182b734d3aa1b4fef7d7701e50f6be48500378b8c8721/maturin-1.8.1-py3-none-manylinux_2_12_i686.manylinux2010_i686.musllinux_1_1_i686.whl", hash = "sha256:621e171c6b39f95f1d0df69a118416034fbd59c0f89dcaea8c2ea62019deecba", size = 7650535, upload-time = "2024-12-30T14:03:21.115Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/64/879418a8a0196013ec1fb19eada0781c04a30e8d6d9227e80f91275a4f5b/maturin-1.8.1-py3-none-manylinux_2_12_x86_64.manylinux2010_x86_64.musllinux_1_1_x86_64.whl", hash = "sha256:98f638739a5132962347871b85c91f525c9246ef4d99796ae98a2031e3df029f", size = 8006702, upload-time = "2024-12-30T14:03:24.318Z" },
+    { url = "https://files.pythonhosted.org/packages/39/c2/605829324f8371294f70303aca130682df75318958efed246873d3d604ab/maturin-1.8.1-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.musllinux_1_1_aarch64.whl", hash = "sha256:f9f5c47521924b6e515cbc652a042fe5f17f8747445be9d931048e5d8ddb50a4", size = 7368164, upload-time = "2024-12-30T14:03:26.582Z" },
+    { url = "https://files.pythonhosted.org/packages/be/6c/30e136d397bb146b94b628c0ef7f17708281611b97849e2cf37847025ac7/maturin-1.8.1-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.musllinux_1_1_armv7l.whl", hash = "sha256:0f4407c7353c31bfbb8cdeb82bc2170e474cbfb97b5ba27568f440c9d6c1fdd4", size = 7450889, upload-time = "2024-12-30T14:03:28.893Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/50/e1f5023512696d4e56096f702e2f68d6d9a30afe0a4eec82b0e27b8eb4e4/maturin-1.8.1-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.musllinux_1_1_ppc64le.whl", hash = "sha256:ec49cd70cad3c389946c6e2bc0bd50772a7fcb463040dd800720345897eec9bf", size = 9585819, upload-time = "2024-12-30T14:03:31.125Z" },
+    { url = "https://files.pythonhosted.org/packages/b7/80/b24b5248d89d2e5982553900237a337ea098ca9297b8369ca2aa95549e0f/maturin-1.8.1-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:c08767d794de8f8a11c5c8b1b47a4ff9fb6ae2d2d97679e27030f2f509c8c2a0", size = 10920801, upload-time = "2024-12-30T14:03:35.127Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/f4/8ede7a662fabf93456b44390a5ad22630e25fb5ddaecf787251071b2e143/maturin-1.8.1-py3-none-win32.whl", hash = "sha256:d678407713f3e10df33c5b3d7a343ec0551eb7f14d8ad9ba6febeb96f4e4c75c", size = 6873556, upload-time = "2024-12-30T14:03:37.913Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/22/757f093ed0e319e9648155b8c9d716765442bea5bc98ebc58ad4ad5b0524/maturin-1.8.1-py3-none-win_amd64.whl", hash = "sha256:a526f90fe0e5cb59ffb81f4ff547ddc42e823bbdeae4a31012c0893ca6dcaf46", size = 7823153, upload-time = "2024-12-30T14:03:40.33Z" },
+    { url = "https://files.pythonhosted.org/packages/a4/f5/051413e04f6da25069db5e76759ecdb8cd2a8ab4a94045b5a3bf548c66fa/maturin-1.8.1-py3-none-win_arm64.whl", hash = "sha256:e95f077fd2ddd2f048182880eed458c308571a534be3eb2add4d3dac55bf57f4", size = 6552131, upload-time = "2024-12-30T14:03:45.203Z" },
 ]
 
 [[package]]
 name = "mdurl"
 version = "0.1.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729 }
+sdist = { url = "https://files.pythonhosted.org/packages/d6/54/cfe61301667036ec958cb99bd3efefba235e65cdeb9c84d24a8293ba1d90/mdurl-0.1.2.tar.gz", hash = "sha256:bb413d29f5eea38f31dd4754dd7377d4465116fb207585f97bf925588687c1ba", size = 8729, upload-time = "2022-08-14T12:40:10.846Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979 },
+    { url = "https://files.pythonhosted.org/packages/b3/38/89ba8ad64ae25be8de66a6d463314cf1eb366222074cfda9ee839c56a4b4/mdurl-0.1.2-py3-none-any.whl", hash = "sha256:84008a41e51615a49fc9966191ff91509e3c40b939176e643fd50a5c2196b8f8", size = 9979, upload-time = "2022-08-14T12:40:09.779Z" },
 ]
 
 [[package]]
@@ -348,57 +349,57 @@ dependencies = [
     { name = "tomli", marker = "python_full_version < '3.11'" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/b9/eb/2c92d8ea1e684440f54fa49ac5d9a5f19967b7b472a281f419e69a8d228e/mypy-1.14.1.tar.gz", hash = "sha256:7ec88144fe9b510e8475ec2f5f251992690fcf89ccb4500b214b4226abcd32d6", size = 3216051 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/9b/7a/87ae2adb31d68402da6da1e5f30c07ea6063e9f09b5e7cfc9dfa44075e74/mypy-1.14.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:52686e37cf13d559f668aa398dd7ddf1f92c5d613e4f8cb262be2fb4fedb0fcb", size = 11211002 },
-    { url = "https://files.pythonhosted.org/packages/e1/23/eada4c38608b444618a132be0d199b280049ded278b24cbb9d3fc59658e4/mypy-1.14.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1fb545ca340537d4b45d3eecdb3def05e913299ca72c290326be19b3804b39c0", size = 10358400 },
-    { url = "https://files.pythonhosted.org/packages/43/c9/d6785c6f66241c62fd2992b05057f404237deaad1566545e9f144ced07f5/mypy-1.14.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:90716d8b2d1f4cd503309788e51366f07c56635a3309b0f6a32547eaaa36a64d", size = 12095172 },
-    { url = "https://files.pythonhosted.org/packages/c3/62/daa7e787770c83c52ce2aaf1a111eae5893de9e004743f51bfcad9e487ec/mypy-1.14.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2ae753f5c9fef278bcf12e1a564351764f2a6da579d4a81347e1d5a15819997b", size = 12828732 },
-    { url = "https://files.pythonhosted.org/packages/1b/a2/5fb18318a3637f29f16f4e41340b795da14f4751ef4f51c99ff39ab62e52/mypy-1.14.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:e0fe0f5feaafcb04505bcf439e991c6d8f1bf8b15f12b05feeed96e9e7bf1427", size = 13012197 },
-    { url = "https://files.pythonhosted.org/packages/28/99/e153ce39105d164b5f02c06c35c7ba958aaff50a2babba7d080988b03fe7/mypy-1.14.1-cp310-cp310-win_amd64.whl", hash = "sha256:7d54bd85b925e501c555a3227f3ec0cfc54ee8b6930bd6141ec872d1c572f81f", size = 9780836 },
-    { url = "https://files.pythonhosted.org/packages/da/11/a9422850fd506edbcdc7f6090682ecceaf1f87b9dd847f9df79942da8506/mypy-1.14.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f995e511de847791c3b11ed90084a7a0aafdc074ab88c5a9711622fe4751138c", size = 11120432 },
-    { url = "https://files.pythonhosted.org/packages/b6/9e/47e450fd39078d9c02d620545b2cb37993a8a8bdf7db3652ace2f80521ca/mypy-1.14.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d64169ec3b8461311f8ce2fd2eb5d33e2d0f2c7b49116259c51d0d96edee48d1", size = 10279515 },
-    { url = "https://files.pythonhosted.org/packages/01/b5/6c8d33bd0f851a7692a8bfe4ee75eb82b6983a3cf39e5e32a5d2a723f0c1/mypy-1.14.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ba24549de7b89b6381b91fbc068d798192b1b5201987070319889e93038967a8", size = 12025791 },
-    { url = "https://files.pythonhosted.org/packages/f0/4c/e10e2c46ea37cab5c471d0ddaaa9a434dc1d28650078ac1b56c2d7b9b2e4/mypy-1.14.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:183cf0a45457d28ff9d758730cd0210419ac27d4d3f285beda038c9083363b1f", size = 12749203 },
-    { url = "https://files.pythonhosted.org/packages/88/55/beacb0c69beab2153a0f57671ec07861d27d735a0faff135a494cd4f5020/mypy-1.14.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f2a0ecc86378f45347f586e4163d1769dd81c5a223d577fe351f26b179e148b1", size = 12885900 },
-    { url = "https://files.pythonhosted.org/packages/a2/75/8c93ff7f315c4d086a2dfcde02f713004357d70a163eddb6c56a6a5eff40/mypy-1.14.1-cp311-cp311-win_amd64.whl", hash = "sha256:ad3301ebebec9e8ee7135d8e3109ca76c23752bac1e717bc84cd3836b4bf3eae", size = 9777869 },
-    { url = "https://files.pythonhosted.org/packages/43/1b/b38c079609bb4627905b74fc6a49849835acf68547ac33d8ceb707de5f52/mypy-1.14.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:30ff5ef8519bbc2e18b3b54521ec319513a26f1bba19a7582e7b1f58a6e69f14", size = 11266668 },
-    { url = "https://files.pythonhosted.org/packages/6b/75/2ed0d2964c1ffc9971c729f7a544e9cd34b2cdabbe2d11afd148d7838aa2/mypy-1.14.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:cb9f255c18052343c70234907e2e532bc7e55a62565d64536dbc7706a20b78b9", size = 10254060 },
-    { url = "https://files.pythonhosted.org/packages/a1/5f/7b8051552d4da3c51bbe8fcafffd76a6823779101a2b198d80886cd8f08e/mypy-1.14.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b4e3413e0bddea671012b063e27591b953d653209e7a4fa5e48759cda77ca11", size = 11933167 },
-    { url = "https://files.pythonhosted.org/packages/04/90/f53971d3ac39d8b68bbaab9a4c6c58c8caa4d5fd3d587d16f5927eeeabe1/mypy-1.14.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:553c293b1fbdebb6c3c4030589dab9fafb6dfa768995a453d8a5d3b23784af2e", size = 12864341 },
-    { url = "https://files.pythonhosted.org/packages/03/d2/8bc0aeaaf2e88c977db41583559319f1821c069e943ada2701e86d0430b7/mypy-1.14.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fad79bfe3b65fe6a1efaed97b445c3d37f7be9fdc348bdb2d7cac75579607c89", size = 12972991 },
-    { url = "https://files.pythonhosted.org/packages/6f/17/07815114b903b49b0f2cf7499f1c130e5aa459411596668267535fe9243c/mypy-1.14.1-cp312-cp312-win_amd64.whl", hash = "sha256:8fa2220e54d2946e94ab6dbb3ba0a992795bd68b16dc852db33028df2b00191b", size = 9879016 },
-    { url = "https://files.pythonhosted.org/packages/9e/15/bb6a686901f59222275ab228453de741185f9d54fecbaacec041679496c6/mypy-1.14.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:92c3ed5afb06c3a8e188cb5da4984cab9ec9a77ba956ee419c68a388b4595255", size = 11252097 },
-    { url = "https://files.pythonhosted.org/packages/f8/b3/8b0f74dfd072c802b7fa368829defdf3ee1566ba74c32a2cb2403f68024c/mypy-1.14.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:dbec574648b3e25f43d23577309b16534431db4ddc09fda50841f1e34e64ed34", size = 10239728 },
-    { url = "https://files.pythonhosted.org/packages/c5/9b/4fd95ab20c52bb5b8c03cc49169be5905d931de17edfe4d9d2986800b52e/mypy-1.14.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8c6d94b16d62eb3e947281aa7347d78236688e21081f11de976376cf010eb31a", size = 11924965 },
-    { url = "https://files.pythonhosted.org/packages/56/9d/4a236b9c57f5d8f08ed346914b3f091a62dd7e19336b2b2a0d85485f82ff/mypy-1.14.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d4b19b03fdf54f3c5b2fa474c56b4c13c9dbfb9a2db4370ede7ec11a2c5927d9", size = 12867660 },
-    { url = "https://files.pythonhosted.org/packages/40/88/a61a5497e2f68d9027de2bb139c7bb9abaeb1be1584649fa9d807f80a338/mypy-1.14.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0c911fde686394753fff899c409fd4e16e9b294c24bfd5e1ea4675deae1ac6fd", size = 12969198 },
-    { url = "https://files.pythonhosted.org/packages/54/da/3d6fc5d92d324701b0c23fb413c853892bfe0e1dbe06c9138037d459756b/mypy-1.14.1-cp313-cp313-win_amd64.whl", hash = "sha256:8b21525cb51671219f5307be85f7e646a153e5acc656e5cebf64bfa076c50107", size = 9885276 },
-    { url = "https://files.pythonhosted.org/packages/ca/1f/186d133ae2514633f8558e78cd658070ba686c0e9275c5a5c24a1e1f0d67/mypy-1.14.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:3888a1816d69f7ab92092f785a462944b3ca16d7c470d564165fe703b0970c35", size = 11200493 },
-    { url = "https://files.pythonhosted.org/packages/af/fc/4842485d034e38a4646cccd1369f6b1ccd7bc86989c52770d75d719a9941/mypy-1.14.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:46c756a444117c43ee984bd055db99e498bc613a70bbbc120272bd13ca579fbc", size = 10357702 },
-    { url = "https://files.pythonhosted.org/packages/b4/e6/457b83f2d701e23869cfec013a48a12638f75b9d37612a9ddf99072c1051/mypy-1.14.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:27fc248022907e72abfd8e22ab1f10e903915ff69961174784a3900a8cba9ad9", size = 12091104 },
-    { url = "https://files.pythonhosted.org/packages/f1/bf/76a569158db678fee59f4fd30b8e7a0d75bcbaeef49edd882a0d63af6d66/mypy-1.14.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:499d6a72fb7e5de92218db961f1a66d5f11783f9ae549d214617edab5d4dbdbb", size = 12830167 },
-    { url = "https://files.pythonhosted.org/packages/43/bc/0bc6b694b3103de9fed61867f1c8bd33336b913d16831431e7cb48ef1c92/mypy-1.14.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:57961db9795eb566dc1d1b4e9139ebc4c6b0cb6e7254ecde69d1552bf7613f60", size = 13013834 },
-    { url = "https://files.pythonhosted.org/packages/b0/79/5f5ec47849b6df1e6943d5fd8e6632fbfc04b4fd4acfa5a5a9535d11b4e2/mypy-1.14.1-cp39-cp39-win_amd64.whl", hash = "sha256:07ba89fdcc9451f2ebb02853deb6aaaa3d2239a236669a63ab3801bbf923ef5c", size = 9781231 },
-    { url = "https://files.pythonhosted.org/packages/a0/b5/32dd67b69a16d088e533962e5044e51004176a9952419de0370cdaead0f8/mypy-1.14.1-py3-none-any.whl", hash = "sha256:b66a60cc4073aeb8ae00057f9c1f64d49e90f918fbcef9a977eb121da8b8f1d1", size = 2752905 },
+sdist = { url = "https://files.pythonhosted.org/packages/b9/eb/2c92d8ea1e684440f54fa49ac5d9a5f19967b7b472a281f419e69a8d228e/mypy-1.14.1.tar.gz", hash = "sha256:7ec88144fe9b510e8475ec2f5f251992690fcf89ccb4500b214b4226abcd32d6", size = 3216051, upload-time = "2024-12-30T16:39:07.335Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/9b/7a/87ae2adb31d68402da6da1e5f30c07ea6063e9f09b5e7cfc9dfa44075e74/mypy-1.14.1-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:52686e37cf13d559f668aa398dd7ddf1f92c5d613e4f8cb262be2fb4fedb0fcb", size = 11211002, upload-time = "2024-12-30T16:37:22.435Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/23/eada4c38608b444618a132be0d199b280049ded278b24cbb9d3fc59658e4/mypy-1.14.1-cp310-cp310-macosx_11_0_arm64.whl", hash = "sha256:1fb545ca340537d4b45d3eecdb3def05e913299ca72c290326be19b3804b39c0", size = 10358400, upload-time = "2024-12-30T16:37:53.526Z" },
+    { url = "https://files.pythonhosted.org/packages/43/c9/d6785c6f66241c62fd2992b05057f404237deaad1566545e9f144ced07f5/mypy-1.14.1-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:90716d8b2d1f4cd503309788e51366f07c56635a3309b0f6a32547eaaa36a64d", size = 12095172, upload-time = "2024-12-30T16:37:50.332Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/62/daa7e787770c83c52ce2aaf1a111eae5893de9e004743f51bfcad9e487ec/mypy-1.14.1-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:2ae753f5c9fef278bcf12e1a564351764f2a6da579d4a81347e1d5a15819997b", size = 12828732, upload-time = "2024-12-30T16:37:29.96Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/a2/5fb18318a3637f29f16f4e41340b795da14f4751ef4f51c99ff39ab62e52/mypy-1.14.1-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:e0fe0f5feaafcb04505bcf439e991c6d8f1bf8b15f12b05feeed96e9e7bf1427", size = 13012197, upload-time = "2024-12-30T16:38:05.037Z" },
+    { url = "https://files.pythonhosted.org/packages/28/99/e153ce39105d164b5f02c06c35c7ba958aaff50a2babba7d080988b03fe7/mypy-1.14.1-cp310-cp310-win_amd64.whl", hash = "sha256:7d54bd85b925e501c555a3227f3ec0cfc54ee8b6930bd6141ec872d1c572f81f", size = 9780836, upload-time = "2024-12-30T16:37:19.726Z" },
+    { url = "https://files.pythonhosted.org/packages/da/11/a9422850fd506edbcdc7f6090682ecceaf1f87b9dd847f9df79942da8506/mypy-1.14.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:f995e511de847791c3b11ed90084a7a0aafdc074ab88c5a9711622fe4751138c", size = 11120432, upload-time = "2024-12-30T16:37:11.533Z" },
+    { url = "https://files.pythonhosted.org/packages/b6/9e/47e450fd39078d9c02d620545b2cb37993a8a8bdf7db3652ace2f80521ca/mypy-1.14.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:d64169ec3b8461311f8ce2fd2eb5d33e2d0f2c7b49116259c51d0d96edee48d1", size = 10279515, upload-time = "2024-12-30T16:37:40.724Z" },
+    { url = "https://files.pythonhosted.org/packages/01/b5/6c8d33bd0f851a7692a8bfe4ee75eb82b6983a3cf39e5e32a5d2a723f0c1/mypy-1.14.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ba24549de7b89b6381b91fbc068d798192b1b5201987070319889e93038967a8", size = 12025791, upload-time = "2024-12-30T16:36:58.73Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/4c/e10e2c46ea37cab5c471d0ddaaa9a434dc1d28650078ac1b56c2d7b9b2e4/mypy-1.14.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:183cf0a45457d28ff9d758730cd0210419ac27d4d3f285beda038c9083363b1f", size = 12749203, upload-time = "2024-12-30T16:37:03.741Z" },
+    { url = "https://files.pythonhosted.org/packages/88/55/beacb0c69beab2153a0f57671ec07861d27d735a0faff135a494cd4f5020/mypy-1.14.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:f2a0ecc86378f45347f586e4163d1769dd81c5a223d577fe351f26b179e148b1", size = 12885900, upload-time = "2024-12-30T16:37:57.948Z" },
+    { url = "https://files.pythonhosted.org/packages/a2/75/8c93ff7f315c4d086a2dfcde02f713004357d70a163eddb6c56a6a5eff40/mypy-1.14.1-cp311-cp311-win_amd64.whl", hash = "sha256:ad3301ebebec9e8ee7135d8e3109ca76c23752bac1e717bc84cd3836b4bf3eae", size = 9777869, upload-time = "2024-12-30T16:37:33.428Z" },
+    { url = "https://files.pythonhosted.org/packages/43/1b/b38c079609bb4627905b74fc6a49849835acf68547ac33d8ceb707de5f52/mypy-1.14.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:30ff5ef8519bbc2e18b3b54521ec319513a26f1bba19a7582e7b1f58a6e69f14", size = 11266668, upload-time = "2024-12-30T16:38:02.211Z" },
+    { url = "https://files.pythonhosted.org/packages/6b/75/2ed0d2964c1ffc9971c729f7a544e9cd34b2cdabbe2d11afd148d7838aa2/mypy-1.14.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:cb9f255c18052343c70234907e2e532bc7e55a62565d64536dbc7706a20b78b9", size = 10254060, upload-time = "2024-12-30T16:37:46.131Z" },
+    { url = "https://files.pythonhosted.org/packages/a1/5f/7b8051552d4da3c51bbe8fcafffd76a6823779101a2b198d80886cd8f08e/mypy-1.14.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8b4e3413e0bddea671012b063e27591b953d653209e7a4fa5e48759cda77ca11", size = 11933167, upload-time = "2024-12-30T16:37:43.534Z" },
+    { url = "https://files.pythonhosted.org/packages/04/90/f53971d3ac39d8b68bbaab9a4c6c58c8caa4d5fd3d587d16f5927eeeabe1/mypy-1.14.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:553c293b1fbdebb6c3c4030589dab9fafb6dfa768995a453d8a5d3b23784af2e", size = 12864341, upload-time = "2024-12-30T16:37:36.249Z" },
+    { url = "https://files.pythonhosted.org/packages/03/d2/8bc0aeaaf2e88c977db41583559319f1821c069e943ada2701e86d0430b7/mypy-1.14.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:fad79bfe3b65fe6a1efaed97b445c3d37f7be9fdc348bdb2d7cac75579607c89", size = 12972991, upload-time = "2024-12-30T16:37:06.743Z" },
+    { url = "https://files.pythonhosted.org/packages/6f/17/07815114b903b49b0f2cf7499f1c130e5aa459411596668267535fe9243c/mypy-1.14.1-cp312-cp312-win_amd64.whl", hash = "sha256:8fa2220e54d2946e94ab6dbb3ba0a992795bd68b16dc852db33028df2b00191b", size = 9879016, upload-time = "2024-12-30T16:37:15.02Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/15/bb6a686901f59222275ab228453de741185f9d54fecbaacec041679496c6/mypy-1.14.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:92c3ed5afb06c3a8e188cb5da4984cab9ec9a77ba956ee419c68a388b4595255", size = 11252097, upload-time = "2024-12-30T16:37:25.144Z" },
+    { url = "https://files.pythonhosted.org/packages/f8/b3/8b0f74dfd072c802b7fa368829defdf3ee1566ba74c32a2cb2403f68024c/mypy-1.14.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:dbec574648b3e25f43d23577309b16534431db4ddc09fda50841f1e34e64ed34", size = 10239728, upload-time = "2024-12-30T16:38:08.634Z" },
+    { url = "https://files.pythonhosted.org/packages/c5/9b/4fd95ab20c52bb5b8c03cc49169be5905d931de17edfe4d9d2986800b52e/mypy-1.14.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:8c6d94b16d62eb3e947281aa7347d78236688e21081f11de976376cf010eb31a", size = 11924965, upload-time = "2024-12-30T16:38:12.132Z" },
+    { url = "https://files.pythonhosted.org/packages/56/9d/4a236b9c57f5d8f08ed346914b3f091a62dd7e19336b2b2a0d85485f82ff/mypy-1.14.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d4b19b03fdf54f3c5b2fa474c56b4c13c9dbfb9a2db4370ede7ec11a2c5927d9", size = 12867660, upload-time = "2024-12-30T16:38:17.342Z" },
+    { url = "https://files.pythonhosted.org/packages/40/88/a61a5497e2f68d9027de2bb139c7bb9abaeb1be1584649fa9d807f80a338/mypy-1.14.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:0c911fde686394753fff899c409fd4e16e9b294c24bfd5e1ea4675deae1ac6fd", size = 12969198, upload-time = "2024-12-30T16:38:32.839Z" },
+    { url = "https://files.pythonhosted.org/packages/54/da/3d6fc5d92d324701b0c23fb413c853892bfe0e1dbe06c9138037d459756b/mypy-1.14.1-cp313-cp313-win_amd64.whl", hash = "sha256:8b21525cb51671219f5307be85f7e646a153e5acc656e5cebf64bfa076c50107", size = 9885276, upload-time = "2024-12-30T16:38:20.828Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/1f/186d133ae2514633f8558e78cd658070ba686c0e9275c5a5c24a1e1f0d67/mypy-1.14.1-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:3888a1816d69f7ab92092f785a462944b3ca16d7c470d564165fe703b0970c35", size = 11200493, upload-time = "2024-12-30T16:38:26.935Z" },
+    { url = "https://files.pythonhosted.org/packages/af/fc/4842485d034e38a4646cccd1369f6b1ccd7bc86989c52770d75d719a9941/mypy-1.14.1-cp39-cp39-macosx_11_0_arm64.whl", hash = "sha256:46c756a444117c43ee984bd055db99e498bc613a70bbbc120272bd13ca579fbc", size = 10357702, upload-time = "2024-12-30T16:38:50.623Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/e6/457b83f2d701e23869cfec013a48a12638f75b9d37612a9ddf99072c1051/mypy-1.14.1-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:27fc248022907e72abfd8e22ab1f10e903915ff69961174784a3900a8cba9ad9", size = 12091104, upload-time = "2024-12-30T16:38:53.735Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/bf/76a569158db678fee59f4fd30b8e7a0d75bcbaeef49edd882a0d63af6d66/mypy-1.14.1-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:499d6a72fb7e5de92218db961f1a66d5f11783f9ae549d214617edab5d4dbdbb", size = 12830167, upload-time = "2024-12-30T16:38:56.437Z" },
+    { url = "https://files.pythonhosted.org/packages/43/bc/0bc6b694b3103de9fed61867f1c8bd33336b913d16831431e7cb48ef1c92/mypy-1.14.1-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:57961db9795eb566dc1d1b4e9139ebc4c6b0cb6e7254ecde69d1552bf7613f60", size = 13013834, upload-time = "2024-12-30T16:38:59.204Z" },
+    { url = "https://files.pythonhosted.org/packages/b0/79/5f5ec47849b6df1e6943d5fd8e6632fbfc04b4fd4acfa5a5a9535d11b4e2/mypy-1.14.1-cp39-cp39-win_amd64.whl", hash = "sha256:07ba89fdcc9451f2ebb02853deb6aaaa3d2239a236669a63ab3801bbf923ef5c", size = 9781231, upload-time = "2024-12-30T16:39:05.124Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/b5/32dd67b69a16d088e533962e5044e51004176a9952419de0370cdaead0f8/mypy-1.14.1-py3-none-any.whl", hash = "sha256:b66a60cc4073aeb8ae00057f9c1f64d49e90f918fbcef9a977eb121da8b8f1d1", size = 2752905, upload-time = "2024-12-30T16:38:42.021Z" },
 ]
 
 [[package]]
 name = "mypy-extensions"
 version = "1.0.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/98/a4/1ab47638b92648243faf97a5aeb6ea83059cc3624972ab6b8d2316078d3f/mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782", size = 4433 }
+sdist = { url = "https://files.pythonhosted.org/packages/98/a4/1ab47638b92648243faf97a5aeb6ea83059cc3624972ab6b8d2316078d3f/mypy_extensions-1.0.0.tar.gz", hash = "sha256:75dbf8955dc00442a438fc4d0666508a9a97b6bd41aa2f0ffe9d2f2725af0782", size = 4433, upload-time = "2023-02-04T12:11:27.157Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/2a/e2/5d3f6ada4297caebe1a2add3b126fe800c96f56dbe5d1988a2cbe0b267aa/mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d", size = 4695 },
+    { url = "https://files.pythonhosted.org/packages/2a/e2/5d3f6ada4297caebe1a2add3b126fe800c96f56dbe5d1988a2cbe0b267aa/mypy_extensions-1.0.0-py3-none-any.whl", hash = "sha256:4392f6c0eb8a5668a69e23d168ffa70f0be9ccfd32b5cc2d26a34ae5b844552d", size = 4695, upload-time = "2023-02-04T12:11:25.002Z" },
 ]
 
 [[package]]
 name = "nodeenv"
 version = "1.9.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/43/16/fc88b08840de0e0a72a2f9d8c6bae36be573e475a6326ae854bcc549fc45/nodeenv-1.9.1.tar.gz", hash = "sha256:6ec12890a2dab7946721edbfbcd91f3319c6ccc9aec47be7c7e6b7011ee6645f", size = 47437 }
+sdist = { url = "https://files.pythonhosted.org/packages/43/16/fc88b08840de0e0a72a2f9d8c6bae36be573e475a6326ae854bcc549fc45/nodeenv-1.9.1.tar.gz", hash = "sha256:6ec12890a2dab7946721edbfbcd91f3319c6ccc9aec47be7c7e6b7011ee6645f", size = 47437, upload-time = "2024-06-04T18:44:11.171Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/d2/1d/1b658dbd2b9fa9c4c9f32accbfc0205d532c8c6194dc0f2a4c0428e7128a/nodeenv-1.9.1-py2.py3-none-any.whl", hash = "sha256:ba11c9782d29c27c70ffbdda2d7415098754709be8a7056d79a737cd901155c9", size = 22314 },
+    { url = "https://files.pythonhosted.org/packages/d2/1d/1b658dbd2b9fa9c4c9f32accbfc0205d532c8c6194dc0f2a4c0428e7128a/nodeenv-1.9.1-py2.py3-none-any.whl", hash = "sha256:ba11c9782d29c27c70ffbdda2d7415098754709be8a7056d79a737cd901155c9", size = 22314, upload-time = "2024-06-04T18:44:08.352Z" },
 ]
 
 [[package]]
@@ -408,32 +409,32 @@ source = { registry = "https://pypi.org/simple" }
 resolution-markers = [
     "python_full_version < '3.10'",
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a9/75/10dd1f8116a8b796cb2c737b674e02d02e80454bda953fa7e65d8c12b016/numpy-2.0.2.tar.gz", hash = "sha256:883c987dee1880e2a864ab0dc9892292582510604156762362d9326444636e78", size = 18902015 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/21/91/3495b3237510f79f5d81f2508f9f13fea78ebfdf07538fc7444badda173d/numpy-2.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:51129a29dbe56f9ca83438b706e2e69a39892b5eda6cedcb6b0c9fdc9b0d3ece", size = 21165245 },
-    { url = "https://files.pythonhosted.org/packages/6e/16/7bfcebf27bb4f9d7ec67332ffebee4d1bf085c84246552d52dbb548600e7/numpy-2.0.2-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:becfae3ddd30736fe1889a37f1f580e245ba79a5855bff5f2a29cb3ccc22dd7b", size = 6901774 },
-    { url = "https://files.pythonhosted.org/packages/fa/66/f7177ab331876200ac7563a580140643d1179c8b4b6a6b0fc9838de2a9b8/numpy-2.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:496f71341824ed9f3d2fd36cf3ac57ae2e0165c143b55c3a035ee219413f3318", size = 19523451 },
-    { url = "https://files.pythonhosted.org/packages/25/7f/0b209498009ad6453e4efc2c65bcdf0ae08a182b2b7877d7ab38a92dc542/numpy-2.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:a61ec659f68ae254e4d237816e33171497e978140353c0c2038d46e63282d0c8", size = 19927572 },
-    { url = "https://files.pythonhosted.org/packages/10/05/3442317535028bc29cf0c0dd4c191a4481e8376e9f0db6bcf29703cadae6/numpy-2.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:c7b0be4ef08607dd04da4092faee0b86607f111d5ae68036f16cc787e250a131", size = 15905558 },
-    { url = "https://files.pythonhosted.org/packages/8b/cf/034500fb83041aa0286e0fb16e7c76e5c8b67c0711bb6e9e9737a717d5fe/numpy-2.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:49ca4decb342d66018b01932139c0961a8f9ddc7589611158cb3c27cbcf76448", size = 21169137 },
-    { url = "https://files.pythonhosted.org/packages/0e/78/a3e4f9fb6aa4e6fdca0c5428e8ba039408514388cf62d89651aade838269/numpy-2.0.2-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:8cafab480740e22f8d833acefed5cc87ce276f4ece12fdaa2e8903db2f82897a", size = 6905573 },
-    { url = "https://files.pythonhosted.org/packages/ba/a8/c17acf65a931ce551fee11b72e8de63bf7e8a6f0e21add4c937c83563538/numpy-2.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:13e689d772146140a252c3a28501da66dfecd77490b498b168b501835041f951", size = 19534895 },
-    { url = "https://files.pythonhosted.org/packages/ba/86/8767f3d54f6ae0165749f84648da9dcc8cd78ab65d415494962c86fac80f/numpy-2.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:9ea91dfb7c3d1c56a0e55657c0afb38cf1eeae4544c208dc465c3c9f3a7c09f9", size = 19937253 },
-    { url = "https://files.pythonhosted.org/packages/eb/57/3a3f14d3a759dcf9bf6e9eda905794726b758819df4663f217d658a58695/numpy-2.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:286cd40ce2b7d652a6f22efdfc6d1edf879440e53e76a75955bc0c826c7e64dc", size = 15910230 },
-    { url = "https://files.pythonhosted.org/packages/45/40/2e117be60ec50d98fa08c2f8c48e09b3edea93cfcabd5a9ff6925d54b1c2/numpy-2.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:df55d490dea7934f330006d0f81e8551ba6010a5bf035a249ef61a94f21c500b", size = 20895803 },
-    { url = "https://files.pythonhosted.org/packages/e3/ff/ddf6dac2ff0dd50a7327bcdba45cb0264d0e96bb44d33324853f781a8f3c/numpy-2.0.2-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:a842d573724391493a97a62ebbb8e731f8a5dcc5d285dfc99141ca15a3302d0c", size = 6633497 },
-    { url = "https://files.pythonhosted.org/packages/39/68/e9f1126d757653496dbc096cb429014347a36b228f5a991dae2c6b6cfd40/numpy-2.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0123ffdaa88fa4ab64835dcbde75dcdf89c453c922f18dced6e27c90d1d0ec5a", size = 19236173 },
-    { url = "https://files.pythonhosted.org/packages/d1/e9/1f5333281e4ebf483ba1c888b1d61ba7e78d7e910fdd8e6499667041cc35/numpy-2.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:96a55f64139912d61de9137f11bf39a55ec8faec288c75a54f93dfd39f7eb40c", size = 19634174 },
-    { url = "https://files.pythonhosted.org/packages/b2/b5/4ac39baebf1fdb2e72585c8352c56d063b6126be9fc95bd2bb5ef5770c20/numpy-2.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:cfd41e13fdc257aa5778496b8caa5e856dc4896d4ccf01841daee1d96465467a", size = 15606179 },
-    { url = "https://files.pythonhosted.org/packages/43/c1/41c8f6df3162b0c6ffd4437d729115704bd43363de0090c7f913cfbc2d89/numpy-2.0.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:9059e10581ce4093f735ed23f3b9d283b9d517ff46009ddd485f1747eb22653c", size = 21169942 },
-    { url = "https://files.pythonhosted.org/packages/2d/98/121996dcfb10a6087a05e54453e28e58694a7db62c5a5a29cee14c6e047b/numpy-2.0.2-cp39-cp39-macosx_14_0_x86_64.whl", hash = "sha256:97032a27bd9d8988b9a97a8c4d2c9f2c15a81f61e2f21404d7e8ef00cb5be729", size = 6906494 },
-    { url = "https://files.pythonhosted.org/packages/b9/14/78635daab4b07c0930c919d451b8bf8c164774e6a3413aed04a6d95758ce/numpy-2.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f26b258c385842546006213344c50655ff1555a9338e2e5e02a0756dc3e803dd", size = 19526099 },
-    { url = "https://files.pythonhosted.org/packages/26/4c/0eeca4614003077f68bfe7aac8b7496f04221865b3a5e7cb230c9d055afd/numpy-2.0.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5fec9451a7789926bcf7c2b8d187292c9f93ea30284802a0ab3f5be8ab36865d", size = 19932823 },
-    { url = "https://files.pythonhosted.org/packages/ea/2b/7fc9f4e7ae5b507c1a3a21f0f15ed03e794c1242ea8a242ac158beb56034/numpy-2.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:a3f4ab0caa7f053f6797fcd4e1e25caee367db3112ef2b6ef82d749530768c73", size = 15911314 },
-    { url = "https://files.pythonhosted.org/packages/8f/3b/df5a870ac6a3be3a86856ce195ef42eec7ae50d2a202be1f5a4b3b340e14/numpy-2.0.2-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:7f0a0c6f12e07fa94133c8a67404322845220c06a9e80e85999afe727f7438b8", size = 21025288 },
-    { url = "https://files.pythonhosted.org/packages/2c/97/51af92f18d6f6f2d9ad8b482a99fb74e142d71372da5d834b3a2747a446e/numpy-2.0.2-pp39-pypy39_pp73-macosx_14_0_x86_64.whl", hash = "sha256:312950fdd060354350ed123c0e25a71327d3711584beaef30cdaa93320c392d4", size = 6762793 },
-    { url = "https://files.pythonhosted.org/packages/12/46/de1fbd0c1b5ccaa7f9a005b66761533e2f6a3e560096682683a223631fe9/numpy-2.0.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:26df23238872200f63518dd2aa984cfca675d82469535dc7162dc2ee52d9dd5c", size = 19334885 },
-    { url = "https://files.pythonhosted.org/packages/cc/dc/d330a6faefd92b446ec0f0dfea4c3207bb1fef3c4771d19cf4543efd2c78/numpy-2.0.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:a46288ec55ebbd58947d31d72be2c63cbf839f0a63b49cb755022310792a3385", size = 15828784 },
+sdist = { url = "https://files.pythonhosted.org/packages/a9/75/10dd1f8116a8b796cb2c737b674e02d02e80454bda953fa7e65d8c12b016/numpy-2.0.2.tar.gz", hash = "sha256:883c987dee1880e2a864ab0dc9892292582510604156762362d9326444636e78", size = 18902015, upload-time = "2024-08-26T20:19:40.945Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/21/91/3495b3237510f79f5d81f2508f9f13fea78ebfdf07538fc7444badda173d/numpy-2.0.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:51129a29dbe56f9ca83438b706e2e69a39892b5eda6cedcb6b0c9fdc9b0d3ece", size = 21165245, upload-time = "2024-08-26T20:04:14.625Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/16/7bfcebf27bb4f9d7ec67332ffebee4d1bf085c84246552d52dbb548600e7/numpy-2.0.2-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:becfae3ddd30736fe1889a37f1f580e245ba79a5855bff5f2a29cb3ccc22dd7b", size = 6901774, upload-time = "2024-08-26T20:04:58.173Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/66/f7177ab331876200ac7563a580140643d1179c8b4b6a6b0fc9838de2a9b8/numpy-2.0.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:496f71341824ed9f3d2fd36cf3ac57ae2e0165c143b55c3a035ee219413f3318", size = 19523451, upload-time = "2024-08-26T20:05:47.479Z" },
+    { url = "https://files.pythonhosted.org/packages/25/7f/0b209498009ad6453e4efc2c65bcdf0ae08a182b2b7877d7ab38a92dc542/numpy-2.0.2-cp310-cp310-musllinux_1_1_x86_64.whl", hash = "sha256:a61ec659f68ae254e4d237816e33171497e978140353c0c2038d46e63282d0c8", size = 19927572, upload-time = "2024-08-26T20:06:17.137Z" },
+    { url = "https://files.pythonhosted.org/packages/10/05/3442317535028bc29cf0c0dd4c191a4481e8376e9f0db6bcf29703cadae6/numpy-2.0.2-cp310-cp310-win_amd64.whl", hash = "sha256:c7b0be4ef08607dd04da4092faee0b86607f111d5ae68036f16cc787e250a131", size = 15905558, upload-time = "2024-08-26T20:07:13.881Z" },
+    { url = "https://files.pythonhosted.org/packages/8b/cf/034500fb83041aa0286e0fb16e7c76e5c8b67c0711bb6e9e9737a717d5fe/numpy-2.0.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:49ca4decb342d66018b01932139c0961a8f9ddc7589611158cb3c27cbcf76448", size = 21169137, upload-time = "2024-08-26T20:07:45.345Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/78/a3e4f9fb6aa4e6fdca0c5428e8ba039408514388cf62d89651aade838269/numpy-2.0.2-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:8cafab480740e22f8d833acefed5cc87ce276f4ece12fdaa2e8903db2f82897a", size = 6905573, upload-time = "2024-08-26T20:08:27.185Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/a8/c17acf65a931ce551fee11b72e8de63bf7e8a6f0e21add4c937c83563538/numpy-2.0.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:13e689d772146140a252c3a28501da66dfecd77490b498b168b501835041f951", size = 19534895, upload-time = "2024-08-26T20:09:16.536Z" },
+    { url = "https://files.pythonhosted.org/packages/ba/86/8767f3d54f6ae0165749f84648da9dcc8cd78ab65d415494962c86fac80f/numpy-2.0.2-cp311-cp311-musllinux_1_1_x86_64.whl", hash = "sha256:9ea91dfb7c3d1c56a0e55657c0afb38cf1eeae4544c208dc465c3c9f3a7c09f9", size = 19937253, upload-time = "2024-08-26T20:09:46.263Z" },
+    { url = "https://files.pythonhosted.org/packages/eb/57/3a3f14d3a759dcf9bf6e9eda905794726b758819df4663f217d658a58695/numpy-2.0.2-cp311-cp311-win_amd64.whl", hash = "sha256:286cd40ce2b7d652a6f22efdfc6d1edf879440e53e76a75955bc0c826c7e64dc", size = 15910230, upload-time = "2024-08-26T20:10:43.413Z" },
+    { url = "https://files.pythonhosted.org/packages/45/40/2e117be60ec50d98fa08c2f8c48e09b3edea93cfcabd5a9ff6925d54b1c2/numpy-2.0.2-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:df55d490dea7934f330006d0f81e8551ba6010a5bf035a249ef61a94f21c500b", size = 20895803, upload-time = "2024-08-26T20:11:13.916Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/ff/ddf6dac2ff0dd50a7327bcdba45cb0264d0e96bb44d33324853f781a8f3c/numpy-2.0.2-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:a842d573724391493a97a62ebbb8e731f8a5dcc5d285dfc99141ca15a3302d0c", size = 6633497, upload-time = "2024-08-26T20:11:55.09Z" },
+    { url = "https://files.pythonhosted.org/packages/39/68/e9f1126d757653496dbc096cb429014347a36b228f5a991dae2c6b6cfd40/numpy-2.0.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0123ffdaa88fa4ab64835dcbde75dcdf89c453c922f18dced6e27c90d1d0ec5a", size = 19236173, upload-time = "2024-08-26T20:12:44.049Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/e9/1f5333281e4ebf483ba1c888b1d61ba7e78d7e910fdd8e6499667041cc35/numpy-2.0.2-cp312-cp312-musllinux_1_1_x86_64.whl", hash = "sha256:96a55f64139912d61de9137f11bf39a55ec8faec288c75a54f93dfd39f7eb40c", size = 19634174, upload-time = "2024-08-26T20:13:13.634Z" },
+    { url = "https://files.pythonhosted.org/packages/b2/b5/4ac39baebf1fdb2e72585c8352c56d063b6126be9fc95bd2bb5ef5770c20/numpy-2.0.2-cp312-cp312-win_amd64.whl", hash = "sha256:cfd41e13fdc257aa5778496b8caa5e856dc4896d4ccf01841daee1d96465467a", size = 15606179, upload-time = "2024-08-26T20:14:08.786Z" },
+    { url = "https://files.pythonhosted.org/packages/43/c1/41c8f6df3162b0c6ffd4437d729115704bd43363de0090c7f913cfbc2d89/numpy-2.0.2-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:9059e10581ce4093f735ed23f3b9d283b9d517ff46009ddd485f1747eb22653c", size = 21169942, upload-time = "2024-08-26T20:14:40.108Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/98/121996dcfb10a6087a05e54453e28e58694a7db62c5a5a29cee14c6e047b/numpy-2.0.2-cp39-cp39-macosx_14_0_x86_64.whl", hash = "sha256:97032a27bd9d8988b9a97a8c4d2c9f2c15a81f61e2f21404d7e8ef00cb5be729", size = 6906494, upload-time = "2024-08-26T20:15:22.055Z" },
+    { url = "https://files.pythonhosted.org/packages/b9/14/78635daab4b07c0930c919d451b8bf8c164774e6a3413aed04a6d95758ce/numpy-2.0.2-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f26b258c385842546006213344c50655ff1555a9338e2e5e02a0756dc3e803dd", size = 19526099, upload-time = "2024-08-26T20:16:11.048Z" },
+    { url = "https://files.pythonhosted.org/packages/26/4c/0eeca4614003077f68bfe7aac8b7496f04221865b3a5e7cb230c9d055afd/numpy-2.0.2-cp39-cp39-musllinux_1_1_x86_64.whl", hash = "sha256:5fec9451a7789926bcf7c2b8d187292c9f93ea30284802a0ab3f5be8ab36865d", size = 19932823, upload-time = "2024-08-26T20:16:40.171Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/2b/7fc9f4e7ae5b507c1a3a21f0f15ed03e794c1242ea8a242ac158beb56034/numpy-2.0.2-cp39-cp39-win_amd64.whl", hash = "sha256:a3f4ab0caa7f053f6797fcd4e1e25caee367db3112ef2b6ef82d749530768c73", size = 15911314, upload-time = "2024-08-26T20:17:36.72Z" },
+    { url = "https://files.pythonhosted.org/packages/8f/3b/df5a870ac6a3be3a86856ce195ef42eec7ae50d2a202be1f5a4b3b340e14/numpy-2.0.2-pp39-pypy39_pp73-macosx_10_9_x86_64.whl", hash = "sha256:7f0a0c6f12e07fa94133c8a67404322845220c06a9e80e85999afe727f7438b8", size = 21025288, upload-time = "2024-08-26T20:18:07.732Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/97/51af92f18d6f6f2d9ad8b482a99fb74e142d71372da5d834b3a2747a446e/numpy-2.0.2-pp39-pypy39_pp73-macosx_14_0_x86_64.whl", hash = "sha256:312950fdd060354350ed123c0e25a71327d3711584beaef30cdaa93320c392d4", size = 6762793, upload-time = "2024-08-26T20:18:19.125Z" },
+    { url = "https://files.pythonhosted.org/packages/12/46/de1fbd0c1b5ccaa7f9a005b66761533e2f6a3e560096682683a223631fe9/numpy-2.0.2-pp39-pypy39_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:26df23238872200f63518dd2aa984cfca675d82469535dc7162dc2ee52d9dd5c", size = 19334885, upload-time = "2024-08-26T20:18:47.237Z" },
+    { url = "https://files.pythonhosted.org/packages/cc/dc/d330a6faefd92b446ec0f0dfea4c3207bb1fef3c4771d19cf4543efd2c78/numpy-2.0.2-pp39-pypy39_pp73-win_amd64.whl", hash = "sha256:a46288ec55ebbd58947d31d72be2c63cbf839f0a63b49cb755022310792a3385", size = 15828784, upload-time = "2024-08-26T20:19:11.19Z" },
 ]
 
 [[package]]
@@ -445,46 +446,46 @@ resolution-markers = [
     "python_full_version == '3.11.*'",
     "python_full_version == '3.10.*'",
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ec/d0/c12ddfd3a02274be06ffc71f3efc6d0e457b0409c4481596881e748cb264/numpy-2.2.2.tar.gz", hash = "sha256:ed6906f61834d687738d25988ae117683705636936cc605be0bb208b23df4d8f", size = 20233295 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/70/2a/69033dc22d981ad21325314f8357438078f5c28310a6d89fb3833030ec8a/numpy-2.2.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:7079129b64cb78bdc8d611d1fd7e8002c0a2565da6a47c4df8062349fee90e3e", size = 21215825 },
-    { url = "https://files.pythonhosted.org/packages/7f/f4/3d8a5a0da297034106c5de92be881aca7079cde6058934215a1de91334f6/numpy-2.2.2-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:995f9e8181723852ca458e22de5d9b7d3ba4da3f11cc1cb113f093b271d7965a", size = 6928931 },
-    { url = "https://files.pythonhosted.org/packages/e3/d7/11fc594838d35c43519763310c316d4fd56f8600d3fc80a8e13e325b5c5c/numpy-2.2.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3fbe72d347fbc59f94124125e73fc4976a06927ebc503ec5afbfb35f193cd957", size = 16381794 },
-    { url = "https://files.pythonhosted.org/packages/30/97/ab96b7650f27f684a9b1e46757a7294ecc50cab27701d05f146e9f779627/numpy-2.2.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:09d6a2032faf25e8d0cadde7fd6145118ac55d2740132c1d845f98721b5ebcfd", size = 18170896 },
-    { url = "https://files.pythonhosted.org/packages/92/9b/95678092febd14070cfb7906ea7932e71e9dd5a6ab3ee948f9ed975e905d/numpy-2.2.2-cp310-cp310-win_amd64.whl", hash = "sha256:64bd6e1762cd7f0986a740fee4dff927b9ec2c5e4d9a28d056eb17d332158014", size = 12915812 },
-    { url = "https://files.pythonhosted.org/packages/21/67/32c68756eed84df181c06528ff57e09138f893c4653448c4967311e0f992/numpy-2.2.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:642199e98af1bd2b6aeb8ecf726972d238c9877b0f6e8221ee5ab945ec8a2189", size = 21220002 },
-    { url = "https://files.pythonhosted.org/packages/47/e2/fccf89d64d9b47ffb242823d4e851fc9d36fa751908c9aac2807924d9b4e/numpy-2.2.2-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:451e854cfae0febe723077bd0cf0a4302a5d84ff25f0bfece8f29206c7bed02e", size = 6933133 },
-    { url = "https://files.pythonhosted.org/packages/5b/86/caec78829311f62afa6fa334c8dfcd79cffb4d24bcf96ee02ae4840d462b/numpy-2.2.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:02935e2c3c0c6cbe9c7955a8efa8908dd4221d7755644c59d1bba28b94fd334f", size = 16393429 },
-    { url = "https://files.pythonhosted.org/packages/d4/bd/d557f10fa50dc4d5871fb9606af563249b66af2fc6f99041a10e8757c6f1/numpy-2.2.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d6d6a0910c3b4368d89dde073e630882cdb266755565155bc33520283b2d9df8", size = 18182967 },
-    { url = "https://files.pythonhosted.org/packages/66/a3/4139296b481ae7304a43581046b8f0a20da6a0dfe0ee47a044cade796603/numpy-2.2.2-cp311-cp311-win_amd64.whl", hash = "sha256:da1eeb460ecce8d5b8608826595c777728cdf28ce7b5a5a8c8ac8d949beadcf2", size = 12919805 },
-    { url = "https://files.pythonhosted.org/packages/0c/e6/847d15770ab7a01e807bdfcd4ead5bdae57c0092b7dc83878171b6af97bb/numpy-2.2.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ac9bea18d6d58a995fac1b2cb4488e17eceeac413af014b1dd26170b766d8467", size = 20912636 },
-    { url = "https://files.pythonhosted.org/packages/7a/1b/50985edb6f1ec495a1c36452e860476f5b7ecdc3fc59ea89ccad3c4926c5/numpy-2.2.2-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:8ec0636d3f7d68520afc6ac2dc4b8341ddb725039de042faf0e311599f54eb37", size = 6661937 },
-    { url = "https://files.pythonhosted.org/packages/5b/73/65d2f0b698df1731e851e3295eb29a5ab8aa06f763f7e4188647a809578d/numpy-2.2.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0349b025e15ea9d05c3d63f9657707a4e1d471128a3b1d876c095f328f8ff7f0", size = 16099146 },
-    { url = "https://files.pythonhosted.org/packages/f0/d8/d8d333ad0d8518d077a21aeea7b7c826eff766a2b1ce1194dea95ca0bacf/numpy-2.2.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:9dd47ff0cb2a656ad69c38da850df3454da88ee9a6fde0ba79acceee0e79daba", size = 17863507 },
-    { url = "https://files.pythonhosted.org/packages/fc/84/7f801a42a67b9772a883223a0a1e12069a14626c81a732bd70aac57aebc1/numpy-2.2.2-cp312-cp312-win_amd64.whl", hash = "sha256:5acea83b801e98541619af398cc0109ff48016955cc0818f478ee9ef1c5c3dcb", size = 12616372 },
-    { url = "https://files.pythonhosted.org/packages/e1/fe/df5624001f4f5c3e0b78e9017bfab7fdc18a8d3b3d3161da3d64924dd659/numpy-2.2.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b208cfd4f5fe34e1535c08983a1a6803fdbc7a1e86cf13dd0c61de0b51a0aadc", size = 20899188 },
-    { url = "https://files.pythonhosted.org/packages/8d/f3/399c15629d5a0c68ef2aa7621d430b2be22034f01dd7f3c65a9c9666c445/numpy-2.2.2-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:128c41c085cab8a85dc29e66ed88c05613dccf6bc28b3866cd16050a2f5448be", size = 6648426 },
-    { url = "https://files.pythonhosted.org/packages/83/9c/96a9ab62274ffafb023f8ee08c88d3d31ee74ca58869f859db6845494fa6/numpy-2.2.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e0c8854b09bc4de7b041148d8550d3bd712b5c21ff6a8ed308085f190235d7ff", size = 16096614 },
-    { url = "https://files.pythonhosted.org/packages/5e/6d/541717a554a8f56fa75e91886d9b79ade2e595918690eb5d0d3dbd3accb9/numpy-2.2.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:57b4012e04cc12b78590a334907e01b3a85efb2107df2b8733ff1ed05fce71de", size = 17859160 },
-    { url = "https://files.pythonhosted.org/packages/56/e5/01106b9291ef1d680f82bc47d0c5b5e26dfed15b0754928e8f856c82c881/numpy-2.2.2-cp313-cp313-win_amd64.whl", hash = "sha256:5a8c863ceacae696aff37d1fd636121f1a512117652e5dfb86031c8d84836369", size = 12609010 },
-    { url = "https://files.pythonhosted.org/packages/9f/30/f23d9876de0f08dceb707c4dcf7f8dd7588266745029debb12a3cdd40be6/numpy-2.2.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:b3482cb7b3325faa5f6bc179649406058253d91ceda359c104dac0ad320e1391", size = 20924451 },
-    { url = "https://files.pythonhosted.org/packages/f7/ec/fe2e91b2642b9d6544518388a441bcd65c904cea38d9ff998e2e8ebf808e/numpy-2.2.2-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:7dca87ca328f5ea7dafc907c5ec100d187911f94825f8700caac0b3f4c384b49", size = 6671958 },
-    { url = "https://files.pythonhosted.org/packages/e1/fb/13c58591d0b6294a08cc40fcc6b9552d239d773d520858ae27f39997f2ae/numpy-2.2.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9fad446ad0bc886855ddf5909cbf8cb5d0faa637aaa6277fb4b19ade134ab3c7", size = 16079759 },
-    { url = "https://files.pythonhosted.org/packages/aa/29/14a177f1a90b8ad8a592ca32124ac06af5eff32889874e53a308f850290f/numpy-2.2.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:106397dbbb1896f99e044efc90360d098b3335060375c26aa89c0d8a97c5f648", size = 17856316 },
-    { url = "https://files.pythonhosted.org/packages/80/94/cd9e9b04012c015cb6320ab3bf43bc615e248dddfeb163728e800a5d96f0/numpy-2.2.2-cp313-cp313t-win_amd64.whl", hash = "sha256:97b974d3ba0fb4612b77ed35d7627490e8e3dff56ab41454d9e8b23448940576", size = 12696208 },
-    { url = "https://files.pythonhosted.org/packages/96/7e/1dd770ee68916ed358991ab62c2cc353ffd98d0b75b901d52183ca28e8bb/numpy-2.2.2-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:b0531f0b0e07643eb089df4c509d30d72c9ef40defa53e41363eca8a8cc61495", size = 21047291 },
-    { url = "https://files.pythonhosted.org/packages/d1/3c/ccd08578dc532a8e6927952339d4a02682b776d5e85be49ed0760308433e/numpy-2.2.2-pp310-pypy310_pp73-macosx_14_0_x86_64.whl", hash = "sha256:e9e82dcb3f2ebbc8cb5ce1102d5f1c5ed236bf8a11730fb45ba82e2841ec21df", size = 6792494 },
-    { url = "https://files.pythonhosted.org/packages/7c/28/8754b9aee4f97199f9a047f73bb644b5a2014994a6d7b061ba67134a42de/numpy-2.2.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e0d4142eb40ca6f94539e4db929410f2a46052a0fe7a2c1c59f6179c39938d2a", size = 16197312 },
-    { url = "https://files.pythonhosted.org/packages/26/96/deb93f871f401045a684ca08a009382b247d14996d7a94fea6aa43c67b94/numpy-2.2.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:356ca982c188acbfa6af0d694284d8cf20e95b1c3d0aefa8929376fea9146f60", size = 12822674 },
+sdist = { url = "https://files.pythonhosted.org/packages/ec/d0/c12ddfd3a02274be06ffc71f3efc6d0e457b0409c4481596881e748cb264/numpy-2.2.2.tar.gz", hash = "sha256:ed6906f61834d687738d25988ae117683705636936cc605be0bb208b23df4d8f", size = 20233295, upload-time = "2025-01-19T00:02:09.581Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/70/2a/69033dc22d981ad21325314f8357438078f5c28310a6d89fb3833030ec8a/numpy-2.2.2-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:7079129b64cb78bdc8d611d1fd7e8002c0a2565da6a47c4df8062349fee90e3e", size = 21215825, upload-time = "2025-01-18T22:56:28.939Z" },
+    { url = "https://files.pythonhosted.org/packages/7f/f4/3d8a5a0da297034106c5de92be881aca7079cde6058934215a1de91334f6/numpy-2.2.2-cp310-cp310-macosx_14_0_x86_64.whl", hash = "sha256:995f9e8181723852ca458e22de5d9b7d3ba4da3f11cc1cb113f093b271d7965a", size = 6928931, upload-time = "2025-01-18T22:57:21.24Z" },
+    { url = "https://files.pythonhosted.org/packages/e3/d7/11fc594838d35c43519763310c316d4fd56f8600d3fc80a8e13e325b5c5c/numpy-2.2.2-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:3fbe72d347fbc59f94124125e73fc4976a06927ebc503ec5afbfb35f193cd957", size = 16381794, upload-time = "2025-01-18T22:58:20.094Z" },
+    { url = "https://files.pythonhosted.org/packages/30/97/ab96b7650f27f684a9b1e46757a7294ecc50cab27701d05f146e9f779627/numpy-2.2.2-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:09d6a2032faf25e8d0cadde7fd6145118ac55d2740132c1d845f98721b5ebcfd", size = 18170896, upload-time = "2025-01-18T22:59:18.84Z" },
+    { url = "https://files.pythonhosted.org/packages/92/9b/95678092febd14070cfb7906ea7932e71e9dd5a6ab3ee948f9ed975e905d/numpy-2.2.2-cp310-cp310-win_amd64.whl", hash = "sha256:64bd6e1762cd7f0986a740fee4dff927b9ec2c5e4d9a28d056eb17d332158014", size = 12915812, upload-time = "2025-01-18T22:59:59.335Z" },
+    { url = "https://files.pythonhosted.org/packages/21/67/32c68756eed84df181c06528ff57e09138f893c4653448c4967311e0f992/numpy-2.2.2-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:642199e98af1bd2b6aeb8ecf726972d238c9877b0f6e8221ee5ab945ec8a2189", size = 21220002, upload-time = "2025-01-18T23:00:41.728Z" },
+    { url = "https://files.pythonhosted.org/packages/47/e2/fccf89d64d9b47ffb242823d4e851fc9d36fa751908c9aac2807924d9b4e/numpy-2.2.2-cp311-cp311-macosx_14_0_x86_64.whl", hash = "sha256:451e854cfae0febe723077bd0cf0a4302a5d84ff25f0bfece8f29206c7bed02e", size = 6933133, upload-time = "2025-01-18T23:01:53.087Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/86/caec78829311f62afa6fa334c8dfcd79cffb4d24bcf96ee02ae4840d462b/numpy-2.2.2-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:02935e2c3c0c6cbe9c7955a8efa8908dd4221d7755644c59d1bba28b94fd334f", size = 16393429, upload-time = "2025-01-18T23:03:00.683Z" },
+    { url = "https://files.pythonhosted.org/packages/d4/bd/d557f10fa50dc4d5871fb9606af563249b66af2fc6f99041a10e8757c6f1/numpy-2.2.2-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:d6d6a0910c3b4368d89dde073e630882cdb266755565155bc33520283b2d9df8", size = 18182967, upload-time = "2025-01-18T23:22:14.371Z" },
+    { url = "https://files.pythonhosted.org/packages/66/a3/4139296b481ae7304a43581046b8f0a20da6a0dfe0ee47a044cade796603/numpy-2.2.2-cp311-cp311-win_amd64.whl", hash = "sha256:da1eeb460ecce8d5b8608826595c777728cdf28ce7b5a5a8c8ac8d949beadcf2", size = 12919805, upload-time = "2025-01-18T23:22:56.851Z" },
+    { url = "https://files.pythonhosted.org/packages/0c/e6/847d15770ab7a01e807bdfcd4ead5bdae57c0092b7dc83878171b6af97bb/numpy-2.2.2-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:ac9bea18d6d58a995fac1b2cb4488e17eceeac413af014b1dd26170b766d8467", size = 20912636, upload-time = "2025-01-18T23:23:58.337Z" },
+    { url = "https://files.pythonhosted.org/packages/7a/1b/50985edb6f1ec495a1c36452e860476f5b7ecdc3fc59ea89ccad3c4926c5/numpy-2.2.2-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:8ec0636d3f7d68520afc6ac2dc4b8341ddb725039de042faf0e311599f54eb37", size = 6661937, upload-time = "2025-01-18T23:26:05.86Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/73/65d2f0b698df1731e851e3295eb29a5ab8aa06f763f7e4188647a809578d/numpy-2.2.2-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:0349b025e15ea9d05c3d63f9657707a4e1d471128a3b1d876c095f328f8ff7f0", size = 16099146, upload-time = "2025-01-18T23:27:15.132Z" },
+    { url = "https://files.pythonhosted.org/packages/f0/d8/d8d333ad0d8518d077a21aeea7b7c826eff766a2b1ce1194dea95ca0bacf/numpy-2.2.2-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:9dd47ff0cb2a656ad69c38da850df3454da88ee9a6fde0ba79acceee0e79daba", size = 17863507, upload-time = "2025-01-18T23:28:56.146Z" },
+    { url = "https://files.pythonhosted.org/packages/fc/84/7f801a42a67b9772a883223a0a1e12069a14626c81a732bd70aac57aebc1/numpy-2.2.2-cp312-cp312-win_amd64.whl", hash = "sha256:5acea83b801e98541619af398cc0109ff48016955cc0818f478ee9ef1c5c3dcb", size = 12616372, upload-time = "2025-01-18T23:29:46.645Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/fe/df5624001f4f5c3e0b78e9017bfab7fdc18a8d3b3d3161da3d64924dd659/numpy-2.2.2-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:b208cfd4f5fe34e1535c08983a1a6803fdbc7a1e86cf13dd0c61de0b51a0aadc", size = 20899188, upload-time = "2025-01-18T23:31:15.292Z" },
+    { url = "https://files.pythonhosted.org/packages/8d/f3/399c15629d5a0c68ef2aa7621d430b2be22034f01dd7f3c65a9c9666c445/numpy-2.2.2-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:128c41c085cab8a85dc29e66ed88c05613dccf6bc28b3866cd16050a2f5448be", size = 6648426, upload-time = "2025-01-18T23:32:06.055Z" },
+    { url = "https://files.pythonhosted.org/packages/83/9c/96a9ab62274ffafb023f8ee08c88d3d31ee74ca58869f859db6845494fa6/numpy-2.2.2-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e0c8854b09bc4de7b041148d8550d3bd712b5c21ff6a8ed308085f190235d7ff", size = 16096614, upload-time = "2025-01-18T23:33:12.265Z" },
+    { url = "https://files.pythonhosted.org/packages/5e/6d/541717a554a8f56fa75e91886d9b79ade2e595918690eb5d0d3dbd3accb9/numpy-2.2.2-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:57b4012e04cc12b78590a334907e01b3a85efb2107df2b8733ff1ed05fce71de", size = 17859160, upload-time = "2025-01-18T23:34:37.857Z" },
+    { url = "https://files.pythonhosted.org/packages/56/e5/01106b9291ef1d680f82bc47d0c5b5e26dfed15b0754928e8f856c82c881/numpy-2.2.2-cp313-cp313-win_amd64.whl", hash = "sha256:5a8c863ceacae696aff37d1fd636121f1a512117652e5dfb86031c8d84836369", size = 12609010, upload-time = "2025-01-18T23:40:31.34Z" },
+    { url = "https://files.pythonhosted.org/packages/9f/30/f23d9876de0f08dceb707c4dcf7f8dd7588266745029debb12a3cdd40be6/numpy-2.2.2-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:b3482cb7b3325faa5f6bc179649406058253d91ceda359c104dac0ad320e1391", size = 20924451, upload-time = "2025-01-18T23:35:26.639Z" },
+    { url = "https://files.pythonhosted.org/packages/f7/ec/fe2e91b2642b9d6544518388a441bcd65c904cea38d9ff998e2e8ebf808e/numpy-2.2.2-cp313-cp313t-macosx_14_0_x86_64.whl", hash = "sha256:7dca87ca328f5ea7dafc907c5ec100d187911f94825f8700caac0b3f4c384b49", size = 6671958, upload-time = "2025-01-18T23:37:05.361Z" },
+    { url = "https://files.pythonhosted.org/packages/e1/fb/13c58591d0b6294a08cc40fcc6b9552d239d773d520858ae27f39997f2ae/numpy-2.2.2-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9fad446ad0bc886855ddf5909cbf8cb5d0faa637aaa6277fb4b19ade134ab3c7", size = 16079759, upload-time = "2025-01-18T23:38:05.757Z" },
+    { url = "https://files.pythonhosted.org/packages/aa/29/14a177f1a90b8ad8a592ca32124ac06af5eff32889874e53a308f850290f/numpy-2.2.2-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:106397dbbb1896f99e044efc90360d098b3335060375c26aa89c0d8a97c5f648", size = 17856316, upload-time = "2025-01-18T23:39:11.454Z" },
+    { url = "https://files.pythonhosted.org/packages/80/94/cd9e9b04012c015cb6320ab3bf43bc615e248dddfeb163728e800a5d96f0/numpy-2.2.2-cp313-cp313t-win_amd64.whl", hash = "sha256:97b974d3ba0fb4612b77ed35d7627490e8e3dff56ab41454d9e8b23448940576", size = 12696208, upload-time = "2025-01-18T23:39:51.85Z" },
+    { url = "https://files.pythonhosted.org/packages/96/7e/1dd770ee68916ed358991ab62c2cc353ffd98d0b75b901d52183ca28e8bb/numpy-2.2.2-pp310-pypy310_pp73-macosx_10_15_x86_64.whl", hash = "sha256:b0531f0b0e07643eb089df4c509d30d72c9ef40defa53e41363eca8a8cc61495", size = 21047291, upload-time = "2025-01-18T23:41:14.547Z" },
+    { url = "https://files.pythonhosted.org/packages/d1/3c/ccd08578dc532a8e6927952339d4a02682b776d5e85be49ed0760308433e/numpy-2.2.2-pp310-pypy310_pp73-macosx_14_0_x86_64.whl", hash = "sha256:e9e82dcb3f2ebbc8cb5ce1102d5f1c5ed236bf8a11730fb45ba82e2841ec21df", size = 6792494, upload-time = "2025-01-18T23:41:34.66Z" },
+    { url = "https://files.pythonhosted.org/packages/7c/28/8754b9aee4f97199f9a047f73bb644b5a2014994a6d7b061ba67134a42de/numpy-2.2.2-pp310-pypy310_pp73-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:e0d4142eb40ca6f94539e4db929410f2a46052a0fe7a2c1c59f6179c39938d2a", size = 16197312, upload-time = "2025-01-18T23:42:26.273Z" },
+    { url = "https://files.pythonhosted.org/packages/26/96/deb93f871f401045a684ca08a009382b247d14996d7a94fea6aa43c67b94/numpy-2.2.2-pp310-pypy310_pp73-win_amd64.whl", hash = "sha256:356ca982c188acbfa6af0d694284d8cf20e95b1c3d0aefa8929376fea9146f60", size = 12822674, upload-time = "2025-01-18T23:42:53.292Z" },
 ]
 
 [[package]]
 name = "packaging"
 version = "24.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f", size = 163950 }
+sdist = { url = "https://files.pythonhosted.org/packages/d0/63/68dbb6eb2de9cb10ee4c9c14a0148804425e13c4fb20d61cce69f53106da/packaging-24.2.tar.gz", hash = "sha256:c228a6dc5e932d346bc5739379109d49e8853dd8223571c7c5b55260edc0b97f", size = 163950, upload-time = "2024-11-08T09:47:47.202Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759", size = 65451 },
+    { url = "https://files.pythonhosted.org/packages/88/ef/eb23f262cca3c0c4eb7ab1933c3b1f03d021f2c48f54763065b6f0e321be/packaging-24.2-py3-none-any.whl", hash = "sha256:09abb1bccd265c01f4a3aa3f7a7db064b36514d2cba19a2f694fe6150451a759", size = 65451, upload-time = "2024-11-08T09:47:44.722Z" },
 ]
 
 [[package]]
@@ -498,67 +499,67 @@ dependencies = [
     { name = "pytz", marker = "python_full_version != '3.13.*' or implementation_name != 'cpython'" },
     { name = "tzdata", marker = "python_full_version != '3.13.*' or implementation_name != 'cpython'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/9c/d6/9f8431bacc2e19dca897724cd097b1bb224a6ad5433784a44b587c7c13af/pandas-2.2.3.tar.gz", hash = "sha256:4f18ba62b61d7e192368b84517265a99b4d7ee8912f8708660fb4a366cc82667", size = 4399213 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/aa/70/c853aec59839bceed032d52010ff5f1b8d87dc3114b762e4ba2727661a3b/pandas-2.2.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:1948ddde24197a0f7add2bdc4ca83bf2b1ef84a1bc8ccffd95eda17fd836ecb5", size = 12580827 },
-    { url = "https://files.pythonhosted.org/packages/44/50/7db2cd5e6373ae796f0ddad3675268c8d59fb6076e66f0c339d61cea886b/pandas-2.2.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:86976a1c5b25ae3f8ccae3a5306e443569ee3c3faf444dfd0f41cda24667ad57", size = 13064210 },
-    { url = "https://files.pythonhosted.org/packages/ce/0d/4cc7b69ce37fac07645a94e1d4b0880b15999494372c1523508511b09e40/pandas-2.2.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:37e0aced3e8f539eccf2e099f65cdb9c8aa85109b0be6e93e2baff94264bdc6f", size = 14416379 },
-    { url = "https://files.pythonhosted.org/packages/31/9e/6ebb433de864a6cd45716af52a4d7a8c3c9aaf3a98368e61db9e69e69a9c/pandas-2.2.3-cp310-cp310-win_amd64.whl", hash = "sha256:56534ce0746a58afaf7942ba4863e0ef81c9c50d3f0ae93e9497d6a41a057645", size = 11598471 },
-    { url = "https://files.pythonhosted.org/packages/a8/44/d9502bf0ed197ba9bf1103c9867d5904ddcaf869e52329787fc54ed70cc8/pandas-2.2.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:66108071e1b935240e74525006034333f98bcdb87ea116de573a6a0dccb6c039", size = 12602222 },
-    { url = "https://files.pythonhosted.org/packages/cd/5f/4dba1d39bb9c38d574a9a22548c540177f78ea47b32f99c0ff2ec499fac5/pandas-2.2.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c124333816c3a9b03fbeef3a9f230ba9a737e9e5bb4060aa2107a86cc0a497fc", size = 13058505 },
-    { url = "https://files.pythonhosted.org/packages/86/4a/03ed6b7ee323cf30404265c284cee9c65c56a212e0a08d9ee06984ba2240/pandas-2.2.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:29401dbfa9ad77319367d36940cd8a0b3a11aba16063e39632d98b0e931ddf32", size = 14440457 },
-    { url = "https://files.pythonhosted.org/packages/ed/8c/87ddf1fcb55d11f9f847e3c69bb1c6f8e46e2f40ab1a2d2abadb2401b007/pandas-2.2.3-cp311-cp311-win_amd64.whl", hash = "sha256:3fc6873a41186404dad67245896a6e440baacc92f5b716ccd1bc9ed2995ab2c5", size = 11617166 },
-    { url = "https://files.pythonhosted.org/packages/17/a3/fb2734118db0af37ea7433f57f722c0a56687e14b14690edff0cdb4b7e58/pandas-2.2.3-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:b1d432e8d08679a40e2a6d8b2f9770a5c21793a6f9f47fdd52c5ce1948a5a8a9", size = 12529893 },
-    { url = "https://files.pythonhosted.org/packages/38/f8/d8fddee9ed0d0c0f4a2132c1dfcf0e3e53265055da8df952a53e7eaf178c/pandas-2.2.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fffb8ae78d8af97f849404f21411c95062db1496aeb3e56f146f0355c9989319", size = 12739445 },
-    { url = "https://files.pythonhosted.org/packages/1d/99/617d07a6a5e429ff90c90da64d428516605a1ec7d7bea494235e1c3882de/pandas-2.2.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:062309c1b9ea12a50e8ce661145c6aab431b1e99530d3cd60640e255778bd43a", size = 14056756 },
-    { url = "https://files.pythonhosted.org/packages/29/d4/1244ab8edf173a10fd601f7e13b9566c1b525c4f365d6bee918e68381889/pandas-2.2.3-cp312-cp312-win_amd64.whl", hash = "sha256:59ef3764d0fe818125a5097d2ae867ca3fa64df032331b7e0917cf5d7bf66b13", size = 11504248 },
-    { url = "https://files.pythonhosted.org/packages/64/22/3b8f4e0ed70644e85cfdcd57454686b9057c6c38d2f74fe4b8bc2527214a/pandas-2.2.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f00d1345d84d8c86a63e476bb4955e46458b304b9575dcf71102b5c705320015", size = 12477643 },
-    { url = "https://files.pythonhosted.org/packages/e8/31/aa8da88ca0eadbabd0a639788a6da13bb2ff6edbbb9f29aa786450a30a91/pandas-2.2.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f3a255b2c19987fbbe62a9dfd6cff7ff2aa9ccab3fc75218fd4b7530f01efa24", size = 12711809 },
-    { url = "https://files.pythonhosted.org/packages/57/b7/8b757e7d92023b832869fa8881a992696a0bfe2e26f72c9ae9f255988d42/pandas-2.2.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6374c452ff3ec675a8f46fd9ab25c4ad0ba590b71cf0656f8b6daa5202bca3fb", size = 14022055 },
-    { url = "https://files.pythonhosted.org/packages/3b/bc/4b18e2b8c002572c5a441a64826252ce5da2aa738855747247a971988043/pandas-2.2.3-cp313-cp313-win_amd64.whl", hash = "sha256:61c5ad4043f791b61dd4752191d9f07f0ae412515d59ba8f005832a532f8736d", size = 11481175 },
-    { url = "https://files.pythonhosted.org/packages/76/a3/a5d88146815e972d40d19247b2c162e88213ef51c7c25993942c39dbf41d/pandas-2.2.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:3b71f27954685ee685317063bf13c7709a7ba74fc996b84fc6821c59b0f06468", size = 12615650 },
-    { url = "https://files.pythonhosted.org/packages/25/b0/98d6ae2e1abac4f35230aa756005e8654649d305df9a28b16b9ae4353bff/pandas-2.2.3-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1db71525a1538b30142094edb9adc10be3f3e176748cd7acc2240c2f2e5aa3a4", size = 11871013 },
-    { url = "https://files.pythonhosted.org/packages/ab/5f/b38085618b950b79d2d9164a711c52b10aefc0ae6833b96f626b7021b2ed/pandas-2.2.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:ad5b65698ab28ed8d7f18790a0dc58005c7629f227be9ecc1072aa74c0c1d43a", size = 13098436 },
-    { url = "https://files.pythonhosted.org/packages/ca/8c/8848a4c9b8fdf5a534fe2077af948bf53cd713d77ffbcd7bd15710348fd7/pandas-2.2.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:bc6b93f9b966093cb0fd62ff1a7e4c09e6d546ad7c1de191767baffc57628f39", size = 12595535 },
-    { url = "https://files.pythonhosted.org/packages/3d/dd/bed19c2974296661493d7acc4407b1d2db4e2a482197df100f8f965b6225/pandas-2.2.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:99df71520d25fade9db7c1076ac94eb994f4d2673ef2aa2e86ee039b6746d20c", size = 13068928 },
-    { url = "https://files.pythonhosted.org/packages/c4/a5/3429bd13d82bebc78f4d78c3945efedef63a7cd0c15c17b2eeb838d1121f/pandas-2.2.3-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:7eee9e7cea6adf3e3d24e304ac6b8300646e2a5d1cd3a3c2abed9101b0846761", size = 14450871 },
-    { url = "https://files.pythonhosted.org/packages/2f/49/5c30646e96c684570925b772eac4eb0a8cb0ca590fa978f56c5d3ae73ea1/pandas-2.2.3-cp39-cp39-win_amd64.whl", hash = "sha256:4850ba03528b6dd51d6c5d273c46f183f39a9baf3f0143e566b89450965b105e", size = 11618011 },
+sdist = { url = "https://files.pythonhosted.org/packages/9c/d6/9f8431bacc2e19dca897724cd097b1bb224a6ad5433784a44b587c7c13af/pandas-2.2.3.tar.gz", hash = "sha256:4f18ba62b61d7e192368b84517265a99b4d7ee8912f8708660fb4a366cc82667", size = 4399213, upload-time = "2024-09-20T13:10:04.827Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/aa/70/c853aec59839bceed032d52010ff5f1b8d87dc3114b762e4ba2727661a3b/pandas-2.2.3-cp310-cp310-macosx_10_9_x86_64.whl", hash = "sha256:1948ddde24197a0f7add2bdc4ca83bf2b1ef84a1bc8ccffd95eda17fd836ecb5", size = 12580827, upload-time = "2024-09-20T13:08:42.347Z" },
+    { url = "https://files.pythonhosted.org/packages/44/50/7db2cd5e6373ae796f0ddad3675268c8d59fb6076e66f0c339d61cea886b/pandas-2.2.3-cp310-cp310-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:86976a1c5b25ae3f8ccae3a5306e443569ee3c3faf444dfd0f41cda24667ad57", size = 13064210, upload-time = "2024-09-20T13:08:48.325Z" },
+    { url = "https://files.pythonhosted.org/packages/ce/0d/4cc7b69ce37fac07645a94e1d4b0880b15999494372c1523508511b09e40/pandas-2.2.3-cp310-cp310-musllinux_1_2_x86_64.whl", hash = "sha256:37e0aced3e8f539eccf2e099f65cdb9c8aa85109b0be6e93e2baff94264bdc6f", size = 14416379, upload-time = "2024-09-20T13:08:50.882Z" },
+    { url = "https://files.pythonhosted.org/packages/31/9e/6ebb433de864a6cd45716af52a4d7a8c3c9aaf3a98368e61db9e69e69a9c/pandas-2.2.3-cp310-cp310-win_amd64.whl", hash = "sha256:56534ce0746a58afaf7942ba4863e0ef81c9c50d3f0ae93e9497d6a41a057645", size = 11598471, upload-time = "2024-09-20T13:08:53.332Z" },
+    { url = "https://files.pythonhosted.org/packages/a8/44/d9502bf0ed197ba9bf1103c9867d5904ddcaf869e52329787fc54ed70cc8/pandas-2.2.3-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:66108071e1b935240e74525006034333f98bcdb87ea116de573a6a0dccb6c039", size = 12602222, upload-time = "2024-09-20T13:08:56.254Z" },
+    { url = "https://files.pythonhosted.org/packages/cd/5f/4dba1d39bb9c38d574a9a22548c540177f78ea47b32f99c0ff2ec499fac5/pandas-2.2.3-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c124333816c3a9b03fbeef3a9f230ba9a737e9e5bb4060aa2107a86cc0a497fc", size = 13058505, upload-time = "2024-09-20T13:09:01.501Z" },
+    { url = "https://files.pythonhosted.org/packages/86/4a/03ed6b7ee323cf30404265c284cee9c65c56a212e0a08d9ee06984ba2240/pandas-2.2.3-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:29401dbfa9ad77319367d36940cd8a0b3a11aba16063e39632d98b0e931ddf32", size = 14440457, upload-time = "2024-09-20T13:09:04.105Z" },
+    { url = "https://files.pythonhosted.org/packages/ed/8c/87ddf1fcb55d11f9f847e3c69bb1c6f8e46e2f40ab1a2d2abadb2401b007/pandas-2.2.3-cp311-cp311-win_amd64.whl", hash = "sha256:3fc6873a41186404dad67245896a6e440baacc92f5b716ccd1bc9ed2995ab2c5", size = 11617166, upload-time = "2024-09-20T13:09:06.917Z" },
+    { url = "https://files.pythonhosted.org/packages/17/a3/fb2734118db0af37ea7433f57f722c0a56687e14b14690edff0cdb4b7e58/pandas-2.2.3-cp312-cp312-macosx_10_9_x86_64.whl", hash = "sha256:b1d432e8d08679a40e2a6d8b2f9770a5c21793a6f9f47fdd52c5ce1948a5a8a9", size = 12529893, upload-time = "2024-09-20T13:09:09.655Z" },
+    { url = "https://files.pythonhosted.org/packages/38/f8/d8fddee9ed0d0c0f4a2132c1dfcf0e3e53265055da8df952a53e7eaf178c/pandas-2.2.3-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:fffb8ae78d8af97f849404f21411c95062db1496aeb3e56f146f0355c9989319", size = 12739445, upload-time = "2024-09-20T13:09:17.621Z" },
+    { url = "https://files.pythonhosted.org/packages/1d/99/617d07a6a5e429ff90c90da64d428516605a1ec7d7bea494235e1c3882de/pandas-2.2.3-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:062309c1b9ea12a50e8ce661145c6aab431b1e99530d3cd60640e255778bd43a", size = 14056756, upload-time = "2024-09-20T13:09:20.474Z" },
+    { url = "https://files.pythonhosted.org/packages/29/d4/1244ab8edf173a10fd601f7e13b9566c1b525c4f365d6bee918e68381889/pandas-2.2.3-cp312-cp312-win_amd64.whl", hash = "sha256:59ef3764d0fe818125a5097d2ae867ca3fa64df032331b7e0917cf5d7bf66b13", size = 11504248, upload-time = "2024-09-20T13:09:23.137Z" },
+    { url = "https://files.pythonhosted.org/packages/64/22/3b8f4e0ed70644e85cfdcd57454686b9057c6c38d2f74fe4b8bc2527214a/pandas-2.2.3-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f00d1345d84d8c86a63e476bb4955e46458b304b9575dcf71102b5c705320015", size = 12477643, upload-time = "2024-09-20T13:09:25.522Z" },
+    { url = "https://files.pythonhosted.org/packages/e8/31/aa8da88ca0eadbabd0a639788a6da13bb2ff6edbbb9f29aa786450a30a91/pandas-2.2.3-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:f3a255b2c19987fbbe62a9dfd6cff7ff2aa9ccab3fc75218fd4b7530f01efa24", size = 12711809, upload-time = "2024-09-20T13:09:30.814Z" },
+    { url = "https://files.pythonhosted.org/packages/57/b7/8b757e7d92023b832869fa8881a992696a0bfe2e26f72c9ae9f255988d42/pandas-2.2.3-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:6374c452ff3ec675a8f46fd9ab25c4ad0ba590b71cf0656f8b6daa5202bca3fb", size = 14022055, upload-time = "2024-09-20T13:09:33.462Z" },
+    { url = "https://files.pythonhosted.org/packages/3b/bc/4b18e2b8c002572c5a441a64826252ce5da2aa738855747247a971988043/pandas-2.2.3-cp313-cp313-win_amd64.whl", hash = "sha256:61c5ad4043f791b61dd4752191d9f07f0ae412515d59ba8f005832a532f8736d", size = 11481175, upload-time = "2024-09-20T13:09:35.871Z" },
+    { url = "https://files.pythonhosted.org/packages/76/a3/a5d88146815e972d40d19247b2c162e88213ef51c7c25993942c39dbf41d/pandas-2.2.3-cp313-cp313t-macosx_10_13_x86_64.whl", hash = "sha256:3b71f27954685ee685317063bf13c7709a7ba74fc996b84fc6821c59b0f06468", size = 12615650, upload-time = "2024-09-20T13:09:38.685Z" },
+    { url = "https://files.pythonhosted.org/packages/25/b0/98d6ae2e1abac4f35230aa756005e8654649d305df9a28b16b9ae4353bff/pandas-2.2.3-cp313-cp313t-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:1db71525a1538b30142094edb9adc10be3f3e176748cd7acc2240c2f2e5aa3a4", size = 11871013, upload-time = "2024-09-20T13:09:44.39Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/5f/b38085618b950b79d2d9164a711c52b10aefc0ae6833b96f626b7021b2ed/pandas-2.2.3-cp313-cp313t-musllinux_1_2_x86_64.whl", hash = "sha256:ad5b65698ab28ed8d7f18790a0dc58005c7629f227be9ecc1072aa74c0c1d43a", size = 13098436, upload-time = "2024-09-20T13:09:48.112Z" },
+    { url = "https://files.pythonhosted.org/packages/ca/8c/8848a4c9b8fdf5a534fe2077af948bf53cd713d77ffbcd7bd15710348fd7/pandas-2.2.3-cp39-cp39-macosx_10_9_x86_64.whl", hash = "sha256:bc6b93f9b966093cb0fd62ff1a7e4c09e6d546ad7c1de191767baffc57628f39", size = 12595535, upload-time = "2024-09-20T13:09:51.339Z" },
+    { url = "https://files.pythonhosted.org/packages/3d/dd/bed19c2974296661493d7acc4407b1d2db4e2a482197df100f8f965b6225/pandas-2.2.3-cp39-cp39-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:99df71520d25fade9db7c1076ac94eb994f4d2673ef2aa2e86ee039b6746d20c", size = 13068928, upload-time = "2024-09-20T13:09:56.746Z" },
+    { url = "https://files.pythonhosted.org/packages/c4/a5/3429bd13d82bebc78f4d78c3945efedef63a7cd0c15c17b2eeb838d1121f/pandas-2.2.3-cp39-cp39-musllinux_1_2_x86_64.whl", hash = "sha256:7eee9e7cea6adf3e3d24e304ac6b8300646e2a5d1cd3a3c2abed9101b0846761", size = 14450871, upload-time = "2024-09-20T13:09:59.779Z" },
+    { url = "https://files.pythonhosted.org/packages/2f/49/5c30646e96c684570925b772eac4eb0a8cb0ca590fa978f56c5d3ae73ea1/pandas-2.2.3-cp39-cp39-win_amd64.whl", hash = "sha256:4850ba03528b6dd51d6c5d273c46f183f39a9baf3f0143e566b89450965b105e", size = 11618011, upload-time = "2024-09-20T13:10:02.351Z" },
 ]
 
 [[package]]
 name = "pathspec"
 version = "0.12.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/ca/bc/f35b8446f4531a7cb215605d100cd88b7ac6f44ab3fc94870c120ab3adbf/pathspec-0.12.1.tar.gz", hash = "sha256:a482d51503a1ab33b1c67a6c3813a26953dbdc71c31dacaef9a838c4e29f5712", size = 51043 }
+sdist = { url = "https://files.pythonhosted.org/packages/ca/bc/f35b8446f4531a7cb215605d100cd88b7ac6f44ab3fc94870c120ab3adbf/pathspec-0.12.1.tar.gz", hash = "sha256:a482d51503a1ab33b1c67a6c3813a26953dbdc71c31dacaef9a838c4e29f5712", size = 51043, upload-time = "2023-12-10T22:30:45Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/cc/20/ff623b09d963f88bfde16306a54e12ee5ea43e9b597108672ff3a408aad6/pathspec-0.12.1-py3-none-any.whl", hash = "sha256:a0d503e138a4c123b27490a4f7beda6a01c6f288df0e4a8b79c7eb0dc7b4cc08", size = 31191 },
+    { url = "https://files.pythonhosted.org/packages/cc/20/ff623b09d963f88bfde16306a54e12ee5ea43e9b597108672ff3a408aad6/pathspec-0.12.1-py3-none-any.whl", hash = "sha256:a0d503e138a4c123b27490a4f7beda6a01c6f288df0e4a8b79c7eb0dc7b4cc08", size = 31191, upload-time = "2023-12-10T22:30:43.14Z" },
 ]
 
 [[package]]
 name = "platformdirs"
 version = "4.3.6"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/13/fc/128cc9cb8f03208bdbf93d3aa862e16d376844a14f9a0ce5cf4507372de4/platformdirs-4.3.6.tar.gz", hash = "sha256:357fb2acbc885b0419afd3ce3ed34564c13c9b95c89360cd9563f73aa5e2b907", size = 21302 }
+sdist = { url = "https://files.pythonhosted.org/packages/13/fc/128cc9cb8f03208bdbf93d3aa862e16d376844a14f9a0ce5cf4507372de4/platformdirs-4.3.6.tar.gz", hash = "sha256:357fb2acbc885b0419afd3ce3ed34564c13c9b95c89360cd9563f73aa5e2b907", size = 21302, upload-time = "2024-09-17T19:06:50.688Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/3c/a6/bc1012356d8ece4d66dd75c4b9fc6c1f6650ddd5991e421177d9f8f671be/platformdirs-4.3.6-py3-none-any.whl", hash = "sha256:73e575e1408ab8103900836b97580d5307456908a03e92031bab39e4554cc3fb", size = 18439 },
+    { url = "https://files.pythonhosted.org/packages/3c/a6/bc1012356d8ece4d66dd75c4b9fc6c1f6650ddd5991e421177d9f8f671be/platformdirs-4.3.6-py3-none-any.whl", hash = "sha256:73e575e1408ab8103900836b97580d5307456908a03e92031bab39e4554cc3fb", size = 18439, upload-time = "2024-09-17T19:06:49.212Z" },
 ]
 
 [[package]]
 name = "pluggy"
 version = "1.5.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/96/2d/02d4312c973c6050a18b314a5ad0b3210edb65a906f868e31c111dede4a6/pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1", size = 67955 }
+sdist = { url = "https://files.pythonhosted.org/packages/96/2d/02d4312c973c6050a18b314a5ad0b3210edb65a906f868e31c111dede4a6/pluggy-1.5.0.tar.gz", hash = "sha256:2cffa88e94fdc978c4c574f15f9e59b7f4201d439195c3715ca9e2486f1d0cf1", size = 67955, upload-time = "2024-04-20T21:34:42.531Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/88/5f/e351af9a41f866ac3f1fac4ca0613908d9a41741cfcf2228f4ad853b697d/pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669", size = 20556 },
+    { url = "https://files.pythonhosted.org/packages/88/5f/e351af9a41f866ac3f1fac4ca0613908d9a41741cfcf2228f4ad853b697d/pluggy-1.5.0-py3-none-any.whl", hash = "sha256:44e1ad92c8ca002de6377e165f3e0f1be63266ab4d554740532335b9d75ea669", size = 20556, upload-time = "2024-04-20T21:34:40.434Z" },
 ]
 
 [[package]]
 name = "pycparser"
 version = "2.22"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/1d/b2/31537cf4b1ca988837256c910a668b553fceb8f069bedc4b1c826024b52c/pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6", size = 172736 }
+sdist = { url = "https://files.pythonhosted.org/packages/1d/b2/31537cf4b1ca988837256c910a668b553fceb8f069bedc4b1c826024b52c/pycparser-2.22.tar.gz", hash = "sha256:491c8be9c040f5390f5bf44a5b07752bd07f56edf992381b05c701439eec10f6", size = 172736, upload-time = "2024-03-30T13:22:22.564Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/13/a3/a812df4e2dd5696d1f351d58b8fe16a405b234ad2886a0dab9183fb78109/pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc", size = 117552 },
+    { url = "https://files.pythonhosted.org/packages/13/a3/a812df4e2dd5696d1f351d58b8fe16a405b234ad2886a0dab9183fb78109/pycparser-2.22-py3-none-any.whl", hash = "sha256:c3702b6d3dd8c7abc1afa565d7e63d53a1d0bd86cdc24edd75470f4de499cfcc", size = 117552, upload-time = "2024-03-30T13:22:20.476Z" },
 ]
 
 [[package]]
@@ -639,7 +640,6 @@ requires-dist = [{ name = "typing-extensions", specifier = ">=4.6.0,!=4.7.0" }]
 
 [package.metadata.requires-dev]
 all = [
-    { name = "backports-zoneinfo", marker = "python_full_version < '3.9'" },
     { name = "coverage" },
     { name = "dirty-equals" },
     { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
@@ -648,8 +648,8 @@ all = [
     { name = "inline-snapshot" },
     { name = "maturin" },
     { name = "mypy" },
-    { name = "numpy", marker = "python_full_version >= '3.9' and python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
-    { name = "pandas", marker = "python_full_version >= '3.9' and python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
+    { name = "numpy", marker = "python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
+    { name = "pandas", marker = "python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
     { name = "pyright" },
     { name = "pytest" },
     { name = "pytest-examples", marker = "implementation_name == 'cpython' and platform_machine == 'x86_64'" },
@@ -673,15 +673,14 @@ linting = [
     { name = "ruff" },
 ]
 testing = [
-    { name = "backports-zoneinfo", marker = "python_full_version < '3.9'" },
     { name = "coverage" },
     { name = "dirty-equals" },
     { name = "exceptiongroup", marker = "python_full_version < '3.11'" },
     { name = "hypothesis" },
     { name = "inline-snapshot" },
     { name = "maturin" },
-    { name = "numpy", marker = "python_full_version >= '3.9' and python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
-    { name = "pandas", marker = "python_full_version >= '3.9' and python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
+    { name = "numpy", marker = "python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
+    { name = "pandas", marker = "python_full_version < '3.13' and implementation_name == 'cpython' and platform_machine == 'x86_64'" },
     { name = "pytest" },
     { name = "pytest-examples", marker = "implementation_name == 'cpython' and platform_machine == 'x86_64'" },
     { name = "pytest-mock" },
@@ -703,9 +702,9 @@ wasm = [
 name = "pygments"
 version = "2.19.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/7c/2d/c3338d48ea6cc0feb8446d8e6937e1408088a72a39937982cc6111d17f84/pygments-2.19.1.tar.gz", hash = "sha256:61c16d2a8576dc0649d9f39e089b5f02bcd27fba10d8fb4dcc28173f7a45151f", size = 4968581 }
+sdist = { url = "https://files.pythonhosted.org/packages/7c/2d/c3338d48ea6cc0feb8446d8e6937e1408088a72a39937982cc6111d17f84/pygments-2.19.1.tar.gz", hash = "sha256:61c16d2a8576dc0649d9f39e089b5f02bcd27fba10d8fb4dcc28173f7a45151f", size = 4968581, upload-time = "2025-01-06T17:26:30.443Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/8a/0b/9fcc47d19c48b59121088dd6da2488a49d5f72dacf8262e2790a1d2c7d15/pygments-2.19.1-py3-none-any.whl", hash = "sha256:9ea1544ad55cecf4b8242fab6dd35a93bbce657034b0611ee383099054ab6d8c", size = 1225293 },
+    { url = "https://files.pythonhosted.org/packages/8a/0b/9fcc47d19c48b59121088dd6da2488a49d5f72dacf8262e2790a1d2c7d15/pygments-2.19.1-py3-none-any.whl", hash = "sha256:9ea1544ad55cecf4b8242fab6dd35a93bbce657034b0611ee383099054ab6d8c", size = 1225293, upload-time = "2025-01-06T17:26:25.553Z" },
 ]
 
 [[package]]
@@ -716,9 +715,9 @@ dependencies = [
     { name = "nodeenv" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/66/df/3c6f6b08fba7ccf49b114dfc4bb33e25c299883fd763f93fad47ef8bc58d/pyright-1.1.392.post0.tar.gz", hash = "sha256:3b7f88de74a28dcfa90c7d90c782b6569a48c2be5f9d4add38472bdaac247ebd", size = 3789911 }
+sdist = { url = "https://files.pythonhosted.org/packages/66/df/3c6f6b08fba7ccf49b114dfc4bb33e25c299883fd763f93fad47ef8bc58d/pyright-1.1.392.post0.tar.gz", hash = "sha256:3b7f88de74a28dcfa90c7d90c782b6569a48c2be5f9d4add38472bdaac247ebd", size = 3789911, upload-time = "2025-01-15T15:01:20.913Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/e7/b1/a18de17f40e4f61ca58856b9ef9b0febf74ff88978c3f7776f910071f567/pyright-1.1.392.post0-py3-none-any.whl", hash = "sha256:252f84458a46fa2f0fd4e2f91fc74f50b9ca52c757062e93f6c250c0d8329eb2", size = 5595487 },
+    { url = "https://files.pythonhosted.org/packages/e7/b1/a18de17f40e4f61ca58856b9ef9b0febf74ff88978c3f7776f910071f567/pyright-1.1.392.post0-py3-none-any.whl", hash = "sha256:252f84458a46fa2f0fd4e2f91fc74f50b9ca52c757062e93f6c250c0d8329eb2", size = 5595487, upload-time = "2025-01-15T15:01:17.775Z" },
 ]
 
 [[package]]
@@ -733,9 +732,9 @@ dependencies = [
     { name = "pluggy" },
     { name = "tomli", marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/05/35/30e0d83068951d90a01852cb1cef56e5d8a09d20c7f511634cc2f7e0372a/pytest-8.3.4.tar.gz", hash = "sha256:965370d062bce11e73868e0335abac31b4d3de0e82f4007408d242b4f8610761", size = 1445919 }
+sdist = { url = "https://files.pythonhosted.org/packages/05/35/30e0d83068951d90a01852cb1cef56e5d8a09d20c7f511634cc2f7e0372a/pytest-8.3.4.tar.gz", hash = "sha256:965370d062bce11e73868e0335abac31b4d3de0e82f4007408d242b4f8610761", size = 1445919, upload-time = "2024-12-01T12:54:25.98Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/11/92/76a1c94d3afee238333bc0a42b82935dd8f9cf8ce9e336ff87ee14d9e1cf/pytest-8.3.4-py3-none-any.whl", hash = "sha256:50e16d954148559c9a74109af1eaf0c945ba2d8f30f0a3d3335edde19788b6f6", size = 343083 },
+    { url = "https://files.pythonhosted.org/packages/11/92/76a1c94d3afee238333bc0a42b82935dd8f9cf8ce9e336ff87ee14d9e1cf/pytest-8.3.4-py3-none-any.whl", hash = "sha256:50e16d954148559c9a74109af1eaf0c945ba2d8f30f0a3d3335edde19788b6f6", size = 343083, upload-time = "2024-12-01T12:54:19.735Z" },
 ]
 
 [[package]]
@@ -747,19 +746,19 @@ dependencies = [
     { name = "pytest", marker = "python_full_version == '3.13.*' and implementation_name == 'cpython'" },
     { name = "rich", marker = "python_full_version == '3.13.*' and implementation_name == 'cpython'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/36/39/4a94b61e981f993d52d0fbff259c3de08a2fb884a77464f35522031125d5/pytest_codspeed-3.1.2.tar.gz", hash = "sha256:09c1733af3aab35e94a621aa510f2d2114f65591e6f644c42ca3f67547edad4b", size = 18277 }
+sdist = { url = "https://files.pythonhosted.org/packages/36/39/4a94b61e981f993d52d0fbff259c3de08a2fb884a77464f35522031125d5/pytest_codspeed-3.1.2.tar.gz", hash = "sha256:09c1733af3aab35e94a621aa510f2d2114f65591e6f644c42ca3f67547edad4b", size = 18277, upload-time = "2025-01-09T13:42:03.27Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/a5/ca/8fbcf065e10fcde0d766fa40452e1e348ad17456b87584fb3136c8b53809/pytest_codspeed-3.1.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aed496f873670ce0ea8f980a7c1a2c6a08f415e0ebdf207bf651b2d922103374", size = 26734 },
-    { url = "https://files.pythonhosted.org/packages/f6/b9/852971f76d8e4aa73ef4dcc028c07d2d8f2ca7add8eb8bc94f9e6053c879/pytest_codspeed-3.1.2-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ee45b0b763f6b5fa5d74c7b91d694a9615561c428b320383660672f4471756e3", size = 25373 },
-    { url = "https://files.pythonhosted.org/packages/44/9f/5d2c0879256ca824c720baf5fac61d51179dd16111c609abab4f84e8ddcb/pytest_codspeed-3.1.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c84e591a7a0f67d45e2dc9fd05b276971a3aabcab7478fe43363ebefec1358f4", size = 26742 },
-    { url = "https://files.pythonhosted.org/packages/5b/ff/862657f1a5a5dc9682dc7c23849fdabb0501df8da44eb307b1a9c3017254/pytest_codspeed-3.1.2-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c6ae6d094247156407770e6b517af70b98862dd59a3c31034aede11d5f71c32c", size = 25375 },
-    { url = "https://files.pythonhosted.org/packages/1b/bb/42fa7de046ddd0cefb1987d72e7ed4ee5ae4d962c8e6c62c29a8d6334e90/pytest_codspeed-3.1.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d0f264991de5b5cdc118b96fc671386cca3f0f34e411482939bf2459dc599097", size = 27114 },
-    { url = "https://files.pythonhosted.org/packages/0a/8e/bc84e8f94637ef31323961e25ce83508edb630e05a5956ce585fa96b57f2/pytest_codspeed-3.1.2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c0695a4bcd5ff04e8379124dba5d9795ea5e0cadf38be7a0406432fc1467b555", size = 25870 },
-    { url = "https://files.pythonhosted.org/packages/d6/a1/b85a880916d8c8992a18ce2ee41b179e867af1b5d9ea1c27a68190780d3d/pytest_codspeed-3.1.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6dc356c8dcaaa883af83310f397ac06c96fac9b8a1146e303d4b374b2cb46a18", size = 27112 },
-    { url = "https://files.pythonhosted.org/packages/23/44/2ba137983072cad2c853687fa737138b790cc0f71dc1842f3672488c61fc/pytest_codspeed-3.1.2-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cc8a5d0366322a75cf562f7d8d672d28c1cf6948695c4dddca50331e08f6b3d5", size = 25859 },
-    { url = "https://files.pythonhosted.org/packages/ea/f4/8deca488c04d993eb8b9a7c30408bdffcd84b87eda8f83759718a8f82efb/pytest_codspeed-3.1.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6c5fe7a19b72f54f217480b3b527102579547b1de9fe3acd9e66cb4629ff46c8", size = 26725 },
-    { url = "https://files.pythonhosted.org/packages/c1/8f/0433514dd85f136057b31c27264bab08a3b96c91f3870912a9a1cb362572/pytest_codspeed-3.1.2-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b67205755a665593f6521a98317d02a9d07d6fdc593f6634de2c94dea47a3055", size = 25364 },
-    { url = "https://files.pythonhosted.org/packages/a0/9f/7833be9ce5ceed7284955e1c1602a19552c397861a5b3c1eab3d6b26fca7/pytest_codspeed-3.1.2-py3-none-any.whl", hash = "sha256:5e7ed0315e33496c5c07dba262b50303b8d0bc4c3d10bf1d422a41e70783f1cb", size = 14938 },
+    { url = "https://files.pythonhosted.org/packages/a5/ca/8fbcf065e10fcde0d766fa40452e1e348ad17456b87584fb3136c8b53809/pytest_codspeed-3.1.2-cp310-cp310-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:aed496f873670ce0ea8f980a7c1a2c6a08f415e0ebdf207bf651b2d922103374", size = 26734, upload-time = "2025-01-09T13:41:44.96Z" },
+    { url = "https://files.pythonhosted.org/packages/f6/b9/852971f76d8e4aa73ef4dcc028c07d2d8f2ca7add8eb8bc94f9e6053c879/pytest_codspeed-3.1.2-cp310-cp310-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:ee45b0b763f6b5fa5d74c7b91d694a9615561c428b320383660672f4471756e3", size = 25373, upload-time = "2025-01-09T13:41:47.236Z" },
+    { url = "https://files.pythonhosted.org/packages/44/9f/5d2c0879256ca824c720baf5fac61d51179dd16111c609abab4f84e8ddcb/pytest_codspeed-3.1.2-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:c84e591a7a0f67d45e2dc9fd05b276971a3aabcab7478fe43363ebefec1358f4", size = 26742, upload-time = "2025-01-09T13:41:49.265Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/ff/862657f1a5a5dc9682dc7c23849fdabb0501df8da44eb307b1a9c3017254/pytest_codspeed-3.1.2-cp311-cp311-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c6ae6d094247156407770e6b517af70b98862dd59a3c31034aede11d5f71c32c", size = 25375, upload-time = "2025-01-09T13:41:51.295Z" },
+    { url = "https://files.pythonhosted.org/packages/1b/bb/42fa7de046ddd0cefb1987d72e7ed4ee5ae4d962c8e6c62c29a8d6334e90/pytest_codspeed-3.1.2-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:d0f264991de5b5cdc118b96fc671386cca3f0f34e411482939bf2459dc599097", size = 27114, upload-time = "2025-01-09T13:41:52.675Z" },
+    { url = "https://files.pythonhosted.org/packages/0a/8e/bc84e8f94637ef31323961e25ce83508edb630e05a5956ce585fa96b57f2/pytest_codspeed-3.1.2-cp312-cp312-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c0695a4bcd5ff04e8379124dba5d9795ea5e0cadf38be7a0406432fc1467b555", size = 25870, upload-time = "2025-01-09T13:41:54.72Z" },
+    { url = "https://files.pythonhosted.org/packages/d6/a1/b85a880916d8c8992a18ce2ee41b179e867af1b5d9ea1c27a68190780d3d/pytest_codspeed-3.1.2-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6dc356c8dcaaa883af83310f397ac06c96fac9b8a1146e303d4b374b2cb46a18", size = 27112, upload-time = "2025-01-09T13:41:55.656Z" },
+    { url = "https://files.pythonhosted.org/packages/23/44/2ba137983072cad2c853687fa737138b790cc0f71dc1842f3672488c61fc/pytest_codspeed-3.1.2-cp313-cp313-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:cc8a5d0366322a75cf562f7d8d672d28c1cf6948695c4dddca50331e08f6b3d5", size = 25859, upload-time = "2025-01-09T13:41:57.94Z" },
+    { url = "https://files.pythonhosted.org/packages/ea/f4/8deca488c04d993eb8b9a7c30408bdffcd84b87eda8f83759718a8f82efb/pytest_codspeed-3.1.2-cp39-cp39-manylinux_2_17_aarch64.manylinux2014_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6c5fe7a19b72f54f217480b3b527102579547b1de9fe3acd9e66cb4629ff46c8", size = 26725, upload-time = "2025-01-09T13:42:00.461Z" },
+    { url = "https://files.pythonhosted.org/packages/c1/8f/0433514dd85f136057b31c27264bab08a3b96c91f3870912a9a1cb362572/pytest_codspeed-3.1.2-cp39-cp39-manylinux_2_5_x86_64.manylinux1_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b67205755a665593f6521a98317d02a9d07d6fdc593f6634de2c94dea47a3055", size = 25364, upload-time = "2025-01-09T13:42:01.434Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/9f/7833be9ce5ceed7284955e1c1602a19552c397861a5b3c1eab3d6b26fca7/pytest_codspeed-3.1.2-py3-none-any.whl", hash = "sha256:5e7ed0315e33496c5c07dba262b50303b8d0bc4c3d10bf1d422a41e70783f1cb", size = 14938, upload-time = "2025-01-09T13:42:02.329Z" },
 ]
 
 [[package]]
@@ -771,9 +770,9 @@ dependencies = [
     { name = "pytest" },
     { name = "ruff" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c3/82/fa4fb866d52934de97b90c84c89896faebfb984436804fc3baa55d48d511/pytest_examples-0.0.15.tar.gz", hash = "sha256:2d6ced2d1f0d59863f81a4d2f193737464b8004a7670907c3bedef6306a5d660", size = 20771 }
+sdist = { url = "https://files.pythonhosted.org/packages/c3/82/fa4fb866d52934de97b90c84c89896faebfb984436804fc3baa55d48d511/pytest_examples-0.0.15.tar.gz", hash = "sha256:2d6ced2d1f0d59863f81a4d2f193737464b8004a7670907c3bedef6306a5d660", size = 20771, upload-time = "2024-11-20T17:27:37.086Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ba/81/3f727a7d2f9c1ff36f581453949a4af314629108642d5140298476e90902/pytest_examples-0.0.15-py3-none-any.whl", hash = "sha256:6e4adc522bf2e3f93cae3b37a4add76fcc2c1ada29d8988b2ea15b236233ec0f", size = 17922 },
+    { url = "https://files.pythonhosted.org/packages/ba/81/3f727a7d2f9c1ff36f581453949a4af314629108642d5140298476e90902/pytest_examples-0.0.15-py3-none-any.whl", hash = "sha256:6e4adc522bf2e3f93cae3b37a4add76fcc2c1ada29d8988b2ea15b236233ec0f", size = 17922, upload-time = "2024-11-20T17:27:35.155Z" },
 ]
 
 [[package]]
@@ -783,9 +782,9 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "pytest" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/c6/90/a955c3ab35ccd41ad4de556596fa86685bf4fc5ffcc62d22d856cfd4e29a/pytest-mock-3.14.0.tar.gz", hash = "sha256:2719255a1efeceadbc056d6bf3df3d1c5015530fb40cf347c0f9afac88410bd0", size = 32814 }
+sdist = { url = "https://files.pythonhosted.org/packages/c6/90/a955c3ab35ccd41ad4de556596fa86685bf4fc5ffcc62d22d856cfd4e29a/pytest-mock-3.14.0.tar.gz", hash = "sha256:2719255a1efeceadbc056d6bf3df3d1c5015530fb40cf347c0f9afac88410bd0", size = 32814, upload-time = "2024-03-21T22:14:04.964Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/f2/3b/b26f90f74e2986a82df6e7ac7e319b8ea7ccece1caec9f8ab6104dc70603/pytest_mock-3.14.0-py3-none-any.whl", hash = "sha256:0b72c38033392a5f4621342fe11e9219ac11ec9d375f8e2a0c164539e0d70f6f", size = 9863 },
+    { url = "https://files.pythonhosted.org/packages/f2/3b/b26f90f74e2986a82df6e7ac7e319b8ea7ccece1caec9f8ab6104dc70603/pytest_mock-3.14.0-py3-none-any.whl", hash = "sha256:0b72c38033392a5f4621342fe11e9219ac11ec9d375f8e2a0c164539e0d70f6f", size = 9863, upload-time = "2024-03-21T22:14:02.694Z" },
 ]
 
 [[package]]
@@ -796,9 +795,9 @@ dependencies = [
     { name = "pytest" },
     { name = "rich" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a5/18/30ad0408295f3157f7a4913f0eaa51a0a377ebad0ffa51ff239e833c6c72/pytest_pretty-1.2.0.tar.gz", hash = "sha256:105a355f128e392860ad2c478ae173ff96d2f03044692f9818ff3d49205d3a60", size = 6542 }
+sdist = { url = "https://files.pythonhosted.org/packages/a5/18/30ad0408295f3157f7a4913f0eaa51a0a377ebad0ffa51ff239e833c6c72/pytest_pretty-1.2.0.tar.gz", hash = "sha256:105a355f128e392860ad2c478ae173ff96d2f03044692f9818ff3d49205d3a60", size = 6542, upload-time = "2023-04-05T17:11:50.917Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/bf/fe/d44d391312c1b8abee2af58ee70fabb1c00b6577ac4e0bdf25b70c1caffb/pytest_pretty-1.2.0-py3-none-any.whl", hash = "sha256:6f79122bf53864ae2951b6c9e94d7a06a87ef753476acd4588aeac018f062036", size = 6180 },
+    { url = "https://files.pythonhosted.org/packages/bf/fe/d44d391312c1b8abee2af58ee70fabb1c00b6577ac4e0bdf25b70c1caffb/pytest_pretty-1.2.0-py3-none-any.whl", hash = "sha256:6f79122bf53864ae2951b6c9e94d7a06a87ef753476acd4588aeac018f062036", size = 6180, upload-time = "2023-04-05T17:11:49.801Z" },
 ]
 
 [[package]]
@@ -808,9 +807,9 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "pytest" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/fe/13/d3bcb2c52f63b774be612cbee51f33a5cf2fa97d2f60fe26264f6720477b/pytest_run_parallel-0.3.1.tar.gz", hash = "sha256:636306d3ed6838898d8d42b3cd379dac7b327ce6d68df1bcc30d55a208d5081e", size = 14142 }
+sdist = { url = "https://files.pythonhosted.org/packages/fe/13/d3bcb2c52f63b774be612cbee51f33a5cf2fa97d2f60fe26264f6720477b/pytest_run_parallel-0.3.1.tar.gz", hash = "sha256:636306d3ed6838898d8d42b3cd379dac7b327ce6d68df1bcc30d55a208d5081e", size = 14142, upload-time = "2025-02-05T20:29:11.504Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/4d/67/4943178bb5dacb2e0b745b4db4ab126112dafab66266f2262896e791dbbe/pytest_run_parallel-0.3.1-py3-none-any.whl", hash = "sha256:0675c9e4c8e843085333c66bc0ce6b8091e3509dc8e6df3429f05c28f5345b17", size = 9468 },
+    { url = "https://files.pythonhosted.org/packages/4d/67/4943178bb5dacb2e0b745b4db4ab126112dafab66266f2262896e791dbbe/pytest_run_parallel-0.3.1-py3-none-any.whl", hash = "sha256:0675c9e4c8e843085333c66bc0ce6b8091e3509dc8e6df3429f05c28f5345b17", size = 9468, upload-time = "2025-02-05T20:29:10.406Z" },
 ]
 
 [[package]]
@@ -822,9 +821,9 @@ dependencies = [
     { name = "pytest" },
     { name = "rich" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/61/21/6acc1504e62f5b72ede4a1d10b70dd3e6a2acc14e21f214673fe701c272b/pytest_speed-0.3.5.tar.gz", hash = "sha256:e76208eb37362d0de9ce228488d18b5d96b95ea0dec6b0ad0e0f4ddfa359f3b0", size = 8702 }
+sdist = { url = "https://files.pythonhosted.org/packages/61/21/6acc1504e62f5b72ede4a1d10b70dd3e6a2acc14e21f214673fe701c272b/pytest_speed-0.3.5.tar.gz", hash = "sha256:e76208eb37362d0de9ce228488d18b5d96b95ea0dec6b0ad0e0f4ddfa359f3b0", size = 8702, upload-time = "2023-01-22T12:09:19.303Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/59/c5/654fe3dae7d791d3a177f8aea58bec6aa72b9d8fdde1e2f30cd2e0c5fe1a/pytest_speed-0.3.5-py3-none-any.whl", hash = "sha256:ef9f17d6800b158e0a78df81bdbfe662a27ef5ddbf86376ff092fd6673135466", size = 9717 },
+    { url = "https://files.pythonhosted.org/packages/59/c5/654fe3dae7d791d3a177f8aea58bec6aa72b9d8fdde1e2f30cd2e0c5fe1a/pytest_speed-0.3.5-py3-none-any.whl", hash = "sha256:ef9f17d6800b158e0a78df81bdbfe662a27ef5ddbf86376ff092fd6673135466", size = 9717, upload-time = "2023-01-22T12:09:17.351Z" },
 ]
 
 [[package]]
@@ -834,9 +833,9 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "pytest" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/93/0d/04719abc7a4bdb3a7a1f968f24b0f5253d698c9cc94975330e9d3145befb/pytest-timeout-2.3.1.tar.gz", hash = "sha256:12397729125c6ecbdaca01035b9e5239d4db97352320af155b3f5de1ba5165d9", size = 17697 }
+sdist = { url = "https://files.pythonhosted.org/packages/93/0d/04719abc7a4bdb3a7a1f968f24b0f5253d698c9cc94975330e9d3145befb/pytest-timeout-2.3.1.tar.gz", hash = "sha256:12397729125c6ecbdaca01035b9e5239d4db97352320af155b3f5de1ba5165d9", size = 17697, upload-time = "2024-03-07T21:04:01.069Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/03/27/14af9ef8321f5edc7527e47def2a21d8118c6f329a9342cc61387a0c0599/pytest_timeout-2.3.1-py3-none-any.whl", hash = "sha256:68188cb703edfc6a18fad98dc25a3c61e9f24d644b0b70f33af545219fc7813e", size = 14148 },
+    { url = "https://files.pythonhosted.org/packages/03/27/14af9ef8321f5edc7527e47def2a21d8118c6f329a9342cc61387a0c0599/pytest_timeout-2.3.1-py3-none-any.whl", hash = "sha256:68188cb703edfc6a18fad98dc25a3c61e9f24d644b0b70f33af545219fc7813e", size = 14148, upload-time = "2024-03-07T21:03:58.764Z" },
 ]
 
 [[package]]
@@ -846,18 +845,18 @@ source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "six" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432 }
+sdist = { url = "https://files.pythonhosted.org/packages/66/c0/0c8b6ad9f17a802ee498c46e004a0eb49bc148f2fd230864601a86dcf6db/python-dateutil-2.9.0.post0.tar.gz", hash = "sha256:37dd54208da7e1cd875388217d5e00ebd4179249f90fb72437e91a35459a0ad3", size = 342432, upload-time = "2024-03-01T18:36:20.211Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892 },
+    { url = "https://files.pythonhosted.org/packages/ec/57/56b9bcc3c9c6a792fcbaf139543cee77261f3651ca9da0c93f5c1221264b/python_dateutil-2.9.0.post0-py2.py3-none-any.whl", hash = "sha256:a8b2bc7bffae282281c8140a97d3aa9c14da0b136dfe83f850eea9a5f7470427", size = 229892, upload-time = "2024-03-01T18:36:18.57Z" },
 ]
 
 [[package]]
 name = "pytz"
 version = "2024.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/3a/31/3c70bf7603cc2dca0f19bdc53b4537a797747a58875b552c8c413d963a3f/pytz-2024.2.tar.gz", hash = "sha256:2aa355083c50a0f93fa581709deac0c9ad65cca8a9e9beac660adcbd493c798a", size = 319692 }
+sdist = { url = "https://files.pythonhosted.org/packages/3a/31/3c70bf7603cc2dca0f19bdc53b4537a797747a58875b552c8c413d963a3f/pytz-2024.2.tar.gz", hash = "sha256:2aa355083c50a0f93fa581709deac0c9ad65cca8a9e9beac660adcbd493c798a", size = 319692, upload-time = "2024-09-11T02:24:47.91Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/11/c3/005fcca25ce078d2cc29fd559379817424e94885510568bc1bc53d7d5846/pytz-2024.2-py2.py3-none-any.whl", hash = "sha256:31c7c1817eb7fae7ca4b8c7ee50c72f93aa2dd863de768e1ef4245d426aa0725", size = 508002 },
+    { url = "https://files.pythonhosted.org/packages/11/c3/005fcca25ce078d2cc29fd559379817424e94885510568bc1bc53d7d5846/pytz-2024.2-py2.py3-none-any.whl", hash = "sha256:31c7c1817eb7fae7ca4b8c7ee50c72f93aa2dd863de768e1ef4245d426aa0725", size = 508002, upload-time = "2024-09-11T02:24:45.8Z" },
 ]
 
 [[package]]
@@ -869,107 +868,107 @@ dependencies = [
     { name = "pygments" },
     { name = "typing-extensions", marker = "python_full_version < '3.11'" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ab/3a/0316b28d0761c6734d6bc14e770d85506c986c85ffb239e688eeaab2c2bc/rich-13.9.4.tar.gz", hash = "sha256:439594978a49a09530cff7ebc4b5c7103ef57baf48d5ea3184f21d9a2befa098", size = 223149 }
+sdist = { url = "https://files.pythonhosted.org/packages/ab/3a/0316b28d0761c6734d6bc14e770d85506c986c85ffb239e688eeaab2c2bc/rich-13.9.4.tar.gz", hash = "sha256:439594978a49a09530cff7ebc4b5c7103ef57baf48d5ea3184f21d9a2befa098", size = 223149, upload-time = "2024-11-01T16:43:57.873Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/19/71/39c7c0d87f8d4e6c020a393182060eaefeeae6c01dab6a84ec346f2567df/rich-13.9.4-py3-none-any.whl", hash = "sha256:6049d5e6ec054bf2779ab3358186963bac2ea89175919d699e378b99738c2a90", size = 242424 },
+    { url = "https://files.pythonhosted.org/packages/19/71/39c7c0d87f8d4e6c020a393182060eaefeeae6c01dab6a84ec346f2567df/rich-13.9.4-py3-none-any.whl", hash = "sha256:6049d5e6ec054bf2779ab3358186963bac2ea89175919d699e378b99738c2a90", size = 242424, upload-time = "2024-11-01T16:43:55.817Z" },
 ]
 
 [[package]]
 name = "ruff"
 version = "0.9.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/80/63/77ecca9d21177600f551d1c58ab0e5a0b260940ea7312195bd2a4798f8a8/ruff-0.9.2.tar.gz", hash = "sha256:b5eceb334d55fae5f316f783437392642ae18e16dcf4f1858d55d3c2a0f8f5d0", size = 3553799 }
+sdist = { url = "https://files.pythonhosted.org/packages/80/63/77ecca9d21177600f551d1c58ab0e5a0b260940ea7312195bd2a4798f8a8/ruff-0.9.2.tar.gz", hash = "sha256:b5eceb334d55fae5f316f783437392642ae18e16dcf4f1858d55d3c2a0f8f5d0", size = 3553799, upload-time = "2025-01-16T13:22:20.512Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/af/b9/0e168e4e7fb3af851f739e8f07889b91d1a33a30fca8c29fa3149d6b03ec/ruff-0.9.2-py3-none-linux_armv6l.whl", hash = "sha256:80605a039ba1454d002b32139e4970becf84b5fee3a3c3bf1c2af6f61a784347", size = 11652408 },
-    { url = "https://files.pythonhosted.org/packages/2c/22/08ede5db17cf701372a461d1cb8fdde037da1d4fa622b69ac21960e6237e/ruff-0.9.2-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:b9aab82bb20afd5f596527045c01e6ae25a718ff1784cb92947bff1f83068b00", size = 11587553 },
-    { url = "https://files.pythonhosted.org/packages/42/05/dedfc70f0bf010230229e33dec6e7b2235b2a1b8cbb2a991c710743e343f/ruff-0.9.2-py3-none-macosx_11_0_arm64.whl", hash = "sha256:fbd337bac1cfa96be615f6efcd4bc4d077edbc127ef30e2b8ba2a27e18c054d4", size = 11020755 },
-    { url = "https://files.pythonhosted.org/packages/df/9b/65d87ad9b2e3def67342830bd1af98803af731243da1255537ddb8f22209/ruff-0.9.2-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:82b35259b0cbf8daa22a498018e300b9bb0174c2bbb7bcba593935158a78054d", size = 11826502 },
-    { url = "https://files.pythonhosted.org/packages/93/02/f2239f56786479e1a89c3da9bc9391120057fc6f4a8266a5b091314e72ce/ruff-0.9.2-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8b6a9701d1e371bf41dca22015c3f89769da7576884d2add7317ec1ec8cb9c3c", size = 11390562 },
-    { url = "https://files.pythonhosted.org/packages/c9/37/d3a854dba9931f8cb1b2a19509bfe59e00875f48ade632e95aefcb7a0aee/ruff-0.9.2-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9cc53e68b3c5ae41e8faf83a3b89f4a5d7b2cb666dff4b366bb86ed2a85b481f", size = 12548968 },
-    { url = "https://files.pythonhosted.org/packages/fa/c3/c7b812bb256c7a1d5553433e95980934ffa85396d332401f6b391d3c4569/ruff-0.9.2-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:8efd9da7a1ee314b910da155ca7e8953094a7c10d0c0a39bfde3fcfd2a015684", size = 13187155 },
-    { url = "https://files.pythonhosted.org/packages/bd/5a/3c7f9696a7875522b66aa9bba9e326e4e5894b4366bd1dc32aa6791cb1ff/ruff-0.9.2-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3292c5a22ea9a5f9a185e2d131dc7f98f8534a32fb6d2ee7b9944569239c648d", size = 12704674 },
-    { url = "https://files.pythonhosted.org/packages/be/d6/d908762257a96ce5912187ae9ae86792e677ca4f3dc973b71e7508ff6282/ruff-0.9.2-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1a605fdcf6e8b2d39f9436d343d1f0ff70c365a1e681546de0104bef81ce88df", size = 14529328 },
-    { url = "https://files.pythonhosted.org/packages/2d/c2/049f1e6755d12d9cd8823242fa105968f34ee4c669d04cac8cea51a50407/ruff-0.9.2-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c547f7f256aa366834829a08375c297fa63386cbe5f1459efaf174086b564247", size = 12385955 },
-    { url = "https://files.pythonhosted.org/packages/91/5a/a9bdb50e39810bd9627074e42743b00e6dc4009d42ae9f9351bc3dbc28e7/ruff-0.9.2-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:d18bba3d3353ed916e882521bc3e0af403949dbada344c20c16ea78f47af965e", size = 11810149 },
-    { url = "https://files.pythonhosted.org/packages/e5/fd/57df1a0543182f79a1236e82a79c68ce210efb00e97c30657d5bdb12b478/ruff-0.9.2-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:b338edc4610142355ccf6b87bd356729b62bf1bc152a2fad5b0c7dc04af77bfe", size = 11479141 },
-    { url = "https://files.pythonhosted.org/packages/dc/16/bc3fd1d38974f6775fc152a0554f8c210ff80f2764b43777163c3c45d61b/ruff-0.9.2-py3-none-musllinux_1_2_i686.whl", hash = "sha256:492a5e44ad9b22a0ea98cf72e40305cbdaf27fac0d927f8bc9e1df316dcc96eb", size = 12014073 },
-    { url = "https://files.pythonhosted.org/packages/47/6b/e4ca048a8f2047eb652e1e8c755f384d1b7944f69ed69066a37acd4118b0/ruff-0.9.2-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:af1e9e9fe7b1f767264d26b1075ac4ad831c7db976911fa362d09b2d0356426a", size = 12435758 },
-    { url = "https://files.pythonhosted.org/packages/c2/40/4d3d6c979c67ba24cf183d29f706051a53c36d78358036a9cd21421582ab/ruff-0.9.2-py3-none-win32.whl", hash = "sha256:71cbe22e178c5da20e1514e1e01029c73dc09288a8028a5d3446e6bba87a5145", size = 9796916 },
-    { url = "https://files.pythonhosted.org/packages/c3/ef/7f548752bdb6867e6939489c87fe4da489ab36191525fadc5cede2a6e8e2/ruff-0.9.2-py3-none-win_amd64.whl", hash = "sha256:c5e1d6abc798419cf46eed03f54f2e0c3adb1ad4b801119dedf23fcaf69b55b5", size = 10773080 },
-    { url = "https://files.pythonhosted.org/packages/0e/4e/33df635528292bd2d18404e4daabcd74ca8a9853b2e1df85ed3d32d24362/ruff-0.9.2-py3-none-win_arm64.whl", hash = "sha256:a1b63fa24149918f8b37cef2ee6fff81f24f0d74b6f0bdc37bc3e1f2143e41c6", size = 10001738 },
+    { url = "https://files.pythonhosted.org/packages/af/b9/0e168e4e7fb3af851f739e8f07889b91d1a33a30fca8c29fa3149d6b03ec/ruff-0.9.2-py3-none-linux_armv6l.whl", hash = "sha256:80605a039ba1454d002b32139e4970becf84b5fee3a3c3bf1c2af6f61a784347", size = 11652408, upload-time = "2025-01-16T13:21:12.732Z" },
+    { url = "https://files.pythonhosted.org/packages/2c/22/08ede5db17cf701372a461d1cb8fdde037da1d4fa622b69ac21960e6237e/ruff-0.9.2-py3-none-macosx_10_12_x86_64.whl", hash = "sha256:b9aab82bb20afd5f596527045c01e6ae25a718ff1784cb92947bff1f83068b00", size = 11587553, upload-time = "2025-01-16T13:21:17.716Z" },
+    { url = "https://files.pythonhosted.org/packages/42/05/dedfc70f0bf010230229e33dec6e7b2235b2a1b8cbb2a991c710743e343f/ruff-0.9.2-py3-none-macosx_11_0_arm64.whl", hash = "sha256:fbd337bac1cfa96be615f6efcd4bc4d077edbc127ef30e2b8ba2a27e18c054d4", size = 11020755, upload-time = "2025-01-16T13:21:21.746Z" },
+    { url = "https://files.pythonhosted.org/packages/df/9b/65d87ad9b2e3def67342830bd1af98803af731243da1255537ddb8f22209/ruff-0.9.2-py3-none-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:82b35259b0cbf8daa22a498018e300b9bb0174c2bbb7bcba593935158a78054d", size = 11826502, upload-time = "2025-01-16T13:21:26.135Z" },
+    { url = "https://files.pythonhosted.org/packages/93/02/f2239f56786479e1a89c3da9bc9391120057fc6f4a8266a5b091314e72ce/ruff-0.9.2-py3-none-manylinux_2_17_armv7l.manylinux2014_armv7l.whl", hash = "sha256:8b6a9701d1e371bf41dca22015c3f89769da7576884d2add7317ec1ec8cb9c3c", size = 11390562, upload-time = "2025-01-16T13:21:29.026Z" },
+    { url = "https://files.pythonhosted.org/packages/c9/37/d3a854dba9931f8cb1b2a19509bfe59e00875f48ade632e95aefcb7a0aee/ruff-0.9.2-py3-none-manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:9cc53e68b3c5ae41e8faf83a3b89f4a5d7b2cb666dff4b366bb86ed2a85b481f", size = 12548968, upload-time = "2025-01-16T13:21:34.147Z" },
+    { url = "https://files.pythonhosted.org/packages/fa/c3/c7b812bb256c7a1d5553433e95980934ffa85396d332401f6b391d3c4569/ruff-0.9.2-py3-none-manylinux_2_17_ppc64.manylinux2014_ppc64.whl", hash = "sha256:8efd9da7a1ee314b910da155ca7e8953094a7c10d0c0a39bfde3fcfd2a015684", size = 13187155, upload-time = "2025-01-16T13:21:40.494Z" },
+    { url = "https://files.pythonhosted.org/packages/bd/5a/3c7f9696a7875522b66aa9bba9e326e4e5894b4366bd1dc32aa6791cb1ff/ruff-0.9.2-py3-none-manylinux_2_17_ppc64le.manylinux2014_ppc64le.whl", hash = "sha256:3292c5a22ea9a5f9a185e2d131dc7f98f8534a32fb6d2ee7b9944569239c648d", size = 12704674, upload-time = "2025-01-16T13:21:45.041Z" },
+    { url = "https://files.pythonhosted.org/packages/be/d6/d908762257a96ce5912187ae9ae86792e677ca4f3dc973b71e7508ff6282/ruff-0.9.2-py3-none-manylinux_2_17_s390x.manylinux2014_s390x.whl", hash = "sha256:1a605fdcf6e8b2d39f9436d343d1f0ff70c365a1e681546de0104bef81ce88df", size = 14529328, upload-time = "2025-01-16T13:21:49.45Z" },
+    { url = "https://files.pythonhosted.org/packages/2d/c2/049f1e6755d12d9cd8823242fa105968f34ee4c669d04cac8cea51a50407/ruff-0.9.2-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:c547f7f256aa366834829a08375c297fa63386cbe5f1459efaf174086b564247", size = 12385955, upload-time = "2025-01-16T13:21:52.71Z" },
+    { url = "https://files.pythonhosted.org/packages/91/5a/a9bdb50e39810bd9627074e42743b00e6dc4009d42ae9f9351bc3dbc28e7/ruff-0.9.2-py3-none-musllinux_1_2_aarch64.whl", hash = "sha256:d18bba3d3353ed916e882521bc3e0af403949dbada344c20c16ea78f47af965e", size = 11810149, upload-time = "2025-01-16T13:21:57.098Z" },
+    { url = "https://files.pythonhosted.org/packages/e5/fd/57df1a0543182f79a1236e82a79c68ce210efb00e97c30657d5bdb12b478/ruff-0.9.2-py3-none-musllinux_1_2_armv7l.whl", hash = "sha256:b338edc4610142355ccf6b87bd356729b62bf1bc152a2fad5b0c7dc04af77bfe", size = 11479141, upload-time = "2025-01-16T13:22:00.585Z" },
+    { url = "https://files.pythonhosted.org/packages/dc/16/bc3fd1d38974f6775fc152a0554f8c210ff80f2764b43777163c3c45d61b/ruff-0.9.2-py3-none-musllinux_1_2_i686.whl", hash = "sha256:492a5e44ad9b22a0ea98cf72e40305cbdaf27fac0d927f8bc9e1df316dcc96eb", size = 12014073, upload-time = "2025-01-16T13:22:03.956Z" },
+    { url = "https://files.pythonhosted.org/packages/47/6b/e4ca048a8f2047eb652e1e8c755f384d1b7944f69ed69066a37acd4118b0/ruff-0.9.2-py3-none-musllinux_1_2_x86_64.whl", hash = "sha256:af1e9e9fe7b1f767264d26b1075ac4ad831c7db976911fa362d09b2d0356426a", size = 12435758, upload-time = "2025-01-16T13:22:07.73Z" },
+    { url = "https://files.pythonhosted.org/packages/c2/40/4d3d6c979c67ba24cf183d29f706051a53c36d78358036a9cd21421582ab/ruff-0.9.2-py3-none-win32.whl", hash = "sha256:71cbe22e178c5da20e1514e1e01029c73dc09288a8028a5d3446e6bba87a5145", size = 9796916, upload-time = "2025-01-16T13:22:10.894Z" },
+    { url = "https://files.pythonhosted.org/packages/c3/ef/7f548752bdb6867e6939489c87fe4da489ab36191525fadc5cede2a6e8e2/ruff-0.9.2-py3-none-win_amd64.whl", hash = "sha256:c5e1d6abc798419cf46eed03f54f2e0c3adb1ad4b801119dedf23fcaf69b55b5", size = 10773080, upload-time = "2025-01-16T13:22:14.155Z" },
+    { url = "https://files.pythonhosted.org/packages/0e/4e/33df635528292bd2d18404e4daabcd74ca8a9853b2e1df85ed3d32d24362/ruff-0.9.2-py3-none-win_arm64.whl", hash = "sha256:a1b63fa24149918f8b37cef2ee6fff81f24f0d74b6f0bdc37bc3e1f2143e41c6", size = 10001738, upload-time = "2025-01-16T13:22:18.121Z" },
 ]
 
 [[package]]
 name = "six"
 version = "1.17.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031 }
+sdist = { url = "https://files.pythonhosted.org/packages/94/e7/b2c673351809dca68a0e064b6af791aa332cf192da575fd474ed7d6f16a2/six-1.17.0.tar.gz", hash = "sha256:ff70335d468e7eb6ec65b95b99d3a2836546063f63acc5171de367e834932a81", size = 34031, upload-time = "2024-12-04T17:35:28.174Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050 },
+    { url = "https://files.pythonhosted.org/packages/b7/ce/149a00dd41f10bc29e5921b496af8b574d8413afcd5e30dfa0ed46c2cc5e/six-1.17.0-py2.py3-none-any.whl", hash = "sha256:4721f391ed90541fddacab5acf947aa0d3dc7d27b2e1e8eda2be8970586c3274", size = 11050, upload-time = "2024-12-04T17:35:26.475Z" },
 ]
 
 [[package]]
 name = "sortedcontainers"
 version = "2.4.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/e8/c4/ba2f8066cceb6f23394729afe52f3bf7adec04bf9ed2c820b39e19299111/sortedcontainers-2.4.0.tar.gz", hash = "sha256:25caa5a06cc30b6b83d11423433f65d1f9d76c4c6a0c90e3379eaa43b9bfdb88", size = 30594 }
+sdist = { url = "https://files.pythonhosted.org/packages/e8/c4/ba2f8066cceb6f23394729afe52f3bf7adec04bf9ed2c820b39e19299111/sortedcontainers-2.4.0.tar.gz", hash = "sha256:25caa5a06cc30b6b83d11423433f65d1f9d76c4c6a0c90e3379eaa43b9bfdb88", size = 30594, upload-time = "2021-05-16T22:03:42.897Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/32/46/9cb0e58b2deb7f82b84065f37f3bffeb12413f947f9388e4cac22c4621ce/sortedcontainers-2.4.0-py2.py3-none-any.whl", hash = "sha256:a163dcaede0f1c021485e957a39245190e74249897e2ae4b2aa38595db237ee0", size = 29575 },
+    { url = "https://files.pythonhosted.org/packages/32/46/9cb0e58b2deb7f82b84065f37f3bffeb12413f947f9388e4cac22c4621ce/sortedcontainers-2.4.0-py2.py3-none-any.whl", hash = "sha256:a163dcaede0f1c021485e957a39245190e74249897e2ae4b2aa38595db237ee0", size = 29575, upload-time = "2021-05-16T22:03:41.177Z" },
 ]
 
 [[package]]
 name = "tomli"
 version = "2.2.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/18/87/302344fed471e44a87289cf4967697d07e532f2421fdaf868a303cbae4ff/tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff", size = 17175 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/43/ca/75707e6efa2b37c77dadb324ae7d9571cb424e61ea73fad7c56c2d14527f/tomli-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678e4fa69e4575eb77d103de3df8a895e1591b48e740211bd1067378c69e8249", size = 131077 },
-    { url = "https://files.pythonhosted.org/packages/c7/16/51ae563a8615d472fdbffc43a3f3d46588c264ac4f024f63f01283becfbb/tomli-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:023aa114dd824ade0100497eb2318602af309e5a55595f76b626d6d9f3b7b0a6", size = 123429 },
-    { url = "https://files.pythonhosted.org/packages/f1/dd/4f6cd1e7b160041db83c694abc78e100473c15d54620083dbd5aae7b990e/tomli-2.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece47d672db52ac607a3d9599a9d48dcb2f2f735c6c2d1f34130085bb12b112a", size = 226067 },
-    { url = "https://files.pythonhosted.org/packages/a9/6b/c54ede5dc70d648cc6361eaf429304b02f2871a345bbdd51e993d6cdf550/tomli-2.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6972ca9c9cc9f0acaa56a8ca1ff51e7af152a9f87fb64623e31d5c83700080ee", size = 236030 },
-    { url = "https://files.pythonhosted.org/packages/1f/47/999514fa49cfaf7a92c805a86c3c43f4215621855d151b61c602abb38091/tomli-2.2.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c954d2250168d28797dd4e3ac5cf812a406cd5a92674ee4c8f123c889786aa8e", size = 240898 },
-    { url = "https://files.pythonhosted.org/packages/73/41/0a01279a7ae09ee1573b423318e7934674ce06eb33f50936655071d81a24/tomli-2.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8dd28b3e155b80f4d54beb40a441d366adcfe740969820caf156c019fb5c7ec4", size = 229894 },
-    { url = "https://files.pythonhosted.org/packages/55/18/5d8bc5b0a0362311ce4d18830a5d28943667599a60d20118074ea1b01bb7/tomli-2.2.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e59e304978767a54663af13c07b3d1af22ddee3bb2fb0618ca1593e4f593a106", size = 245319 },
-    { url = "https://files.pythonhosted.org/packages/92/a3/7ade0576d17f3cdf5ff44d61390d4b3febb8a9fc2b480c75c47ea048c646/tomli-2.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:33580bccab0338d00994d7f16f4c4ec25b776af3ffaac1ed74e0b3fc95e885a8", size = 238273 },
-    { url = "https://files.pythonhosted.org/packages/72/6f/fa64ef058ac1446a1e51110c375339b3ec6be245af9d14c87c4a6412dd32/tomli-2.2.1-cp311-cp311-win32.whl", hash = "sha256:465af0e0875402f1d226519c9904f37254b3045fc5084697cefb9bdde1ff99ff", size = 98310 },
-    { url = "https://files.pythonhosted.org/packages/6a/1c/4a2dcde4a51b81be3530565e92eda625d94dafb46dbeb15069df4caffc34/tomli-2.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2d0f2fdd22b02c6d81637a3c95f8cd77f995846af7414c5c4b8d0545afa1bc4b", size = 108309 },
-    { url = "https://files.pythonhosted.org/packages/52/e1/f8af4c2fcde17500422858155aeb0d7e93477a0d59a98e56cbfe75070fd0/tomli-2.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4a8f6e44de52d5e6c657c9fe83b562f5f4256d8ebbfe4ff922c495620a7f6cea", size = 132762 },
-    { url = "https://files.pythonhosted.org/packages/03/b8/152c68bb84fc00396b83e7bbddd5ec0bd3dd409db4195e2a9b3e398ad2e3/tomli-2.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8d57ca8095a641b8237d5b079147646153d22552f1c637fd3ba7f4b0b29167a8", size = 123453 },
-    { url = "https://files.pythonhosted.org/packages/c8/d6/fc9267af9166f79ac528ff7e8c55c8181ded34eb4b0e93daa767b8841573/tomli-2.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e340144ad7ae1533cb897d406382b4b6fede8890a03738ff1683af800d54192", size = 233486 },
-    { url = "https://files.pythonhosted.org/packages/5c/51/51c3f2884d7bab89af25f678447ea7d297b53b5a3b5730a7cb2ef6069f07/tomli-2.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db2b95f9de79181805df90bedc5a5ab4c165e6ec3fe99f970d0e302f384ad222", size = 242349 },
-    { url = "https://files.pythonhosted.org/packages/ab/df/bfa89627d13a5cc22402e441e8a931ef2108403db390ff3345c05253935e/tomli-2.2.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:40741994320b232529c802f8bc86da4e1aa9f413db394617b9a256ae0f9a7f77", size = 252159 },
-    { url = "https://files.pythonhosted.org/packages/9e/6e/fa2b916dced65763a5168c6ccb91066f7639bdc88b48adda990db10c8c0b/tomli-2.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:400e720fe168c0f8521520190686ef8ef033fb19fc493da09779e592861b78c6", size = 237243 },
-    { url = "https://files.pythonhosted.org/packages/b4/04/885d3b1f650e1153cbb93a6a9782c58a972b94ea4483ae4ac5cedd5e4a09/tomli-2.2.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:02abe224de6ae62c19f090f68da4e27b10af2b93213d36cf44e6e1c5abd19fdd", size = 259645 },
-    { url = "https://files.pythonhosted.org/packages/9c/de/6b432d66e986e501586da298e28ebeefd3edc2c780f3ad73d22566034239/tomli-2.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b82ebccc8c8a36f2094e969560a1b836758481f3dc360ce9a3277c65f374285e", size = 244584 },
-    { url = "https://files.pythonhosted.org/packages/1c/9a/47c0449b98e6e7d1be6cbac02f93dd79003234ddc4aaab6ba07a9a7482e2/tomli-2.2.1-cp312-cp312-win32.whl", hash = "sha256:889f80ef92701b9dbb224e49ec87c645ce5df3fa2cc548664eb8a25e03127a98", size = 98875 },
-    { url = "https://files.pythonhosted.org/packages/ef/60/9b9638f081c6f1261e2688bd487625cd1e660d0a85bd469e91d8db969734/tomli-2.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:7fc04e92e1d624a4a63c76474610238576942d6b8950a2d7f908a340494e67e4", size = 109418 },
-    { url = "https://files.pythonhosted.org/packages/04/90/2ee5f2e0362cb8a0b6499dc44f4d7d48f8fff06d28ba46e6f1eaa61a1388/tomli-2.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f4039b9cbc3048b2416cc57ab3bda989a6fcf9b36cf8937f01a6e731b64f80d7", size = 132708 },
-    { url = "https://files.pythonhosted.org/packages/c0/ec/46b4108816de6b385141f082ba99e315501ccd0a2ea23db4a100dd3990ea/tomli-2.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:286f0ca2ffeeb5b9bd4fcc8d6c330534323ec51b2f52da063b11c502da16f30c", size = 123582 },
-    { url = "https://files.pythonhosted.org/packages/a0/bd/b470466d0137b37b68d24556c38a0cc819e8febe392d5b199dcd7f578365/tomli-2.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a92ef1a44547e894e2a17d24e7557a5e85a9e1d0048b0b5e7541f76c5032cb13", size = 232543 },
-    { url = "https://files.pythonhosted.org/packages/d9/e5/82e80ff3b751373f7cead2815bcbe2d51c895b3c990686741a8e56ec42ab/tomli-2.2.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9316dc65bed1684c9a98ee68759ceaed29d229e985297003e494aa825ebb0281", size = 241691 },
-    { url = "https://files.pythonhosted.org/packages/05/7e/2a110bc2713557d6a1bfb06af23dd01e7dde52b6ee7dadc589868f9abfac/tomli-2.2.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e85e99945e688e32d5a35c1ff38ed0b3f41f43fad8df0bdf79f72b2ba7bc5272", size = 251170 },
-    { url = "https://files.pythonhosted.org/packages/64/7b/22d713946efe00e0adbcdfd6d1aa119ae03fd0b60ebed51ebb3fa9f5a2e5/tomli-2.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ac065718db92ca818f8d6141b5f66369833d4a80a9d74435a268c52bdfa73140", size = 236530 },
-    { url = "https://files.pythonhosted.org/packages/38/31/3a76f67da4b0cf37b742ca76beaf819dca0ebef26d78fc794a576e08accf/tomli-2.2.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:d920f33822747519673ee656a4b6ac33e382eca9d331c87770faa3eef562aeb2", size = 258666 },
-    { url = "https://files.pythonhosted.org/packages/07/10/5af1293da642aded87e8a988753945d0cf7e00a9452d3911dd3bb354c9e2/tomli-2.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a198f10c4d1b1375d7687bc25294306e551bf1abfa4eace6650070a5c1ae2744", size = 243954 },
-    { url = "https://files.pythonhosted.org/packages/5b/b9/1ed31d167be802da0fc95020d04cd27b7d7065cc6fbefdd2f9186f60d7bd/tomli-2.2.1-cp313-cp313-win32.whl", hash = "sha256:d3f5614314d758649ab2ab3a62d4f2004c825922f9e370b29416484086b264ec", size = 98724 },
-    { url = "https://files.pythonhosted.org/packages/c7/32/b0963458706accd9afcfeb867c0f9175a741bf7b19cd424230714d722198/tomli-2.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:a38aa0308e754b0e3c67e344754dff64999ff9b513e691d0e786265c93583c69", size = 109383 },
-    { url = "https://files.pythonhosted.org/packages/6e/c2/61d3e0f47e2b74ef40a68b9e6ad5984f6241a942f7cd3bbfbdbd03861ea9/tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc", size = 14257 },
+sdist = { url = "https://files.pythonhosted.org/packages/18/87/302344fed471e44a87289cf4967697d07e532f2421fdaf868a303cbae4ff/tomli-2.2.1.tar.gz", hash = "sha256:cd45e1dc79c835ce60f7404ec8119f2eb06d38b1deba146f07ced3bbc44505ff", size = 17175, upload-time = "2024-11-27T22:38:36.873Z" }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/43/ca/75707e6efa2b37c77dadb324ae7d9571cb424e61ea73fad7c56c2d14527f/tomli-2.2.1-cp311-cp311-macosx_10_9_x86_64.whl", hash = "sha256:678e4fa69e4575eb77d103de3df8a895e1591b48e740211bd1067378c69e8249", size = 131077, upload-time = "2024-11-27T22:37:54.956Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/16/51ae563a8615d472fdbffc43a3f3d46588c264ac4f024f63f01283becfbb/tomli-2.2.1-cp311-cp311-macosx_11_0_arm64.whl", hash = "sha256:023aa114dd824ade0100497eb2318602af309e5a55595f76b626d6d9f3b7b0a6", size = 123429, upload-time = "2024-11-27T22:37:56.698Z" },
+    { url = "https://files.pythonhosted.org/packages/f1/dd/4f6cd1e7b160041db83c694abc78e100473c15d54620083dbd5aae7b990e/tomli-2.2.1-cp311-cp311-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:ece47d672db52ac607a3d9599a9d48dcb2f2f735c6c2d1f34130085bb12b112a", size = 226067, upload-time = "2024-11-27T22:37:57.63Z" },
+    { url = "https://files.pythonhosted.org/packages/a9/6b/c54ede5dc70d648cc6361eaf429304b02f2871a345bbdd51e993d6cdf550/tomli-2.2.1-cp311-cp311-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:6972ca9c9cc9f0acaa56a8ca1ff51e7af152a9f87fb64623e31d5c83700080ee", size = 236030, upload-time = "2024-11-27T22:37:59.344Z" },
+    { url = "https://files.pythonhosted.org/packages/1f/47/999514fa49cfaf7a92c805a86c3c43f4215621855d151b61c602abb38091/tomli-2.2.1-cp311-cp311-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:c954d2250168d28797dd4e3ac5cf812a406cd5a92674ee4c8f123c889786aa8e", size = 240898, upload-time = "2024-11-27T22:38:00.429Z" },
+    { url = "https://files.pythonhosted.org/packages/73/41/0a01279a7ae09ee1573b423318e7934674ce06eb33f50936655071d81a24/tomli-2.2.1-cp311-cp311-musllinux_1_2_aarch64.whl", hash = "sha256:8dd28b3e155b80f4d54beb40a441d366adcfe740969820caf156c019fb5c7ec4", size = 229894, upload-time = "2024-11-27T22:38:02.094Z" },
+    { url = "https://files.pythonhosted.org/packages/55/18/5d8bc5b0a0362311ce4d18830a5d28943667599a60d20118074ea1b01bb7/tomli-2.2.1-cp311-cp311-musllinux_1_2_i686.whl", hash = "sha256:e59e304978767a54663af13c07b3d1af22ddee3bb2fb0618ca1593e4f593a106", size = 245319, upload-time = "2024-11-27T22:38:03.206Z" },
+    { url = "https://files.pythonhosted.org/packages/92/a3/7ade0576d17f3cdf5ff44d61390d4b3febb8a9fc2b480c75c47ea048c646/tomli-2.2.1-cp311-cp311-musllinux_1_2_x86_64.whl", hash = "sha256:33580bccab0338d00994d7f16f4c4ec25b776af3ffaac1ed74e0b3fc95e885a8", size = 238273, upload-time = "2024-11-27T22:38:04.217Z" },
+    { url = "https://files.pythonhosted.org/packages/72/6f/fa64ef058ac1446a1e51110c375339b3ec6be245af9d14c87c4a6412dd32/tomli-2.2.1-cp311-cp311-win32.whl", hash = "sha256:465af0e0875402f1d226519c9904f37254b3045fc5084697cefb9bdde1ff99ff", size = 98310, upload-time = "2024-11-27T22:38:05.908Z" },
+    { url = "https://files.pythonhosted.org/packages/6a/1c/4a2dcde4a51b81be3530565e92eda625d94dafb46dbeb15069df4caffc34/tomli-2.2.1-cp311-cp311-win_amd64.whl", hash = "sha256:2d0f2fdd22b02c6d81637a3c95f8cd77f995846af7414c5c4b8d0545afa1bc4b", size = 108309, upload-time = "2024-11-27T22:38:06.812Z" },
+    { url = "https://files.pythonhosted.org/packages/52/e1/f8af4c2fcde17500422858155aeb0d7e93477a0d59a98e56cbfe75070fd0/tomli-2.2.1-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:4a8f6e44de52d5e6c657c9fe83b562f5f4256d8ebbfe4ff922c495620a7f6cea", size = 132762, upload-time = "2024-11-27T22:38:07.731Z" },
+    { url = "https://files.pythonhosted.org/packages/03/b8/152c68bb84fc00396b83e7bbddd5ec0bd3dd409db4195e2a9b3e398ad2e3/tomli-2.2.1-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:8d57ca8095a641b8237d5b079147646153d22552f1c637fd3ba7f4b0b29167a8", size = 123453, upload-time = "2024-11-27T22:38:09.384Z" },
+    { url = "https://files.pythonhosted.org/packages/c8/d6/fc9267af9166f79ac528ff7e8c55c8181ded34eb4b0e93daa767b8841573/tomli-2.2.1-cp312-cp312-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:4e340144ad7ae1533cb897d406382b4b6fede8890a03738ff1683af800d54192", size = 233486, upload-time = "2024-11-27T22:38:10.329Z" },
+    { url = "https://files.pythonhosted.org/packages/5c/51/51c3f2884d7bab89af25f678447ea7d297b53b5a3b5730a7cb2ef6069f07/tomli-2.2.1-cp312-cp312-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:db2b95f9de79181805df90bedc5a5ab4c165e6ec3fe99f970d0e302f384ad222", size = 242349, upload-time = "2024-11-27T22:38:11.443Z" },
+    { url = "https://files.pythonhosted.org/packages/ab/df/bfa89627d13a5cc22402e441e8a931ef2108403db390ff3345c05253935e/tomli-2.2.1-cp312-cp312-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:40741994320b232529c802f8bc86da4e1aa9f413db394617b9a256ae0f9a7f77", size = 252159, upload-time = "2024-11-27T22:38:13.099Z" },
+    { url = "https://files.pythonhosted.org/packages/9e/6e/fa2b916dced65763a5168c6ccb91066f7639bdc88b48adda990db10c8c0b/tomli-2.2.1-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:400e720fe168c0f8521520190686ef8ef033fb19fc493da09779e592861b78c6", size = 237243, upload-time = "2024-11-27T22:38:14.766Z" },
+    { url = "https://files.pythonhosted.org/packages/b4/04/885d3b1f650e1153cbb93a6a9782c58a972b94ea4483ae4ac5cedd5e4a09/tomli-2.2.1-cp312-cp312-musllinux_1_2_i686.whl", hash = "sha256:02abe224de6ae62c19f090f68da4e27b10af2b93213d36cf44e6e1c5abd19fdd", size = 259645, upload-time = "2024-11-27T22:38:15.843Z" },
+    { url = "https://files.pythonhosted.org/packages/9c/de/6b432d66e986e501586da298e28ebeefd3edc2c780f3ad73d22566034239/tomli-2.2.1-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b82ebccc8c8a36f2094e969560a1b836758481f3dc360ce9a3277c65f374285e", size = 244584, upload-time = "2024-11-27T22:38:17.645Z" },
+    { url = "https://files.pythonhosted.org/packages/1c/9a/47c0449b98e6e7d1be6cbac02f93dd79003234ddc4aaab6ba07a9a7482e2/tomli-2.2.1-cp312-cp312-win32.whl", hash = "sha256:889f80ef92701b9dbb224e49ec87c645ce5df3fa2cc548664eb8a25e03127a98", size = 98875, upload-time = "2024-11-27T22:38:19.159Z" },
+    { url = "https://files.pythonhosted.org/packages/ef/60/9b9638f081c6f1261e2688bd487625cd1e660d0a85bd469e91d8db969734/tomli-2.2.1-cp312-cp312-win_amd64.whl", hash = "sha256:7fc04e92e1d624a4a63c76474610238576942d6b8950a2d7f908a340494e67e4", size = 109418, upload-time = "2024-11-27T22:38:20.064Z" },
+    { url = "https://files.pythonhosted.org/packages/04/90/2ee5f2e0362cb8a0b6499dc44f4d7d48f8fff06d28ba46e6f1eaa61a1388/tomli-2.2.1-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:f4039b9cbc3048b2416cc57ab3bda989a6fcf9b36cf8937f01a6e731b64f80d7", size = 132708, upload-time = "2024-11-27T22:38:21.659Z" },
+    { url = "https://files.pythonhosted.org/packages/c0/ec/46b4108816de6b385141f082ba99e315501ccd0a2ea23db4a100dd3990ea/tomli-2.2.1-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:286f0ca2ffeeb5b9bd4fcc8d6c330534323ec51b2f52da063b11c502da16f30c", size = 123582, upload-time = "2024-11-27T22:38:22.693Z" },
+    { url = "https://files.pythonhosted.org/packages/a0/bd/b470466d0137b37b68d24556c38a0cc819e8febe392d5b199dcd7f578365/tomli-2.2.1-cp313-cp313-manylinux_2_17_aarch64.manylinux2014_aarch64.whl", hash = "sha256:a92ef1a44547e894e2a17d24e7557a5e85a9e1d0048b0b5e7541f76c5032cb13", size = 232543, upload-time = "2024-11-27T22:38:24.367Z" },
+    { url = "https://files.pythonhosted.org/packages/d9/e5/82e80ff3b751373f7cead2815bcbe2d51c895b3c990686741a8e56ec42ab/tomli-2.2.1-cp313-cp313-manylinux_2_17_x86_64.manylinux2014_x86_64.whl", hash = "sha256:9316dc65bed1684c9a98ee68759ceaed29d229e985297003e494aa825ebb0281", size = 241691, upload-time = "2024-11-27T22:38:26.081Z" },
+    { url = "https://files.pythonhosted.org/packages/05/7e/2a110bc2713557d6a1bfb06af23dd01e7dde52b6ee7dadc589868f9abfac/tomli-2.2.1-cp313-cp313-manylinux_2_5_i686.manylinux1_i686.manylinux_2_17_i686.manylinux2014_i686.whl", hash = "sha256:e85e99945e688e32d5a35c1ff38ed0b3f41f43fad8df0bdf79f72b2ba7bc5272", size = 251170, upload-time = "2024-11-27T22:38:27.921Z" },
+    { url = "https://files.pythonhosted.org/packages/64/7b/22d713946efe00e0adbcdfd6d1aa119ae03fd0b60ebed51ebb3fa9f5a2e5/tomli-2.2.1-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:ac065718db92ca818f8d6141b5f66369833d4a80a9d74435a268c52bdfa73140", size = 236530, upload-time = "2024-11-27T22:38:29.591Z" },
+    { url = "https://files.pythonhosted.org/packages/38/31/3a76f67da4b0cf37b742ca76beaf819dca0ebef26d78fc794a576e08accf/tomli-2.2.1-cp313-cp313-musllinux_1_2_i686.whl", hash = "sha256:d920f33822747519673ee656a4b6ac33e382eca9d331c87770faa3eef562aeb2", size = 258666, upload-time = "2024-11-27T22:38:30.639Z" },
+    { url = "https://files.pythonhosted.org/packages/07/10/5af1293da642aded87e8a988753945d0cf7e00a9452d3911dd3bb354c9e2/tomli-2.2.1-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:a198f10c4d1b1375d7687bc25294306e551bf1abfa4eace6650070a5c1ae2744", size = 243954, upload-time = "2024-11-27T22:38:31.702Z" },
+    { url = "https://files.pythonhosted.org/packages/5b/b9/1ed31d167be802da0fc95020d04cd27b7d7065cc6fbefdd2f9186f60d7bd/tomli-2.2.1-cp313-cp313-win32.whl", hash = "sha256:d3f5614314d758649ab2ab3a62d4f2004c825922f9e370b29416484086b264ec", size = 98724, upload-time = "2024-11-27T22:38:32.837Z" },
+    { url = "https://files.pythonhosted.org/packages/c7/32/b0963458706accd9afcfeb867c0f9175a741bf7b19cd424230714d722198/tomli-2.2.1-cp313-cp313-win_amd64.whl", hash = "sha256:a38aa0308e754b0e3c67e344754dff64999ff9b513e691d0e786265c93583c69", size = 109383, upload-time = "2024-11-27T22:38:34.455Z" },
+    { url = "https://files.pythonhosted.org/packages/6e/c2/61d3e0f47e2b74ef40a68b9e6ad5984f6241a942f7cd3bbfbdbd03861ea9/tomli-2.2.1-py3-none-any.whl", hash = "sha256:cb55c73c5f4408779d0cf3eef9f762b9c9f147a77de7b258bef0a5628adc85cc", size = 14257, upload-time = "2024-11-27T22:38:35.385Z" },
 ]
 
 [[package]]
 name = "typing-extensions"
 version = "4.12.2"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/df/db/f35a00659bc03fec321ba8bce9420de607a1d37f8342eee1863174c69557/typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8", size = 85321 }
+sdist = { url = "https://files.pythonhosted.org/packages/df/db/f35a00659bc03fec321ba8bce9420de607a1d37f8342eee1863174c69557/typing_extensions-4.12.2.tar.gz", hash = "sha256:1a7ead55c7e559dd4dee8856e3a88b41225abfe1ce8df57b7c13915fe121ffb8", size = 85321, upload-time = "2024-06-07T18:52:15.995Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/26/9f/ad63fc0248c5379346306f8668cda6e2e2e9c95e01216d2b8ffd9ff037d0/typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d", size = 37438 },
+    { url = "https://files.pythonhosted.org/packages/26/9f/ad63fc0248c5379346306f8668cda6e2e2e9c95e01216d2b8ffd9ff037d0/typing_extensions-4.12.2-py3-none-any.whl", hash = "sha256:04e5ca0351e0f3f85c6853954072df659d0d13fac324d0072316b67d7794700d", size = 37438, upload-time = "2024-06-07T18:52:13.582Z" },
 ]
 
 [[package]]
 name = "tzdata"
 version = "2025.1"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/43/0f/fa4723f22942480be4ca9527bbde8d43f6c3f2fe8412f00e7f5f6746bc8b/tzdata-2025.1.tar.gz", hash = "sha256:24894909e88cdb28bd1636c6887801df64cb485bd593f2fd83ef29075a81d694", size = 194950 }
+sdist = { url = "https://files.pythonhosted.org/packages/43/0f/fa4723f22942480be4ca9527bbde8d43f6c3f2fe8412f00e7f5f6746bc8b/tzdata-2025.1.tar.gz", hash = "sha256:24894909e88cdb28bd1636c6887801df64cb485bd593f2fd83ef29075a81d694", size = 194950, upload-time = "2025-01-21T19:49:38.686Z" }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/0f/dd/84f10e23edd882c6f968c21c2434fe67bd4a528967067515feca9e611e5e/tzdata-2025.1-py2.py3-none-any.whl", hash = "sha256:7e127113816800496f027041c570f50bcd464a020098a3b6b199517772303639", size = 346762 },
+    { url = "https://files.pythonhosted.org/packages/0f/dd/84f10e23edd882c6f968c21c2434fe67bd4a528967067515feca9e611e5e/tzdata-2025.1-py2.py3-none-any.whl", hash = "sha256:7e127113816800496f027041c570f50bcd464a020098a3b6b199517772303639", size = 346762, upload-time = "2025-01-21T19:49:37.187Z" },
 ]

From cc3ac463415d63669d39445fafa5dac6b67eb59c Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Sun, 18 May 2025 11:16:23 +0200
Subject: [PATCH 541/550] Mark constructor parameters of exceptions as
 positional-only (#1699)

---
 python/pydantic_core/_pydantic_core.pyi | 60 +++++++++----------------
 src/errors/value_exception.rs           |  4 +-
 src/serializers/errors.rs               |  3 +-
 3 files changed, 25 insertions(+), 42 deletions(-)

diff --git a/python/pydantic_core/_pydantic_core.pyi b/python/pydantic_core/_pydantic_core.pyi
index 17098cca5..398020bb1 100644
--- a/python/pydantic_core/_pydantic_core.pyi
+++ b/python/pydantic_core/_pydantic_core.pyi
@@ -714,22 +714,16 @@ class PydanticCustomError(ValueError):
                 raise PydanticCustomError('custom_value_error', 'Value must be greater than {value}', {'value': 10, 'extra_context': 'extra_data'})
             return v
         ```
+
+    Arguments:
+        error_type: The error type.
+        message_template: The message template.
+        context: The data to inject into the message template.
     """
 
     def __init__(
-        self, error_type: LiteralString, message_template: LiteralString, context: dict[str, Any] | None = None
-    ) -> None:
-        """Initializes the `PydanticCustomError`.
-
-        Arguments:
-            error_type: The error type.
-            message_template: The message template.
-            context: The data to inject into the message template.
-        """
-
-    def __new__(
-        cls, error_type: LiteralString, message_template: LiteralString, context: dict[str, Any] | None = None
-    ) -> Self: ...
+        self, error_type: LiteralString, message_template: LiteralString, context: dict[str, Any] | None = None, /
+    ) -> None: ...
     @property
     def context(self) -> dict[str, Any] | None:
         """Values which are required to render the error message, and could hence be useful in passing error data forward."""
@@ -757,20 +751,16 @@ class PydanticKnownError(ValueError):
 
         def custom_validator(v) -> None:
             if v <= 10:
-                raise PydanticKnownError(error_type='greater_than', context={'gt': 10})
+                raise PydanticKnownError('greater_than', {'gt': 10})
             return v
         ```
-    """
-
-    def __init__(self, error_type: ErrorType, context: dict[str, Any] | None = None) -> None:
-        """Initializes the `PydanticKnownError`.
 
-        Arguments:
-            error_type: The error type.
-            context: The data to inject into the message template.
-        """
+    Arguments:
+        error_type: The error type.
+        context: The data to inject into the message template.
+    """
 
-    def __new__(cls, error_type: ErrorType, context: dict[str, Any] | None = None) -> Self: ...
+    def __init__(self, error_type: ErrorType, context: dict[str, Any] | None = None, /) -> None: ...
     @property
     def context(self) -> dict[str, Any] | None:
         """Values which are required to render the error message, and could hence be useful in passing error data forward."""
@@ -870,16 +860,12 @@ class PydanticSerializationError(ValueError):
     """An error raised when an issue occurs during serialization.
 
     In custom serializers, this error can be used to indicate that serialization has failed.
-    """
-
-    def __init__(self, message: str) -> None:
-        """Initializes the `PydanticSerializationError`.
 
-        Arguments:
-            message: The message associated with the error.
-        """
+    Arguments:
+        message: The message associated with the error.
+    """
 
-    def __new__(cls, message: str) -> Self: ...
+    def __init__(self, message: str, /) -> None: ...
 
 @final
 class PydanticSerializationUnexpectedValue(ValueError):
@@ -918,16 +904,12 @@ class PydanticSerializationUnexpectedValue(ValueError):
 
     This is often used internally in `pydantic-core` when unexpected types are encountered during serialization,
     but it can also be used by users in custom serializers, as seen above.
-    """
-
-    def __init__(self, message: str) -> None:
-        """Initializes the `PydanticSerializationUnexpectedValue`.
 
-        Arguments:
-            message: The message associated with the unexpected value.
-        """
+    Arguments:
+        message: The message associated with the unexpected value.
+    """
 
-    def __new__(cls, message: str | None = None) -> Self: ...
+    def __init__(self, message: str, /) -> None: ...
 
 @final
 class ArgsKwargs:
diff --git a/src/errors/value_exception.rs b/src/errors/value_exception.rs
index d428dc524..964899905 100644
--- a/src/errors/value_exception.rs
+++ b/src/errors/value_exception.rs
@@ -65,7 +65,7 @@ pub struct PydanticCustomError {
 #[pymethods]
 impl PydanticCustomError {
     #[new]
-    #[pyo3(signature = (error_type, message_template, context = None))]
+    #[pyo3(signature = (error_type, message_template, context = None, /))]
     pub fn py_new(error_type: String, message_template: String, context: Option<Bound<'_, PyDict>>) -> Self {
         Self {
             error_type,
@@ -144,7 +144,7 @@ pub struct PydanticKnownError {
 #[pymethods]
 impl PydanticKnownError {
     #[new]
-    #[pyo3(signature = (error_type, context=None))]
+    #[pyo3(signature = (error_type, context=None, /))]
     pub fn py_new(py: Python, error_type: &str, context: Option<Bound<'_, PyDict>>) -> PyResult<Self> {
         let error_type = ErrorType::new(py, error_type, context)?;
         Ok(Self { error_type })
diff --git a/src/serializers/errors.rs b/src/serializers/errors.rs
index d9ba85682..c309b9e3a 100644
--- a/src/serializers/errors.rs
+++ b/src/serializers/errors.rs
@@ -81,6 +81,7 @@ impl PydanticSerializationError {
 #[pymethods]
 impl PydanticSerializationError {
     #[new]
+    #[pyo3(signature = (message, /))]
     fn py_new(message: String) -> Self {
         Self { message }
     }
@@ -139,7 +140,7 @@ impl PydanticSerializationUnexpectedValue {
 #[pymethods]
 impl PydanticSerializationUnexpectedValue {
     #[new]
-    #[pyo3(signature = (message=None, field_type=None, input_value=None))]
+    #[pyo3(signature = (message=None, field_type=None, input_value=None, /))]
     fn py_new(message: Option<String>, field_type: Option<String>, input_value: Option<PyObject>) -> Self {
         Self {
             message,

From 4375d6ad14413c5f8f12aa600dd44bd84b542518 Mon Sep 17 00:00:00 2001
From: Chiawei Ong <ongchiawei@gmail.com>
Date: Sun, 18 May 2025 15:36:36 +0200
Subject: [PATCH 542/550] fix: submodel fields with wrap validator affect smart
 union selection (#1700)

---
 src/validators/function.rs     |  4 +-
 src/validators/generator.rs    |  4 ++
 tests/validators/test_union.py | 80 ++++++++++++++++++++++++++++++++++
 3 files changed, 87 insertions(+), 1 deletion(-)

diff --git a/src/validators/function.rs b/src/validators/function.rs
index e65ff79c3..ddb096054 100644
--- a/src/validators/function.rs
+++ b/src/validators/function.rs
@@ -380,7 +380,9 @@ impl Validator for FunctionWrapValidator {
         let handler = Bound::new(py, handler)?;
         #[allow(clippy::used_underscore_items)]
         let result = self._validate(handler.as_any(), py, input, state);
-        state.exactness = handler.borrow_mut().validator.exactness;
+        let handler = handler.borrow();
+        state.exactness = handler.validator.exactness;
+        state.fields_set_count = handler.validator.fields_set_count;
         result
     }
 
diff --git a/src/validators/generator.rs b/src/validators/generator.rs
index 12d76b3be..b4be4c68f 100644
--- a/src/validators/generator.rs
+++ b/src/validators/generator.rs
@@ -225,6 +225,7 @@ pub struct InternalValidator {
     self_instance: Option<PyObject>,
     recursion_guard: RecursionState,
     pub(crate) exactness: Option<Exactness>,
+    pub(crate) fields_set_count: Option<usize>,
     validation_mode: InputType,
     hide_input_in_errors: bool,
     validation_error_cause: bool,
@@ -256,6 +257,7 @@ impl InternalValidator {
             self_instance: extra.self_instance.map(|d| d.clone().unbind()),
             recursion_guard: state.recursion_guard.clone(),
             exactness: state.exactness,
+            fields_set_count: state.fields_set_count,
             validation_mode: extra.input_type,
             hide_input_in_errors,
             validation_error_cause,
@@ -323,6 +325,7 @@ impl InternalValidator {
         };
         let mut state = ValidationState::new(extra, &mut self.recursion_guard, false.into());
         state.exactness = self.exactness;
+        state.fields_set_count = self.fields_set_count;
         let result = self.validator.validate(py, input, &mut state).map_err(|e| {
             ValidationError::from_val_error(
                 py,
@@ -335,6 +338,7 @@ impl InternalValidator {
             )
         });
         self.exactness = state.exactness;
+        self.fields_set_count = state.fields_set_count;
         result
     }
 }
diff --git a/tests/validators/test_union.py b/tests/validators/test_union.py
index f35ebfec0..7e0daacec 100644
--- a/tests/validators/test_union.py
+++ b/tests/validators/test_union.py
@@ -1358,3 +1358,83 @@ class Model:
 
     assert isinstance(validator.validate_python({'x': {'foo': 'foo'}}).x, Foo)
     assert isinstance(validator.validate_python({'x': {'bar': 'bar'}}).x, Bar)
+
+
+def test_smart_union_wrap_validator_should_not_change_nested_model_field_counts() -> None:
+    """Adding a wrap validator on a union member should not affect smart union behavior"""
+
+    class SubModel:
+        x: str = 'x'
+
+    class ModelA:
+        type: str = 'A'
+        sub: SubModel
+
+    class ModelB:
+        type: str = 'B'
+        sub: SubModel
+
+    submodel_schema = core_schema.model_schema(
+        SubModel,
+        core_schema.model_fields_schema(fields={'x': core_schema.model_field(core_schema.str_schema())}),
+    )
+
+    wrapped_submodel_schema = core_schema.no_info_wrap_validator_function(
+        lambda v, handler: handler(v), submodel_schema
+    )
+
+    model_a_schema = core_schema.model_schema(
+        ModelA,
+        core_schema.model_fields_schema(
+            fields={
+                'type': core_schema.model_field(
+                    core_schema.with_default_schema(core_schema.literal_schema(['A']), default='A'),
+                ),
+                'sub': core_schema.model_field(wrapped_submodel_schema),
+            },
+        ),
+    )
+
+    model_b_schema = core_schema.model_schema(
+        ModelB,
+        core_schema.model_fields_schema(
+            fields={
+                'type': core_schema.model_field(
+                    core_schema.with_default_schema(core_schema.literal_schema(['B']), default='B'),
+                ),
+                'sub': core_schema.model_field(submodel_schema),
+            },
+        ),
+    )
+
+    for choices in permute_choices([model_a_schema, model_b_schema]):
+        schema = core_schema.union_schema(choices)
+        validator = SchemaValidator(schema)
+
+        assert isinstance(validator.validate_python({'type': 'A', 'sub': {'x': 'x'}}), ModelA)
+        assert isinstance(validator.validate_python({'type': 'B', 'sub': {'x': 'x'}}), ModelB)
+
+        # defaults to leftmost choice if there's a tie
+        assert isinstance(validator.validate_python({'sub': {'x': 'x'}}), choices[0]['cls'])
+
+    # test validate_assignment
+    class RootModel:
+        ab: Union[ModelA, ModelB]
+
+    root_model = core_schema.model_schema(
+        RootModel,
+        core_schema.model_fields_schema(
+            fields={'ab': core_schema.model_field(core_schema.union_schema([model_a_schema, model_b_schema]))}
+        ),
+    )
+
+    validator = SchemaValidator(root_model)
+    m = validator.validate_python({'ab': {'type': 'B', 'sub': {'x': 'x'}}})
+    assert isinstance(m, RootModel)
+    assert isinstance(m.ab, ModelB)
+    assert m.ab.sub.x == 'x'
+
+    m = validator.validate_assignment(m, 'ab', {'sub': {'x': 'y'}})
+    assert isinstance(m, RootModel)
+    assert isinstance(m.ab, ModelA)
+    assert m.ab.sub.x == 'y'

From de128b4f18171258b8f22e247ab2ad2c3a86bbe9 Mon Sep 17 00:00:00 2001
From: Samuel Colvin <s@muelcolvin.com>
Date: Sun, 18 May 2025 11:57:24 -0400
Subject: [PATCH 543/550] use `pypa/gh-action-pypi-publish` (#1599)

Co-authored-by: David Hewitt <david.hewitt@pydantic.dev>
---
 .github/workflows/ci.yml | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 6392972cb..1907554a3 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -662,6 +662,10 @@ jobs:
     needs: [test-builds-arch, test-builds-os, build-sdist, check]
     if: always() && startsWith(github.ref, 'refs/tags/')
     runs-on: ubuntu-latest
+    environment: release
+
+    permissions:
+      id-token: write
 
     steps:
       - uses: actions/checkout@v4
@@ -685,11 +689,10 @@ jobs:
 
       - run: twine check --strict dist/*
 
-      - name: upload to pypi
-        run: twine upload dist/*
-        env:
-          TWINE_USERNAME: __token__
-          TWINE_PASSWORD: ${{ secrets.pypi_token }}
+      - name: Publish to PyPI
+        uses: pypa/gh-action-pypi-publish@v1
+        with:
+          skip-existing: true
 
       - name: get wasm dist artifacts
         uses: actions/download-artifact@v4

From c0f4a7f69236cac583f58e999c51a2b1eda4d7fd Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Sun, 18 May 2025 13:25:38 -0400
Subject: [PATCH 544/550] ci: fix coverage job (#1713)

---
 .github/workflows/ci.yml | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 1907554a3..18a8fbe12 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -14,22 +14,15 @@ env:
 
 jobs:
   coverage:
-    runs-on: ubuntu-20.04
+    runs-on: ubuntu-latest
 
     steps:
       - uses: actions/checkout@v4
 
-      - name: install rust nightly
-        uses: dtolnay/rust-toolchain@nightly
-
-      - id: cache-rust
-        name: cache rust
-        uses: Swatinem/rust-cache@v2
-
-      - run: cargo install rustfilt coverage-prepare
-        if: steps.cache-rust.outputs.cache-hit != 'true'
-
-      - run: rustup component add llvm-tools-preview
+      # rust-nightly used for `#[coverage(off)]`
+      - uses: dtolnay/rust-toolchain@nightly
+      - uses: Swatinem/rust-cache@v2
+      - uses: taiki-e/install-action@cargo-llvm-cov
 
       - name: install uv
         uses: astral-sh/setup-uv@v6
@@ -39,7 +32,10 @@ jobs:
 
       - run: rustc --version --verbose
 
-      - run: make build-dev
+      - run: |
+          source <(cargo llvm-cov show-env --export-prefix)
+          cargo llvm-cov clean --workspace --profraw-only
+          make build-dev
         env:
           RUST_BACKTRACE: 1
           RUSTFLAGS: '-C instrument-coverage'
@@ -51,9 +47,13 @@ jobs:
       - run: ls -lha
       - run: uv run coverage xml
 
-      - run: coverage-prepare lcov python/pydantic_core/*.so
+      - run: |
+          source <(cargo llvm-cov show-env --export-prefix)
+          cargo llvm-cov --codecov --output-path=codecov.json
 
       - uses: codecov/codecov-action@v5
+        with:
+          files: codecov.json
 
   # See https://github.com/PyO3/pyo3/discussions/2781
   # tests intermittently segfault with pypy and cpython 3.7 when using `coverage run ...`, hence separate job

From 5c56fde19b7de2c8f59303dbb6196a69380d86de Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Mon, 19 May 2025 12:32:44 -0400
Subject: [PATCH 545/550] add critical sections around bytearray reads (#1717)

---
 src/serializers/infer.rs | 44 +++++++++++++++++++++++-----------------
 1 file changed, 25 insertions(+), 19 deletions(-)

diff --git a/src/serializers/infer.rs b/src/serializers/infer.rs
index 33f53b290..70910aeb1 100644
--- a/src/serializers/infer.rs
+++ b/src/serializers/infer.rs
@@ -140,10 +140,14 @@ pub(crate) fn infer_to_python_known(
                 .into_py_any(py)?,
             ObType::Bytearray => {
                 let py_byte_array = value.downcast::<PyByteArray>()?;
-                // Safety: the GIL is held while bytes_to_string is running; it doesn't run
-                // arbitrary Python code, so py_byte_array cannot be mutated.
-                let bytes = unsafe { py_byte_array.as_bytes() };
-                extra.config.bytes_mode.bytes_to_string(py, bytes)?.into_py_any(py)?
+                pyo3::sync::with_critical_section(py_byte_array, || {
+                    // SAFETY: `py_byte_array` is protected by a critical section,
+                    // which guarantees no mutation, and `bytes_to_string` does not
+                    // run any code which could cause the critical section to be
+                    // released.
+                    let bytes = unsafe { py_byte_array.as_bytes() };
+                    extra.config.bytes_mode.bytes_to_string(py, bytes)?.into_py_any(py)
+                })?
             }
             ObType::Tuple => {
                 let elements = serialize_seq_filter!(PyTuple);
@@ -432,12 +436,14 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
         }
         ObType::Bytearray => {
             let py_byte_array = value.downcast::<PyByteArray>().map_err(py_err_se_err)?;
-            // Safety: the GIL is held while serialize_bytes is running; it doesn't run
-            // arbitrary Python code, so py_byte_array cannot be mutated.
-            extra
-                .config
-                .bytes_mode
-                .serialize_bytes(unsafe { py_byte_array.as_bytes() }, serializer)
+            pyo3::sync::with_critical_section(py_byte_array, || {
+                // SAFETY: `py_byte_array` is protected by a critical section,
+                // which guarantees no mutation, and `serialize_bytes` does not
+                // run any code which could cause the critical section to be
+                // released.
+                let bytes = unsafe { py_byte_array.as_bytes() };
+                extra.config.bytes_mode.serialize_bytes(bytes, serializer)
+            })
         }
         ObType::Dict => {
             let dict = value.downcast::<PyDict>().map_err(py_err_se_err)?;
@@ -612,15 +618,15 @@ pub(crate) fn infer_json_key_known<'a>(
             .bytes_to_string(key.py(), key.downcast::<PyBytes>()?.as_bytes()),
         ObType::Bytearray => {
             let py_byte_array = key.downcast::<PyByteArray>()?;
-            // Safety: the GIL is held while serialize_bytes is running; it doesn't run
-            // arbitrary Python code, so py_byte_array cannot be mutated during the call.
-            //
-            // We copy the bytes into a new buffer immediately afterwards
-            extra
-                .config
-                .bytes_mode
-                .bytes_to_string(key.py(), unsafe { py_byte_array.as_bytes() })
-                .map(|cow| Cow::Owned(cow.into_owned()))
+            pyo3::sync::with_critical_section(py_byte_array, || {
+                // SAFETY: `py_byte_array` is protected by a critical section,
+                // which guarantees no mutation, and `bytes_to_string` does not
+                // run any code which could cause the critical section to be
+                // released.
+                let bytes = unsafe { py_byte_array.as_bytes() };
+                extra.config.bytes_mode.bytes_to_string(key.py(), bytes)
+            })
+            .map(|cow| Cow::Owned(cow.into_owned()))
         }
         ObType::Datetime => {
             let iso_dt = super::type_serializers::datetime_etc::datetime_to_string(key.downcast()?)?;

From e20b74efb92070e5596a63816c8a1dc2ff608009 Mon Sep 17 00:00:00 2001
From: ajay-sentry <159853603+ajay-sentry@users.noreply.github.com>
Date: Tue, 20 May 2025 07:45:10 -0700
Subject: [PATCH 546/550] Add Codecov Test Analytics (#1684)

---
 .github/workflows/ci.yml | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 18a8fbe12..1cbf627af 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -42,7 +42,7 @@ jobs:
 
       - run: uv pip freeze
 
-      - run: uv run coverage run -m pytest
+      - run: uv run coverage run -m pytest --junitxml=junit.xml -o junit_family=legacy
 
       - run: ls -lha
       - run: uv run coverage xml
@@ -55,6 +55,8 @@ jobs:
         with:
           files: codecov.json
 
+      - uses: codecov/test-results-action@v1
+
   # See https://github.com/PyO3/pyo3/discussions/2781
   # tests intermittently segfault with pypy and cpython 3.7 when using `coverage run ...`, hence separate job
   test-python:

From 774778195af0a6f332fd321d03247af5f0163712 Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Wed, 21 May 2025 10:30:59 +0100
Subject: [PATCH 547/550] simplify ser-as-any mechanism (#1478)

Co-authored-by: nix <khiem3t@gmail.com>
---
 src/errors/validation_exception.rs            |  14 +-
 src/serializers/computed_fields.rs            | 194 ++++++++--------
 src/serializers/extra.rs                      |  55 +----
 src/serializers/fields.rs                     |  33 +--
 src/serializers/infer.rs                      |  21 +-
 src/serializers/mod.rs                        |  24 +-
 src/serializers/prebuilt.rs                   |   6 +-
 src/serializers/shared.rs                     |  70 +++++-
 src/serializers/type_serializers/dataclass.rs |  23 +-
 .../type_serializers/definitions.rs           |   6 +-
 src/serializers/type_serializers/function.rs  |  16 +-
 src/serializers/type_serializers/model.rs     |  30 +--
 tests/serializers/test_serialize_as_any.py    | 215 ++++++++++++++++++
 13 files changed, 449 insertions(+), 258 deletions(-)

diff --git a/src/errors/validation_exception.rs b/src/errors/validation_exception.rs
index 16e89eb68..aa07ef7b7 100644
--- a/src/errors/validation_exception.rs
+++ b/src/errors/validation_exception.rs
@@ -18,7 +18,7 @@ use crate::build_tools::py_schema_error_type;
 use crate::errors::LocItem;
 use crate::get_pydantic_version;
 use crate::input::InputType;
-use crate::serializers::{DuckTypingSerMode, Extra, SerMode, SerializationState};
+use crate::serializers::{Extra, SerMode, SerializationState};
 use crate::tools::{safe_repr, write_truncated_to_limited_bytes, SchemaDict};
 
 use super::line_error::ValLineError;
@@ -341,17 +341,7 @@ impl ValidationError {
         include_input: bool,
     ) -> PyResult<Bound<'py, PyString>> {
         let state = SerializationState::new("iso8601", "utf8", "constants")?;
-        let extra = state.extra(
-            py,
-            &SerMode::Json,
-            None,
-            false,
-            false,
-            true,
-            None,
-            DuckTypingSerMode::SchemaBased,
-            None,
-        );
+        let extra = state.extra(py, &SerMode::Json, None, false, false, true, None, false, None);
         let serializer = ValidationErrorSerializer {
             py,
             line_errors: &self.line_errors,
diff --git a/src/serializers/computed_fields.rs b/src/serializers/computed_fields.rs
index 6e6786d73..7a574093c 100644
--- a/src/serializers/computed_fields.rs
+++ b/src/serializers/computed_fields.rs
@@ -2,13 +2,12 @@ use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyList, PyString};
 use pyo3::{intern, PyTraverseError, PyVisit};
 use serde::ser::SerializeMap;
-use serde::Serialize;
 
 use crate::build_tools::py_schema_error_type;
 use crate::definitions::DefinitionsBuilder;
 use crate::py_gc::PyGcTraverse;
 use crate::serializers::filter::SchemaFilter;
-use crate::serializers::shared::{BuildSerializer, CombinedSerializer, PydanticSerializer, TypeSerializer};
+use crate::serializers::shared::{BuildSerializer, CombinedSerializer, PydanticSerializer};
 use crate::tools::SchemaDict;
 
 use super::errors::py_err_se_err;
@@ -48,18 +47,31 @@ impl ComputedFields {
         exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> PyResult<()> {
-        if extra.round_trip {
-            // Do not serialize computed fields
-            return Ok(());
-        }
-        for computed_field in &self.0 {
-            let field_extra = Extra {
-                field_name: Some(computed_field.property_name.as_str()),
-                ..*extra
-            };
-            computed_field.to_python(model, output_dict, filter, include, exclude, &field_extra)?;
-        }
-        Ok(())
+        self.serialize_fields(
+            model,
+            filter,
+            include,
+            exclude,
+            extra,
+            |e| e,
+            |ComputedFieldToSerialize {
+                 computed_field,
+                 value,
+                 include,
+                 exclude,
+                 field_extra,
+             }| {
+                let key = match field_extra.serialize_by_alias_or(computed_field.serialize_by_alias) {
+                    true => computed_field.alias_py.bind(model.py()),
+                    false => computed_field.property_name_py.bind(model.py()),
+                };
+                let value =
+                    computed_field
+                        .serializer
+                        .to_python(&value, include.as_ref(), exclude.as_ref(), &field_extra)?;
+                output_dict.set_item(key, value)
+            },
+        )
     }
 
     pub fn serde_serialize<S: serde::ser::Serializer>(
@@ -71,6 +83,49 @@ impl ComputedFields {
         exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<(), S::Error> {
+        self.serialize_fields(
+            model,
+            filter,
+            include,
+            exclude,
+            extra,
+            py_err_se_err,
+            |ComputedFieldToSerialize {
+                 computed_field,
+                 value,
+                 include,
+                 exclude,
+                 field_extra,
+             }| {
+                let key = match field_extra.serialize_by_alias_or(computed_field.serialize_by_alias) {
+                    true => &computed_field.alias,
+                    false => &computed_field.property_name,
+                };
+                let s = PydanticSerializer::new(
+                    &value,
+                    &computed_field.serializer,
+                    include.as_ref(),
+                    exclude.as_ref(),
+                    &field_extra,
+                );
+                map.serialize_entry(key, &s)
+            },
+        )
+    }
+
+    /// Iterate each field for serialization, filtering on
+    /// `include` and `exclude` if provided.
+    #[allow(clippy::too_many_arguments)]
+    fn serialize_fields<'a, 'py, E>(
+        &'a self,
+        model: &'a Bound<'py, PyAny>,
+        filter: &'a SchemaFilter<isize>,
+        include: Option<&'a Bound<'py, PyAny>>,
+        exclude: Option<&'a Bound<'py, PyAny>>,
+        extra: &'a Extra,
+        convert_error: impl FnOnce(PyErr) -> E,
+        mut serialize: impl FnMut(ComputedFieldToSerialize<'a, 'py>) -> Result<(), E>,
+    ) -> Result<(), E> {
         if extra.round_trip {
             // Do not serialize computed fields
             return Ok(());
@@ -78,37 +133,46 @@ impl ComputedFields {
 
         for computed_field in &self.0 {
             let property_name_py = computed_field.property_name_py.bind(model.py());
+            let (next_include, next_exclude) = match filter.key_filter(property_name_py, include, exclude) {
+                Ok(Some((next_include, next_exclude))) => (next_include, next_exclude),
+                Ok(None) => continue,
+                Err(e) => return Err(convert_error(e)),
+            };
 
-            if let Some((next_include, next_exclude)) = filter
-                .key_filter(property_name_py, include, exclude)
-                .map_err(py_err_se_err)?
-            {
-                let value = model.getattr(property_name_py).map_err(py_err_se_err)?;
-                if extra.exclude_none && value.is_none() {
-                    continue;
+            let value = match model.getattr(property_name_py) {
+                Ok(field_value) => field_value,
+                Err(e) => {
+                    return Err(convert_error(e));
                 }
-                let field_extra = Extra {
-                    field_name: Some(computed_field.property_name.as_str()),
-                    ..*extra
-                };
-                let cfs = ComputedFieldSerializer {
-                    model,
-                    computed_field,
-                    include: next_include.as_ref(),
-                    exclude: next_exclude.as_ref(),
-                    extra: &field_extra,
-                };
-                let key = match extra.serialize_by_alias_or(computed_field.serialize_by_alias) {
-                    true => computed_field.alias.as_str(),
-                    false => computed_field.property_name.as_str(),
-                };
-                map.serialize_entry(key, &cfs)?;
+            };
+            if extra.exclude_none && value.is_none() {
+                continue;
             }
+
+            let field_extra = Extra {
+                field_name: Some(&computed_field.property_name),
+                ..*extra
+            };
+            serialize(ComputedFieldToSerialize {
+                computed_field,
+                value,
+                include: next_include,
+                exclude: next_exclude,
+                field_extra,
+            })?;
         }
         Ok(())
     }
 }
 
+struct ComputedFieldToSerialize<'a, 'py> {
+    computed_field: &'a ComputedField,
+    value: Bound<'py, PyAny>,
+    include: Option<Bound<'py, PyAny>>,
+    exclude: Option<Bound<'py, PyAny>>,
+    field_extra: Extra<'a>,
+}
+
 #[derive(Debug)]
 struct ComputedField {
     property_name: String,
@@ -143,44 +207,6 @@ impl ComputedField {
             serialize_by_alias: config.get_as(intern!(py, "serialize_by_alias"))?,
         })
     }
-
-    fn to_python(
-        &self,
-        model: &Bound<'_, PyAny>,
-        output_dict: &Bound<'_, PyDict>,
-        filter: &SchemaFilter<isize>,
-        include: Option<&Bound<'_, PyAny>>,
-        exclude: Option<&Bound<'_, PyAny>>,
-        extra: &Extra,
-    ) -> PyResult<()> {
-        let py = model.py();
-        let property_name_py = self.property_name_py.bind(py);
-
-        if let Some((next_include, next_exclude)) = filter.key_filter(property_name_py, include, exclude)? {
-            let next_value = model.getattr(property_name_py)?;
-
-            let value = self
-                .serializer
-                .to_python(&next_value, next_include.as_ref(), next_exclude.as_ref(), extra)?;
-            if extra.exclude_none && value.is_none(py) {
-                return Ok(());
-            }
-            let key = match extra.serialize_by_alias_or(self.serialize_by_alias) {
-                true => self.alias_py.bind(py),
-                false => property_name_py,
-            };
-            output_dict.set_item(key, value)?;
-        }
-        Ok(())
-    }
-}
-
-pub(crate) struct ComputedFieldSerializer<'py> {
-    model: &'py Bound<'py, PyAny>,
-    computed_field: &'py ComputedField,
-    include: Option<&'py Bound<'py, PyAny>>,
-    exclude: Option<&'py Bound<'py, PyAny>>,
-    extra: &'py Extra<'py>,
 }
 
 impl_py_gc_traverse!(ComputedField { serializer });
@@ -190,21 +216,3 @@ impl PyGcTraverse for ComputedFields {
         self.0.py_gc_traverse(visit)
     }
 }
-
-impl_py_gc_traverse!(ComputedFieldSerializer<'_> { computed_field });
-
-impl Serialize for ComputedFieldSerializer<'_> {
-    fn serialize<S: serde::ser::Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
-        let py = self.model.py();
-        let property_name_py = self.computed_field.property_name_py.bind(py);
-        let next_value = self.model.getattr(property_name_py).map_err(py_err_se_err)?;
-        let s = PydanticSerializer::new(
-            &next_value,
-            &self.computed_field.serializer,
-            self.include,
-            self.exclude,
-            self.extra,
-        );
-        s.serialize(serializer)
-    }
-}
diff --git a/src/serializers/extra.rs b/src/serializers/extra.rs
index 82c432342..e919beb8c 100644
--- a/src/serializers/extra.rs
+++ b/src/serializers/extra.rs
@@ -27,45 +27,6 @@ pub(crate) struct SerializationState {
     config: SerializationConfig,
 }
 
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum DuckTypingSerMode {
-    // Don't check the type of the value, use the type of the schema
-    SchemaBased,
-    // Check the type of the value, use the type of the value
-    NeedsInference,
-    // We already checked the type of the value
-    // we don't want to infer again, but if we recurse down
-    // we do want to flip this back to NeedsInference for the
-    // fields / keys / items of any inner serializers
-    Inferred,
-}
-
-impl DuckTypingSerMode {
-    pub fn from_bool(serialize_as_any: bool) -> Self {
-        if serialize_as_any {
-            DuckTypingSerMode::NeedsInference
-        } else {
-            DuckTypingSerMode::SchemaBased
-        }
-    }
-
-    pub fn to_bool(self) -> bool {
-        match self {
-            DuckTypingSerMode::SchemaBased => false,
-            DuckTypingSerMode::NeedsInference => true,
-            DuckTypingSerMode::Inferred => true,
-        }
-    }
-
-    pub fn next_mode(self) -> Self {
-        match self {
-            DuckTypingSerMode::SchemaBased => DuckTypingSerMode::SchemaBased,
-            DuckTypingSerMode::NeedsInference => DuckTypingSerMode::Inferred,
-            DuckTypingSerMode::Inferred => DuckTypingSerMode::NeedsInference,
-        }
-    }
-}
-
 impl SerializationState {
     pub fn new(timedelta_mode: &str, bytes_mode: &str, inf_nan_mode: &str) -> PyResult<Self> {
         let warnings = CollectWarnings::new(WarningsMode::None);
@@ -88,7 +49,7 @@ impl SerializationState {
         round_trip: bool,
         serialize_unknown: bool,
         fallback: Option<&'py Bound<'_, PyAny>>,
-        duck_typing_ser_mode: DuckTypingSerMode,
+        serialize_as_any: bool,
         context: Option<&'py Bound<'_, PyAny>>,
     ) -> Extra<'py> {
         Extra::new(
@@ -104,7 +65,7 @@ impl SerializationState {
             &self.rec_guard,
             serialize_unknown,
             fallback,
-            duck_typing_ser_mode,
+            serialize_as_any,
             context,
         )
     }
@@ -137,7 +98,7 @@ pub(crate) struct Extra<'a> {
     pub field_name: Option<&'a str>,
     pub serialize_unknown: bool,
     pub fallback: Option<&'a Bound<'a, PyAny>>,
-    pub duck_typing_ser_mode: DuckTypingSerMode,
+    pub serialize_as_any: bool,
     pub context: Option<&'a Bound<'a, PyAny>>,
 }
 
@@ -156,7 +117,7 @@ impl<'a> Extra<'a> {
         rec_guard: &'a SerRecursionState,
         serialize_unknown: bool,
         fallback: Option<&'a Bound<'a, PyAny>>,
-        duck_typing_ser_mode: DuckTypingSerMode,
+        serialize_as_any: bool,
         context: Option<&'a Bound<'a, PyAny>>,
     ) -> Self {
         Self {
@@ -175,7 +136,7 @@ impl<'a> Extra<'a> {
             field_name: None,
             serialize_unknown,
             fallback,
-            duck_typing_ser_mode,
+            serialize_as_any,
             context,
         }
     }
@@ -243,7 +204,7 @@ pub(crate) struct ExtraOwned {
     field_name: Option<String>,
     serialize_unknown: bool,
     pub fallback: Option<PyObject>,
-    duck_typing_ser_mode: DuckTypingSerMode,
+    serialize_as_any: bool,
     pub context: Option<PyObject>,
 }
 
@@ -264,7 +225,7 @@ impl ExtraOwned {
             field_name: extra.field_name.map(ToString::to_string),
             serialize_unknown: extra.serialize_unknown,
             fallback: extra.fallback.map(|model| model.clone().into()),
-            duck_typing_ser_mode: extra.duck_typing_ser_mode,
+            serialize_as_any: extra.serialize_as_any,
             context: extra.context.map(|model| model.clone().into()),
         }
     }
@@ -286,7 +247,7 @@ impl ExtraOwned {
             field_name: self.field_name.as_deref(),
             serialize_unknown: self.serialize_unknown,
             fallback: self.fallback.as_ref().map(|m| m.bind(py)),
-            duck_typing_ser_mode: self.duck_typing_ser_mode,
+            serialize_as_any: self.serialize_as_any,
             context: self.context.as_ref().map(|m| m.bind(py)),
         }
     }
diff --git a/src/serializers/fields.rs b/src/serializers/fields.rs
index d4bc8bb67..a5c5bc6b3 100644
--- a/src/serializers/fields.rs
+++ b/src/serializers/fields.rs
@@ -8,7 +8,6 @@ use serde::ser::SerializeMap;
 use smallvec::SmallVec;
 
 use crate::serializers::extra::SerCheck;
-use crate::serializers::DuckTypingSerMode;
 use crate::PydanticSerializationUnexpectedValue;
 
 use super::computed_fields::ComputedFields;
@@ -191,7 +190,7 @@ impl GeneralFieldsSerializer {
                         Some(serializer) => {
                             serializer.to_python(&value, next_include.as_ref(), next_exclude.as_ref(), &field_extra)?
                         }
-                        None => infer_to_python(&value, next_include.as_ref(), next_exclude.as_ref(), &field_extra)?,
+                        _ => infer_to_python(&value, next_include.as_ref(), next_exclude.as_ref(), &field_extra)?,
                     };
                     output_dict.set_item(key, value)?;
                 } else if field_extra.check == SerCheck::Strict {
@@ -332,20 +331,6 @@ impl TypeSerializer for GeneralFieldsSerializer {
         // If there is no model, we (a TypedDict) are the model
         let model = extra.model.map_or_else(|| Some(value), Some);
 
-        // If there is no model, use duck typing ser logic for TypedDict
-        // If there is a model, skip this step, as BaseModel and dataclass duck typing
-        // is handled in their respective serializers
-        if extra.model.is_none() {
-            let duck_typing_ser_mode = extra.duck_typing_ser_mode.next_mode();
-            let td_extra = Extra {
-                model,
-                duck_typing_ser_mode,
-                ..*extra
-            };
-            if td_extra.duck_typing_ser_mode == DuckTypingSerMode::Inferred {
-                return infer_to_python(value, include, exclude, &td_extra);
-            }
-        }
         let (main_dict, extra_dict) = if let Some(main_extra_dict) = self.extract_dicts(value) {
             main_extra_dict
         } else {
@@ -367,7 +352,7 @@ impl TypeSerializer for GeneralFieldsSerializer {
                         Some(serializer) => {
                             serializer.to_python(&value, next_include.as_ref(), next_exclude.as_ref(), extra)?
                         }
-                        None => infer_to_python(&value, next_include.as_ref(), next_exclude.as_ref(), extra)?,
+                        _ => infer_to_python(&value, next_include.as_ref(), next_exclude.as_ref(), extra)?,
                     };
                     output_dict.set_item(key, value)?;
                 }
@@ -401,20 +386,6 @@ impl TypeSerializer for GeneralFieldsSerializer {
         // If there is no model, we (a TypedDict) are the model
         let model = extra.model.map_or_else(|| Some(value), Some);
 
-        // If there is no model, use duck typing ser logic for TypedDict
-        // If there is a model, skip this step, as BaseModel and dataclass duck typing
-        // is handled in their respective serializers
-        if extra.model.is_none() {
-            let duck_typing_ser_mode = extra.duck_typing_ser_mode.next_mode();
-            let td_extra = Extra {
-                model,
-                duck_typing_ser_mode,
-                ..*extra
-            };
-            if td_extra.duck_typing_ser_mode == DuckTypingSerMode::Inferred {
-                return infer_serialize(value, serializer, include, exclude, &td_extra);
-            }
-        }
         let expected_len = match self.mode {
             FieldsMode::TypedDictAllow => main_dict.len() + self.computed_field_count(),
             _ => self.fields.len() + option_length!(extra_dict) + self.computed_field_count(),
diff --git a/src/serializers/infer.rs b/src/serializers/infer.rs
index 70910aeb1..eb067b81d 100644
--- a/src/serializers/infer.rs
+++ b/src/serializers/infer.rs
@@ -21,7 +21,7 @@ use super::errors::{py_err_se_err, PydanticSerializationError};
 use super::extra::{Extra, SerMode};
 use super::filter::{AnyFilter, SchemaFilter};
 use super::ob_type::ObType;
-use super::shared::{any_dataclass_iter, PydanticSerializer, TypeSerializer};
+use super::shared::any_dataclass_iter;
 use super::SchemaSerializer;
 
 pub(crate) fn infer_to_python(
@@ -106,10 +106,14 @@ pub(crate) fn infer_to_python_known(
             extra.rec_guard,
             extra.serialize_unknown,
             extra.fallback,
-            extra.duck_typing_ser_mode,
+            extra.serialize_as_any,
             extra.context,
         );
-        serializer.serializer.to_python(value, include, exclude, &extra)
+        // Avoid falling immediately back into inference because we need to use the serializer
+        // to drive the next step of serialization
+        serializer
+            .serializer
+            .to_python_no_infer(value, include, exclude, &extra)
     };
 
     let value = match extra.mode {
@@ -489,6 +493,7 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
                 .getattr(intern!(py, "__pydantic_serializer__"))
                 .map_err(py_err_se_err)?;
             let extracted_serializer: PyRef<SchemaSerializer> = py_serializer.extract().map_err(py_err_se_err)?;
+
             let extra = extracted_serializer.build_extra(
                 py,
                 extra.mode,
@@ -501,12 +506,14 @@ pub(crate) fn infer_serialize_known<S: Serializer>(
                 extra.rec_guard,
                 extra.serialize_unknown,
                 extra.fallback,
-                extra.duck_typing_ser_mode,
+                extra.serialize_as_any,
                 extra.context,
             );
-            let pydantic_serializer =
-                PydanticSerializer::new(value, &extracted_serializer.serializer, include, exclude, &extra);
-            pydantic_serializer.serialize(serializer)
+            // Avoid falling immediately back into inference because we need to use the serializer
+            // to drive the next step of serialization
+            extracted_serializer
+                .serializer
+                .serde_serialize_no_infer(value, serializer, include, exclude, &extra)
         }
         ObType::Dataclass => {
             let (pairs_iter, fields_dict) = any_dataclass_iter(value).map_err(py_err_se_err)?;
diff --git a/src/serializers/mod.rs b/src/serializers/mod.rs
index 5516f81e1..0da5f188f 100644
--- a/src/serializers/mod.rs
+++ b/src/serializers/mod.rs
@@ -4,6 +4,7 @@ use std::sync::atomic::{AtomicUsize, Ordering};
 use pyo3::prelude::*;
 use pyo3::types::{PyBytes, PyDict, PyTuple, PyType};
 use pyo3::{PyTraverseError, PyVisit};
+use type_serializers::any::AnySerializer;
 
 use crate::definitions::{Definitions, DefinitionsBuilder};
 use crate::py_gc::PyGcTraverse;
@@ -12,9 +13,9 @@ pub(crate) use config::BytesMode;
 use config::SerializationConfig;
 pub use errors::{PydanticSerializationError, PydanticSerializationUnexpectedValue};
 use extra::{CollectWarnings, SerRecursionState, WarningsMode};
-pub(crate) use extra::{DuckTypingSerMode, Extra, SerMode, SerializationState};
+pub(crate) use extra::{Extra, SerMode, SerializationState};
+use shared::to_json_bytes;
 pub use shared::CombinedSerializer;
-use shared::{to_json_bytes, TypeSerializer};
 
 mod computed_fields;
 mod config;
@@ -63,7 +64,7 @@ impl SchemaSerializer {
         rec_guard: &'a SerRecursionState,
         serialize_unknown: bool,
         fallback: Option<&'a Bound<'a, PyAny>>,
-        duck_typing_ser_mode: DuckTypingSerMode,
+        serialize_as_any: bool,
         context: Option<&'a Bound<'a, PyAny>>,
     ) -> Extra<'b> {
         Extra::new(
@@ -79,7 +80,7 @@ impl SchemaSerializer {
             rec_guard,
             serialize_unknown,
             fallback,
-            duck_typing_ser_mode,
+            serialize_as_any,
             context,
         )
     }
@@ -133,7 +134,6 @@ impl SchemaSerializer {
         };
         let warnings = CollectWarnings::new(warnings_mode);
         let rec_guard = SerRecursionState::default();
-        let duck_typing_ser_mode = DuckTypingSerMode::from_bool(serialize_as_any);
         let extra = self.build_extra(
             py,
             &mode,
@@ -146,7 +146,7 @@ impl SchemaSerializer {
             &rec_guard,
             false,
             fallback,
-            duck_typing_ser_mode,
+            serialize_as_any,
             context,
         );
         let v = self.serializer.to_python(value, include, exclude, &extra)?;
@@ -181,7 +181,6 @@ impl SchemaSerializer {
         };
         let warnings = CollectWarnings::new(warnings_mode);
         let rec_guard = SerRecursionState::default();
-        let duck_typing_ser_mode = DuckTypingSerMode::from_bool(serialize_as_any);
         let extra = self.build_extra(
             py,
             &SerMode::Json,
@@ -194,7 +193,7 @@ impl SchemaSerializer {
             &rec_guard,
             false,
             fallback,
-            duck_typing_ser_mode,
+            serialize_as_any,
             context,
         );
         let bytes = to_json_bytes(
@@ -261,7 +260,6 @@ pub fn to_json(
     context: Option<&Bound<'_, PyAny>>,
 ) -> PyResult<PyObject> {
     let state = SerializationState::new(timedelta_mode, bytes_mode, inf_nan_mode)?;
-    let duck_typing_ser_mode = DuckTypingSerMode::from_bool(serialize_as_any);
     let extra = state.extra(
         py,
         &SerMode::Json,
@@ -270,11 +268,10 @@ pub fn to_json(
         round_trip,
         serialize_unknown,
         fallback,
-        duck_typing_ser_mode,
+        serialize_as_any,
         context,
     );
-    let serializer = type_serializers::any::AnySerializer.into();
-    let bytes = to_json_bytes(value, &serializer, include, exclude, &extra, indent, 1024)?;
+    let bytes = to_json_bytes(value, AnySerializer::get(), include, exclude, &extra, indent, 1024)?;
     state.final_check(py)?;
     let py_bytes = PyBytes::new(py, &bytes);
     Ok(py_bytes.into())
@@ -302,7 +299,6 @@ pub fn to_jsonable_python(
     context: Option<&Bound<'_, PyAny>>,
 ) -> PyResult<PyObject> {
     let state = SerializationState::new(timedelta_mode, bytes_mode, inf_nan_mode)?;
-    let duck_typing_ser_mode = DuckTypingSerMode::from_bool(serialize_as_any);
     let extra = state.extra(
         py,
         &SerMode::Json,
@@ -311,7 +307,7 @@ pub fn to_jsonable_python(
         round_trip,
         serialize_unknown,
         fallback,
-        duck_typing_ser_mode,
+        serialize_as_any,
         context,
     );
     let v = infer::infer_to_python(value, include, exclude, &extra)?;
diff --git a/src/serializers/prebuilt.rs b/src/serializers/prebuilt.rs
index 3f1cf1c68..323dbe2e9 100644
--- a/src/serializers/prebuilt.rs
+++ b/src/serializers/prebuilt.rs
@@ -39,11 +39,11 @@ impl TypeSerializer for PrebuiltSerializer {
         self.schema_serializer
             .get()
             .serializer
-            .to_python(value, include, exclude, extra)
+            .to_python_no_infer(value, include, exclude, extra)
     }
 
     fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
-        self.schema_serializer.get().serializer.json_key(key, extra)
+        self.schema_serializer.get().serializer.json_key_no_infer(key, extra)
     }
 
     fn serde_serialize<S: serde::ser::Serializer>(
@@ -57,7 +57,7 @@ impl TypeSerializer for PrebuiltSerializer {
         self.schema_serializer
             .get()
             .serializer
-            .serde_serialize(value, serializer, include, exclude, extra)
+            .serde_serialize_no_infer(value, serializer, include, exclude, extra)
     }
 
     fn get_name(&self) -> &str {
diff --git a/src/serializers/shared.rs b/src/serializers/shared.rs
index e28ae9cee..1255e1128 100644
--- a/src/serializers/shared.rs
+++ b/src/serializers/shared.rs
@@ -20,7 +20,7 @@ use crate::tools::{py_err, SchemaDict};
 
 use super::errors::se_err_py_err;
 use super::extra::Extra;
-use super::infer::infer_json_key;
+use super::infer::{infer_json_key, infer_serialize, infer_to_python};
 use super::ob_type::{IsType, ObType};
 
 pub(crate) trait BuildSerializer: Sized {
@@ -221,6 +221,74 @@ impl CombinedSerializer {
 
         Self::find_serializer(type_, schema, config, definitions)
     }
+
+    /// Main recursive way to call serializers, supports possible recursive type inference by
+    /// switching to type inference mode eagerly.
+    pub fn to_python(
+        &self,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
+        extra: &Extra,
+    ) -> PyResult<PyObject> {
+        if extra.serialize_as_any {
+            infer_to_python(value, include, exclude, extra)
+        } else {
+            self.to_python_no_infer(value, include, exclude, extra)
+        }
+    }
+
+    /// Variant of the above which does not fall back to inference mode immediately
+    #[inline]
+    pub fn to_python_no_infer(
+        &self,
+        value: &Bound<'_, PyAny>,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
+        extra: &Extra,
+    ) -> PyResult<PyObject> {
+        TypeSerializer::to_python(self, value, include, exclude, extra)
+    }
+
+    pub fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
+        if extra.serialize_as_any {
+            infer_json_key(key, extra)
+        } else {
+            self.json_key_no_infer(key, extra)
+        }
+    }
+
+    #[inline]
+    pub fn json_key_no_infer<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
+        TypeSerializer::json_key(self, key, extra)
+    }
+
+    pub fn serde_serialize<S: serde::ser::Serializer>(
+        &self,
+        value: &Bound<'_, PyAny>,
+        serializer: S,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
+        extra: &Extra,
+    ) -> Result<S::Ok, S::Error> {
+        if extra.serialize_as_any {
+            infer_serialize(value, serializer, include, exclude, extra)
+        } else {
+            self.serde_serialize_no_infer(value, serializer, include, exclude, extra)
+        }
+    }
+
+    #[inline]
+    pub fn serde_serialize_no_infer<S: serde::ser::Serializer>(
+        &self,
+        value: &Bound<'_, PyAny>,
+        serializer: S,
+        include: Option<&Bound<'_, PyAny>>,
+        exclude: Option<&Bound<'_, PyAny>>,
+        extra: &Extra,
+    ) -> Result<S::Ok, S::Error> {
+        TypeSerializer::serde_serialize(self, value, serializer, include, exclude, extra)
+    }
 }
 
 impl BuildSerializer for CombinedSerializer {
diff --git a/src/serializers/type_serializers/dataclass.rs b/src/serializers/type_serializers/dataclass.rs
index a080a9b4f..996a80d72 100644
--- a/src/serializers/type_serializers/dataclass.rs
+++ b/src/serializers/type_serializers/dataclass.rs
@@ -8,7 +8,6 @@ use serde::ser::SerializeMap;
 
 use crate::build_tools::{py_schema_error_type, ExtraBehavior};
 use crate::definitions::DefinitionsBuilder;
-use crate::serializers::DuckTypingSerMode;
 use crate::tools::SchemaDict;
 
 use super::{
@@ -141,19 +140,11 @@ impl TypeSerializer for DataclassSerializer {
         extra: &Extra,
     ) -> PyResult<PyObject> {
         let model = Some(value);
-        let duck_typing_ser_mode = extra.duck_typing_ser_mode.next_mode();
-        let dc_extra = Extra {
-            model,
-            duck_typing_ser_mode,
-            ..*extra
-        };
-        if dc_extra.duck_typing_ser_mode == DuckTypingSerMode::Inferred {
-            return infer_to_python(value, include, exclude, &dc_extra);
-        }
+        let dc_extra = Extra { model, ..*extra };
         if self.allow_value(value, &dc_extra)? {
             let py = value.py();
             if let CombinedSerializer::Fields(ref fields_serializer) = *self.serializer {
-                let output_dict = fields_serializer.main_to_python(
+                let output_dict: Bound<PyDict> = fields_serializer.main_to_python(
                     py,
                     known_dataclass_iter(&self.fields, value),
                     include,
@@ -190,16 +181,8 @@ impl TypeSerializer for DataclassSerializer {
         exclude: Option<&Bound<'_, PyAny>>,
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
-        let duck_typing_ser_mode = extra.duck_typing_ser_mode.next_mode();
         let model = Some(value);
-        let dc_extra = Extra {
-            model,
-            duck_typing_ser_mode,
-            ..*extra
-        };
-        if dc_extra.duck_typing_ser_mode == DuckTypingSerMode::Inferred {
-            return infer_serialize(value, serializer, include, exclude, &dc_extra);
-        }
+        let dc_extra = Extra { model, ..*extra };
         if self.allow_value(value, &dc_extra).map_err(py_err_se_err)? {
             if let CombinedSerializer::Fields(ref fields_serializer) = *self.serializer {
                 let expected_len = self.fields.len() + fields_serializer.computed_field_count();
diff --git a/src/serializers/type_serializers/definitions.rs b/src/serializers/type_serializers/definitions.rs
index 38fd7cea5..4f517b6f2 100644
--- a/src/serializers/type_serializers/definitions.rs
+++ b/src/serializers/type_serializers/definitions.rs
@@ -94,12 +94,12 @@ impl TypeSerializer for DefinitionRefSerializer {
         self.definition.read(|comb_serializer| {
             let comb_serializer = comb_serializer.unwrap();
             let mut guard = extra.recursion_guard(value, self.definition.id())?;
-            comb_serializer.to_python(value, include, exclude, guard.state())
+            comb_serializer.to_python_no_infer(value, include, exclude, guard.state())
         })
     }
 
     fn json_key<'a>(&self, key: &'a Bound<'_, PyAny>, extra: &Extra) -> PyResult<Cow<'a, str>> {
-        self.definition.read(|s| s.unwrap().json_key(key, extra))
+        self.definition.read(|s| s.unwrap().json_key_no_infer(key, extra))
     }
 
     fn serde_serialize<S: serde::ser::Serializer>(
@@ -115,7 +115,7 @@ impl TypeSerializer for DefinitionRefSerializer {
             let mut guard = extra
                 .recursion_guard(value, self.definition.id())
                 .map_err(py_err_se_err)?;
-            comb_serializer.serde_serialize(value, serializer, include, exclude, guard.state())
+            comb_serializer.serde_serialize_no_infer(value, serializer, include, exclude, guard.state())
         })
     }
 
diff --git a/src/serializers/type_serializers/function.rs b/src/serializers/type_serializers/function.rs
index 3c66583e2..9a351694c 100644
--- a/src/serializers/type_serializers/function.rs
+++ b/src/serializers/type_serializers/function.rs
@@ -497,6 +497,10 @@ impl SerializationCallable {
         value: &Bound<'_, PyAny>,
         index_key: Option<&Bound<'_, PyAny>>,
     ) -> PyResult<Option<PyObject>> {
+        // NB wrap serializers have strong coupling to their inner type,
+        // so use to_python_no_infer so that type inference can't apply
+        // at this layer
+
         let include = self.include.as_ref().map(|o| o.bind(py));
         let exclude = self.exclude.as_ref().map(|o| o.bind(py));
         let extra = self.extra_owned.to_extra(py);
@@ -508,16 +512,16 @@ impl SerializationCallable {
                 self.filter.key_filter(index_key, include, exclude)?
             };
             if let Some((next_include, next_exclude)) = filter {
-                let v = self
-                    .serializer
-                    .to_python(value, next_include.as_ref(), next_exclude.as_ref(), &extra)?;
+                let v =
+                    self.serializer
+                        .to_python_no_infer(value, next_include.as_ref(), next_exclude.as_ref(), &extra)?;
                 extra.warnings.final_check(py)?;
                 Ok(Some(v))
             } else {
                 Err(PydanticOmit::new_err())
             }
         } else {
-            let v = self.serializer.to_python(value, include, exclude, &extra)?;
+            let v = self.serializer.to_python_no_infer(value, include, exclude, &extra)?;
             extra.warnings.final_check(py)?;
             Ok(Some(v))
         }
@@ -581,7 +585,7 @@ impl SerializationInfo {
                     exclude_none: extra.exclude_none,
                     round_trip: extra.round_trip,
                     field_name: Some(field_name.to_string()),
-                    serialize_as_any: extra.duck_typing_ser_mode.to_bool(),
+                    serialize_as_any: extra.serialize_as_any,
                 }),
                 _ => Err(PyRuntimeError::new_err(
                     "Model field context expected for field serialization info but no model field was found",
@@ -599,7 +603,7 @@ impl SerializationInfo {
                 exclude_none: extra.exclude_none,
                 round_trip: extra.round_trip,
                 field_name: None,
-                serialize_as_any: extra.duck_typing_ser_mode.to_bool(),
+                serialize_as_any: extra.serialize_as_any,
             })
         }
     }
diff --git a/src/serializers/type_serializers/model.rs b/src/serializers/type_serializers/model.rs
index 4bae243fc..21f7ce024 100644
--- a/src/serializers/type_serializers/model.rs
+++ b/src/serializers/type_serializers/model.rs
@@ -16,7 +16,6 @@ use crate::build_tools::py_schema_err;
 use crate::build_tools::{py_schema_error_type, ExtraBehavior};
 use crate::definitions::DefinitionsBuilder;
 use crate::serializers::errors::PydanticSerializationUnexpectedValue;
-use crate::serializers::extra::DuckTypingSerMode;
 use crate::tools::SchemaDict;
 
 const ROOT_FIELD: &str = "root";
@@ -171,16 +170,8 @@ impl TypeSerializer for ModelSerializer {
         extra: &Extra,
     ) -> PyResult<PyObject> {
         let model = Some(value);
-        let duck_typing_ser_mode = extra.duck_typing_ser_mode.next_mode();
 
-        let model_extra = Extra {
-            model,
-            duck_typing_ser_mode,
-            ..*extra
-        };
-        if model_extra.duck_typing_ser_mode == DuckTypingSerMode::Inferred {
-            return infer_to_python(value, include, exclude, &model_extra);
-        }
+        let model_extra = Extra { model, ..*extra };
         if self.root_model {
             let field_name = Some(ROOT_FIELD);
             let root_extra = Extra {
@@ -198,7 +189,10 @@ impl TypeSerializer for ModelSerializer {
             self.serializer.to_python(&root, include, exclude, &root_extra)
         } else if self.allow_value(value, &model_extra)? {
             let inner_value = self.get_inner_value(value, &model_extra)?;
-            self.serializer.to_python(&inner_value, include, exclude, &model_extra)
+            // There is strong coupling between a model serializer and its child, we should
+            // not fall back to type inference in the midddle.
+            self.serializer
+                .to_python_no_infer(&inner_value, include, exclude, &model_extra)
         } else {
             extra.warnings.on_fallback_py(self.get_name(), value, &model_extra)?;
             infer_to_python(value, include, exclude, &model_extra)
@@ -223,15 +217,7 @@ impl TypeSerializer for ModelSerializer {
         extra: &Extra,
     ) -> Result<S::Ok, S::Error> {
         let model = Some(value);
-        let duck_typing_ser_mode = extra.duck_typing_ser_mode.next_mode();
-        let model_extra = Extra {
-            model,
-            duck_typing_ser_mode,
-            ..*extra
-        };
-        if model_extra.duck_typing_ser_mode == DuckTypingSerMode::Inferred {
-            return infer_serialize(value, serializer, include, exclude, &model_extra);
-        }
+        let model_extra = Extra { model, ..*extra };
         if self.root_model {
             let field_name = Some(ROOT_FIELD);
             let root_extra = Extra {
@@ -244,8 +230,10 @@ impl TypeSerializer for ModelSerializer {
                 .serde_serialize(&root, serializer, include, exclude, &root_extra)
         } else if self.allow_value(value, &model_extra).map_err(py_err_se_err)? {
             let inner_value = self.get_inner_value(value, &model_extra).map_err(py_err_se_err)?;
+            // There is strong coupling between a model serializer and its child, we should
+            // not fall back to type inference in the midddle.
             self.serializer
-                .serde_serialize(&inner_value, serializer, include, exclude, &model_extra)
+                .serde_serialize_no_infer(&inner_value, serializer, include, exclude, &model_extra)
         } else {
             extra
                 .warnings
diff --git a/tests/serializers/test_serialize_as_any.py b/tests/serializers/test_serialize_as_any.py
index 1d1be238b..ee841ffa8 100644
--- a/tests/serializers/test_serialize_as_any.py
+++ b/tests/serializers/test_serialize_as_any.py
@@ -1,4 +1,5 @@
 from dataclasses import dataclass
+from typing import Optional
 
 from typing_extensions import TypedDict
 
@@ -155,3 +156,217 @@ class Other:
         'x': 1,
         'y': 'hopefully not a secret',
     }
+
+
+def test_serialize_as_any_with_nested_models() -> None:
+    class Parent:
+        x: int
+
+    class Other(Parent):
+        y: str
+
+    class Outer:
+        p: Parent
+
+    Parent.__pydantic_core_schema__ = core_schema.model_schema(
+        Parent,
+        core_schema.model_fields_schema(
+            {
+                'x': core_schema.model_field(core_schema.int_schema()),
+            }
+        ),
+        ref='Parent',
+    )
+    Parent.__pydantic_validator__ = SchemaValidator(Parent.__pydantic_core_schema__)
+    Parent.__pydantic_serializer__ = SchemaSerializer(Parent.__pydantic_core_schema__)
+
+    Other.__pydantic_core_schema__ = core_schema.model_schema(
+        Other,
+        core_schema.model_fields_schema(
+            {
+                'x': core_schema.model_field(core_schema.int_schema()),
+                'y': core_schema.model_field(core_schema.str_schema()),
+            }
+        ),
+        config=core_schema.CoreConfig(extra_fields_behavior='allow'),
+    )
+    Other.__pydantic_validator__ = SchemaValidator(Other.__pydantic_core_schema__)
+    Other.__pydantic_serializer__ = SchemaSerializer(Other.__pydantic_core_schema__)
+
+    Outer.__pydantic_core_schema__ = core_schema.definitions_schema(
+        core_schema.model_schema(
+            Outer,
+            core_schema.model_fields_schema(
+                {
+                    'p': core_schema.model_field(core_schema.definition_reference_schema('Parent')),
+                }
+            ),
+        ),
+        [
+            Parent.__pydantic_core_schema__,
+        ],
+    )
+    Outer.__pydantic_validator__ = SchemaValidator(Outer.__pydantic_core_schema__)
+    Outer.__pydantic_serializer__ = SchemaSerializer(Outer.__pydantic_core_schema__)
+
+    other = Other.__pydantic_validator__.validate_python({'x': 1, 'y': 'hopefully not a secret'})
+    outer = Outer()
+    outer.p = other
+
+    assert Outer.__pydantic_serializer__.to_python(outer, serialize_as_any=False) == {
+        'p': {'x': 1},
+    }
+    assert Outer.__pydantic_serializer__.to_python(outer, serialize_as_any=True) == {
+        'p': {
+            'x': 1,
+            'y': 'hopefully not a secret',
+        }
+    }
+
+    assert Outer.__pydantic_serializer__.to_json(outer, serialize_as_any=False) == b'{"p":{"x":1}}'
+    assert (
+        Outer.__pydantic_serializer__.to_json(outer, serialize_as_any=True)
+        == b'{"p":{"x":1,"y":"hopefully not a secret"}}'
+    )
+
+
+def test_serialize_with_recursive_models() -> None:
+    class Node:
+        next: Optional['Node'] = None
+        value: int = 42
+
+    schema = core_schema.definitions_schema(
+        core_schema.definition_reference_schema('Node'),
+        [
+            core_schema.model_schema(
+                Node,
+                core_schema.model_fields_schema(
+                    {
+                        'value': core_schema.model_field(
+                            core_schema.with_default_schema(core_schema.int_schema(), default=42)
+                        ),
+                        'next': core_schema.model_field(
+                            core_schema.with_default_schema(
+                                core_schema.nullable_schema(core_schema.definition_reference_schema('Node')),
+                                default=None,
+                            )
+                        ),
+                    }
+                ),
+                ref='Node',
+            )
+        ],
+    )
+
+    Node.__pydantic_core_schema__ = schema
+    Node.__pydantic_validator__ = SchemaValidator(Node.__pydantic_core_schema__)
+    Node.__pydantic_serializer__ = SchemaSerializer(Node.__pydantic_core_schema__)
+    other = Node.__pydantic_validator__.validate_python({'next': {'value': 4}})
+
+    assert Node.__pydantic_serializer__.to_python(other, serialize_as_any=False) == {
+        'next': {'next': None, 'value': 4},
+        'value': 42,
+    }
+    assert Node.__pydantic_serializer__.to_python(other, serialize_as_any=True) == {
+        'next': {'next': None, 'value': 4},
+        'value': 42,
+    }
+
+
+def test_serialize_with_custom_type_and_subclasses():
+    class Node:
+        x: int
+
+    Node.__pydantic_core_schema__ = core_schema.model_schema(
+        Node,
+        core_schema.model_fields_schema(
+            {
+                'x': core_schema.model_field(core_schema.int_schema()),
+            }
+        ),
+        ref='Node',
+    )
+    Node.__pydantic_validator__ = SchemaValidator(Node.__pydantic_core_schema__)
+    Node.__pydantic_serializer__ = SchemaSerializer(Node.__pydantic_core_schema__)
+
+    class NodeSubClass(Node):
+        y: int
+
+    NodeSubClass.__pydantic_core_schema__ = core_schema.model_schema(
+        NodeSubClass,
+        core_schema.model_fields_schema(
+            {
+                'x': core_schema.model_field(core_schema.int_schema()),
+                'y': core_schema.model_field(core_schema.int_schema()),
+            }
+        ),
+    )
+    NodeSubClass.__pydantic_validator__ = SchemaValidator(NodeSubClass.__pydantic_core_schema__)
+    NodeSubClass.__pydantic_serializer__ = SchemaSerializer(NodeSubClass.__pydantic_core_schema__)
+
+    class CustomType:
+        values: list[Node]
+
+    CustomType.__pydantic_core_schema__ = core_schema.model_schema(
+        CustomType,
+        core_schema.definitions_schema(
+            core_schema.model_fields_schema(
+                {
+                    'values': core_schema.model_field(
+                        core_schema.list_schema(core_schema.definition_reference_schema('Node'))
+                    ),
+                }
+            ),
+            [
+                Node.__pydantic_core_schema__,
+            ],
+        ),
+    )
+    CustomType.__pydantic_validator__ = SchemaValidator(CustomType.__pydantic_core_schema__)
+    CustomType.__pydantic_serializer__ = SchemaSerializer(CustomType.__pydantic_core_schema__)
+
+    value = CustomType.__pydantic_validator__.validate_python({'values': [{'x': 1}, {'x': 2}]})
+    value.values.append(NodeSubClass.__pydantic_validator__.validate_python({'x': 3, 'y': 4}))
+
+    assert CustomType.__pydantic_serializer__.to_python(value, serialize_as_any=False) == {
+        'values': [{'x': 1}, {'x': 2}, {'x': 3}],
+    }
+    assert CustomType.__pydantic_serializer__.to_python(value, serialize_as_any=True) == {
+        'values': [{'x': 1}, {'x': 2}, {'x': 3, 'y': 4}],
+    }
+
+
+def test_serialize_as_any_wrap_serializer_applied_once() -> None:
+    # https://github.com/pydantic/pydantic/issues/11139
+
+    class InnerModel:
+        an_inner_field: int
+
+    InnerModel.__pydantic_core_schema__ = core_schema.model_schema(
+        InnerModel,
+        core_schema.model_fields_schema({'an_inner_field': core_schema.model_field(core_schema.int_schema())}),
+    )
+    InnerModel.__pydantic_validator__ = SchemaValidator(InnerModel.__pydantic_core_schema__)
+    InnerModel.__pydantic_serializer__ = SchemaSerializer(InnerModel.__pydantic_core_schema__)
+
+    class MyModel:
+        a_field: InnerModel
+
+        def a_model_serializer(self, handler, info):
+            return {k + '_wrapped': v for k, v in handler(self).items()}
+
+    MyModel.__pydantic_core_schema__ = core_schema.model_schema(
+        MyModel,
+        core_schema.model_fields_schema({'a_field': core_schema.model_field(InnerModel.__pydantic_core_schema__)}),
+        serialization=core_schema.wrap_serializer_function_ser_schema(
+            MyModel.a_model_serializer,
+            info_arg=True,
+        ),
+    )
+    MyModel.__pydantic_validator__ = SchemaValidator(MyModel.__pydantic_core_schema__)
+    MyModel.__pydantic_serializer__ = SchemaSerializer(MyModel.__pydantic_core_schema__)
+
+    instance = MyModel.__pydantic_validator__.validate_python({'a_field': {'an_inner_field': 1}})
+    assert MyModel.__pydantic_serializer__.to_python(instance, serialize_as_any=True) == {
+        'a_field_wrapped': {'an_inner_field': 1},
+    }

From e43c144a63efb6d69c0f7984493f896b8632cc7f Mon Sep 17 00:00:00 2001
From: Samuel Colvin <s@muelcolvin.com>
Date: Thu, 22 May 2025 23:21:47 +0100
Subject: [PATCH 548/550] fix wasm-preview

---
 wasm-preview/run_tests.py | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/wasm-preview/run_tests.py b/wasm-preview/run_tests.py
index 806e01164..f4a7b3f33 100644
--- a/wasm-preview/run_tests.py
+++ b/wasm-preview/run_tests.py
@@ -38,7 +38,15 @@ async def main(tests_zip: str, tag_name: str):
     print(f'Mounted {count} test files, installing dependencies...')
 
     await micropip.install(
-        ['dirty-equals', 'hypothesis', 'pytest-speed', 'pytest-mock', 'tzdata', 'inline-snapshot', pydantic_core_wheel]
+        [
+            'dirty-equals',
+            'hypothesis',
+            'pytest-speed',
+            'pytest-mock',
+            'tzdata',
+            'inline-snapshot<0.21',
+            pydantic_core_wheel,
+        ]
     )
     importlib.invalidate_caches()
 

From 22d34a73ec5e47c414e191f93e234a97855b38cc Mon Sep 17 00:00:00 2001
From: Victorien <65306057+Viicos@users.noreply.github.com>
Date: Sun, 25 May 2025 14:08:30 +0200
Subject: [PATCH 549/550] Coerce `'time'` schema constraints (#1720)

---
 src/input/mod.rs              |  2 +-
 src/validators/time.rs        | 19 ++++++++++++-------
 tests/validators/test_time.py |  9 +++++++++
 3 files changed, 22 insertions(+), 8 deletions(-)

diff --git a/src/input/mod.rs b/src/input/mod.rs
index 779454b3c..19be9fad1 100644
--- a/src/input/mod.rs
+++ b/src/input/mod.rs
@@ -13,7 +13,7 @@ mod shared;
 pub use datetime::TzInfo;
 pub(crate) use datetime::{
     duration_as_pytimedelta, pydate_as_date, pydatetime_as_datetime, pytime_as_time, EitherDate, EitherDateTime,
-    EitherTime, EitherTimedelta,
+    EitherTimedelta,
 };
 pub(crate) use input_abstract::{
     Arguments, BorrowInput, ConsumeIterator, Input, InputType, KeywordArgs, PositionalArgs, ValidatedDict,
diff --git a/src/validators/time.rs b/src/validators/time.rs
index eda4935a3..db98846b1 100644
--- a/src/validators/time.rs
+++ b/src/validators/time.rs
@@ -1,14 +1,14 @@
+use pyo3::exceptions::PyValueError;
 use pyo3::intern;
 use pyo3::prelude::*;
 use pyo3::types::{PyDict, PyString};
 
 use pyo3::IntoPyObjectExt;
-use speedate::Time;
+use speedate::{MicrosecondsPrecisionOverflowBehavior, Time};
 
 use crate::build_tools::is_strict;
 use crate::errors::{ErrorType, ValError, ValResult};
-use crate::input::{EitherTime, Input};
-use crate::tools::SchemaDict;
+use crate::input::Input;
 
 use super::datetime::extract_microseconds_precision;
 use super::datetime::TZConstraint;
@@ -18,7 +18,7 @@ use super::{BuildValidator, CombinedValidator, DefinitionsBuilder, ValidationSta
 pub struct TimeValidator {
     strict: bool,
     constraints: Option<TimeConstraints>,
-    microseconds_precision: speedate::MicrosecondsPrecisionOverflowBehavior,
+    microseconds_precision: MicrosecondsPrecisionOverflowBehavior,
 }
 
 impl BuildValidator for TimeValidator {
@@ -86,9 +86,14 @@ impl Validator for TimeValidator {
     }
 }
 
-fn convert_pytime(schema: &Bound<'_, PyDict>, field: &Bound<'_, PyString>) -> PyResult<Option<Time>> {
-    match schema.get_as(field)? {
-        Some(date) => Ok(Some(EitherTime::Py(date).as_raw()?)),
+fn convert_pytime(schema: &Bound<'_, PyDict>, key: &Bound<'_, PyString>) -> PyResult<Option<Time>> {
+    match schema.get_item(key)? {
+        Some(value) => match value.validate_time(false, MicrosecondsPrecisionOverflowBehavior::default()) {
+            Ok(v) => Ok(Some(v.into_inner().as_raw()?)),
+            Err(_) => Err(PyValueError::new_err(format!(
+                "'{key}' must be coercible to a time instance",
+            ))),
+        },
         None => Ok(None),
     }
 }
diff --git a/tests/validators/test_time.py b/tests/validators/test_time.py
index 069e359ad..c5f5e3c39 100644
--- a/tests/validators/test_time.py
+++ b/tests/validators/test_time.py
@@ -10,6 +10,15 @@
 from ..conftest import Err, PyAndJson
 
 
+@pytest.mark.parametrize(
+    'constraint',
+    ['le', 'lt', 'ge', 'gt'],
+)
+def test_constraints_schema_validation_error(constraint: str) -> None:
+    with pytest.raises(SchemaError, match=f"'{constraint}' must be coercible to a time instance"):
+        SchemaValidator(core_schema.time_schema(**{constraint: 'bad_value'}))
+
+
 @pytest.mark.parametrize(
     'input_value,expected',
     [

From 238c1c7453bca0fad1298c84efb69797f32ab8af Mon Sep 17 00:00:00 2001
From: David Hewitt <david.hewitt@pydantic.dev>
Date: Wed, 28 May 2025 17:33:27 +0100
Subject: [PATCH 550/550] drop serde-json `preserve_order` feature (#1724)

---
 Cargo.lock | 23 -----------------------
 Cargo.toml |  2 +-
 2 files changed, 1 insertion(+), 24 deletions(-)

diff --git a/Cargo.lock b/Cargo.lock
index db9b19775..0c17d18df 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -83,12 +83,6 @@ dependencies = [
  "syn",
 ]
 
-[[package]]
-name = "equivalent"
-version = "1.0.1"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
-
 [[package]]
 name = "form_urlencoded"
 version = "1.2.1"
@@ -115,12 +109,6 @@ dependencies = [
  "wasi",
 ]
 
-[[package]]
-name = "hashbrown"
-version = "0.14.5"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e5274423e17b7c9fc20b6e7e208532f9b19825d82dfd615708b70edd83df41f1"
-
 [[package]]
 name = "heck"
 version = "0.5.0"
@@ -272,16 +260,6 @@ dependencies = [
  "icu_properties",
 ]
 
-[[package]]
-name = "indexmap"
-version = "2.2.6"
-source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "168fb715dda47215e360912c096649d23d58bf392ac62f73919e831745e40f26"
-dependencies = [
- "equivalent",
- "hashbrown",
-]
-
 [[package]]
 name = "indoc"
 version = "2.0.5"
@@ -604,7 +582,6 @@ version = "1.0.140"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "20068b6e96dc6c9bd23e01df8827e6c7e1f2fddd43c21810382803c136b99373"
 dependencies = [
- "indexmap",
  "itoa",
  "memchr",
  "ryu",
diff --git a/Cargo.toml b/Cargo.toml
index 57cc42d6b..c8bc0cce6 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -33,7 +33,7 @@ pyo3 = { version = "0.24", features = ["generate-import-lib", "num-bigint", "py-
 regex = "1.11.1"
 strum = { version = "0.26.3", features = ["derive"] }
 strum_macros = "0.26.4"
-serde_json = {version = "1.0.140", features = ["arbitrary_precision", "preserve_order"]}
+serde_json = { version = "1.0.140", features = ["arbitrary_precision"] }
 enum_dispatch = "0.3.13"
 serde = { version = "1.0.219", features = ["derive"] }
 speedate = "0.15.0"