Upgrade to pyo3 0.27 (#13708)

* Upgrade to pyo3 0.27

* 0.27.1

* fix for pypy

Author: alex

Cargo.lock

@@ -30,8 +30,8 @@ foreign-types-shared = "0.1"
 openssl = "0.10.74"
 openssl-sys = "0.9.108"
 pem = { version = "3", default-features = false }
-pyo3 = { version = "0.26", features = ["abi3"] }
-pyo3-build-config = { version = "0.26" }
+pyo3 = { version = "0.27.1", features = ["abi3"] }
+pyo3-build-config = { version = "0.27.1" }
 self_cell = "1"
 
 [profile.release]

Cargo.toml

@@ -14,7 +14,7 @@ pub(crate) fn py_oid_to_oid(
     py_oid: pyo3::Bound<'_, pyo3::PyAny>,
 ) -> pyo3::PyResult<asn1::ObjectIdentifier> {
     Ok(py_oid
-        .downcast::<crate::oid::ObjectIdentifier>()?
+        .cast::<crate::oid::ObjectIdentifier>()?
         .get()
         .oid
         .clone())
@@ -85,8 +85,8 @@ pub(crate) fn py_uint_to_big_endian_bytes<'p>(
         .extract::<usize>()?
         / 8
         + 1;
-    v.call_method1(pyo3::intern!(py, "to_bytes"), (n, "big"))?
-        .extract()
+    Ok(v.call_method1(pyo3::intern!(py, "to_bytes"), (n, "big"))?
+        .extract()?)
 }
 
 pub(crate) fn encode_der_data<'p>(

src/rust/src/asn1.rs

@@ -592,18 +592,18 @@ fn cipher_supported(
 
 #[pyo3::pyfunction]
 fn _advance(ctx: pyo3::Bound<'_, pyo3::PyAny>, n: u64) {
-    if let Ok(c) = ctx.downcast::<PyAEADEncryptionContext>() {
+    if let Ok(c) = ctx.cast::<PyAEADEncryptionContext>() {
         c.borrow_mut().bytes_remaining -= n;
-    } else if let Ok(c) = ctx.downcast::<PyAEADDecryptionContext>() {
+    } else if let Ok(c) = ctx.cast::<PyAEADDecryptionContext>() {
         c.borrow_mut().bytes_remaining -= n;
     }
 }
 
 #[pyo3::pyfunction]
 fn _advance_aad(ctx: pyo3::Bound<'_, pyo3::PyAny>, n: u64) {
-    if let Ok(c) = ctx.downcast::<PyAEADEncryptionContext>() {
+    if let Ok(c) = ctx.cast::<PyAEADEncryptionContext>() {
         c.borrow_mut().aad_bytes_remaining -= n;
-    } else if let Ok(c) = ctx.downcast::<PyAEADDecryptionContext>() {
+    } else if let Ok(c) = ctx.cast::<PyAEADDecryptionContext>() {
         c.borrow_mut().aad_bytes_remaining -= n;
     }
 }

src/rust/src/backend/ciphers.rs

@@ -184,7 +184,9 @@ impl DHPrivateKey {
 
         let parameter_numbers = DHParameterNumbers {
             p: py_p.extract()?,
-            q: py_q.map(|q| q.extract()).transpose()?,
+            q: py_q
+                .map(|q| q.extract().map_err(CryptographyError::from))
+                .transpose()?,
             g: py_g.extract()?,
         };
         let public_numbers = DHPublicNumbers {
@@ -291,7 +293,9 @@ impl DHPublicKey {
 
         let parameter_numbers = DHParameterNumbers {
             p: py_p.extract()?,
-            q: py_q.map(|q| q.extract()).transpose()?,
+            q: py_q
+                .map(|q| q.extract().map_err(CryptographyError::from))
+                .transpose()?,
             g: py_g.extract()?,
         };
 
@@ -331,7 +335,9 @@ impl DHParameters {
 
         Ok(DHParameterNumbers {
             p: py_p.extract()?,
-            q: py_q.map(|q| q.extract()).transpose()?,
+            q: py_q
+                .map(|q| q.extract().map_err(CryptographyError::from))
+                .transpose()?,
             g: py_g.extract()?,
         })
     }

src/rust/src/backend/dh.rs

@@ -10,7 +10,9 @@ use pyo3::types::PyAnyMethods;
 use crate::types;
 
 // Common error message generation
-fn generate_non_convertible_buffer_error_msg(pyobj: &pyo3::Bound<'_, pyo3::PyAny>) -> String {
+fn generate_non_convertible_buffer_error_msg(
+    pyobj: &pyo3::Borrowed<'_, '_, pyo3::PyAny>,
+) -> String {
     if pyobj.is_instance_of::<pyo3::types::PyString>() {
         format!(
             "Cannot convert \"{}\" instance to a buffer.\nDid you mean to pass a bytestring instead?",
@@ -26,7 +28,7 @@ fn generate_non_convertible_buffer_error_msg(pyobj: &pyo3::Bound<'_, pyo3::PyAny
 
 #[cfg(Py_3_11)]
 fn _extract_buffer_length(
-    pyobj: &pyo3::Bound<'_, pyo3::PyAny>,
+    pyobj: &pyo3::Borrowed<'_, '_, pyo3::PyAny>,
     mutable: bool,
 ) -> pyo3::PyResult<(Option<pyo3::buffer::PyBuffer<u8>>, usize, usize)> {
     let buf = pyo3::buffer::PyBuffer::<u8>::get(pyobj).map_err(|_| {
@@ -45,7 +47,7 @@ fn _extract_buffer_length(
 
 #[cfg(not(Py_3_11))]
 fn _extract_buffer_length<'p>(
-    pyobj: &pyo3::Bound<'p, pyo3::PyAny>,
+    pyobj: &pyo3::Borrowed<'_, 'p, pyo3::PyAny>,
     mutable: bool,
 ) -> pyo3::PyResult<(pyo3::Bound<'p, pyo3::PyAny>, usize, usize)> {
     let py = pyobj.py();
@@ -101,9 +103,11 @@ impl<'a> CffiBuf<'a> {
     }
 }
 
-impl<'a> pyo3::conversion::FromPyObject<'a> for CffiBuf<'a> {
-    fn extract_bound(pyobj: &pyo3::Bound<'a, pyo3::PyAny>) -> pyo3::PyResult<Self> {
-        let (bufobj, ptrval, len) = _extract_buffer_length(pyobj, false)?;
+impl<'p> pyo3::conversion::FromPyObject<'_, 'p> for CffiBuf<'p> {
+    type Error = pyo3::PyErr;
+
+    fn extract(pyobj: pyo3::Borrowed<'_, 'p, pyo3::PyAny>) -> pyo3::PyResult<Self> {
+        let (bufobj, ptrval, len) = _extract_buffer_length(&pyobj, false)?;
         let buf = if len == 0 {
             &[]
         } else {
@@ -118,7 +122,7 @@ impl<'a> pyo3::conversion::FromPyObject<'a> for CffiBuf<'a> {
             unsafe { slice::from_raw_parts(ptrval as *const u8, len) }
         };
         Ok(CffiBuf {
-            pyobj: pyobj.clone(),
+            pyobj: pyobj.to_owned(),
             _bufobj: bufobj,
             buf,
         })
@@ -140,9 +144,11 @@ impl CffiMutBuf<'_> {
     }
 }
 
-impl<'a> pyo3::conversion::FromPyObject<'a> for CffiMutBuf<'a> {
-    fn extract_bound(pyobj: &pyo3::Bound<'a, pyo3::PyAny>) -> pyo3::PyResult<Self> {
-        let (bufobj, ptrval, len) = _extract_buffer_length(pyobj, true)?;
+impl<'p> pyo3::conversion::FromPyObject<'_, 'p> for CffiMutBuf<'p> {
+    type Error = pyo3::PyErr;
+
+    fn extract(pyobj: pyo3::Borrowed<'_, 'p, pyo3::PyAny>) -> pyo3::PyResult<Self> {
+        let (bufobj, ptrval, len) = _extract_buffer_length(&pyobj, true)?;
         let buf = if len == 0 {
             &mut []
         } else {
@@ -157,7 +163,7 @@ impl<'a> pyo3::conversion::FromPyObject<'a> for CffiMutBuf<'a> {
             unsafe { slice::from_raw_parts_mut(ptrval as *mut u8, len) }
         };
         Ok(CffiMutBuf {
-            _pyobj: pyobj.clone(),
+            _pyobj: pyobj.to_owned(),
             _bufobj: bufobj,
             buf,
         })

src/rust/src/buf.rs

@@ -27,7 +27,7 @@ fn decode_pyint<'a>(
 ) -> ParseResult<pyo3::Bound<'a, pyo3::types::PyInt>> {
     let value = parser.read_element::<asn1::BigInt<'a>>()?;
     let pyint =
-        big_byte_slice_to_py_int(py, value.as_bytes())?.downcast_into::<pyo3::types::PyInt>()?;
+        big_byte_slice_to_py_int(py, value.as_bytes())?.cast_into::<pyo3::types::PyInt>()?;
     Ok(pyint)
 }
 
@@ -64,7 +64,7 @@ fn decode_utc_time<'a>(
     let dt = value.as_datetime();
 
     let inner = crate::x509::datetime_to_py_utc(py, dt)?
-        .downcast_into::<pyo3::types::PyDateTime>()?
+        .cast_into::<pyo3::types::PyDateTime>()?
         .unbind();
 
     Ok(pyo3::Bound::new(py, UtcTime { inner })?)
@@ -90,7 +90,7 @@ fn decode_generalized_time<'a>(
     };
 
     let inner = crate::x509::datetime_to_py_utc_with_microseconds(py, dt, microseconds)?
-        .downcast_into::<pyo3::types::PyDateTime>()?
+        .cast_into::<pyo3::types::PyDateTime>()?
         .unbind();
 
     Ok(pyo3::Bound::new(py, GeneralizedTime { inner })?)
@@ -121,7 +121,7 @@ pub(crate) fn decode_annotated_type<'a>(
                 let kwargs = pyo3::types::PyDict::new(py);
                 let fields = fields.bind(py);
                 for (name, ann_type) in fields.into_iter() {
-                    let ann_type = ann_type.downcast::<AnnotatedType>()?;
+                    let ann_type = ann_type.cast::<AnnotatedType>()?;
                     let value = decode_annotated_type(py, d, ann_type.get())?;
                     kwargs.set_item(name, value)?;
                 }

src/rust/src/declarative_asn1/decode.rs

@@ -44,10 +44,10 @@ impl asn1::Asn1Writable for AnnotatedTypeObject<'_> {
                 &asn1::SequenceWriter::new(&|w| {
                     for (name, ann_type) in fields.bind(py).into_iter() {
                         let name = name
-                            .downcast::<pyo3::types::PyString>()
+                            .cast::<pyo3::types::PyString>()
                             .map_err(|_| asn1::WriteError::AllocationError)?;
                         let ann_type = ann_type
-                            .downcast::<AnnotatedType>()
+                            .cast::<AnnotatedType>()
                             .map_err(|_| asn1::WriteError::AllocationError)?;
                         let object = AnnotatedTypeObject {
                             annotated_type: ann_type.get(),
@@ -100,7 +100,7 @@ impl asn1::Asn1Writable for AnnotatedTypeObject<'_> {
             }
             Type::PrintableString() => {
                 let val: &pyo3::Bound<'_, PrintableString> = value
-                    .downcast()
+                    .cast()
                     .map_err(|_| asn1::WriteError::AllocationError)?;
                 let inner_str = val
                     .get()
@@ -114,7 +114,7 @@ impl asn1::Asn1Writable for AnnotatedTypeObject<'_> {
             }
             Type::UtcTime() => {
                 let val: &pyo3::Bound<'_, UtcTime> = value
-                    .downcast()
+                    .cast()
                     .map_err(|_| asn1::WriteError::AllocationError)?;
                 let py_datetime = val.get().inner.clone_ref(py).into_bound(py);
                 let datetime = crate::x509::py_to_datetime(py, py_datetime)
@@ -125,7 +125,7 @@ impl asn1::Asn1Writable for AnnotatedTypeObject<'_> {
             }
             Type::GeneralizedTime() => {
                 let val: &pyo3::Bound<'_, GeneralizedTime> = value
-                    .downcast()
+                    .cast()
                     .map_err(|_| asn1::WriteError::AllocationError)?;
                 let py_datetime = val.get().inner.clone_ref(py).into_bound(py);
                 let (datetime, microseconds) =

src/rust/src/declarative_asn1/encode.rs

@@ -259,7 +259,7 @@ pub(crate) fn python_class_to_annotated<'p>(
 ) -> pyo3::PyResult<pyo3::Bound<'p, AnnotatedType>> {
     if let Ok(root) = class.getattr("__asn1_root__") {
         // Handle decorated classes
-        Ok(root.downcast_into::<AnnotatedType>()?)
+        Ok(root.cast_into::<AnnotatedType>()?)
     } else {
         // Handle builtin types
         pyo3::Bound::new(py, non_root_type_to_annotated(py, class)?)

src/rust/src/declarative_asn1/types.rs

@@ -36,14 +36,14 @@ impl From<pyo3::PyErr> for CryptographyError {
     }
 }
 
-impl From<pyo3::DowncastError<'_, '_>> for CryptographyError {
-    fn from(e: pyo3::DowncastError<'_, '_>) -> CryptographyError {
+impl From<pyo3::CastError<'_, '_>> for CryptographyError {
+    fn from(e: pyo3::CastError<'_, '_>) -> CryptographyError {
         CryptographyError::Py(e.into())
     }
 }
 
-impl From<pyo3::DowncastIntoError<'_>> for CryptographyError {
-    fn from(e: pyo3::DowncastIntoError<'_>) -> CryptographyError {
+impl From<pyo3::CastIntoError<'_>> for CryptographyError {
+    fn from(e: pyo3::CastIntoError<'_>) -> CryptographyError {
         CryptographyError::Py(e.into())
     }
 }
@@ -305,6 +305,8 @@ pub(crate) fn capture_error_stack(
 
 #[cfg(test)]
 mod tests {
+    use pyo3::PyTypeInfo;
+
     use super::CryptographyError;
 
     #[test]
@@ -329,7 +331,11 @@ mod tests {
             let py_e: pyo3::PyErr = e.into();
             assert!(py_e.is_instance_of::<pyo3::exceptions::PyMemoryError>(py));
 
-            let e: CryptographyError = pyo3::DowncastError::new(py.None().bind(py), "abc").into();
+            let e: CryptographyError = pyo3::CastError::new(
+                py.None().bind(py).as_borrowed(),
+                pyo3::types::PyString::type_object(py).into_any(),
+            )
+            .into();
             assert!(matches!(e, CryptographyError::Py(_)));
 
             let e = cryptography_key_parsing::KeyParsingError::OpenSSL(
@@ -338,7 +344,11 @@ mod tests {
             .into();
             assert!(matches!(e, CryptographyError::OpenSSL(_)));
 
-            let e = pyo3::DowncastIntoError::new(py.None().into_bound(py), "abc").into();
+            let e = pyo3::CastIntoError::new(
+                py.None().into_bound(py),
+                pyo3::types::PyString::type_object(py).into_any(),
+            )
+            .into();
             assert!(matches!(e, CryptographyError::Py(_)));
         })
     }