wavelet-matrix 2.2.1__tar.gz → 2.2.2__tar.gz

{wavelet_matrix-2.2.1 → wavelet_matrix-2.2.2}/.github/workflows/CI.yml

@@ -206,7 +206,7 @@ jobs:
       - name: Install packages
         run: python -m pip install -e .[test,dev]
       - name: Run tests
-        run: pytest --benchmark-skip
+        run: python -m pytest --benchmark-skip
       - name: Docs check
         run: |
           pdoc wavelet_matrix \
@@ -245,7 +245,7 @@ jobs:
           python -m pip install --upgrade pip
           python -m pip install -e .[test]
       - name: Run benchmarks
-        run: pytest --benchmark-only --db .pymon
+        run: python -m pytest --benchmark-only --db .pymon
       - name: Display benchmark results
         run: |
           sqlite3 -header -column .pymon '

{wavelet_matrix-2.2.1 → wavelet_matrix-2.2.2}/Cargo.lock

@@ -8,17 +8,29 @@ version = "1.5.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
 
+[[package]]
+name = "bitflags"
+version = "2.13.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b4388bee8683e3d04af747c73422af53102d2bd24d9eadb6cbc100baef4b43f8"
+
 [[package]]
 name = "bytemuck"
 version = "1.25.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "c8efb64bd706a16a1bdde310ae86b351e4d21550d98d056f22f8a7f7a2183fec"
 
+[[package]]
+name = "cfg-if"
+version = "1.0.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9330f8b2ff13f34540b44e946ef35111825727b38d33286ef986142615121801"
+
 [[package]]
 name = "crossbeam-deque"
