Merge remote-tracking branch 'origin/main' into publication

.rustfmt.toml

@@ -0,0 +1,7 @@
+edition = "2021"
+max_width = 100
+comment_width = 80
+wrap_comments = true
+imports_granularity = "Crate"
+use_small_heuristics = "Max"
+group_imports = "StdExternalCrate"

Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "vodozemac-python"
-version = "0.7.0"
+version = "0.8.1"
 edition = "2021"
 repository = "https://github.com/matrix-nio/vodozemac-python"
 homepage = "https://github.com/matrix-nio/vodozemac-python"
@@ -12,18 +12,14 @@ crate-type = ["cdylib"]
 
 [dependencies]
 paste = "1.0.15"
-thiserror = "1.0.63"
+thiserror = "2.0.3"
 [dependencies.vodozemac]
-git = "https://github.com/matrix-org/vodozemac.git"
-rev = "12f9036bf7f2536c172273602afcdc9aeddf8cf7"
+version = "0.8.1"
 features = ["insecure-pk-encryption"]
 
 [package.metadata.maturin]
 name = "vodozemac"
 
 [dependencies.pyo3]
-version = "0.22.2"
+version = "0.23.2"
 features = ["extension-module"]
-
-[features]
-gil-refs = []

src/account.rs

@@ -6,14 +6,13 @@ use pyo3::{
 };
 use vodozemac::olm::SessionConfig;
 
+use super::session::Session;
 use crate::{
     convert_to_pybytes,
     error::{LibolmPickleError, PickleError, SessionError},
     types::{Curve25519PublicKey, Ed25519PublicKey, Ed25519Signature, PreKeyMessage},
 };
 
-use super::session::Session;
-
 #[pyclass]
 pub struct Account {
     inner: vodozemac::olm::Account,
@@ -23,9 +22,7 @@ pub struct Account {
 impl Account {
     #[new]
     fn new() -> Self {
-        Self {
-            inner: vodozemac::olm::Account::new(),
-        }
+        Self { inner: vodozemac::olm::Account::new() }
     }
 
     #[classmethod]
@@ -34,9 +31,8 @@ impl Account {
         pickle: &str,
         pickle_key: &[u8],
     ) -> Result<Self, PickleError> {
-        let pickle_key: &[u8; 32] = pickle_key
-            .try_into()
-            .map_err(|_| PickleError::InvalidKeySize(pickle_key.len()))?;
+        let pickle_key: &[u8; 32] =
+            pickle_key.try_into().map_err(|_| PickleError::InvalidKeySize(pickle_key.len()))?;
 
         let pickle = vodozemac::olm::AccountPickle::from_encrypted(pickle, pickle_key)?;
 
@@ -57,9 +53,8 @@ impl Account {
     }
 
     fn pickle(&self, pickle_key: &[u8]) -> Result<String, PickleError> {
-        let pickle_key: &[u8; 32] = pickle_key
-            .try_into()
-            .map_err(|_| PickleError::InvalidKeySize(pickle_key.len()))?;
+        let pickle_key: &[u8; 32] =
+            pickle_key.try_into().map_err(|_| PickleError::InvalidKeySize(pickle_key.len()))?;
 
         Ok(self.inner.pickle().encrypt(pickle_key))
     }
@@ -80,11 +75,7 @@ impl Account {
 
     #[getter]
     fn one_time_keys(&self) -> HashMap<String, Curve25519PublicKey> {
-        self.inner
-            .one_time_keys()
-            .into_iter()
-            .map(|(k, v)| (k.to_base64(), v.into()))
-            .collect()
+        self.inner.one_time_keys().into_iter().map(|(k, v)| (k.to_base64(), v.into())).collect()
     }
 
     #[getter]
@@ -98,11 +89,7 @@ impl Account {
 
     #[getter]
     fn fallback_key(&self) -> HashMap<String, Curve25519PublicKey> {
-        self.inner
-            .fallback_key()
-            .into_iter()
-            .map(|(k, v)| (k.to_base64(), v.into()))
-            .collect()
+        self.inner.fallback_key().into_iter().map(|(k, v)| (k.to_base64(), v.into())).collect()
     }
 
     fn generate_fallback_key(&mut self) {
@@ -132,15 +119,8 @@ impl Account {
         identity_key: &Curve25519PublicKey,
         message: &PreKeyMessage,
     ) -> Result<(Session, Py<PyBytes>), SessionError> {
-        let result = self
-            .inner
-            .create_inbound_session(identity_key.inner, &message.inner)?;
-
-        Ok((
-            Session {
-                inner: result.session,
-            },
-            convert_to_pybytes(result.plaintext.as_slice()),
-        ))
+        let result = self.inner.create_inbound_session(identity_key.inner, &message.inner)?;
+
+        Ok((Session { inner: result.session }, convert_to_pybytes(result.plaintext.as_slice())))
     }
 }

src/error.rs

@@ -41,22 +41,10 @@ create_error!(vodozemac::megolm::SessionKeyDecodeError, SessionKeyDecode);
 create_error!(vodozemac::DecodeError, Decode);
 
 pyo3::create_exception!(module, PickleException, pyo3::exceptions::PyValueError);
-pyo3::create_exception!(
-    module,
-    SessionCreationException,
-    pyo3::exceptions::PyValueError
-);
+pyo3::create_exception!(module, SessionCreationException, pyo3::exceptions::PyValueError);
 pyo3::create_exception!(module, SasException, pyo3::exceptions::PyValueError);
-pyo3::create_exception!(
-    module,
-    OlmDecryptionException,
-    pyo3::exceptions::PyValueError
-);
-pyo3::create_exception!(
-    module,
-    MegolmDecryptionException,
-    pyo3::exceptions::PyValueError
-);
+pyo3::create_exception!(module, OlmDecryptionException, pyo3::exceptions::PyValueError);
+pyo3::create_exception!(module, MegolmDecryptionException, pyo3::exceptions::PyValueError);
 
 #[derive(Debug, Error)]
 pub enum MegolmDecryptionError {
@@ -140,8 +128,8 @@ impl From<PickleError> for PyErr {
     }
 }
 
-/// An error type describing failures which can happen during the use of `PkEncryption`
-/// and `PkDecryption` objects.
+/// An error type describing failures which can happen during the use of
+/// `PkEncryption` and `PkDecryption` objects.
 #[derive(Debug, Error)]
 pub enum PkEncryptionError {
     #[error("The key doesn't have the correct size, got {0}, expected 32 bytes")]
@@ -150,11 +138,7 @@ pub enum PkEncryptionError {
     Decode(#[from] vodozemac::pk_encryption::Error),
 }
 
-pyo3::create_exception!(
-    module,
-    PkInvalidKeySizeException,
-    pyo3::exceptions::PyValueError
-);
+pyo3::create_exception!(module, PkInvalidKeySizeException, pyo3::exceptions::PyValueError);
 pyo3::create_exception!(module, PkDecodeException, pyo3::exceptions::PyValueError);
 
 impl From<PkEncryptionError> for PyErr {