Bump deps: pyo3 0.22→0.28, bincode 1→2, lru, uuid, assert_cmd

Cargo.toml

@@ -22,7 +22,7 @@ sha2 = "0.10"
 tracing = { version = "0.1.37", optional = true }
 rand = "0.9.0"
 serde = { version = "1.0", features = ["derive"] }
-bincode = "1.3.3"
+bincode = { version = "2.0", features = ["serde"] }
 thiserror = "2.0"
 parking_lot = "0.12"
 twox-hash = "2.0"
@@ -32,15 +32,15 @@ schemars = "0.8"
 parquet = { version = "58.1.0", features = ["arrow"] }
 gix = { version = "0.81", features = ["blocking-network-client"], optional = true }
 clap = { version = "4.6", features = ["derive"], optional = true }
-lru = { version = "0.16", optional = true }
+lru = { version = "0.18", optional = true }
 hex = { version = "0.4", optional = true }
 chrono = { version = "0.4", features = ["serde"], optional = true }
 gluesql-core = { version = "0.19", optional = true }
 async-trait = { version = "0.1", optional = true }
-uuid = { version = "1.0", features = ["v4"], optional = true }
+uuid = { version = "1.23", features = ["v4"], optional = true }
 futures = { version = "0.3", optional = true }
 tokio = { version = "1.0", features = ["rt-multi-thread", "macros", "sync"], optional = true }
-pyo3 = { version = "0.22", features = ["extension-module", "abi3-py38"], optional = true }
+pyo3 = { version = "0.28", features = ["extension-module", "abi3-py38"], optional = true }
 rocksdb = { version = "0.22", optional = true }
 candle-core = { version = "0.10", optional = true }
 candle-nn = { version = "0.10", optional = true }
