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

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

@@ -42,8 +42,8 @@ jobs:
           - runner: ubuntu-latest
             target: ppc64le
     steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-python@v6
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
         with:
           python-version: 3.x
       - name: Build wheels
@@ -55,7 +55,7 @@ jobs:
           manylinux: auto
       - name: Upload wheels
         if: ${{ startsWith(github.ref, 'refs/tags/') || github.event_name == 'workflow_dispatch' }}
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v7
         with:
           name: wheels-linux-${{ matrix.platform.target }}
           path: dist
@@ -75,8 +75,8 @@ jobs:
           - runner: ubuntu-latest
             target: armv7
     steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-python@v6
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
         with:
           python-version: 3.x
       - name: Build wheels
@@ -88,7 +88,7 @@ jobs:
           manylinux: musllinux_1_2
       - name: Upload wheels
         if: ${{ startsWith(github.ref, 'refs/tags/') || github.event_name == 'workflow_dispatch' }}
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v7
         with:
           name: wheels-musllinux-${{ matrix.platform.target }}
           path: dist
@@ -104,8 +104,8 @@ jobs:
           - runner: windows-latest
             target: x86
     steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-python@v6
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
         with:
           python-version: 3.x
           architecture: ${{ matrix.platform.target }}
@@ -117,7 +117,7 @@ jobs:
           sccache: ${{ !startsWith(github.ref, 'refs/tags/') }}
       - name: Upload wheels
         if: ${{ startsWith(github.ref, 'refs/tags/') || github.event_name == 'workflow_dispatch' }}
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v7
         with:
           name: wheels-windows-${{ matrix.platform.target }}
           path: dist
@@ -133,8 +133,8 @@ jobs:
           - runner: macos-latest
             target: aarch64
     steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-python@v6
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
         with:
           python-version: 3.x
       - name: Build wheels
@@ -145,7 +145,7 @@ jobs:
           sccache: ${{ !startsWith(github.ref, 'refs/tags/') }}
       - name: Upload wheels
         if: ${{ startsWith(github.ref, 'refs/tags/') || github.event_name == 'workflow_dispatch' }}
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v7
         with:
           name: wheels-macos-${{ matrix.platform.target }}
           path: dist
@@ -154,8 +154,8 @@ jobs:
     needs: [cargo-test, python-test]
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-python@v6
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
         with:
           python-version: 3.x
       - name: Build sdist
@@ -165,7 +165,7 @@ jobs:
           args: --out dist
       - name: Upload sdist
         if: ${{ startsWith(github.ref, 'refs/tags/') || github.event_name == 'workflow_dispatch' }}
-        uses: actions/upload-artifact@v6
+        uses: actions/upload-artifact@v7
         with:
           name: wheels-sdist
           path: dist
@@ -173,7 +173,7 @@ jobs:
   cargo-test:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v7
       - uses: dtolnay/rust-toolchain@stable
         with:
           components: clippy
@@ -191,7 +191,7 @@ jobs:
       - name: Clippy check
         run: cargo clippy --all-targets --all-features -- -D warnings
       - name: Upload coverage reports to Codecov
-        uses: codecov/codecov-action@v5
+        uses: codecov/codecov-action@v7
         with:
           fail_ci_if_error: true
           token: ${{ secrets.CODECOV_TOKEN }}
@@ -199,8 +199,8 @@ jobs:
   python-test:
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-python@v6
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
         with:
           python-version: 3.x
       - name: Install packages
@@ -233,11 +233,11 @@ jobs:
           - "3.12"
           - "3.13"
           - "3.14"
-          - "3.15.0-beta.3"
+          - "3.15-dev"
           - "pypy3.11"
     steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-python@v6
+      - uses: actions/checkout@v7
+      - uses: actions/setup-python@v7
         with:
           python-version: ${{ matrix.python }}
       - name: Install packages
@@ -278,10 +278,6 @@ jobs:
           pattern: wheels-*
           path: dist
           merge-multiple: true
