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] 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
                 };