wavelet-matrix 2.2.4__tar.gz → 2.2.5__tar.gz

{wavelet_matrix-2.2.4 → wavelet_matrix-2.2.5}/Cargo.lock

@@ -53,9 +53,9 @@ checksum = "61803da095bee82a81bb1a452ecc25d3b2f1416d1897eb86430c6159ef717c17"
 
 [[package]]
 name = "either"
-version = "1.16.0"
+version = "1.17.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91622ff5e7162018101f2fea40d6ebf4a78bbe5a49736a2020649edf9693679e"
+checksum = "9e5e8f6c15a24b9a3ee5efec809ccd006d3b30e8b3bb63c39af737c7f87daa1d"
 
 [[package]]
 name = "errno"
@@ -305,7 +305,7 @@ checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
 
 [[package]]
 name = "wavelet-matrix"
-version = "2.2.4"
+version = "2.2.5"
 dependencies = [
  "bytemuck",
  "memmap2",

{wavelet_matrix-2.2.4 → wavelet_matrix-2.2.5}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "wavelet-matrix"
-version = "2.2.4"
+version = "2.2.5"
 edition = "2024"
 readme = "README.md"
 
@@ -10,9 +10,9 @@ name = "wavelet_matrix"
 crate-type = ["cdylib"]
 
 [dependencies]
-bytemuck = "1.25.0"
-memmap2 = "0.9.10"
-num-bigint = "0.4.6"
+bytemuck = "1.25.2"
+memmap2 = "0.9.11"
+num-bigint = "0.4.8"
 num-integer = "0.1.46"
 num-traits = "0.2.19"
 pyo3 = { version = "0.29.0", features = ["num-bigint"] }

{wavelet_matrix-2.2.4 → wavelet_matrix-2.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wavelet-matrix
-Version: 2.2.4
+Version: 2.2.5
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
 Classifier: Intended Audience :: Information Technology

{wavelet_matrix-2.2.4 → wavelet_matrix-2.2.5}/src/disk_wavelet_matrix/disk_bit_vector.rs

@@ -6,7 +6,7 @@ use num_integer::Integer;
 use num_traits::{One, Zero};
 use pyo3::{
     PyResult,
-    exceptions::{PyIndexError, PyRuntimeError, PyValueError},
+    exceptions::{PyIndexError, PyOSError, PyValueError},
 };
 use tempfile::tempfile;
 
@@ -33,47 +33,49 @@ impl DiskBitVector {
         let blocks_slice: &[BlockType] = cast_slice(&blocks[..]);
 
         // Build the rank index structure.
-        let ranks_file = tempfile().map_err(PyRuntimeError::new_err)?;
+        let ranks_file = tempfile().map_err(PyOSError::new_err)?;
         ranks_file
             .set_len((blocks_slice.len() + 1) as u64 * mem::size_of::<usize>() as u64)
-            .map_err(PyRuntimeError::new_err)?;
+            .map_err(PyOSError::new_err)?;
         #[allow(unsafe_code)]
-        let mut ranks = unsafe { MmapMut::map_mut(&ranks_file).map_err(PyRuntimeError::new_err)? };
+        let mut ranks = unsafe { MmapMut::map_mut(&ranks_file).map_err(PyOSError::new_err)? };
         let ranks_slice: &mut [usize] = cast_slice_mut(&mut ranks[..]);
-        iter::once(0usize)
-            .chain(blocks_slice.iter().scan(0usize, |acc, block| {
-                *acc += block.count_ones() as usize;
-                Some(*acc)
-            }))
-            .enumerate()
-            .for_each(|(index, rank)| ranks_slice[index] = rank);
+        ranks_slice.copy_from_slice(
+            iter::once(0)
+                .chain(blocks_slice.iter().scan(0usize, |acc, block| {
+                    *acc += block.count_ones() as usize;
+                    Some(*acc)
+                }))
+                .collect::<Vec<_>>()
+                .as_slice(),
+        );
 
         let select_index_file = [
             {
-                let file = tempfile().map_err(PyRuntimeError::new_err)?;
+                let file = tempfile().map_err(PyOSError::new_err)?;
                 file.set_len(
                     (((len - ranks_slice.last().unwrap()) / SELECT_INDEX_INTERVAL + 2)
                         * mem::size_of::<usize>()) as u64,
                 )
-                .map_err(PyRuntimeError::new_err)?;
+                .map_err(PyOSError::new_err)?;
                 file
             },
             {
-                let file = tempfile().map_err(PyRuntimeError::new_err)?;
+                let file = tempfile().map_err(PyOSError::new_err)?;
                 file.set_len(
                     ((ranks_slice.last().unwrap() / SELECT_INDEX_INTERVAL + 2)
                         * mem::size_of::<usize>()) as u64,
                 )
-                .map_err(PyRuntimeError::new_err)?;
+                .map_err(PyOSError::new_err)?;
                 file
             },
         ];
         #[allow(unsafe_code)]
         let mut select_index_0 =
-            unsafe { MmapMut::map_mut(&select_index_file[0]).map_err(PyRuntimeError::new_err)? };
+            unsafe { MmapMut::map_mut(&select_index_file[0]).map_err(PyOSError::new_err)? };
         #[allow(unsafe_code)]
         let mut select_index_1 =
-            unsafe { MmapMut::map_mut(&select_index_file[1]).map_err(PyRuntimeError::new_err)? };
+            unsafe { MmapMut::map_mut(&select_index_file[1]).map_err(PyOSError::new_err)? };
         let select_index_slice: [&mut [usize]; 2] = [
             cast_slice_mut(&mut select_index_0[..]),
             cast_slice_mut(&mut select_index_1[..]),
@@ -101,62 +103,61 @@ impl DiskBitVector {
 
         Ok(Self {
             len,
-            ranks: ranks.make_read_only().map_err(PyRuntimeError::new_err)?,
+            ranks: ranks.make_read_only().map_err(PyOSError::new_err)?,
             ranks_file,
             blocks,
             blocks_file,
             select_index: [
                 select_index_0
                     .make_read_only()
-                    .map_err(PyRuntimeError::new_err)?,
+                    .map_err(PyOSError::new_err)?,
                 select_index_1
                     .make_read_only()
-                    .map_err(PyRuntimeError::new_err)?,
+                    .map_err(PyOSError::new_err)?,
             ],
             select_index_file,
         })
     }
 
     pub(super) fn try_clone(&self) -> PyResult<Self> {
-        let ranks_file = tempfile().map_err(PyRuntimeError::new_err)?;
+        let ranks_file = tempfile().map_err(PyOSError::new_err)?;
         ranks_file
             .set_len(self.ranks.len() as u64)
-            .map_err(PyRuntimeError::new_err)?;
+            .map_err(PyOSError::new_err)?;
         #[allow(unsafe_code)]
-        let mut ranks = unsafe { MmapMut::map_mut(&ranks_file).map_err(PyRuntimeError::new_err)? };
+        let mut ranks = unsafe { MmapMut::map_mut(&ranks_file).map_err(PyOSError::new_err)? };
         ranks.copy_from_slice(&self.ranks[..]);
 
-        let blocks_file = tempfile().map_err(PyRuntimeError::new_err)?;
+        let blocks_file = tempfile().map_err(PyOSError::new_err)?;
         blocks_file
             .set_len(self.blocks.len() as u64)
-            .map_err(PyRuntimeError::new_err)?;
+            .map_err(PyOSError::new_err)?;
         #[allow(unsafe_code)]
-        let mut blocks =
-            unsafe { MmapMut::map_mut(&blocks_file).map_err(PyRuntimeError::new_err)? };
+        let mut blocks = unsafe { MmapMut::map_mut(&blocks_file).map_err(PyOSError::new_err)? };
         blocks.copy_from_slice(&self.blocks[..]);
 
         let select_index_file = [
             {
-                let file = tempfile().map_err(PyRuntimeError::new_err)?;
+                let file = tempfile().map_err(PyOSError::new_err)?;
                 file.set_len(self.select_index[0].len() as u64)
-                    .map_err(PyRuntimeError::new_err)?;
+                    .map_err(PyOSError::new_err)?;
                 file
             },
             {
-                let file = tempfile().map_err(PyRuntimeError::new_err)?;
+                let file = tempfile().map_err(PyOSError::new_err)?;
                 file.set_len(self.select_index[1].len() as u64)
-                    .map_err(PyRuntimeError::new_err)?;
+                    .map_err(PyOSError::new_err)?;
                 file
             },
         ];
         let mut select_index = [
             #[allow(unsafe_code)]
             unsafe {
-                MmapMut::map_mut(&select_index_file[0]).map_err(PyRuntimeError::new_err)?
+                MmapMut::map_mut(&select_index_file[0]).map_err(PyOSError::new_err)?
             },
             #[allow(unsafe_code)]
             unsafe {
-                MmapMut::map_mut(&select_index_file[1]).map_err(PyRuntimeError::new_err)?
+                MmapMut::map_mut(&select_index_file[1]).map_err(PyOSError::new_err)?
             },
         ];
         select_index[0].copy_from_slice(&self.select_index[0][..]);
@@ -166,17 +167,17 @@ impl DiskBitVector {
 
         Ok(Self {
             len: self.len,
-            ranks: ranks.make_read_only().map_err(PyRuntimeError::new_err)?,
+            ranks: ranks.make_read_only().map_err(PyOSError::new_err)?,
             ranks_file,
-            blocks: blocks.make_read_only().map_err(PyRuntimeError::new_err)?,
+            blocks: blocks.make_read_only().map_err(PyOSError::new_err)?,
             blocks_file,
             select_index: [
                 select_index_0
                     .make_read_only()
-                    .map_err(PyRuntimeError::new_err)?,
+                    .map_err(PyOSError::new_err)?,
                 select_index_1
                     .make_read_only()
-                    .map_err(PyRuntimeError::new_err)?,
+                    .map_err(PyOSError::new_err)?,
             ],
             select_index_file,
         })
@@ -288,10 +289,9 @@ mod tests {
         #[allow(unsafe_code)]
         let mut blocks = unsafe { MmapMut::map_mut(&blocks_file).unwrap() };
         let blocks_slice: &mut [BlockType] = cast_slice_mut(&mut blocks[..]);
-        bits.chunks(BlockType::BITS as usize)
-            .enumerate()
-            .for_each(|(index, chunk)| {
-                blocks_slice[index] =
+        blocks_slice.copy_from_slice(
+            bits.chunks(BlockType::BITS as usize)
+                .map(|chunk| {
                     chunk
                         .iter()
                         .enumerate()
@@ -302,7 +302,10 @@ mod tests {
                                 acc
                             }
                         })
-            });
+                })
+                .collect::<Vec<_>>()
+                .as_slice(),
+        );
 
         DiskBitVector::new(blocks.make_read_only().unwrap(), blocks_file, len).unwrap()
     }

{wavelet_matrix-2.2.4 → wavelet_matrix-2.2.5}/src/disk_wavelet_matrix/disk_wavelet_matrix.rs

@@ -4,7 +4,7 @@ use bytemuck::{Pod, cast_slice, cast_slice_mut};
 use memmap2::MmapMut;
 use num_bigint::ToBigUint;
 use num_traits::{One, PrimInt, Unsigned};
-use pyo3::{PyResult, exceptions::PyRuntimeError};
+use pyo3::{PyResult, exceptions::PyOSError};
 use rayon::prelude::*;
 use tempfile::tempfile;
 
@@ -42,16 +42,15 @@ where
         let mut zeros_count_per_layer = Vec::with_capacity(height);
         let mut layer_blocks_vec = Vec::with_capacity(height);
         for i in 0..height {
-            let current_layer_bits_file = tempfile().map_err(PyRuntimeError::new_err)?;
+            let current_layer_bits_file = tempfile().map_err(PyOSError::new_err)?;
             current_layer_bits_file
                 .set_len(
                     (len.div_ceil(BlockType::BITS as usize) * mem::size_of::<BlockType>()) as u64,
                 )
-                .map_err(PyRuntimeError::new_err)?;
+                .map_err(PyOSError::new_err)?;
             #[allow(unsafe_code)]
-            let mut current_layer_bits = unsafe {
-                MmapMut::map_mut(&current_layer_bits_file).map_err(PyRuntimeError::new_err)?
-            };
+            let mut current_layer_bits =
+                unsafe { MmapMut::map_mut(&current_layer_bits_file).map_err(PyOSError::new_err)? };
             assert!(
                 current_layer_bits
                     .len()
@@ -79,13 +78,13 @@ where
                     .map(|&block| block.count_ones() as usize)
                     .sum::<usize>();
 
-            let next_values_file = tempfile().map_err(PyRuntimeError::new_err)?;
+            let next_values_file = tempfile().map_err(PyOSError::new_err)?;
             next_values_file
                 .set_len((len * mem::size_of::<NumberType>()) as u64)
-                .map_err(PyRuntimeError::new_err)?;
+                .map_err(PyOSError::new_err)?;
             #[allow(unsafe_code)]
             let mut next_values =
-                unsafe { MmapMut::map_mut(&next_values_file).map_err(PyRuntimeError::new_err)? };
+                unsafe { MmapMut::map_mut(&next_values_file).map_err(PyOSError::new_err)? };
             assert!(
                 next_values
                     .len()
@@ -118,7 +117,7 @@ where
             layer_blocks_vec.push((
                 current_layer_bits
                     .make_read_only()
-                    .map_err(PyRuntimeError::new_err)?,
+                    .map_err(PyOSError::new_err)?,
                 current_layer_bits_file,
             ));
             values = next_values;
@@ -200,15 +199,11 @@ mod tests {
 
     fn create_u8() -> DiskWaveletMatrix<u8> {
         let elements: Vec<u8> = vec![5, 4, 5, 5, 2, 1, 5, 6, 1, 3, 5, 0];
-        let file = tempfile().map_err(PyRuntimeError::new_err).unwrap();
+        let file = tempfile().map_err(PyOSError::new_err).unwrap();
         file.set_len((elements.len() * mem::size_of::<u8>()) as u64)
             .unwrap();
         #[allow(unsafe_code)]
-        let mut mmap = unsafe {
-            MmapMut::map_mut(&file)
-                .map_err(PyRuntimeError::new_err)
-                .unwrap()
-        };
+        let mut mmap = unsafe { MmapMut::map_mut(&file).map_err(PyOSError::new_err).unwrap() };
         let mmap_slice: &mut [u8] = cast_slice_mut(&mut mmap[..]);
         mmap_slice.copy_from_slice(&elements);
         DiskWaveletMatrix::new(mmap, file).unwrap()
@@ -216,15 +211,11 @@ mod tests {
 
     fn create_u128() -> DiskWaveletMatrix<u128> {
         let elements: Vec<u128> = vec![5u128, 4, 5, 5, 2, 1, 5, 6, 1, 3, 5, 0];
-        let file = tempfile().map_err(PyRuntimeError::new_err).unwrap();
+        let file = tempfile().map_err(PyOSError::new_err).unwrap();
         file.set_len((elements.len() * mem::size_of::<u128>()) as u64)
             .unwrap();
         #[allow(unsafe_code)]
-        let mut mmap = unsafe {
-            MmapMut::map_mut(&file)
-                .map_err(PyRuntimeError::new_err)
-                .unwrap()
-        };
+        let mut mmap = unsafe { MmapMut::map_mut(&file).map_err(PyOSError::new_err).unwrap() };
         let mmap_slice: &mut [u128] = cast_slice_mut(&mut mmap[..]);
         mmap_slice.copy_from_slice(&elements);
         DiskWaveletMatrix::new(mmap, file).unwrap()
@@ -234,13 +225,9 @@ mod tests {
     fn test_empty() {
         Python::initialize();
 
-        let file = tempfile().map_err(PyRuntimeError::new_err).unwrap();
+        let file = tempfile().map_err(PyOSError::new_err).unwrap();
         #[allow(unsafe_code)]
-        let mmap_empty = unsafe {
-            MmapMut::map_mut(&file)
-                .map_err(PyRuntimeError::new_err)
-                .unwrap()
-        };
+        let mmap_empty = unsafe { MmapMut::map_mut(&file).map_err(PyOSError::new_err).unwrap() };
         let wv_u8 = DiskWaveletMatrix::<u8>::new(mmap_empty, file).unwrap();
         assert_eq!(wv_u8.len(), 0);
         assert_eq!(wv_u8.height(), 0);
@@ -298,14 +285,10 @@ mod tests {
             "ValueError: start must be less than end"
         );
 
-        let file = tempfile().map_err(PyRuntimeError::new_err).unwrap();
+        let file = tempfile().map_err(PyOSError::new_err).unwrap();
         file.set_len(0).unwrap();
         #[allow(unsafe_code)]
-        let mmap_empty = unsafe {
-            MmapMut::map_mut(&file)
-                .map_err(PyRuntimeError::new_err)
-                .unwrap()
-        };
+        let mmap_empty = unsafe { MmapMut::map_mut(&file).map_err(PyOSError::new_err).unwrap() };
         let wv_u128 = DiskWaveletMatrix::<u128>::new(mmap_empty, file).unwrap();
         assert_eq!(wv_u128.height(), 0);
         assert_eq!(wv_u128.values().unwrap(), Vec::<u128>::new());
@@ -373,14 +356,11 @@ mod tests {
     fn test_all_zero() {
         Python::initialize();
 
-        let file = tempfile().map_err(PyRuntimeError::new_err).unwrap();
+        let file = tempfile().map_err(PyOSError::new_err).unwrap();
         file.set_len((64 * mem::size_of::<u8>()) as u64).unwrap();
         #[allow(unsafe_code)]
-        let mmap_u8_all_zero = unsafe {
-            MmapMut::map_mut(&file)
-                .map_err(PyRuntimeError::new_err)
-                .unwrap()
-        };
+        let mmap_u8_all_zero =
+            unsafe { MmapMut::map_mut(&file).map_err(PyOSError::new_err).unwrap() };
         let wv_u8 = DiskWaveletMatrix::<u8>::new(mmap_u8_all_zero, file).unwrap();
         assert_eq!(wv_u8.len(), 64);
         assert_eq!(wv_u8.height(), 0);
@@ -398,14 +378,11 @@ mod tests {
         assert_eq!(wv_u8.prev_value(0, 64, None).unwrap(), Some(0u8));
         assert_eq!(wv_u8.next_value(0, 64, None).unwrap(), Some(0u8));
 
-        let file = tempfile().map_err(PyRuntimeError::new_err).unwrap();
+        let file = tempfile().map_err(PyOSError::new_err).unwrap();
         file.set_len((64 * mem::size_of::<u128>()) as u64).unwrap();
         #[allow(unsafe_code)]
-        let mmap_u128_all_zero = unsafe {
-            MmapMut::map_mut(&file)
-                .map_err(PyRuntimeError::new_err)
-                .unwrap()
-        };
+        let mmap_u128_all_zero =
+            unsafe { MmapMut::map_mut(&file).map_err(PyOSError::new_err).unwrap() };
         let wv_u128 = DiskWaveletMatrix::<u128>::new(mmap_u128_all_zero, file).unwrap();
         assert_eq!(wv_u128.len(), 64);
         assert_eq!(wv_u128.height(), 0);
@@ -428,14 +405,11 @@ mod tests {
     fn test_max_value() {
         Python::initialize();
 
-        let file = tempfile().map_err(PyRuntimeError::new_err).unwrap();
+        let file = tempfile().map_err(PyOSError::new_err).unwrap();
         file.set_len((64 * mem::size_of::<u8>()) as u64).unwrap();
         #[allow(unsafe_code)]
-        let mut mmap_u8_max_value = unsafe {
-            MmapMut::map_mut(&file)
-                .map_err(PyRuntimeError::new_err)
-                .unwrap()
-        };
+        let mut mmap_u8_max_value =
+            unsafe { MmapMut::map_mut(&file).map_err(PyOSError::new_err).unwrap() };
         let mmap_u8_slice: &mut [u8] = cast_slice_mut(&mut mmap_u8_max_value[..]);
         mmap_u8_slice.fill(u8::MAX);
         let wv_u8 = DiskWaveletMatrix::<u8>::new(mmap_u8_max_value, file).unwrap();
@@ -458,14 +432,11 @@ mod tests {
         assert_eq!(wv_u8.prev_value(0, 64, None).unwrap(), Some(u8::MAX));
         assert_eq!(wv_u8.next_value(0, 64, None).unwrap(), Some(u8::MAX));
 
-        let file = tempfile().map_err(PyRuntimeError::new_err).unwrap();
+        let file = tempfile().map_err(PyOSError::new_err).unwrap();
         file.set_len((64 * mem::size_of::<u128>()) as u64).unwrap();
         #[allow(unsafe_code)]
-        let mut mmap_u128_max_value = unsafe {
-            MmapMut::map_mut(&file)
-                .map_err(PyRuntimeError::new_err)
-                .unwrap()
-        };
+        let mut mmap_u128_max_value =
+            unsafe { MmapMut::map_mut(&file).map_err(PyOSError::new_err).unwrap() };
         let mmap_u128_slice: &mut [u128] = cast_slice_mut(&mut mmap_u128_max_value[..]);
         mmap_u128_slice.fill(u128::MAX);
         let wv_u128 = DiskWaveletMatrix::<u128>::new(mmap_u128_max_value, file).unwrap();

{wavelet_matrix-2.2.4 → wavelet_matrix-2.2.5}/src/dynamic_wavelet_matrix/dynamic_wavelet_matrix.rs

@@ -2,7 +2,7 @@ use std::{fmt, iter, marker, ops};
 
 use num_bigint::ToBigUint;
 use num_traits::{One, Zero};
-use pyo3::{PyResult, exceptions::PyValueError};
+use pyo3::{PyResult, exceptions::PyOverflowError};
 use rayon::prelude::*;
 
 use super::dynamic_bit_vector::DynamicBitVector;
@@ -37,7 +37,7 @@ where
             .max()
             .map_or(0usize, |max| max.bit_width());
         if max_bit.is_some_and(|max_bit| max_bit < max_width) {
-            return Err(PyValueError::new_err(format!(
+            return Err(PyOverflowError::new_err(format!(
                 "max_bit = {} is less than the maximum bit width of the data = {}",
                 max_bit.unwrap(),
                 max_width