-version = "0.8.6"
+version = "0.8.7"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9dd111b7b7f7d55b72c0a6ae361660ee5853c9af73f70c3c2ef6858b950e2e51"
+checksum = "5181e0de7b61eb03a81e347d6dd8797bae9da5146707b51077e2d71a54ec0ceb"
 dependencies = [
  "crossbeam-epoch",
  "crossbeam-utils",
@@ -26,18 +38,18 @@ dependencies = [
 
 [[package]]
 name = "crossbeam-epoch"
-version = "0.9.18"
+version = "0.9.20"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5b82ac4a3c2ca9c3460964f020e1402edd5753411d7737aa39c3714ad1b5420e"
+checksum = "2d6914041f254d6e9176c01941b21115dcfb7089e55135a35411081bd106ef3f"
 dependencies = [
  "crossbeam-utils",
 ]
 
 [[package]]
 name = "crossbeam-utils"
-version = "0.8.21"
+version = "0.8.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "d0a5c400df2834b80a4c3327b3aad3a4c4cd4de0629063962b03235697506a28"
+checksum = "61803da095bee82a81bb1a452ecc25d3b2f1416d1897eb86430c6159ef717c17"
 
 [[package]]
 name = "either"
@@ -45,18 +57,60 @@ version = "1.16.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "91622ff5e7162018101f2fea40d6ebf4a78bbe5a49736a2020649edf9693679e"
 
+[[package]]
+name = "errno"
+version = "0.3.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "39cab71617ae0d63f51a36d69f866391735b51691dbda63cf6f96d042b63efeb"
+dependencies = [
+ "libc",
+ "windows-sys",
+]
+
+[[package]]
+name = "fastrand"
+version = "2.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6"
+
+[[package]]
+name = "getrandom"
+version = "0.4.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "300e883d756b2e4ec94e02791f39b04b522276138852cfc41d9fb7e904106099"
+dependencies = [
+ "cfg-if",
+ "libc",
+ "r-efi",
+]
+
 [[package]]
 name = "heck"
 version = "0.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
 
+[[package]]
+name = "itertools"
+version = "0.15.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b4baf93f58d4425749ca49a51c50ebab072c5df6994d08fed93541c331481dc"
+dependencies = [
+ "either",
+]
+
 [[package]]
 name = "libc"
 version = "0.2.186"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
 
+[[package]]
+name = "linux-raw-sys"
+version = "0.12.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a66949e030da00e8c7d4434b251670a91556f4144941d37452769c25d58a53"
+
 [[package]]
 name = "memmap2"
 version = "0.9.11"
@@ -68,9 +122,9 @@ dependencies = [
 
 [[package]]
 name = "num-bigint"
-version = "0.4.6"
+version = "0.4.8"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "a5e44f723f1133c9deac646763579fdb3ac745e418f2a7af9cd0c431da1f20b9"
+checksum = "c89e69e7e0f03bea5ef08013795c25018e101932225a656383bd384495ecc367"
 dependencies = [
  "num-integer",
  "num-traits",
@@ -117,9 +171,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3"
-version = "0.28.3"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "91fd8e38a3b50ed1167fb981cd6fd60147e091784c427b8f7183a7ee32c31c12"
+checksum = "cd274650b21d4bfc26a0a47587962c1edb425f69287324355cd040c3ea66071c"
 dependencies = [
  "libc",
  "num-bigint",
@@ -133,18 +187,18 @@ dependencies = [
 
 [[package]]
 name = "pyo3-build-config"
-version = "0.28.3"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "e368e7ddfdeb98c9bca7f8383be1648fd84ab466bf2bc015e94008db6d35611e"
+checksum = "c5e2a7d2f0d013342f295c048ad19237add5154a55b1c5a254c0ec93d4109078"
 dependencies = [
  "target-lexicon",
 ]
 
 [[package]]
 name = "pyo3-ffi"
-version = "0.28.3"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7f29e10af80b1f7ccaf7f69eace800a03ecd13e883acfacc1e5d0988605f651e"
+checksum = "ca85c467da1bbc8d866eea5deff9cf29ea5f7785054a17da36e65bda9c05845b"
 dependencies = [
  "libc",
  "pyo3-build-config",
@@ -152,9 +206,9 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros"
-version = "0.28.3"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "df6e520eff47c45997d2fc7dd8214b25dd1310918bbb2642156ef66a67f29813"
+checksum = "9ac53762fd065daa3194dd09337a38bd793a188100fd1a9304c4ab312d901771"
 dependencies = [
  "proc-macro2",
  "pyo3-macros-backend",
@@ -164,13 +218,12 @@ dependencies = [
 
 [[package]]
 name = "pyo3-macros-backend"
-version = "0.28.3"
+version = "0.29.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c4cdc218d835738f81c2338f822078af45b4afdf8b2e33cbb5916f108b813acb"
+checksum = "4ca3a1557399783172dc5bf39cfca835157732532cba56b71d2292161e53b362"
 dependencies = [
  "heck",
  "proc-macro2",
- "pyo3-build-config",
  "quote",
  "syn",
 ]
@@ -184,6 +237,12 @@ dependencies = [
  "proc-macro2",
 ]
 
+[[package]]
+name = "r-efi"
+version = "6.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f8dcc9c7d52a811697d2151c701e0d08956f92b0e24136cf4cf27b57a6a0d9bf"
+
 [[package]]
 name = "rayon"
 version = "1.12.0"
@@ -204,6 +263,19 @@ dependencies = [
  "crossbeam-utils",
 ]
 
+[[package]]
+name = "rustix"
+version = "1.1.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b6fe4565b9518b83ef4f91bb47ce29620ca828bd32cb7e408f0062e9930ba190"
+dependencies = [
+ "bitflags",
+ "errno",
+ "libc",
+ "linux-raw-sys",
+ "windows-sys",
+]
+
 [[package]]
 name = "syn"
 version = "2.0.118"
@@ -221,6 +293,19 @@ version = "0.13.5"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "adb6935a6f5c20170eeceb1a3835a49e12e19d792f6dd344ccc76a985ca5a6ca"
 
+[[package]]
+name = "tempfile"
+version = "3.27.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32497e9a4c7b38532efcdebeef879707aa9f794296a4f0244f6f69e9bc8574bd"
+dependencies = [
+ "fastrand",
+ "getrandom",
+ "once_cell",
+ "rustix",
+ "windows-sys",
+]
+
 [[package]]
 name = "unicode-ident"
 version = "1.0.24"
@@ -229,13 +314,30 @@ checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
 
 [[package]]
 name = "wavelet-matrix"
-version = "2.2.1"
+version = "2.2.2"
 dependencies = [
  "bytemuck",
+ "itertools",
  "memmap2",
  "num-bigint",
  "num-integer",
  "num-traits",
  "pyo3",
  "rayon",
+ "tempfile",
+]
+
+[[package]]
+name = "windows-link"
+version = "0.2.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f0805222e57f7521d6a62e36fa9163bc891acd422f971defe97d64e70d0a4fe5"
+
+[[package]]
+name = "windows-sys"
+version = "0.61.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ae137229bcbd6cdf0f7b80a31df61766145077ddf49416a728b02cb3921ff3fc"
+dependencies = [
+ "windows-link",
 ]

{wavelet_matrix-2.2.1 → wavelet_matrix-2.2.2}/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "wavelet-matrix"
-version = "2.2.1"
+version = "2.2.2"
 edition = "2024"
 readme = "README.md"
 
@@ -11,9 +11,11 @@ crate-type = ["cdylib"]
 
 [dependencies]
 bytemuck = "1.25.0"
+itertools = "0.15.0"
 memmap2 = "0.9.10"
 num-bigint = "0.4.6"
 num-integer = "0.1.46"
 num-traits = "0.2.19"
-pyo3 = { version = "0.28.3", features = ["num-bigint"] }
+pyo3 = { version = "0.29.0", features = ["num-bigint"] }
 rayon = "1.12.0"
+tempfile = "3.27.0"

{wavelet_matrix-2.2.1 → wavelet_matrix-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wavelet-matrix
-Version: 2.2.1
+Version: 2.2.2
 Classifier: Intended Audience :: Developers
 Classifier: Intended Audience :: Science/Research
 Classifier: Intended Audience :: Information Technology
@@ -47,7 +47,6 @@ Project-URL: repository, https://github.com/math-hiyoko/wavelet-matrix
 [![PyPI Downloads](https://static.pepy.tech/personalized-badge/wavelet-matrix?period=total&units=INTERNATIONAL_SYSTEM&left_color=GRAY&right_color=GREEN&left_text=PyPI%20downloads)](https://pepy.tech/projects/wavelet-matrix)
 ![PyPI - Format](https://img.shields.io/pypi/format/wavelet-matrix)
 ![Rust](https://img.shields.io/badge/powered%20by-Rust-orange)
-![Unsafe](https://img.shields.io/badge/unsafe-0-success)
 ![GitHub Repo stars](https://img.shields.io/github/stars/math-hiyoko/wavelet-matrix)
 
 
@@ -63,7 +62,6 @@ supporting fast rank / select / range queries over indexed sequences
 - Rich range queries (freq / sum / top-k / min / max)
 - Optional disk-backed storage for static WaveletMatrix (`on_disk=True`)
 - Optional dynamic updates (insert / remove / update)
-- Safe Rust (no unsafe)
 
 ## Installation
 ```bash
@@ -177,10 +175,6 @@ dwm.update(index=4, value=5)
 # or dwm[4] = 5
 ```
 
-## Safety
-- Powered by safe Rust
-- Memory-safe by design
-
 ## Development
 
 ### Running Tests

{wavelet_matrix-2.2.1 → wavelet_matrix-2.2.2}/README.md

@@ -10,7 +10,6 @@
 [![PyPI Downloads](https://static.pepy.tech/personalized-badge/wavelet-matrix?period=total&units=INTERNATIONAL_SYSTEM&left_color=GRAY&right_color=GREEN&left_text=PyPI%20downloads)](https://pepy.tech/projects/wavelet-matrix)
 ![PyPI - Format](https://img.shields.io/pypi/format/wavelet-matrix)
 ![Rust](https://img.shields.io/badge/powered%20by-Rust-orange)
-![Unsafe](https://img.shields.io/badge/unsafe-0-success)
 ![GitHub Repo stars](https://img.shields.io/github/stars/math-hiyoko/wavelet-matrix)
 
 
@@ -26,7 +25,6 @@ supporting fast rank / select / range queries over indexed sequences
 - Rich range queries (freq / sum / top-k / min / max)
 - Optional disk-backed storage for static WaveletMatrix (`on_disk=True`)
 - Optional dynamic updates (insert / remove / update)
-- Safe Rust (no unsafe)
 
 ## Installation
 ```bash
@@ -140,10 +138,6 @@ dwm.update(index=4, value=5)
 # or dwm[4] = 5
 ```
 
-## Safety
-- Powered by safe Rust
-- Memory-safe by design
-
 ## Development
 
 ### Running Tests

{wavelet_matrix-2.2.1 → wavelet_matrix-2.2.2}/src/disk_wavelet_matrix/disk_bit_vector.rs

@@ -1,4 +1,4 @@
-use std::{iter, mem};
+use std::{fs, iter, mem};
 
 use bytemuck::{cast_slice, cast_slice_mut};
 use memmap2::{Mmap, MmapMut};
@@ -8,6 +8,7 @@ use pyo3::{
     PyResult,
     exceptions::{PyIndexError, PyRuntimeError, PyValueError},
 };
+use tempfile::tempfile;
 
 use crate::traits::{
     bit_vector::bit_vector::{BitVectorTrait, BlockType},
@@ -19,19 +20,25 @@ const SELECT_INDEX_INTERVAL: usize = 512;
 pub(crate) struct DiskBitVector {
     len: usize,
     ranks: Mmap,
+    ranks_file: fs::File,
     blocks: Mmap,
+    blocks_file: fs::File,
     select_index: [Mmap; 2],
+    select_index_file: [fs::File; 2],
 }
 
 impl DiskBitVector {
-    pub(super) fn new(blocks: Mmap, len: usize) -> PyResult<Self> {
+    pub(super) fn new(blocks: Mmap, blocks_file: fs::File, len: usize) -> PyResult<Self> {
         assert!(blocks.len().is_multiple_of(mem::size_of::<BlockType>()));
         let blocks_data: &[BlockType] = cast_slice(&blocks[..]);
 
         // Build the rank index structure.
-        let mut ranks = MmapMut::map_anon((blocks_data.len() + 1) * mem::size_of::<usize>())
+        let ranks_file = tempfile().map_err(PyRuntimeError::new_err)?;
+        ranks_file
+            .set_len((blocks_data.len() + 1) as u64 * mem::size_of::<usize>() as u64)
             .map_err(PyRuntimeError::new_err)?;
-        assert!(ranks.len().is_multiple_of(mem::size_of::<usize>()));
+        #[allow(unsafe_code)]
+        let mut ranks = unsafe { MmapMut::map_mut(&ranks_file).map_err(PyRuntimeError::new_err)? };
         let ranks_data: &mut [usize] = cast_slice_mut(&mut ranks[..]);
         iter::once(0usize)
             .chain(blocks_data.iter().scan(0usize, |acc, block| {
@@ -41,16 +48,32 @@ impl DiskBitVector {
             .enumerate()
             .for_each(|(index, rank)| ranks_data[index] = rank);
 
-        let mut select_index_0 = MmapMut::map_anon(
-            ((len - ranks_data.last().unwrap()) / SELECT_INDEX_INTERVAL + 2)
-                * mem::size_of::<usize>(),
-        )
-        .map_err(PyRuntimeError::new_err)?;
-        let mut select_index_1 = MmapMut::map_anon(
-            (ranks_data.last().unwrap() / SELECT_INDEX_INTERVAL + 2) * mem::size_of::<usize>(),
-        )
-        .map_err(PyRuntimeError::new_err)?;
-
+        let select_index_file = [
+            {
+                let file = tempfile().map_err(PyRuntimeError::new_err)?;
+                file.set_len(
+                    (((len - ranks_data.last().unwrap()) / SELECT_INDEX_INTERVAL + 2)
+                        * mem::size_of::<usize>()) as u64,
+                )
+                .map_err(PyRuntimeError::new_err)?;
+                file
+            },
+            {
+                let file = tempfile().map_err(PyRuntimeError::new_err)?;
+                file.set_len(
+                    ((ranks_data.last().unwrap() / SELECT_INDEX_INTERVAL + 2)
+                        * mem::size_of::<usize>()) as u64,
+                )
+                .map_err(PyRuntimeError::new_err)?;
+                file
+            },
+        ];
+        #[allow(unsafe_code)]
+        let mut select_index_0 =
+            unsafe { MmapMut::map_mut(&select_index_file[0]).map_err(PyRuntimeError::new_err)? };
+        #[allow(unsafe_code)]
+        let mut select_index_1 =
+            unsafe { MmapMut::map_mut(&select_index_file[1]).map_err(PyRuntimeError::new_err)? };
         let select_index_data: [&mut [usize]; 2] = [
             cast_slice_mut(&mut select_index_0[..]),
             cast_slice_mut(&mut select_index_1[..]),
@@ -79,7 +102,9 @@ impl DiskBitVector {
         Ok(Self {
             len,
             ranks: ranks.make_read_only().map_err(PyRuntimeError::new_err)?,
+            ranks_file,
             blocks,
+            blocks_file,
             select_index: [
                 select_index_0
                     .make_read_only()
@@ -88,20 +113,47 @@ impl DiskBitVector {
                     .make_read_only()
                     .map_err(PyRuntimeError::new_err)?,
             ],
+            select_index_file,
         })
     }
 }
 
 impl Clone for DiskBitVector {
     fn clone(&self) -> Self {
-        let mut ranks = MmapMut::map_anon(self.ranks.len()).unwrap();
-        let mut blocks = MmapMut::map_anon(self.blocks.len()).unwrap();
-        let mut select_index = [
-            MmapMut::map_anon(self.select_index[0].len()).unwrap(),
-            MmapMut::map_anon(self.select_index[1].len()).unwrap(),
-        ];
+        let ranks_file = tempfile().unwrap();
+        ranks_file.set_len(self.ranks.len() as u64).unwrap();
+        #[allow(unsafe_code)]
+        let mut ranks = unsafe { MmapMut::map_mut(&ranks_file).unwrap() };
         ranks.copy_from_slice(&self.ranks[..]);
+
+        let blocks_file = tempfile().unwrap();
+        blocks_file.set_len(self.blocks.len() as u64).unwrap();
+        #[allow(unsafe_code)]
+        let mut blocks = unsafe { MmapMut::map_mut(&blocks_file).unwrap() };
         blocks.copy_from_slice(&self.blocks[..]);
+
+        let select_index_file = [
+            {
+                let file = tempfile().unwrap();
+                file.set_len(self.select_index[0].len() as u64).unwrap();
+                file
+            },
+            {
+                let file = tempfile().unwrap();
+                file.set_len(self.select_index[1].len() as u64).unwrap();
+                file
+            },
+        ];
+        let mut select_index = [
+            #[allow(unsafe_code)]
+            unsafe {
+                MmapMut::map_mut(&select_index_file[0]).unwrap()
+            },
+            #[allow(unsafe_code)]
+            unsafe {
+                MmapMut::map_mut(&select_index_file[1]).unwrap()
+            },
+        ];
         select_index[0].copy_from_slice(&self.select_index[0][..]);
         select_index[1].copy_from_slice(&self.select_index[1][..]);
 
@@ -110,11 +162,14 @@ impl Clone for DiskBitVector {
         Self {
             len: self.len,
             ranks: ranks.make_read_only().unwrap(),
+            ranks_file,
             blocks: blocks.make_read_only().unwrap(),
+            blocks_file,
             select_index: [
                 select_index_0.make_read_only().unwrap(),
                 select_index_1.make_read_only().unwrap(),
             ],
+            select_index_file,
         }
     }
 }
@@ -217,10 +272,12 @@ mod tests {
 
     fn create_disk_bit_vector(bits: Vec<bool>) -> DiskBitVector {
         let len = bits.len();
-        let mut blocks =
-            MmapMut::map_anon(len.div_ceil(BlockType::BITS as usize) * mem::size_of::<BlockType>())
-                .map_err(PyRuntimeError::new_err)
-                .unwrap();
+        let blocks_file = tempfile().unwrap();
+        blocks_file
+            .set_len((len.div_ceil(BlockType::BITS as usize) * mem::size_of::<BlockType>()) as u64)
+            .unwrap();
+        #[allow(unsafe_code)]
+        let mut blocks = unsafe { MmapMut::map_mut(&blocks_file).unwrap() };
         let blocks_data: &mut [BlockType] = cast_slice_mut(&mut blocks[..]);
         bits.chunks(BlockType::BITS as usize)
             .enumerate()
@@ -238,7 +295,7 @@ mod tests {
                         })
             });
 
-        DiskBitVector::new(blocks.make_read_only().unwrap(), len).unwrap()
+        DiskBitVector::new(blocks.make_read_only().unwrap(), blocks_file, len).unwrap()
     }
 
     fn create_dummy() -> DiskBitVector {

{wavelet_matrix-2.2.1 → wavelet_matrix-2.2.2}/src/disk_wavelet_matrix/disk_wavelet_matrix.rs

@@ -1,11 +1,12 @@
-use std::{iter, marker, mem, ops};
+use std::{fs, iter, marker, mem, ops};
 
 use bytemuck::{Pod, cast_slice, cast_slice_mut};
-use memmap2::{Mmap, MmapMut};
+use memmap2::MmapMut;
 use num_bigint::ToBigUint;
 use num_traits::{One, PrimInt, Unsigned};
 use pyo3::{PyResult, exceptions::PyRuntimeError};
 use rayon::prelude::*;
+use tempfile::tempfile;
 
 use super::disk_bit_vector::DiskBitVector;
 use crate::traits::{
@@ -27,11 +28,12 @@ where
     NumberType: BitWidth + One + PrimInt + Unsigned + Pod + Send + Sync,
     for<'a> &'a NumberType: ops::Shr<usize, Output = NumberType>,
 {
-    pub(crate) fn new(data: Mmap) -> PyResult<Self> {
+    pub(crate) fn new(data: MmapMut, data_file: fs::File) -> PyResult<Self> {
         assert!(data.len().is_multiple_of(mem::size_of::<NumberType>()));
         let len = data.len() / mem::size_of::<NumberType>();
 
         let mut values = data;
+        let mut _values_file = data_file;
         let values_data: &[NumberType] = cast_slice(&values[..]);
         let height = values_data
             .par_iter()
@@ -41,10 +43,16 @@ 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 mut current_layer_bits = MmapMut::map_anon(
-                len.div_ceil(BlockType::BITS as usize) * mem::size_of::<BlockType>(),
-            )
-            .map_err(PyRuntimeError::new_err)?;
+            let current_layer_bits_file = tempfile().map_err(PyRuntimeError::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)?;
+            #[allow(unsafe_code)]
+            let mut current_layer_bits = unsafe {
+                MmapMut::map_mut(&current_layer_bits_file).map_err(PyRuntimeError::new_err)?
+            };
             assert!(
                 current_layer_bits
                     .len()
@@ -53,32 +61,39 @@ where
             let current_layer_bits_data: &mut [BlockType] =
                 cast_slice_mut(&mut current_layer_bits[..]);
             let values_data: &[NumberType] = cast_slice(&values[..]);
-            values_data
-                .par_iter()
-                .map(|value| (value >> (height - i - 1) & NumberType::one()).is_one())
-                .chunks(BlockType::BITS as usize)
-                .zip(current_layer_bits_data.par_iter_mut())
-                .for_each(|(bits_chunk, block)| {
-                    bits_chunk.iter().enumerate().for_each(|(j, &bit)| {
-                        if bit {
+            current_layer_bits_data
+                .iter_mut()
+                .enumerate()
+                .for_each(|(block_index, block)| {
+                    let start = block_index * BlockType::BITS as usize;
+                    let end = (start + BlockType::BITS as usize).min(len);
+                    for (j, value) in values_data[start..end].iter().enumerate() {
+                        if ((value >> (height - i - 1)) & NumberType::one()).is_one() {
                             *block |= BlockType::one() << j;
                         }
-                    });
+                    }
                 });
+
             let zeros_count = len
                 - current_layer_bits_data
                     .par_iter()
                     .map(|&block| block.count_ones() as usize)
                     .sum::<usize>();
 
-            let mut next_values = MmapMut::map_anon(len * mem::size_of::<NumberType>())
+            let next_values_file = tempfile().map_err(PyRuntimeError::new_err)?;
+            next_values_file
+                .set_len((len * mem::size_of::<NumberType>()) as u64)
                 .map_err(PyRuntimeError::new_err)?;
+            #[allow(unsafe_code)]
+            let mut next_values =
+                unsafe { MmapMut::map_mut(&next_values_file).map_err(PyRuntimeError::new_err)? };
             assert!(
                 next_values
                     .len()
                     .is_multiple_of(mem::size_of::<NumberType>())
             );
             let next_values_data: &mut [NumberType] = cast_slice_mut(&mut next_values[..]);
+
             let mut zero_index = 0usize;
             let mut one_index = zeros_count;
             for (bit, value) in iter::zip(
@@ -101,19 +116,19 @@ where
             }
 
             zeros_count_per_layer.push(zeros_count);
-            layer_blocks_vec.push(
+            layer_blocks_vec.push((
                 current_layer_bits
                     .make_read_only()
                     .map_err(PyRuntimeError::new_err)?,
-            );
-            values = next_values
-                .make_read_only()
-                .map_err(PyRuntimeError::new_err)?;
+                current_layer_bits_file,
+            ));
+            values = next_values;
+            _values_file = next_values_file;
         }
 
         let layers = layer_blocks_vec
             .into_par_iter()
-            .map(|blocks| DiskBitVector::new(blocks, len))
+            .map(|(blocks, blocks_file)| DiskBitVector::new(blocks, blocks_file, len))
             .collect::<PyResult<Vec<_>>>()?;
 
         Ok(Self {
@@ -164,32 +179,55 @@ where
 
 #[cfg(test)]
 mod tests {
+    use num_bigint::BigUint;
     use pyo3::Python;
 
     use super::*;
 
     fn create_u8() -> DiskWaveletMatrix<u8> {
         let elements: Vec<u8> = vec![5, 4, 5, 5, 2, 1, 5, 6, 1, 3, 5, 0];
-        let mut mmap = MmapMut::map_anon(elements.len() * mem::size_of::<u8>()).unwrap();
+        let file = tempfile().map_err(PyRuntimeError::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 mmap_data: &mut [u8] = cast_slice_mut(&mut mmap[..]);
         mmap_data.copy_from_slice(&elements);
-        DiskWaveletMatrix::new(mmap.make_read_only().unwrap()).unwrap()
+        DiskWaveletMatrix::new(mmap, file).unwrap()
     }
 
     fn create_u128() -> DiskWaveletMatrix<u128> {
         let elements: Vec<u128> = vec![5u128, 4, 5, 5, 2, 1, 5, 6, 1, 3, 5, 0];
-        let mut mmap = MmapMut::map_anon(elements.len() * mem::size_of::<u128>()).unwrap();
+        let file = tempfile().map_err(PyRuntimeError::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 mmap_data: &mut [u128] = cast_slice_mut(&mut mmap[..]);
         mmap_data.copy_from_slice(&elements);
-        DiskWaveletMatrix::new(mmap.make_read_only().unwrap()).unwrap()
+        DiskWaveletMatrix::new(mmap, file).unwrap()
     }
 
     #[test]
     fn test_empty() {
         Python::initialize();
 
-        let mmap_empty = MmapMut::map_anon(0).unwrap();
-        let wv_u8 = DiskWaveletMatrix::<u8>::new(mmap_empty.make_read_only().unwrap()).unwrap();
+        let file = tempfile().map_err(PyRuntimeError::new_err).unwrap();
+        #[allow(unsafe_code)]
+        let mmap_empty = unsafe {
+            MmapMut::map_mut(&file)
+                .map_err(PyRuntimeError::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);
         assert_eq!(wv_u8.values().unwrap(), Vec::<u8>::new());
@@ -246,9 +284,15 @@ mod tests {
             "ValueError: start must be less than end"
         );
 
-        let mmap_empty = MmapMut::map_anon(0).unwrap();
-        let wv_u128 = DiskWaveletMatrix::<u128>::new(mmap_empty.make_read_only().unwrap()).unwrap();
-        assert_eq!(wv_u128.len(), 0);
+        let file = tempfile().map_err(PyRuntimeError::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 wv_u128 = DiskWaveletMatrix::<u128>::new(mmap_empty, file).unwrap();
         assert_eq!(wv_u128.height(), 0);
         assert_eq!(wv_u128.values().unwrap(), Vec::<u128>::new());
         assert_eq!(
@@ -315,9 +359,15 @@ mod tests {
     fn test_all_zero() {
         Python::initialize();
 
-        let mmap_u8_all_zero = MmapMut::map_anon(64 * mem::size_of::<u8>()).unwrap();
-        let wv_u8 =
-            DiskWaveletMatrix::<u8>::new(mmap_u8_all_zero.make_read_only().unwrap()).unwrap();
+        let file = tempfile().map_err(PyRuntimeError::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 wv_u8 = DiskWaveletMatrix::<u8>::new(mmap_u8_all_zero, file).unwrap();
         assert_eq!(wv_u8.len(), 64);
         assert_eq!(wv_u8.height(), 0);
         assert_eq!(wv_u8.values().unwrap(), vec![0u8; 64]);
@@ -334,9 +384,15 @@ 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 mmap_u128_all_zero = MmapMut::map_anon(64 * mem::size_of::<u128>()).unwrap();
-        let wv_u128 =
-            DiskWaveletMatrix::<u128>::new(mmap_u128_all_zero.make_read_only().unwrap()).unwrap();
+        let file = tempfile().map_err(PyRuntimeError::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 wv_u128 = DiskWaveletMatrix::<u128>::new(mmap_u128_all_zero, file).unwrap();
         assert_eq!(wv_u128.len(), 64);
         assert_eq!(wv_u128.height(), 0);
         assert_eq!(wv_u128.values().unwrap(), vec![0u128; 64]);
@@ -358,11 +414,17 @@ mod tests {
     fn test_max_value() {
         Python::initialize();
 
-        let mut mmap_u8_max_value = MmapMut::map_anon(64 * mem::size_of::<u8>()).unwrap();
+        let file = tempfile().map_err(PyRuntimeError::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 mmap_u8_data: &mut [u8] = cast_slice_mut(&mut mmap_u8_max_value[..]);
         mmap_u8_data.fill(u8::MAX);
-        let wv_u8 =
-            DiskWaveletMatrix::<u8>::new(mmap_u8_max_value.make_read_only().unwrap()).unwrap();
+        let wv_u8 = DiskWaveletMatrix::<u8>::new(mmap_u8_max_value, file).unwrap();
         assert_eq!(wv_u8.len(), 64);
         assert_eq!(wv_u8.height(), 8);
         assert_eq!(wv_u8.values().unwrap(), vec![u8::MAX; 64]);
@@ -381,6 +443,36 @@ mod tests {
         assert_eq!(wv_u8.range_mink(0, 64, None).unwrap().len(), 1);
         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();
+        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 mmap_u128_data: &mut [u128] = cast_slice_mut(&mut mmap_u128_max_value[..]);
+        mmap_u128_data.fill(u128::MAX);
+        let wv_u128 = DiskWaveletMatrix::<u128>::new(mmap_u128_max_value, file).unwrap();
+        assert_eq!(wv_u128.len(), 64);
+        assert_eq!(wv_u128.height(), 128);
+        assert_eq!(wv_u128.values().unwrap(), vec![u128::MAX; 64]);
+        assert_eq!(wv_u128.access(1).unwrap(), u128::MAX);
+        assert_eq!(wv_u128.rank(&u128::MAX, 1).unwrap(), 1);
+        assert_eq!(wv_u128.select(&u128::MAX, 1).unwrap(), Some(0));
+        assert_eq!(wv_u128.quantile(0, 64, 1).unwrap(), u128::MAX);
+        assert_eq!(wv_u128.topk(0, 64, None).unwrap().len(), 1);
+        assert_eq!(
+            wv_u128.range_sum(0, 64).unwrap(),
+            BigUint::from(u128::MAX) * 64u128,
+        );
+        assert_eq!(wv_u128.range_freq(0, 64, None, None).unwrap(), 64usize);
+        assert_eq!(wv_u128.range_list(0, 64, None, None).unwrap().len(), 1);
+        assert_eq!(wv_u128.range_maxk(0, 64, None).unwrap().len(), 1);
+        assert_eq!(wv_u128.range_mink(0, 64, None).unwrap().len(), 1);
+        assert_eq!(wv_u128.prev_value(0, 64, None).unwrap(), Some(u128::MAX));
+        assert_eq!(wv_u128.next_value(0, 64, None).unwrap(), Some(u128::MAX));
     }
 
     #[test]

{wavelet_matrix-2.2.1 → wavelet_matrix-2.2.2}/src/lib.rs

@@ -1,4 +1,4 @@
-#![forbid(unsafe_code)]
+#![deny(unsafe_code)]
 mod disk_wavelet_matrix;
 mod dynamic_wavelet_matrix;
 mod python;

{wavelet_matrix-2.2.1 → wavelet_matrix-2.2.2}/src/python/wavelet_matrix.rs

@@ -7,8 +7,9 @@ use num_traits::Zero;
 use pyo3::{
     exceptions::{PyIndexError, PyRuntimeError, PyTypeError, PyValueError},
     prelude::*,
-    types::{PyDict, PyInt, PyList, PySequence, PySlice, PySliceIndices},
+    types::{PyAny, PyDict, PyInt, PyList, PySlice, PySliceIndices},
 };
+use tempfile::tempfile;
 
 use crate::{
     disk_wavelet_matrix::disk_wavelet_matrix::DiskWaveletMatrix,
@@ -66,7 +67,7 @@ impl PyWaveletMatrix {
     /// Creates a new Wavelet Matrix from the given list or tuple of integers.
     #[new]
     #[pyo3(signature = (data, on_disk=false))]
-    fn new(data: &Bound<'_, PySequence>, on_disk: bool) -> PyResult<Self> {
+    fn new(data: &Bound<'_, PyAny>, on_disk: bool) -> PyResult<Self> {
         let (len, max_value) =
             data.try_iter()?
                 .try_fold((0usize, BigUint::zero()), |(len, max_value), item| {
@@ -121,74 +122,69 @@ impl PyWaveletMatrix {
                 WaveletMatrixEnum::BigUint(WaveletMatrix::<BigUint>::new(values))
             }
             (true, 0..=8) => {
-                let mut values = MmapMut::map_anon(len * mem::size_of::<u8>())
+                let file = tempfile().map_err(PyRuntimeError::new_err)?;
+                file.set_len((len * mem::size_of::<u8>()) as u64)
                     .map_err(PyRuntimeError::new_err)?;
+                #[allow(unsafe_code)]
+                let mut values =
+                    unsafe { MmapMut::map_mut(&file).map_err(PyRuntimeError::new_err)? };
                 let values_data: &mut [u8] = cast_slice_mut(&mut values[..]);
-                data.try_iter()?
-                    .zip(values_data.iter_mut())
-                    .try_for_each(|(item, value)| {
-                        *value = item?.extract::<u8>().map_err(PyValueError::new_err)?;
-                        Ok::<_, PyErr>(())
-                    })?;
-                WaveletMatrixEnum::DiskU8(DiskWaveletMatrix::<u8>::new(
-                    values.make_read_only().unwrap(),
-                )?)
+                for (i, item) in data.try_iter()?.enumerate() {
+                    values_data[i] = item?.extract::<u8>().map_err(PyValueError::new_err)?;
+                }
+                WaveletMatrixEnum::DiskU8(DiskWaveletMatrix::<u8>::new(values, file)?)
             }
             (true, 9..=16) => {
-                let mut values = MmapMut::map_anon(len * mem::size_of::<u16>())
+                let file = tempfile().map_err(PyRuntimeError::new_err)?;
+                file.set_len((len * mem::size_of::<u16>()) as u64)
                     .map_err(PyRuntimeError::new_err)?;
+                #[allow(unsafe_code)]
+                let mut values =
+                    unsafe { MmapMut::map_mut(&file).map_err(PyRuntimeError::new_err)? };
                 let values_data: &mut [u16] = cast_slice_mut(&mut values[..]);
-                data.try_iter()?
-                    .zip(values_data.iter_mut())
-                    .try_for_each(|(item, value)| {
-                        *value = item?.extract::<u16>().map_err(PyValueError::new_err)?;
-                        Ok::<_, PyErr>(())
-                    })?;
-                WaveletMatrixEnum::DiskU16(DiskWaveletMatrix::<u16>::new(
-                    values.make_read_only().unwrap(),
-                )?)
+                for (i, item) in data.try_iter()?.enumerate() {
+                    values_data[i] = item?.extract::<u16>().map_err(PyValueError::new_err)?;
+                }
+                WaveletMatrixEnum::DiskU16(DiskWaveletMatrix::<u16>::new(values, file)?)
             }
             (true, 17..=32) => {
-                let mut values = MmapMut::map_anon(len * mem::size_of::<u32>())
+                let file = tempfile().map_err(PyRuntimeError::new_err)?;
+                file.set_len((len * mem::size_of::<u32>()) as u64)
                     .map_err(PyRuntimeError::new_err)?;
+                #[allow(unsafe_code)]
+                let mut values =
+                    unsafe { MmapMut::map_mut(&file).map_err(PyRuntimeError::new_err)? };
                 let values_data: &mut [u32] = cast_slice_mut(&mut values[..]);
-                data.try_iter()?
-                    .zip(values_data.iter_mut())
-                    .try_for_each(|(item, value)| {
-                        *value = item?.extract::<u32>().map_err(PyValueError::new_err)?;
-                        Ok::<_, PyErr>(())
-                    })?;
-                WaveletMatrixEnum::DiskU32(DiskWaveletMatrix::<u32>::new(
-                    values.make_read_only().unwrap(),
-                )?)
+                for (i, item) in data.try_iter()?.enumerate() {
+                    values_data[i] = item?.extract::<u32>().map_err(PyValueError::new_err)?;
+                }
+                WaveletMatrixEnum::DiskU32(DiskWaveletMatrix::<u32>::new(values, file)?)
             }
             (true, 33..=64) => {
-                let mut values = MmapMut::map_anon(len * mem::size_of::<u64>())
+                let file = tempfile().map_err(PyRuntimeError::new_err)?;
+                file.set_len((len * mem::size_of::<u64>()) as u64)
                     .map_err(PyRuntimeError::new_err)?;
+                #[allow(unsafe_code)]
+                let mut values =
+                    unsafe { MmapMut::map_mut(&file).map_err(PyRuntimeError::new_err)? };
                 let values_data: &mut [u64] = cast_slice_mut(&mut values[..]);
-                data.try_iter()?
-                    .zip(values_data.iter_mut())
-                    .try_for_each(|(item, value)| {
-                        *value = item?.extract::<u64>().map_err(PyValueError::new_err)?;
-                        Ok::<_, PyErr>(())
-                    })?;
-                WaveletMatrixEnum::DiskU64(DiskWaveletMatrix::<u64>::new(
-                    values.make_read_only().unwrap(),
-                )?)
+                for (i, item) in data.try_iter()?.enumerate() {
+                    values_data[i] = item?.extract::<u64>().map_err(PyValueError::new_err)?;
+                }
+                WaveletMatrixEnum::DiskU64(DiskWaveletMatrix::<u64>::new(values, file)?)
             }
             (true, 65..=128) => {
-                let mut values = MmapMut::map_anon(len * mem::size_of::<u128>())
+                let file = tempfile().map_err(PyRuntimeError::new_err)?;
+                file.set_len((len * mem::size_of::<u128>()) as u64)
                     .map_err(PyRuntimeError::new_err)?;
+                #[allow(unsafe_code)]
+                let mut values =
+                    unsafe { MmapMut::map_mut(&file).map_err(PyRuntimeError::new_err)? };
                 let values_data: &mut [u128] = cast_slice_mut(&mut values[..]);
-                data.try_iter()?
-                    .zip(values_data.iter_mut())
-                    .try_for_each(|(item, value)| {
-                        *value = item?.extract::<u128>().map_err(PyValueError::new_err)?;
-                        Ok::<_, PyErr>(())
-                    })?;
-                WaveletMatrixEnum::DiskU128(DiskWaveletMatrix::<u128>::new(
-                    values.make_read_only().unwrap(),
-                )?)
+                for (i, item) in data.try_iter()?.enumerate() {
+                    values_data[i] = item?.extract::<u128>().map_err(PyValueError::new_err)?;
+                }
+                WaveletMatrixEnum::DiskU128(DiskWaveletMatrix::<u128>::new(values, file)?)
             }
             (true, _) => {
                 return Err(PyValueError::new_err(
@@ -1150,9 +1146,9 @@ mod tests {
         Python::attach(|py| {
             let elements = vec![5, 4, 5, 5, 2, 1, 5, 6, 1, 3, 5, 0];
             let pylist = PyList::new(py, &elements).unwrap();
-            let pysequence = pylist.cast::<PySequence>().unwrap();
-            let wm = PyWaveletMatrix::new(pysequence, false).unwrap();
-            let disk_wm = PyWaveletMatrix::new(pysequence, true).unwrap();
+            let pyany = pylist.cast::<PyAny>().unwrap();
+            let wm = PyWaveletMatrix::new(pyany, false).unwrap();
+            let disk_wm = PyWaveletMatrix::new(pyany, true).unwrap();
 
             assert_eq!(wm.__len__(py).unwrap(), elements.len());
             assert_eq!(disk_wm.__len__(py).unwrap(), elements.len());
@@ -1534,9 +1530,9 @@ mod tests {
                 0 << 8,
             ];
             let pylist = PyList::new(py, &elements).unwrap();
-            let pysequence = pylist.cast::<PySequence>().unwrap();
-            let wm = PyWaveletMatrix::new(pysequence, false).unwrap();
-            let disk_wm = PyWaveletMatrix::new(pysequence, true).unwrap();
+            let pyany = pylist.cast::<PyAny>().unwrap();
+            let wm = PyWaveletMatrix::new(pyany, false).unwrap();
+            let disk_wm = PyWaveletMatrix::new(pyany, true).unwrap();
 
             assert_eq!(wm.__len__(py).unwrap(), elements.len());
             assert_eq!(disk_wm.__len__(py).unwrap(), elements.len());
@@ -1918,9 +1914,9 @@ mod tests {
                 0 << 16,
             ];
             let pylist = PyList::new(py, &elements).unwrap();
-            let pysequence = pylist.cast::<PySequence>().unwrap();
-            let wm = PyWaveletMatrix::new(pysequence, false).unwrap();
-            let disk_wm = PyWaveletMatrix::new(pysequence, true).unwrap();
+            let pyany = pylist.cast::<PyAny>().unwrap();
+            let wm = PyWaveletMatrix::new(pyany, false).unwrap();
+            let disk_wm = PyWaveletMatrix::new(pyany, true).unwrap();
 
             assert_eq!(wm.__len__(py).unwrap(), elements.len());
             assert_eq!(disk_wm.__len__(py).unwrap(), elements.len());
@@ -2302,9 +2298,9 @@ mod tests {
                 0 << 32,
             ];
             let pylist = PyList::new(py, &elements).unwrap();
-            let pysequence = pylist.cast::<PySequence>().unwrap();
-            let wm = PyWaveletMatrix::new(pysequence, false).unwrap();
-            let disk_wm = PyWaveletMatrix::new(pysequence, true).unwrap();
+            let pyany = pylist.cast::<PyAny>().unwrap();
+            let wm = PyWaveletMatrix::new(pyany, false).unwrap();
+            let disk_wm = PyWaveletMatrix::new(pyany, true).unwrap();
 
             assert_eq!(wm.__len__(py).unwrap(), elements.len());
             assert_eq!(disk_wm.__len__(py).unwrap(), elements.len());
@@ -2686,9 +2682,9 @@ mod tests {
                 0 << 64,
             ];
             let pylist = PyList::new(py, &elements).unwrap();
-            let pysequence = pylist.cast::<PySequence>().unwrap();
-            let wm = PyWaveletMatrix::new(pysequence, false).unwrap();
-            let disk_wm = PyWaveletMatrix::new(pysequence, true).unwrap();
+            let pyany = pylist.cast::<PyAny>().unwrap();
+            let wm = PyWaveletMatrix::new(pyany, false).unwrap();
+            let disk_wm = PyWaveletMatrix::new(pyany, true).unwrap();
 
             assert_eq!(wm.__len__(py).unwrap(), elements.len());
             assert_eq!(disk_wm.__len__(py).unwrap(), elements.len());
@@ -3074,8 +3070,8 @@ mod tests {
                 BigUint::from(0u32) << 128,
             ];
             let pylist = elements.clone().into_pyobject(py).unwrap();
-            let pysequence = pylist.cast::<PySequence>().unwrap();
-            let wm = PyWaveletMatrix::new(pysequence, false).unwrap();
+            let pyany = pylist.cast::<PyAny>().unwrap();
+            let wm = PyWaveletMatrix::new(pyany, false).unwrap();
 
             assert_eq!(wm.__len__(py).unwrap(), elements.len());
             assert_eq!(

{wavelet_matrix-2.2.1 → wavelet_matrix-2.2.2}/src/wavelet_matrix/wavelet_matrix.rs

@@ -1,5 +1,6 @@
 use std::{collections, hash, iter, ops};
 
+use itertools::Itertools;
 use num_bigint::ToBigUint;
 use num_traits::{One, Zero};
 use rayon::prelude::*;
@@ -46,8 +47,8 @@ where
                 .par_iter()
                 .map(|value| (value >> (height - i - 1) & NumberType::one()).is_one())
                 .collect::<Vec<bool>>();
-            let zeros_count = current_layer_bits.par_iter().filter(|&&b| !b).count();
 
+            let zeros_count = current_layer_bits.par_iter().filter(|&&b| !b).count();
             let mut next_values = vec![NumberType::one(); len];
             let mut zero_index = 0usize;
             let mut one_index = zeros_count;
@@ -62,19 +63,17 @@ where
             }
 
             let current_layer_blocks = current_layer_bits
-                .into_par_iter()
+                .into_iter()
                 .chunks(BlockType::BITS as usize)
+                .into_iter()
                 .map(|chunk| {
-                    chunk
-                        .iter()
-                        .enumerate()
-                        .fold(BlockType::zero(), |acc, (j, &b)| {
-                            if b {
-                                acc | (BlockType::one() << j)
-                            } else {
-                                acc
-                            }
-                        })
+                    chunk.enumerate().fold(BlockType::zero(), |acc, (j, b)| {
+                        if b {
+                            acc | (BlockType::one() << j)
+                        } else {
+                            acc
+                        }
+                    })
                 })
                 .collect::<Vec<_>>();