Upgrade to pyo3 0.26, fixing all warnings (pyca#13366)

* Upgrade to pyo3 0.26, fixing all warnings

* GHA

Author: alex

Cargo.lock

@@ -22,8 +22,8 @@ license = "Apache-2.0 OR BSD-3-Clause"
 
 [workspace.dependencies]
 asn1 = { version = "0.22.0", default-features = false }
-pyo3 = { version = "0.25", features = ["abi3"] }
-pyo3-build-config = { version = "0.25" }
+pyo3 = { version = "0.26", features = ["abi3"] }
+pyo3-build-config = { version = "0.26" }
 openssl = "0.10.73"
 openssl-sys = "0.9.108"
 

Cargo.toml

@@ -11,8 +11,8 @@ use crate::error::CryptographyResult;
 use crate::types;
 
 struct RegistryKey {
-    algorithm: pyo3::PyObject,
-    mode: pyo3::PyObject,
+    algorithm: pyo3::Py<pyo3::PyAny>,
+    mode: pyo3::Py<pyo3::PyAny>,
     key_size: Option<u16>,
 
     algorithm_hash: isize,
@@ -22,8 +22,8 @@ struct RegistryKey {
 impl RegistryKey {
     fn new(
         py: pyo3::Python<'_>,
-        algorithm: pyo3::PyObject,
-        mode: pyo3::PyObject,
+        algorithm: pyo3::Py<pyo3::PyAny>,
+        mode: pyo3::Py<pyo3::PyAny>,
         key_size: Option<u16>,
     ) -> CryptographyResult<Self> {
         Ok(Self {
@@ -113,8 +113,8 @@ impl<'p> RegistryBuilder<'p> {
 fn get_cipher_registry(
     py: pyo3::Python<'_>,
 ) -> CryptographyResult<&HashMap<RegistryKey, RegistryCipher>> {
-    static REGISTRY: pyo3::sync::GILOnceCell<HashMap<RegistryKey, RegistryCipher>> =
-        pyo3::sync::GILOnceCell::new();
+    static REGISTRY: pyo3::sync::PyOnceLock<HashMap<RegistryKey, RegistryCipher>> =
+        pyo3::sync::PyOnceLock::new();
 
     REGISTRY.get_or_try_init(py, || {
         let mut m = RegistryBuilder::new(py);

src/rust/src/backend/cipher_registry.rs

@@ -12,8 +12,8 @@ use crate::{exceptions, types};
 
 pub(crate) struct CipherContext {
     ctx: openssl::cipher_ctx::CipherCtx,
-    py_mode: pyo3::PyObject,
-    py_algorithm: pyo3::PyObject,
+    py_mode: pyo3::Py<pyo3::PyAny>,
+    py_algorithm: pyo3::Py<pyo3::PyAny>,
     side: openssl::symm::Mode,
 }
 

src/rust/src/backend/ciphers.rs

@@ -377,9 +377,9 @@ mod tests {
     #[test]
     #[cfg(not(any(CRYPTOGRAPHY_IS_BORINGSSL, CRYPTOGRAPHY_IS_AWSLC)))]
     fn test_public_key_from_pkey_unknown_key() {
-        pyo3::prepare_freethreaded_python();
+        pyo3::Python::initialize();
 
-        pyo3::Python::with_gil(|py| {
+        pyo3::Python::attach(|py| {
             let pkey =
                 openssl::pkey::PKey::public_key_from_raw_bytes(&[0; 32], openssl::pkey::Id::X25519)
                     .unwrap();
@@ -392,9 +392,9 @@ mod tests {
     #[test]
     #[cfg(not(any(CRYPTOGRAPHY_IS_BORINGSSL, CRYPTOGRAPHY_IS_AWSLC)))]
     fn test_private_key_from_pkey_unknown_key() {
-        pyo3::prepare_freethreaded_python();
+        pyo3::Python::initialize();
 
-        pyo3::Python::with_gil(|py| {
+        pyo3::Python::attach(|py| {
             let pkey = openssl::pkey::PKey::hmac(&[0; 32]).unwrap();
             assert!(private_key_from_pkey(py, &pkey, false).is_err());
         });

src/rust/src/backend/keys.rs

@@ -158,7 +158,7 @@ impl From<CryptographyError> for pyo3::PyErr {
                 pyo3::exceptions::PyMemoryError::new_err(e.to_string())
             }
             CryptographyError::Py(py_error) => py_error,
-            CryptographyError::OpenSSL(ref error_stack) => pyo3::Python::with_gil(|py| {
+            CryptographyError::OpenSSL(ref error_stack) => pyo3::Python::attach(|py| {
                 let errors = list_from_openssl_error(py, error_stack);
                 exceptions::InternalError::new_err((e.to_string(), errors.unbind()))
             }),
@@ -238,8 +238,8 @@ mod tests {
 
     #[test]
     fn test_cryptographyerror_display() {
-        pyo3::prepare_freethreaded_python();
-        pyo3::Python::with_gil(|py| {
+        pyo3::Python::initialize();
+        pyo3::Python::attach(|py| {
             let py_error = pyo3::exceptions::PyRuntimeError::new_err("abc");
             let e: CryptographyError = py_error.clone_ref(py).into();
             assert!(e.to_string() == py_error.to_string());
@@ -248,8 +248,8 @@ mod tests {
 
     #[test]
     fn test_cryptographyerror_from() {
-        pyo3::prepare_freethreaded_python();
-        pyo3::Python::with_gil(|py| {
+        pyo3::Python::initialize();
+        pyo3::Python::attach(|py| {
             let e: CryptographyError = asn1::WriteError::AllocationError.into();
             assert!(matches!(
                 e,

src/rust/src/error.rs

@@ -39,7 +39,10 @@ impl ObjectIdentifier {
             .call_method1(pyo3::intern!(py, "get"), (slf, "Unknown OID"))
     }
 
-    fn __deepcopy__(slf: pyo3::PyRef<'_, Self>, _memo: pyo3::PyObject) -> pyo3::PyRef<'_, Self> {
+    fn __deepcopy__(
+        slf: pyo3::PyRef<'_, Self>,
+        _memo: pyo3::Py<pyo3::PyAny>,
+    ) -> pyo3::PyRef<'_, Self> {
         slf
     }
 

src/rust/src/oid.rs

@@ -7,15 +7,15 @@ use pyo3::types::PyAnyMethods;
 pub struct LazyPyImport {
     module: &'static str,
     names: &'static [&'static str],
-    value: pyo3::sync::GILOnceCell<pyo3::PyObject>,
+    value: pyo3::sync::PyOnceLock<pyo3::Py<pyo3::PyAny>>,
 }
 
 impl LazyPyImport {
     pub const fn new(module: &'static str, names: &'static [&'static str]) -> LazyPyImport {
         LazyPyImport {
             module,
             names,
-            value: pyo3::sync::GILOnceCell::new(),
+            value: pyo3::sync::PyOnceLock::new(),
         }
     }
 
@@ -608,10 +608,10 @@ mod tests {
 
     #[test]
     fn test_basic() {
-        pyo3::prepare_freethreaded_python();
+        pyo3::Python::initialize();
 
         let v = LazyPyImport::new("foo", &["bar"]);
-        pyo3::Python::with_gil(|py| {
+        pyo3::Python::attach(|py| {
             assert!(v.get(py).is_err());
         });
     }

src/rust/src/types.rs

@@ -41,7 +41,7 @@ self_cell::self_cell!(
 #[pyo3::pyclass(frozen, module = "cryptography.hazmat.bindings._rust.x509")]
 pub(crate) struct Certificate {
     pub(crate) raw: OwnedCertificate,
-    pub(crate) cached_extensions: pyo3::sync::GILOnceCell<pyo3::PyObject>,
+    pub(crate) cached_extensions: pyo3::sync::PyOnceLock<pyo3::Py<pyo3::PyAny>>,
 }
 
 #[pyo3::pymethods]
@@ -62,7 +62,10 @@ impl Certificate {
         Ok(format!("<Certificate(subject={subject_repr}, ...)>"))
     }
 
-    fn __deepcopy__(slf: pyo3::PyRef<'_, Self>, _memo: pyo3::PyObject) -> pyo3::PyRef<'_, Self> {
+    fn __deepcopy__(
+        slf: pyo3::PyRef<'_, Self>,
+        _memo: pyo3::Py<pyo3::PyAny>,
+    ) -> pyo3::PyRef<'_, Self> {
         slf
     }
 
@@ -292,7 +295,7 @@ impl Certificate {
     }
 
     #[getter]
-    fn extensions(&self, py: pyo3::Python<'_>) -> pyo3::PyResult<pyo3::PyObject> {
+    fn extensions(&self, py: pyo3::Python<'_>) -> pyo3::PyResult<pyo3::Py<pyo3::PyAny>> {
         x509::parse_and_cache_extensions(
             py,
             &self.cached_extensions,
@@ -432,7 +435,7 @@ pub(crate) fn load_der_x509_certificate(
 
     Ok(Certificate {
         raw,
-        cached_extensions: pyo3::sync::GILOnceCell::new(),
+        cached_extensions: pyo3::sync::PyOnceLock::new(),
     })
 }
 

src/rust/src/x509/certificate.rs

@@ -382,10 +382,10 @@ pub(crate) fn parse_and_cache_extensions<
     F: Fn(&Extension<'p>) -> Result<Option<pyo3::Bound<'p, pyo3::PyAny>>, CryptographyError>,
 >(
     py: pyo3::Python<'p>,
-    cached_extensions: &pyo3::sync::GILOnceCell<pyo3::PyObject>,
+    cached_extensions: &pyo3::sync::PyOnceLock<pyo3::Py<pyo3::PyAny>>,
     raw_extensions: &Option<RawExtensions<'p>>,
     parse_ext: F,
-) -> pyo3::PyResult<pyo3::PyObject> {
+) -> pyo3::PyResult<pyo3::Py<pyo3::PyAny>> {
     cached_extensions
         .get_or_try_init(py, || {
             let extensions = match Extensions::from_raw_extensions(raw_extensions.as_ref()) {