-      - name: Generate artifact attestation
-        uses: actions/attest-build-provenance@v3
-        with:
-          subject-path: 'dist/*'
       - name: Publish to PyPI
         if: ${{ startsWith(github.ref, 'refs/tags/') }}
         uses: pypa/gh-action-pypi-publish@release/v1

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

@@ -10,15 +10,15 @@ checksum = "f2032f911046de80f0a198e0901378627c33f59ea0ac00e363d481118bd70a53"
 
 [[package]]
 name = "bitflags"
-version = "2.13.0"
+version = "2.13.1"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "b4388bee8683e3d04af747c73422af53102d2bd24d9eadb6cbc100baef4b43f8"
+checksum = "b588b76d00fde79687d7646a9b5bdf3cc0f655e0bbd080335a95d7e96f3587da"
 
 [[package]]
 name = "bytemuck"
-version = "1.25.0"
+version = "1.25.2"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c8efb64bd706a16a1bdde310ae86b351e4d21550d98d056f22f8a7f7a2183fec"
+checksum = "95832e849adfb21180ccb6826a99da14e5d266ae5c2e668e1602cf234f153797"
 
 [[package]]
 name = "cfg-if"
@@ -69,9 +69,9 @@ dependencies = [
 
 [[package]]
 name = "fastrand"
-version = "2.4.1"
+version = "2.5.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "9f1f227452a390804cdb637b74a86990f2a7d7ba4b7d5693aac9b4dd6defd8d6"
+checksum = "da7c62ceae207dd37ea5b845da6a0696c799f85e97da1ab5b7910be3c1c80223"
 
 [[package]]
 name = "getrandom"
@@ -90,20 +90,11 @@ 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"
+version = "0.2.189"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "68ab91017fe16c622486840e4c83c9a37afeff978bd239b5293d61ece587de66"
+checksum = "3eaf3ede3fee6db1a4c2ee091bf8a8b4dccdc6d17f656fb07896ee72867612f2"
 
 [[package]]
 name = "linux-raw-sys"
@@ -156,15 +147,15 @@ checksum = "9f7c3e4beb33f85d45ae3e3a1792185706c8e16d043238c593331cc7cd313b50"
 
 [[package]]
 name = "portable-atomic"
-version = "1.13.1"
+version = "1.14.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"
+checksum = "3d20d5497ef88037a52ff98267d066e7f11fcc5e99bbfbd58a42336193aacec3"
 
 [[package]]
 name = "proc-macro2"
-version = "1.0.106"
+version = "1.0.107"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "8fd00f0bb2e90d81d1044c2b32617f68fcb9fa3bb7640c23e9c748e53fb30934"
+checksum = "985e7ec9bb745e6ce6535b544d84d6cd6f7ad8bd711c398938ae983b91a766d9"
 dependencies = [
  "unicode-ident",
 ]
@@ -230,9 +221,9 @@ dependencies = [
 
 [[package]]
 name = "quote"
-version = "1.0.46"
+version = "1.0.47"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "dfbc457d0c7a0759a614551b11a6409e5951f6c7537be1f1b7682b9ae9230368"
+checksum = "1fbf4db142a473a8d80c26bbf18454ed458bf8d26c8219c331daecfdbd079001"
 dependencies = [
  "proc-macro2",
 ]
@@ -278,9 +269,9 @@ dependencies = [
 
 [[package]]
 name = "syn"
-version = "2.0.118"
+version = "2.0.119"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1b9ae57f904213ebb649ce6895b8a66c66f0203b9319718f69a5612a065b1422"
+checksum = "872831b642d1a07999a962a351ed35b955ea2cfc8f3862091e2a240a84f17297"
 dependencies = [
  "proc-macro2",
  "quote",
@@ -314,10 +305,9 @@ checksum = "e6e4313cd5fcd3dad5cafa179702e2b244f760991f45397d14d4ebf38247da75"
 
 [[package]]
 name = "wavelet-matrix"
-version = "2.2.2"
+version = "2.2.4"
 dependencies = [
  "bytemuck",
- "itertools",
  "memmap2",
  "num-bigint",
  "num-integer",

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

@@ -1,6 +1,6 @@
 [package]
 name = "wavelet-matrix"
-version = "2.2.2"
+version = "2.2.4"
 edition = "2024"
 readme = "README.md"
 
@@ -11,7 +11,6 @@ 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"

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

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

{wavelet_matrix-2.2.2 → wavelet_matrix-2.2.4}/benchmarks/bench_disk_wavelet_matrix.py

@@ -22,39 +22,39 @@ def random_disk_wavelet_matrix(random_data: list[int]) -> WaveletMatrix:
 @pytest.mark.parametrize("size", [500, 10000, 200000])
 @pytest.mark.parametrize("max_bit", [8, 32, 128])
 class BenchDiskWaveletMatrix:
-    def bench_construction(self, benchmark, random_data):
+    def bench_disk_construction(self, benchmark, random_data):
         """Benchmark DiskWaveletMatrix construction"""
         benchmark(WaveletMatrix, random_data, on_disk=True)
 
-    def bench_values(self, benchmark, random_disk_wavelet_matrix):
+    def bench_disk_values(self, benchmark, random_disk_wavelet_matrix):
         """Benchmark DiskWaveletMatrix values retrieval"""
         benchmark(random_disk_wavelet_matrix.values)
 
-    def bench_access(self, benchmark, random_disk_wavelet_matrix, size):
+    def bench_disk_access(self, benchmark, random_disk_wavelet_matrix, size):
         """Benchmark DiskWaveletMatrix access"""
         index = random.randint(0, size - 1)
         benchmark(random_disk_wavelet_matrix.access, index)
 
-    def bench_rank(self, benchmark, random_disk_wavelet_matrix, size):
+    def bench_disk_rank(self, benchmark, random_disk_wavelet_matrix, size):
         """Benchmark DiskWaveletMatrix rank"""
         value = random_disk_wavelet_matrix[random.randint(0, size - 1)]
         end = random.randint(0, size)
         benchmark(random_disk_wavelet_matrix.rank, value, end)
 
-    def bench_select(self, benchmark, random_disk_wavelet_matrix, size):
+    def bench_disk_select(self, benchmark, random_disk_wavelet_matrix, size):
         """Benchmark DiskWaveletMatrix select"""
         value = random_disk_wavelet_matrix[random.randint(0, size - 1)]
         kth = random_disk_wavelet_matrix.rank(value, size)
         benchmark(random_disk_wavelet_matrix.select, value, kth)
 
-    def bench_quantile(self, benchmark, random_disk_wavelet_matrix, size):
+    def bench_disk_quantile(self, benchmark, random_disk_wavelet_matrix, size):
         """Benchmark DiskWaveletMatrix quantile"""
         start = size // 4
         end = size * 3 // 4
         kth = random.randint(1, end - start)
         benchmark(random_disk_wavelet_matrix.quantile, start, end, kth)
 
-    def bench_range_freq(self, benchmark, random_disk_wavelet_matrix, size, max_bit):
+    def bench_disk_range_freq(self, benchmark, random_disk_wavelet_matrix, size, max_bit):
         """Benchmark DiskWaveletMatrix range_freq"""
         start = size // 4
         end = size * 3 // 4
@@ -62,28 +62,28 @@ class BenchDiskWaveletMatrix:
         upper = (1 << max_bit) * 3 // 4
         benchmark(random_disk_wavelet_matrix.range_freq, start, end, lower, upper)
 
-    def bench_range_maxk(self, benchmark, random_disk_wavelet_matrix, size):
+    def bench_disk_range_maxk(self, benchmark, random_disk_wavelet_matrix, size):
         """Benchmark DiskWaveletMatrix range_maxk"""
         start = size // 4
         end = size * 3 // 4
         k = 10
         benchmark(random_disk_wavelet_matrix.range_maxk, start, end, k)
 
-    def bench_range_mink(self, benchmark, random_disk_wavelet_matrix, size):
+    def bench_disk_range_mink(self, benchmark, random_disk_wavelet_matrix, size):
         """Benchmark DiskWaveletMatrix range_mink"""
         start = size // 4
         end = size * 3 // 4
         k = 10
         benchmark(random_disk_wavelet_matrix.range_mink, start, end, k)
 
-    def bench_prev_value(self, benchmark, random_disk_wavelet_matrix, size, max_bit):
+    def bench_disk_prev_value(self, benchmark, random_disk_wavelet_matrix, size, max_bit):
         """Benchmark DiskWaveletMatrix prev_value"""
         start = size // 4
         end = size * 3 // 4
         upper = 1 << (max_bit - 1)
         benchmark(random_disk_wavelet_matrix.prev_value, start, end, upper)
 
-    def bench_next_value(self, benchmark, random_disk_wavelet_matrix, size, max_bit):
+    def bench_disk_next_value(self, benchmark, random_disk_wavelet_matrix, size, max_bit):
         """Benchmark DiskWaveletMatrix next_value"""
         start = size // 4
         end = size * 3 // 4

{wavelet_matrix-2.2.2 → wavelet_matrix-2.2.4}/pyproject.toml

@@ -75,7 +75,7 @@ addopts = [
     "--strict-markers",
     "--tb=short",
     "--benchmark-columns=mean,stddev,min,max",
-    "--benchmark-group-by=fullfunc",
+    "--benchmark-group-by=func",
 ]
 
 [tool.ruff]

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

@@ -30,29 +30,29 @@ pub(crate) struct DiskBitVector {
 impl DiskBitVector {
     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[..]);
+        let blocks_slice: &[BlockType] = cast_slice(&blocks[..]);
 
         // Build the rank index structure.
         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)
+            .set_len((blocks_slice.len() + 1) as u64 * mem::size_of::<usize>() as u64)
             .map_err(PyRuntimeError::new_err)?;
         #[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[..]);
+        let ranks_slice: &mut [usize] = cast_slice_mut(&mut ranks[..]);
         iter::once(0usize)
-            .chain(blocks_data.iter().scan(0usize, |acc, block| {
+            .chain(blocks_slice.iter().scan(0usize, |acc, block| {
                 *acc += block.count_ones() as usize;
                 Some(*acc)
             }))
             .enumerate()
-            .for_each(|(index, rank)| ranks_data[index] = rank);
+            .for_each(|(index, rank)| ranks_slice[index] = rank);
 
         let select_index_file = [
             {
                 let file = tempfile().map_err(PyRuntimeError::new_err)?;
                 file.set_len(
-                    (((len - ranks_data.last().unwrap()) / SELECT_INDEX_INTERVAL + 2)
+                    (((len - ranks_slice.last().unwrap()) / SELECT_INDEX_INTERVAL + 2)
                         * mem::size_of::<usize>()) as u64,
                 )
                 .map_err(PyRuntimeError::new_err)?;
@@ -61,7 +61,7 @@ impl DiskBitVector {
             {
                 let file = tempfile().map_err(PyRuntimeError::new_err)?;
                 file.set_len(
-                    ((ranks_data.last().unwrap() / SELECT_INDEX_INTERVAL + 2)
+                    ((ranks_slice.last().unwrap() / SELECT_INDEX_INTERVAL + 2)
                         * mem::size_of::<usize>()) as u64,
                 )
                 .map_err(PyRuntimeError::new_err)?;
@@ -74,14 +74,14 @@ impl DiskBitVector {
         #[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] = [
+        let select_index_slice: [&mut [usize]; 2] = [
             cast_slice_mut(&mut select_index_0[..]),
             cast_slice_mut(&mut select_index_1[..]),
         ];
-        select_index_data[0][0] = 0;
-        select_index_data[1][0] = 0;
+        select_index_slice[0][0] = 0;
+        select_index_slice[1][0] = 0;
         let mut count = [0usize, 0usize];
-        for (index, bit) in blocks_data
+        for (index, bit) in blocks_slice
             .iter()
             .flat_map(|block| {
                 (0..BlockType::BITS as usize)
@@ -93,11 +93,11 @@ impl DiskBitVector {
             count[bit] += 1;
             let (count_div, count_rem) = count[bit].div_rem(&SELECT_INDEX_INTERVAL);
             if count_rem.is_zero() {
-                select_index_data[bit][count_div] = index;
+                select_index_slice[bit][count_div] = index;
             }
         }
-        select_index_data[0][count[0] / SELECT_INDEX_INTERVAL + 1] = len;
-        select_index_data[1][count[1] / SELECT_INDEX_INTERVAL + 1] = len;
+        select_index_slice[0][count[0] / SELECT_INDEX_INTERVAL + 1] = len;
+        select_index_slice[1][count[1] / SELECT_INDEX_INTERVAL + 1] = len;
 
         Ok(Self {
             len,
@@ -116,42 +116,47 @@ impl DiskBitVector {
             select_index_file,
         })
     }
-}
 
-impl Clone for DiskBitVector {
-    fn clone(&self) -> Self {
-        let ranks_file = tempfile().unwrap();
-        ranks_file.set_len(self.ranks.len() as u64).unwrap();
+    pub(super) fn try_clone(&self) -> PyResult<Self> {
+        let ranks_file = tempfile().map_err(PyRuntimeError::new_err)?;
+        ranks_file
+            .set_len(self.ranks.len() as u64)
+            .map_err(PyRuntimeError::new_err)?;
         #[allow(unsafe_code)]
-        let mut ranks = unsafe { MmapMut::map_mut(&ranks_file).unwrap() };
+        let mut ranks = unsafe { MmapMut::map_mut(&ranks_file).map_err(PyRuntimeError::new_err)? };
         ranks.copy_from_slice(&self.ranks[..]);
 
-        let blocks_file = tempfile().unwrap();
-        blocks_file.set_len(self.blocks.len() as u64).unwrap();
+        let blocks_file = tempfile().map_err(PyRuntimeError::new_err)?;
+        blocks_file
+            .set_len(self.blocks.len() as u64)
+            .map_err(PyRuntimeError::new_err)?;
         #[allow(unsafe_code)]
-        let mut blocks = unsafe { MmapMut::map_mut(&blocks_file).unwrap() };
+        let mut blocks =
+            unsafe { MmapMut::map_mut(&blocks_file).map_err(PyRuntimeError::new_err)? };
         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();
+                let file = tempfile().map_err(PyRuntimeError::new_err)?;
+                file.set_len(self.select_index[0].len() as u64)
+                    .map_err(PyRuntimeError::new_err)?;
                 file
             },
             {
-                let file = tempfile().unwrap();
-                file.set_len(self.select_index[1].len() as u64).unwrap();
+                let file = tempfile().map_err(PyRuntimeError::new_err)?;
+                file.set_len(self.select_index[1].len() as u64)
+                    .map_err(PyRuntimeError::new_err)?;
                 file
             },
         ];
         let mut select_index = [
             #[allow(unsafe_code)]
             unsafe {
-                MmapMut::map_mut(&select_index_file[0]).unwrap()
+                MmapMut::map_mut(&select_index_file[0]).map_err(PyRuntimeError::new_err)?
             },
             #[allow(unsafe_code)]
             unsafe {
-                MmapMut::map_mut(&select_index_file[1]).unwrap()
+                MmapMut::map_mut(&select_index_file[1]).map_err(PyRuntimeError::new_err)?
             },
         ];
         select_index[0].copy_from_slice(&self.select_index[0][..]);
@@ -159,18 +164,22 @@ impl Clone for DiskBitVector {
 
         let [select_index_0, select_index_1] = select_index;
 
-        Self {
+        Ok(Self {
             len: self.len,
-            ranks: ranks.make_read_only().unwrap(),
+            ranks: ranks.make_read_only().map_err(PyRuntimeError::new_err)?,
             ranks_file,
-            blocks: blocks.make_read_only().unwrap(),
+            blocks: blocks.make_read_only().map_err(PyRuntimeError::new_err)?,
             blocks_file,
             select_index: [
-                select_index_0.make_read_only().unwrap(),
-                select_index_1.make_read_only().unwrap(),
+                select_index_0
+                    .make_read_only()
+                    .map_err(PyRuntimeError::new_err)?,
+                select_index_1
+                    .make_read_only()
+                    .map_err(PyRuntimeError::new_err)?,
             ],
             select_index_file,
-        }
+        })
     }
 }
 
@@ -186,8 +195,8 @@ impl BitVectorTrait for DiskBitVector {
             return Err(PyIndexError::new_err("index out of bounds"));
         }
         let (block_index, bit_index) = index.div_rem(&(BlockType::BITS as usize));
-        let blocks_data: &[BlockType] = cast_slice(&self.blocks[..]);
-        Ok(((blocks_data[block_index] >> bit_index) & BlockType::one()).is_one())
+        let blocks_slice: &[BlockType] = cast_slice(&self.blocks[..]);
+        Ok(((blocks_slice[block_index] >> bit_index) & BlockType::one()).is_one())
     }
 
     #[inline]
@@ -203,11 +212,11 @@ impl BitVectorTrait for DiskBitVector {
         }
 
         let (block_index, bit_index) = end.div_rem(&(BlockType::BITS as usize));
-        let ranks_data: &[usize] = cast_slice(&self.ranks[..]);
-        let blocks_data: &[BlockType] = cast_slice(&self.blocks[..]);
-        let mut rank = ranks_data[block_index];
-        if block_index < blocks_data.len() {
-            rank += (blocks_data[block_index]
+        let ranks_slice: &[usize] = cast_slice(&self.ranks[..]);
+        let blocks_slice: &[BlockType] = cast_slice(&self.blocks[..]);
+        let mut rank = ranks_slice[block_index];
+        if block_index < blocks_slice.len() {
+            rank += (blocks_slice[block_index]
                 & ((BlockType::one() << bit_index) - BlockType::one()))
             .count_ones() as usize;
         }
@@ -223,25 +232,25 @@ impl BitVectorTrait for DiskBitVector {
             return Ok(None);
         }
 
-        let select_index_data: [&[usize]; 2] = [
+        let select_index_slice: [&[usize]; 2] = [
             cast_slice(&self.select_index[0][..]),
             cast_slice(&self.select_index[1][..]),
         ];
-        let ranks_data: &[usize] = cast_slice(&self.ranks[..]);
-        let blocks_data: &[BlockType] = cast_slice(&self.blocks[..]);
+        let ranks_slice: &[usize] = cast_slice(&self.ranks[..]);
+        let blocks_slice: &[BlockType] = cast_slice(&self.blocks[..]);
 
         let block_index = {
-            let mut left = select_index_data[bit as usize][(kth - 1) / SELECT_INDEX_INTERVAL]
+            let mut left = select_index_slice[bit as usize][(kth - 1) / SELECT_INDEX_INTERVAL]
                 / (BlockType::BITS as usize);
-            let mut right = select_index_data[bit as usize][kth / SELECT_INDEX_INTERVAL + 1]
+            let mut right = select_index_slice[bit as usize][kth / SELECT_INDEX_INTERVAL + 1]
                 .div_ceil(BlockType::BITS as usize);
             debug_assert!(right <= self.blocks.len());
             while left + 1 < right {
                 let mid = (left + right) / 2;
                 let rank_at_mid = if bit {
-                    ranks_data[mid]
+                    ranks_slice[mid]
                 } else {
-                    mid * (BlockType::BITS as usize) - ranks_data[mid]
+                    mid * (BlockType::BITS as usize) - ranks_slice[mid]
                 };
                 if rank_at_mid < kth {
                     left = mid;
@@ -253,11 +262,11 @@ impl BitVectorTrait for DiskBitVector {
         };
 
         kth -= if bit {
-            ranks_data[block_index]
+            ranks_slice[block_index]
         } else {
-            block_index * (BlockType::BITS as usize) - ranks_data[block_index]
+            block_index * (BlockType::BITS as usize) - ranks_slice[block_index]
         };
-        let index = blocks_data[block_index].bit_select(bit, kth).unwrap()
+        let index = blocks_slice[block_index].bit_select(bit, kth).unwrap()
             + block_index * (BlockType::BITS as usize);
 
         Ok(Some(index))
@@ -278,11 +287,11 @@ mod tests {
             .unwrap();
         #[allow(unsafe_code)]
         let mut blocks = unsafe { MmapMut::map_mut(&blocks_file).unwrap() };
-        let blocks_data: &mut [BlockType] = cast_slice_mut(&mut blocks[..]);
+        let blocks_slice: &mut [BlockType] = cast_slice_mut(&mut blocks[..]);
         bits.chunks(BlockType::BITS as usize)
             .enumerate()
             .for_each(|(index, chunk)| {
-                blocks_data[index] =
+                blocks_slice[index] =
                     chunk
                         .iter()
                         .enumerate()

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

@@ -14,7 +14,6 @@ use crate::traits::{
     wavelet_matrix::wavelet_matrix::WaveletMatrixTrait,
 };
 
-#[derive(Clone)]
 pub(crate) struct DiskWaveletMatrix<NumberType> {
     layers: Vec<DiskBitVector>,
     zeros_count_per_layer: Vec<usize>,
@@ -34,8 +33,8 @@ where
 
         let mut values = data;
         let mut _values_file = data_file;
-        let values_data: &[NumberType] = cast_slice(&values[..]);
-        let height = values_data
+        let values_slice: &[NumberType] = cast_slice(&values[..]);
+        let height = values_slice
             .par_iter()
             .max()
             .map_or(0usize, |max| max.bit_width());
@@ -60,14 +59,14 @@ where
             );
             let current_layer_bits_data: &mut [BlockType] =
                 cast_slice_mut(&mut current_layer_bits[..]);
-            let values_data: &[NumberType] = cast_slice(&values[..]);
+            let values_slice: &[NumberType] = cast_slice(&values[..]);
             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() {
+                    for (j, value) in values_slice[start..end].iter().enumerate() {
                         if ((value >> (height - i - 1)) & NumberType::one()).is_one() {
                             *block |= BlockType::one() << j;
                         }
@@ -104,7 +103,7 @@ where
                             .map(move |i| ((block >> i) & BlockType::one()).is_one())
                     })
                     .take(len),
-                values_data.iter(),
+                values_slice.iter(),
             ) {
                 if bit {
                     next_values_data[one_index] = *value;
@@ -139,6 +138,21 @@ where
             phantom: marker::PhantomData,
         })
     }
+
+    pub(crate) fn try_clone(&self) -> PyResult<Self> {
+        let layers = self
+            .layers
+            .par_iter()
+            .map(|layer| layer.try_clone())
+            .collect::<PyResult<Vec<_>>>()?;
+        Ok(Self {
+            layers,
+            zeros_count_per_layer: self.zeros_count_per_layer.clone(),
+            height: self.height,
+            len: self.len,
+            phantom: marker::PhantomData,
+        })
+    }
 }
 
 impl<NumberType> WaveletMatrixTrait<NumberType, DiskBitVector> for DiskWaveletMatrix<NumberType>
@@ -195,8 +209,8 @@ mod tests {
                 .map_err(PyRuntimeError::new_err)
                 .unwrap()
         };
-        let mmap_data: &mut [u8] = cast_slice_mut(&mut mmap[..]);
-        mmap_data.copy_from_slice(&elements);
+        let mmap_slice: &mut [u8] = cast_slice_mut(&mut mmap[..]);
+        mmap_slice.copy_from_slice(&elements);
         DiskWaveletMatrix::new(mmap, file).unwrap()
     }
 
@@ -211,8 +225,8 @@ mod tests {
                 .map_err(PyRuntimeError::new_err)
                 .unwrap()
         };
-        let mmap_data: &mut [u128] = cast_slice_mut(&mut mmap[..]);
-        mmap_data.copy_from_slice(&elements);
+        let mmap_slice: &mut [u128] = cast_slice_mut(&mut mmap[..]);
+        mmap_slice.copy_from_slice(&elements);
         DiskWaveletMatrix::new(mmap, file).unwrap()
     }
 
@@ -422,8 +436,8 @@ mod tests {
                 .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 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();
         assert_eq!(wv_u8.len(), 64);
         assert_eq!(wv_u8.height(), 8);
@@ -452,8 +466,8 @@ mod tests {
                 .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 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();
         assert_eq!(wv_u128.len(), 64);
         assert_eq!(wv_u128.height(), 128);

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

@@ -17,7 +17,6 @@ use crate::{
     wavelet_matrix::wavelet_matrix::WaveletMatrix,
 };
 
-#[derive(Clone)]
 enum WaveletMatrixEnum {
     U8(WaveletMatrix<u8>),
     U16(WaveletMatrix<u16>),
@@ -56,7 +55,6 @@ enum WaveletMatrixEnum {
 /// from wavelet_matrix import WaveletMatrix
 /// wm = WaveletMatrix([5, 4, 5, 5, 2, 1, 5, 6, 1, 3, 5, 0], on_disk=False)  # in-memory
 /// ```
-#[derive(Clone)]
 #[pyclass(name = "WaveletMatrix", skip_from_py_object)]
 pub(crate) struct PyWaveletMatrix {
     inner: WaveletMatrixEnum,
@@ -289,11 +287,45 @@ impl PyWaveletMatrix {
     }
 
     fn __copy__(&self, py: Python<'_>) -> PyResult<Self> {
-        py.detach(move || Ok(self.clone()))
+        py.detach(move || match &self.inner {
+            WaveletMatrixEnum::U8(wm) => Ok(PyWaveletMatrix {
+                inner: WaveletMatrixEnum::U8(wm.clone()),
+            }),
+            WaveletMatrixEnum::U16(wm) => Ok(PyWaveletMatrix {
+                inner: WaveletMatrixEnum::U16(wm.clone()),
+            }),
+            WaveletMatrixEnum::U32(wm) => Ok(PyWaveletMatrix {
+                inner: WaveletMatrixEnum::U32(wm.clone()),
+            }),
+            WaveletMatrixEnum::U64(wm) => Ok(PyWaveletMatrix {
+                inner: WaveletMatrixEnum::U64(wm.clone()),
+            }),
+            WaveletMatrixEnum::U128(wm) => Ok(PyWaveletMatrix {
+                inner: WaveletMatrixEnum::U128(wm.clone()),
+            }),
+            WaveletMatrixEnum::BigUint(wm) => Ok(PyWaveletMatrix {
+                inner: WaveletMatrixEnum::BigUint(wm.clone()),
+            }),
+            WaveletMatrixEnum::DiskU8(wm) => Ok(PyWaveletMatrix {
+                inner: WaveletMatrixEnum::DiskU8(wm.try_clone()?),
+            }),
+            WaveletMatrixEnum::DiskU16(wm) => Ok(PyWaveletMatrix {
+                inner: WaveletMatrixEnum::DiskU16(wm.try_clone()?),
+            }),
+            WaveletMatrixEnum::DiskU32(wm) => Ok(PyWaveletMatrix {
+                inner: WaveletMatrixEnum::DiskU32(wm.try_clone()?),
+            }),
+            WaveletMatrixEnum::DiskU64(wm) => Ok(PyWaveletMatrix {
+                inner: WaveletMatrixEnum::DiskU64(wm.try_clone()?),
+            }),
+            WaveletMatrixEnum::DiskU128(wm) => Ok(PyWaveletMatrix {
+                inner: WaveletMatrixEnum::DiskU128(wm.try_clone()?),
+            }),
+        })
     }
 
     fn __deepcopy__(&self, py: Python<'_>, _memo: &Bound<'_, PyAny>) -> PyResult<Self> {
-        py.detach(move || Ok(self.clone()))
+        self.__copy__(py)
     }
 
     /// Return the entire sequence as a Python list.

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

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