[pre-commit.ci] auto fixes from pre-commit.com hooks

for more information, see https://pre-commit.ci

Author: pre-commit-ci[bot]

src/rapids_singlecell/pertpy_gpu/_distances_standalone.py

@@ -131,7 +131,7 @@ def generate_bootstrap_indices(
     """
     Generate bootstrap indices for all groups and all bootstrap iterations.
     This matches the CPU implementation's random sampling logic for reproducibility.
-    
+
     Parameters
     ----------
     cat_offsets : cp.ndarray
@@ -142,31 +142,31 @@ def generate_bootstrap_indices(
         Number of bootstrap samples
     random_state : int
         Random seed for reproducibility
-        
+
     Returns
     -------
     bootstrap_indices : list[list[cp.ndarray]]
         For each bootstrap iteration, list of indices arrays for each group
         Shape: [n_bootstrap][k] where each element is cp.ndarray of group_size
     """
     import numpy as np
-    
+
     # Use same RNG logic as CPU code
     rng = np.random.default_rng(random_state)
-    
+
     # Convert to numpy for CPU-based random generation
     cat_offsets_np = cat_offsets.get()
-    
+
     bootstrap_indices = []
-    
+
     for bootstrap_iter in range(n_bootstrap):
         group_indices = []
-        
+
         for group_idx in range(k):
             start_idx = cat_offsets_np[group_idx]
             end_idx = cat_offsets_np[group_idx + 1]
             group_size = end_idx - start_idx
-            
+
             if group_size > 0:
                 # Generate bootstrap indices using same logic as CPU code
                 # rng.choice(a=X.shape[0], size=X.shape[0], replace=True)
@@ -178,9 +178,9 @@ def generate_bootstrap_indices(
             else:
                 # Empty group
                 group_indices.append(cp.array([], dtype=cp.int32))
-        
+
         bootstrap_indices.append(group_indices)
-    
+
     return bootstrap_indices
 
 
@@ -193,7 +193,7 @@ def _bootstrap_sample_cells_from_indices(
 ) -> tuple[cp.ndarray, cp.ndarray]:
     """
     Bootstrap sample cells using pre-generated indices.
-    
+
     Parameters
     ----------
     cat_offsets : cp.ndarray
@@ -204,32 +204,32 @@ def _bootstrap_sample_cells_from_indices(
         Number of groups
     bootstrap_group_indices : list[cp.ndarray]
         Pre-generated bootstrap indices for each group
-        
+
     Returns
     -------
     new_cat_offsets, new_cell_indices : tuple[cp.ndarray, cp.ndarray]
         New category structure with bootstrapped cells
     """
     new_cell_indices = []
     new_cat_offsets = cp.zeros(k + 1, dtype=cp.int32)
-    
+
     for group_idx in range(k):
         start_idx = cat_offsets[group_idx]
         end_idx = cat_offsets[group_idx + 1]
         group_size = end_idx - start_idx
-        
+
         if group_size > 0:
             # Get original cell indices for this group
             group_cells = cell_indices[start_idx:end_idx]
-            
+
             # Use pre-generated bootstrap indices
             bootstrap_indices = bootstrap_group_indices[group_idx]
             bootstrap_cells = group_cells[bootstrap_indices]
-            
+
             new_cell_indices.extend(bootstrap_cells.get().tolist())
-        
+
         new_cat_offsets[group_idx + 1] = len(new_cell_indices)
-    
+
     return new_cat_offsets, cp.array(new_cell_indices, dtype=cp.int32)
 
 
@@ -245,7 +245,7 @@ def compute_pairwise_means_gpu_bootstrap(
     """
     Compute bootstrap statistics for between-group distances.
     Uses CPU-compatible random generation for reproducibility.
-    
+
     Returns:
         means: [k, k] matrix of bootstrap means
         variances: [k, k] matrix of bootstrap variances
@@ -254,9 +254,9 @@ def compute_pairwise_means_gpu_bootstrap(
     bootstrap_indices = generate_bootstrap_indices(
         cat_offsets, k, n_bootstrap, random_state
     )
-    
+
     bootstrap_results = []
-    
+
     for bootstrap_iter in range(n_bootstrap):
         # Use pre-generated indices for this bootstrap iteration
         boot_cat_offsets, boot_cell_indices = _bootstrap_sample_cells_from_indices(
@@ -265,7 +265,7 @@ def compute_pairwise_means_gpu_bootstrap(
             k=k,
             bootstrap_group_indices=bootstrap_indices[bootstrap_iter],
         )
-        
+
         # Compute distances with bootstrapped samples
         pairwise_means = compute_pairwise_means_gpu(
             embedding=embedding,
@@ -274,12 +274,12 @@ def compute_pairwise_means_gpu_bootstrap(
             k=k,
         )
         bootstrap_results.append(pairwise_means.get())
-    
+
     # Compute statistics across bootstrap samples
     bootstrap_stack = cp.array(bootstrap_results)  # [n_bootstrap, k, k]
     means = cp.mean(bootstrap_stack, axis=0)
     variances = cp.var(bootstrap_stack, axis=0)
-    
+
     return means, variances
 
 

tmp_scripts/compute_edistance_standalone.py

@@ -2,18 +2,18 @@
 
 import os
 import time
+from argparse import ArgumentParser
+from pathlib import Path
 
 import anndata as ad
 import cupy as cp
 import numpy as np
 import pandas as pd
 import rmm
 from rmm.allocators.cupy import rmm_cupy_allocator
-from argparse import ArgumentParser
-from pathlib import Path
+
 import rapids_singlecell as rsc
 from rapids_singlecell.pertpy_gpu._distances_standalone import pairwise_edistance_gpu
-from pathlib import Path
 
 rmm.reinitialize(
     managed_memory=False,  # Allows oversubscription
@@ -37,24 +37,31 @@
 
     df_expected = None
     if bootstrap:
-        df_cpu_bootstrap_var = pd.read_csv(home_dir / "df_cpu_bootstrap_var.csv", index_col=0)
+        df_cpu_bootstrap_var = pd.read_csv(
+            home_dir / "df_cpu_bootstrap_var.csv", index_col=0
+        )
         df_cpu_bootstrap = pd.read_csv(home_dir / "df_cpu_bootstrap.csv", index_col=0)
         df_expected = df_cpu_bootstrap
     else:
         df_cpu_float64 = pd.read_csv(home_dir / "df_cpu_float64.csv", index_col=0)
         df_expected = df_cpu_float64
 
-
     start_time = time.time()
     if not bootstrap:
-        df_gpu = pairwise_edistance_gpu(adata, groupby=obs_key, obsm_key="X_pca", bootstrap=bootstrap)
+        df_gpu = pairwise_edistance_gpu(
+            adata, groupby=obs_key, obsm_key="X_pca", bootstrap=bootstrap
+        )
     else:
-        df_gpu, df_gpu_var = pairwise_edistance_gpu(adata, groupby=obs_key, obsm_key="X_pca", bootstrap=bootstrap, n_bootstrap=100)
+        df_gpu, df_gpu_var = pairwise_edistance_gpu(
+            adata,
+            groupby=obs_key,
+            obsm_key="X_pca",
+            bootstrap=bootstrap,
+            n_bootstrap=100,
+        )
     end_time = time.time()
     print(f"Time taken: {end_time - start_time} seconds")
 
-  
-
     is_not_close = []
     groups = adata.obs[obs_key].unique()
     k = len(groups)
@@ -67,15 +74,18 @@
                 assert df_gpu.loc[group_x, group_y] == 0
             else:
                 if not np.isclose(
-                    df_gpu.loc[group_x, group_y], df_expected.loc[group_x, group_y], atol=atol
+                    df_gpu.loc[group_x, group_y],
+                    df_expected.loc[group_x, group_y],
+                    atol=atol,
                 ):
                     is_not_close.append(
                         (
                             (group_x, group_y),
                             df_expected.loc[group_x, group_y],
                             df_gpu.loc[group_x, group_y],
                             np.abs(
-                                df_expected.loc[group_x, group_y] - df_gpu.loc[group_x, group_y]
+                                df_expected.loc[group_x, group_y]
+                                - df_gpu.loc[group_x, group_y]
                             ),
                         )
                     )