add FromPyObject::Error

Author: Icxolu

guide/src/class.md

@@ -1397,6 +1397,7 @@ impl pyo3::PyClass for MyClass {
 impl<'a, 'holder, 'py> pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'holder, 'py, false> for &'holder MyClass
 {
     type Holder = ::std::option::Option<pyo3::PyClassGuard<'a, MyClass>>;
+    type Error = pyo3::PyErr;
     #[cfg(feature = "experimental-inspect")]
     const INPUT_TYPE: &'static str = "MyClass";
 
@@ -1409,6 +1410,7 @@ impl<'a, 'holder, 'py> pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'ho
 impl<'a, 'holder, 'py> pyo3::impl_::extract_argument::PyFunctionArgument<'a, 'holder, 'py, false> for &'holder mut MyClass
 {
     type Holder = ::std::option::Option<pyo3::PyClassGuardMut<'a, MyClass>>;
+    type Error = pyo3::PyErr;
     #[cfg(feature = "experimental-inspect")]
     const INPUT_TYPE: &'static str = "MyClass";
 

guide/src/migration.md

@@ -134,7 +134,9 @@ impl<'a, 'py, T> FromPyObject<'a, 'py> for MyWrapper<T>
 where
     T: FromPyObject<'a, 'py>
 {
-    fn extract(obj: Borrowed<'a, 'py, PyAny>) -> PyResult<Self> {
+    type Error = T::Error;
+
+    fn extract(obj: Borrowed<'a, 'py, PyAny>) -> Result<Self, Self::Error> {
         obj.extract().map(MyWrapper)
     }
 }
@@ -172,10 +174,12 @@ where
     T: FromPyObjectOwned<'py> // 👈 can only extract owned values, because each `item` below
                               //    is a temporary short lived owned reference
 {
-    fn extract(obj: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
+    type Error = PyErr;
+
+    fn extract(obj: Borrowed<'_, 'py, PyAny>) -> Result<Self, Self::Error> {
         let mut v = MyVec(Vec::new());
         for item in obj.try_iter()? {
-            v.0.push(item?.extract::<T>()?);
+            v.0.push(item?.extract::<T>().map_err(Into::into)?);
         }
         Ok(v)
     }

pyo3-macros-backend/src/frompyobject.rs

@@ -507,7 +507,8 @@ pub fn build_derive_from_pyobject(tokens: &DeriveInput) -> Result<TokenStream> {
     Ok(quote!(
         #[automatically_derived]
         impl #impl_generics #pyo3_path::FromPyObject<'_, #lt_param> for #ident #ty_generics #where_clause {
-            fn extract(obj: #pyo3_path::Borrowed<'_, #lt_param, #pyo3_path::PyAny>) -> #pyo3_path::PyResult<Self> {
+            type Error = #pyo3_path::PyErr;
+            fn extract(obj: #pyo3_path::Borrowed<'_, #lt_param, #pyo3_path::PyAny>) -> ::std::result::Result<Self, Self::Error> {
                 let obj: &#pyo3_path::Bound<'_, _> = &*obj;
                 #derives
             }

pyo3-macros-backend/src/pyclass.rs

@@ -2156,6 +2156,7 @@ impl<'a> PyClassImplsBuilder<'a> {
                 impl<'a, 'holder, 'py> #pyo3_path::impl_::extract_argument::PyFunctionArgument<'a, 'holder, 'py, false> for &'holder #cls
                 {
                     type Holder = ::std::option::Option<#pyo3_path::PyClassGuard<'a, #cls>>;
+                    type Error = #pyo3_path::PyErr;
 
                     #input_type
 
@@ -2170,6 +2171,7 @@ impl<'a> PyClassImplsBuilder<'a> {
                 impl<'a, 'holder, 'py> #pyo3_path::impl_::extract_argument::PyFunctionArgument<'a, 'holder, 'py, false> for &'holder #cls
                 {
                     type Holder = ::std::option::Option<#pyo3_path::PyClassGuard<'a, #cls>>;
+                    type Error = #pyo3_path::PyErr;
 
                     #input_type
 
@@ -2182,6 +2184,7 @@ impl<'a> PyClassImplsBuilder<'a> {
                 impl<'a, 'holder, 'py> #pyo3_path::impl_::extract_argument::PyFunctionArgument<'a, 'holder, 'py, false> for &'holder mut #cls
                 {
                     type Holder = ::std::option::Option<#pyo3_path::PyClassGuardMut<'a, #cls>>;
+                    type Error =#pyo3_path::PyErr;
 
                     #input_type
 

src/buffer.rs

@@ -19,7 +19,7 @@
 
 //! `PyBuffer` implementation
 use crate::{err, exceptions::PyBufferError, ffi, FromPyObject, PyAny, PyResult, Python};
-use crate::{Borrowed, Bound};
+use crate::{Borrowed, Bound, PyErr};
 use std::marker::PhantomData;
 use std::os::raw;
 use std::pin::Pin;
@@ -183,7 +183,9 @@ pub unsafe trait Element: Copy {
 }
 
 impl<T: Element> FromPyObject<'_, '_> for PyBuffer<T> {
-    fn extract(obj: Borrowed<'_, '_, PyAny>) -> PyResult<PyBuffer<T>> {
+    type Error = PyErr;
+
+    fn extract(obj: Borrowed<'_, '_, PyAny>) -> Result<PyBuffer<T>, Self::Error> {
         Self::get(&obj)
     }
 }

src/conversion.rs

@@ -290,6 +290,9 @@ impl<'py, T> IntoPyObjectExt<'py> for T where T: IntoPyObject<'py> {}
 /// [`Cow::Borrowed`]: std::borrow::Cow::Borrowed
 /// [`Cow::Owned`]: std::borrow::Cow::Owned
 pub trait FromPyObject<'a, 'py>: Sized {
+    /// The type returned in the event of a conversion error.
+    type Error: Into<PyErr>;
+
     /// Provides the type hint information for this type when it appears as an argument.
     ///
     /// For example, `Vec<u32>` would be `collections.abc.Sequence[int]`.
@@ -301,7 +304,7 @@ pub trait FromPyObject<'a, 'py>: Sized {
     ///
     /// Users are advised against calling this method directly: instead, use this via
     /// [`Bound<'_, PyAny>::extract`](crate::types::any::PyAnyMethods::extract) or [`Py::extract`].
-    fn extract(obj: Borrowed<'a, 'py, PyAny>) -> PyResult<Self>;
+    fn extract(obj: Borrowed<'a, 'py, PyAny>) -> Result<Self, Self::Error>;
 
     /// Extracts the type hint information for this type when it appears as an argument.
     ///
@@ -338,7 +341,9 @@ pub trait FromPyObject<'a, 'py>: Sized {
 /// where
 ///     T: FromPyObject<'a, 'py>
 /// {
-///     fn extract(obj: Borrowed<'a, 'py, PyAny>) -> PyResult<Self> {
+///     type Error = T::Error;
+///
+///     fn extract(obj: Borrowed<'a, 'py, PyAny>) -> Result<Self, Self::Error> {
 ///         obj.extract().map(MyWrapper)
 ///     }
 /// }
@@ -351,10 +356,12 @@ pub trait FromPyObject<'a, 'py>: Sized {
 ///     T: FromPyObjectOwned<'py> // 👈 can only extract owned values, because each `item` below
 ///                               //    is a temporary short lived owned reference
 /// {
-///     fn extract(obj: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
+///     type Error = PyErr;
+///
+///     fn extract(obj: Borrowed<'_, 'py, PyAny>) -> Result<Self, Self::Error> {
 ///         let mut v = MyVec(Vec::new());
 ///         for item in obj.try_iter()? {
-///             v.0.push(item?.extract::<T>()?);
+///             v.0.push(item?.extract::<T>().map_err(Into::into)?);
 ///         }
 ///         Ok(v)
 ///     }
@@ -370,7 +377,9 @@ impl<T> FromPyObject<'_, '_> for T
 where
     T: PyClass + Clone,
 {
-    fn extract(obj: Borrowed<'_, '_, PyAny>) -> PyResult<Self> {
+    type Error = PyErr;
+
+    fn extract(obj: Borrowed<'_, '_, PyAny>) -> Result<Self, Self::Error> {
         let bound = obj.cast::<Self>()?;
         Ok(bound.try_borrow()?.clone())
     }
@@ -380,7 +389,9 @@ impl<'py, T> FromPyObject<'_, 'py> for PyRef<'py, T>
 where
     T: PyClass,
 {
-    fn extract(obj: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
+    type Error = PyErr;
+
+    fn extract(obj: Borrowed<'_, 'py, PyAny>) -> Result<Self, Self::Error> {
         obj.cast::<T>()?.try_borrow().map_err(Into::into)
     }
 }
@@ -389,7 +400,9 @@ impl<'py, T> FromPyObject<'_, 'py> for PyRefMut<'py, T>
 where
     T: PyClass<Frozen = False>,
 {
-    fn extract(obj: Borrowed<'_, 'py, PyAny>) -> PyResult<Self> {
+    type Error = PyErr;
+
+    fn extract(obj: Borrowed<'_, 'py, PyAny>) -> Result<Self, Self::Error> {
         obj.cast::<T>()?.try_borrow_mut().map_err(Into::into)
     }
 }

src/conversions/bigdecimal.rs

@@ -72,6 +72,8 @@ fn get_invalid_operation_error_cls(py: Python<'_>) -> PyResult<&Bound<'_, PyType
 }
 
 impl FromPyObject<'_, '_> for BigDecimal {
+    type Error = PyErr;
+
     fn extract(obj: Borrowed<'_, '_, PyAny>) -> PyResult<Self> {
         let py_str = &obj.str()?;
         let rs_str = &py_str.to_cow()?;

src/conversions/bytes.rs

@@ -66,10 +66,12 @@ use crate::conversion::IntoPyObject;
 use crate::instance::Bound;
 use crate::pybacked::PyBackedBytes;
 use crate::types::PyBytes;
-use crate::{Borrowed, FromPyObject, PyAny, PyErr, PyResult, Python};
+use crate::{Borrowed, DowncastError, FromPyObject, PyAny, PyErr, Python};
 
-impl FromPyObject<'_, '_> for Bytes {
-    fn extract(obj: Borrowed<'_, '_, PyAny>) -> PyResult<Self> {
+impl<'a, 'py> FromPyObject<'a, 'py> for Bytes {
+    type Error = DowncastError<'a, 'py>;
+
+    fn extract(obj: Borrowed<'a, 'py, PyAny>) -> Result<Self, Self::Error> {
         Ok(Bytes::from_owner(obj.extract::<PyBackedBytes>()?))
     }
 }

src/conversions/chrono.rs

@@ -109,7 +109,9 @@ impl<'py> IntoPyObject<'py> for &Duration {
 }
 
 impl FromPyObject<'_, '_> for Duration {
-    fn extract(ob: Borrowed<'_, '_, PyAny>) -> PyResult<Duration> {
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, '_, PyAny>) -> Result<Self, Self::Error> {
         let delta = ob.cast::<PyDelta>()?;
         // Python size are much lower than rust size so we do not need bound checks.
         // 0 <= microseconds < 1000000
@@ -163,7 +165,9 @@ impl<'py> IntoPyObject<'py> for &NaiveDate {
 }
 
 impl FromPyObject<'_, '_> for NaiveDate {
-    fn extract(ob: Borrowed<'_, '_, PyAny>) -> PyResult<NaiveDate> {
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, '_, PyAny>) -> Result<Self, Self::Error> {
         let date = &*ob.cast::<PyDate>()?;
         py_date_to_naive_date(date)
     }
@@ -205,7 +209,9 @@ impl<'py> IntoPyObject<'py> for &NaiveTime {
 }
 
 impl FromPyObject<'_, '_> for NaiveTime {
-    fn extract(ob: Borrowed<'_, '_, PyAny>) -> PyResult<NaiveTime> {
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, '_, PyAny>) -> Result<Self, Self::Error> {
         let time = &*ob.cast::<PyTime>()?;
         py_time_to_naive_time(time)
     }
@@ -248,7 +254,9 @@ impl<'py> IntoPyObject<'py> for &NaiveDateTime {
 }
 
 impl FromPyObject<'_, '_> for NaiveDateTime {
-    fn extract(dt: Borrowed<'_, '_, PyAny>) -> PyResult<NaiveDateTime> {
+    type Error = PyErr;
+
+    fn extract(dt: Borrowed<'_, '_, PyAny>) -> Result<Self, Self::Error> {
         let dt = &*dt.cast::<PyDateTime>()?;
 
         // If the user tries to convert a timezone aware datetime into a naive one,
@@ -328,12 +336,14 @@ impl<'py, Tz> FromPyObject<'_, 'py> for DateTime<Tz>
 where
     Tz: TimeZone + FromPyObjectOwned<'py>,
 {
-    fn extract(dt: Borrowed<'_, 'py, PyAny>) -> PyResult<DateTime<Tz>> {
+    type Error = PyErr;
+
+    fn extract(dt: Borrowed<'_, 'py, PyAny>) -> Result<Self, Self::Error> {
         let dt = &*dt.cast::<PyDateTime>()?;
         let tzinfo = dt.get_tzinfo();
 
         let tz = if let Some(tzinfo) = tzinfo {
-            tzinfo.extract()?
+            tzinfo.extract().map_err(Into::into)?
         } else {
             return Err(PyTypeError::new_err(
                 "expected a datetime with non-None tzinfo",
@@ -386,11 +396,13 @@ impl<'py> IntoPyObject<'py> for &FixedOffset {
 }
 
 impl FromPyObject<'_, '_> for FixedOffset {
+    type Error = PyErr;
+
     /// Convert python tzinfo to rust [`FixedOffset`].
     ///
     /// Note that the conversion will result in precision lost in microseconds as chrono offset
     /// does not supports microseconds.
-    fn extract(ob: Borrowed<'_, '_, PyAny>) -> PyResult<FixedOffset> {
+    fn extract(ob: Borrowed<'_, '_, PyAny>) -> Result<Self, Self::Error> {
         let ob = ob.cast::<PyTzInfo>()?;
 
         // Passing Python's None to the `utcoffset` function will only
@@ -435,7 +447,9 @@ impl<'py> IntoPyObject<'py> for &Utc {
 }
 
 impl FromPyObject<'_, '_> for Utc {
-    fn extract(ob: Borrowed<'_, '_, PyAny>) -> PyResult<Utc> {
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, '_, PyAny>) -> Result<Self, Self::Error> {
         let py_utc = PyTzInfo::utc(ob.py())?;
         if ob.eq(py_utc)? {
             Ok(Utc)
@@ -479,6 +493,8 @@ impl<'py> IntoPyObject<'py> for &Local {
 
 #[cfg(feature = "chrono-local")]
 impl FromPyObject<'_, '_> for Local {
+    type Error = PyErr;
+
     fn extract(ob: Borrowed<'_, '_, PyAny>) -> PyResult<Local> {
         let local_tz = Local.into_pyobject(ob.py())?;
         if ob.eq(local_tz)? {

src/conversions/chrono_tz.rs

@@ -38,7 +38,7 @@ use crate::conversion::IntoPyObject;
 use crate::exceptions::PyValueError;
 use crate::pybacked::PyBackedStr;
 use crate::types::{any::PyAnyMethods, PyTzInfo};
-use crate::{intern, Borrowed, Bound, FromPyObject, PyAny, PyErr, PyResult, Python};
+use crate::{intern, Borrowed, Bound, FromPyObject, PyAny, PyErr, Python};
 use chrono_tz::Tz;
 use std::str::FromStr;
 
@@ -64,7 +64,9 @@ impl<'py> IntoPyObject<'py> for &Tz {
 }
 
 impl FromPyObject<'_, '_> for Tz {
-    fn extract(ob: Borrowed<'_, '_, PyAny>) -> PyResult<Tz> {
+    type Error = PyErr;
+
+    fn extract(ob: Borrowed<'_, '_, PyAny>) -> Result<Self, Self::Error> {
         Tz::from_str(
             &ob.getattr(intern!(ob.py(), "key"))?
                 .extract::<PyBackedStr>()?,