@@ -50,7 +50,7 @@ ureq = { version = "2.10", optional = true, default-features = false, features =
 dirs = { version = "5.0", optional = true }
 
 [dev-dependencies]
-assert_cmd = "2.0"
+assert_cmd = "2.2"
 bytes = "1.10.1"
 criterion = "0.5"
 predicates = "3.0"

src/git/operations.rs

@@ -600,9 +600,10 @@ impl<const N: usize> GitOperations<N> {
             .ok_or_else(|| GitKvError::GitObjectError("Root object is not a blob".to_string()))?;
 
         // Deserialize the prolly node
-        let root_node: ProllyNode<N> = bincode::deserialize(blob_ref.data).map_err(|e| {
-            GitKvError::GitObjectError(format!("Failed to deserialize root node: {e}"))
-        })?;
+        let root_node: ProllyNode<N> =
+            crate::serde_bincode::deserialize(blob_ref.data).map_err(|e| {
+                GitKvError::GitObjectError(format!("Failed to deserialize root node: {e}"))
+            })?;
 
         // Traverse the tree and collect all key-value pairs
         let mut result = HashMap::new();
@@ -652,7 +653,7 @@ impl<const N: usize> GitOperations<N> {
                         })?;
 
                     let child_node: ProllyNode<N> =
-                        bincode::deserialize(blob_ref.data).map_err(|e| {
+                        crate::serde_bincode::deserialize(blob_ref.data).map_err(|e| {
                             GitKvError::GitObjectError(format!(
                                 "Failed to deserialize child node: {e}"
                             ))

src/git/types.rs

@@ -26,8 +26,11 @@ pub enum GitKvError {
     #[error("Git object error: {0}")]
     GitObjectError(String),
 
-    #[error("Serialization error: {0}")]
-    SerializationError(#[from] bincode::Error),
+    #[error("Serialization encode error: {0}")]
+    SerializationEncodeError(#[from] bincode::error::EncodeError),
+
+    #[error("Serialization decode error: {0}")]
+    SerializationDecodeError(#[from] bincode::error::DecodeError),
 
     #[error("IO error: {0}")]
     IoError(#[from] std::io::Error),

src/git/versioned_store/core.rs

@@ -370,8 +370,8 @@ where
         let staging_file = self.get_staging_file_path()?;
 
         // Serialize the staging area
-        let serialized =
-            bincode::serialize(&self.staging_area).map_err(GitKvError::SerializationError)?;
+        let serialized = crate::serde_bincode::serialize(&self.staging_area)
+            .map_err(GitKvError::SerializationEncodeError)?;
 
         std::fs::write(staging_file, serialized).map_err(|e| {
             GitKvError::GitObjectError(format!("Failed to write staging area: {e}"))
@@ -389,8 +389,8 @@ where
                 GitKvError::GitObjectError(format!("Failed to read staging area: {e}"))
             })?;
 
-            self.staging_area =
-                bincode::deserialize(&data).map_err(GitKvError::SerializationError)?;
+            self.staging_area = crate::serde_bincode::deserialize(&data)
+                .map_err(GitKvError::SerializationDecodeError)?;
         }
 
         Ok(())

src/lib.rs

@@ -76,6 +76,7 @@ pub mod proximity;
 pub mod python;
 #[cfg(feature = "rocksdb_storage")]
 pub mod rocksdb;
+pub(crate) mod serde_bincode;
 #[cfg(feature = "sql")]
 pub mod sql;
 pub mod storage;

src/node.rs

@@ -1711,8 +1711,8 @@ mod tests {
         let mut node = ProllyNode::<32>::default();
         node.split = true;
         node.merged = true;
-        let bytes = bincode::serialize(&node).unwrap();
-        let de: ProllyNode<32> = bincode::deserialize(&bytes).unwrap();
+        let bytes = crate::serde_bincode::serialize(&node).unwrap();
+        let de: ProllyNode<32> = crate::serde_bincode::deserialize(&bytes).unwrap();
         assert!(
             !de.split && !de.merged,
             "Split/merged flags should not be serialized"

src/proximity/index.rs

@@ -162,7 +162,7 @@ pub struct PersistedProximityState<const N: usize> {
 pub fn deserialize_persisted_state<const N: usize>(
     bytes: &[u8],
 ) -> Result<PersistedProximityState<N>, ProximityError> {
-    let state: SavedProximityState<N> = bincode::deserialize(bytes)
+    let state: SavedProximityState<N> = crate::serde_bincode::deserialize(bytes)
         .map_err(|e| ProximityError::InvalidSavedState(e.to_string()))?;
     Ok(PersistedProximityState {
         config: state.config,
@@ -322,8 +322,8 @@ impl<const N: usize, S: NodeStorage<N>> ProximityIndex<N, S> {
             entries: self.entries.clone(),
             root: self.root.clone(),
         };
-        let bytes =
-            bincode::serialize(&state).map_err(|e| ProximityError::Serialize(e.to_string()))?;
+        let bytes = crate::serde_bincode::serialize(&state)
+            .map_err(|e| ProximityError::Serialize(e.to_string()))?;
         self.storage.save_config(&Self::state_key(name), &bytes);
         self.storage.sync()?;
         Ok(self.root.clone())
@@ -335,7 +335,7 @@ impl<const N: usize, S: NodeStorage<N>> ProximityIndex<N, S> {
         let bytes = storage
             .get_config(&Self::state_key(name))
             .ok_or_else(|| ProximityError::NotFound(name.to_string()))?;
-        let state: SavedProximityState<N> = bincode::deserialize(&bytes)
+        let state: SavedProximityState<N> = crate::serde_bincode::deserialize(&bytes)
             .map_err(|e| ProximityError::InvalidSavedState(e.to_string()))?;
         Ok(Self {
             entries: state.entries,

src/proximity/node.rs

@@ -91,7 +91,7 @@ impl<const N: usize> ProximityNode<N> {
     /// Content hash over the canonical bincode encoding of the node. The
     /// digest is what `NodeStorage` will index this node under in later PRs.
     pub fn get_hash(&self) -> ValueDigest<N> {
-        let bytes = bincode::serialize(self).expect("ProximityNode bincode serialize");
+        let bytes = crate::serde_bincode::serialize(self).expect("ProximityNode bincode serialize");
         ValueDigest::new(&bytes)
     }
 }
@@ -146,8 +146,8 @@ mod tests {
             2,
             1,
         );
-        let bytes = bincode::serialize(&original).unwrap();
-        let restored: ProximityNode<32> = bincode::deserialize(&bytes).unwrap();
+        let bytes = crate::serde_bincode::serialize(&original).unwrap();
+        let restored: ProximityNode<32> = crate::serde_bincode::deserialize(&bytes).unwrap();
         assert_eq!(original.level, restored.level);
         assert_eq!(original.ids, restored.ids);
         assert_eq!(original.vectors, restored.vectors);