M3Drop 0.4.38__py3-none-any.whl → 0.4.40__py3-none-any.whl

m3Drop/diagnosticsGPU.py

@@ -12,12 +12,15 @@ from scipy import sparse
 from scipy import stats
 import anndata
 
-# [GOVERNOR INTEGRATION]
+# [GOVERNOR INTEGRATION] 
 from .coreGPU import hidden_calc_valsGPU, NBumiFitModelGPU, NBumiFitDispVsMeanGPU, get_optimal_chunk_size
 from cupy.sparse import csr_matrix as cp_csr_matrix
 import scipy.sparse as sp
 from scipy.sparse import csr_matrix as sp_csr_matrix
+
 import statsmodels.api as sm
+from scipy.stats import norm
+from statsmodels.stats.multitest import multipletests
 
 def NBumiFitBasicModelGPU(
     cleaned_filename: str,
@@ -137,7 +140,7 @@ def NBumiCheckFitFSGPU(
     plot_filename=None
 ) -> dict:
     """
-    Calculates the fit errors (gene_error, cell_error) for a given model.
+    FIXED VERSION - No cupy.errstate, proper GPU computation.
     """
     start_time = time.perf_counter()
     print(f"FUNCTION: NBumiCheckFitFS() | FILE: {cleaned_filename}")
@@ -168,10 +171,14 @@ def NBumiCheckFitFSGPU(
     print("Phase [1/2]: COMPLETE")
 
     # --- Phase 2: Calculate Expected Dropouts ---
-    print(f"Phase [2/2]: Calculating expected dropouts (Chunk: {chunk_size})...")
+    print("Phase [2/2]: Calculating expected dropouts from data chunks...")
+    
+    # [GOVERNOR INTEGRATION] Removed naive calculation, utilizing Governor's chunk_size
+    optimal_chunk = chunk_size
+    print(f"  Using governor chunk size: {optimal_chunk}")
     
-    for i in range(0, nc, chunk_size):
-        end_col = min(i + chunk_size, nc)
+    for i in range(0, nc, optimal_chunk):
+        end_col = min(i + optimal_chunk, nc)
         print(f"Phase [2/2]: Processing: {end_col} of {nc} cells.", end='\r')
 
         tis_chunk_gpu = tis_gpu[i:end_col]
@@ -192,7 +199,11 @@ def NBumiCheckFitFSGPU(
         
         # Clean up
         del mu_chunk_gpu, p_is_chunk_gpu, base, tis_chunk_gpu
-        cp.get_default_memory_pool().free_all_blocks()
+        
+        # Periodic memory cleanup
+        mempool = cp.get_default_memory_pool()
+        if (i // optimal_chunk) % 10 == 0:
+            mempool.free_all_blocks()
 
     print(f"Phase [2/2]: COMPLETE{' ' * 50}")
 
@@ -245,7 +256,7 @@ def NBumiCheckFitFSGPU(
     }
 
 def NBumiCompareModelsGPU(
-    raw_filename: str, # Kept for API compatibility, but functionally we use cleaned_filename for indices
+    raw_filename: str,
     cleaned_filename: str,
     stats: dict,
     fit_adjust: dict,
@@ -254,118 +265,132 @@ def NBumiCompareModelsGPU(
     plot_filename=None
 ) -> dict:
     """
-    OPTIMIZED VERSION (IN-MEMORY):
-    - Eliminates the 46GB '_basic_norm.h5ad' temporary file.
-    - Performs depth normalization and variance calculation on-the-fly in GPU VRAM.
-    - PRESERVED SCIENTIFIC LOGIC: Var(X) = E[X^2] - (E[X])^2 on normalized data.
+    OPTIMIZED VERSION - Faster normalization and sparse matrix writing.
     """
     pipeline_start_time = time.time()
     print(f"FUNCTION: NBumiCompareModels() | Comparing models for {cleaned_filename}")
 
-    # [GOVERNOR] High multiplier (12.0) because we hold Raw + Norm + Square in VRAM
+    # [GOVERNOR INTEGRATION] Calculate chunk size for normalization phase (heavy IO)
     if chunk_size is None:
-        chunk_size = get_optimal_chunk_size(cleaned_filename, multiplier=12.0, is_dense=False)
-
-    # --- Phase 1: In-Memory "Basic Fit" (Normalization + Variance) ---
-    print("Phase [1/3]: Calculating Basic Model (Depth-Normalized) variance on-the-fly...")
-    
-    # 1. Prepare Size Factors (CPU)
-    tjs = stats['tjs'].values # Gene sums
-    tis = stats['tis'].values # Cell sums
-    nc, ng = stats['nc'], stats['ng']
+        # Multiplier 10.0 for safety during normalization of massive dense expansion
+        chunk_size = get_optimal_chunk_size(cleaned_filename, multiplier=10.0, is_dense=True)
+
+    # --- Phase 1: OPTIMIZED Normalization ---
+    print("Phase [1/4]: Creating temporary 'basic' normalized data file...")
+    basic_norm_filename = cleaned_filename.replace('.h5ad', '_basic_norm.h5ad')
+
+    # Read metadata. In 'backed' mode, this keeps a file handle open.
+    adata_meta = anndata.read_h5ad(cleaned_filename, backed='r')
+    nc, ng = adata_meta.shape
+    obs_df = adata_meta.obs.copy()
+    var_df = adata_meta.var.copy()
     
-    median_sum = np.median(tis[tis > 0])
-    size_factors = np.ones_like(tis, dtype=np.float32)
-    non_zero_mask = tis > 0
-    size_factors[non_zero_mask] = tis[non_zero_mask] / median_sum
+    cell_sums = stats['tis'].values
+    median_sum = np.median(cell_sums[cell_sums > 0])
     
-    # 2. Prepare GPU Arrays
-    sum_x_sq_gpu = cp.zeros(ng, dtype=cp.float64)
-    sum_x_gpu = cp.zeros(ng, dtype=cp.float64) # Need sum(x) to calc mean(x) for variance
-    
-    # 3. GPU Loop (Raw Data -> Normalize -> Accumulate)
-    # CRITICAL: We read CLEANED_FILENAME to ensure indices match 'stats'
-    with h5py.File(cleaned_filename, 'r') as f_in:
-        h5_indptr = f_in['X']['indptr']
-        h5_data = f_in['X']['data']
-        h5_indices = f_in['X']['indices']
+    # Avoid division by zero for cells with zero counts
+    size_factors = np.ones_like(cell_sums, dtype=np.float32)
+    non_zero_mask = cell_sums > 0
+    size_factors[non_zero_mask] = cell_sums[non_zero_mask] / median_sum
+
+    adata_out = anndata.AnnData(obs=obs_df, var=var_df)
+    # [OPTION 2 CHANGE] Removed compression="gzip" to speed up I/O
+    adata_out.write_h5ad(basic_norm_filename)
+
+    with h5py.File(basic_norm_filename, 'a') as f_out:
+        if 'X' in f_out:
+            del f_out['X']
+        x_group_out = f_out.create_group('X')
+        x_group_out.attrs['encoding-type'] = 'csr_matrix'
+        x_group_out.attrs['encoding-version'] = '0.1.0'
+        x_group_out.attrs['shape'] = np.array([nc, ng], dtype='int64')
+
+        out_data = x_group_out.create_dataset('data', shape=(0,), maxshape=(None,), dtype='float32')
+        out_indices = x_group_out.create_dataset('indices', shape=(0,), maxshape=(None,), dtype='int32')
+        out_indptr = x_group_out.create_dataset('indptr', shape=(nc + 1,), dtype='int64')
+        out_indptr[0] = 0
+        current_nnz = 0
+
+        with h5py.File(cleaned_filename, 'r') as f_in:
+            h5_indptr = f_in['X']['indptr']
+            h5_data = f_in['X']['data']
+            h5_indices = f_in['X']['indices']
+
+            for i in range(0, nc, chunk_size):
+                end_row = min(i + chunk_size, nc)
+                print(f"Phase [1/4]: Normalizing: {end_row} of {nc} cells.", end='\r')
+                
+                start_idx, end_idx = h5_indptr[i], h5_indptr[end_row]
+                if start_idx == end_idx:
+                    out_indptr[i + 1 : end_row + 1] = current_nnz
+                    continue
 
-        for i in range(0, nc, chunk_size):
-            end_row = min(i + chunk_size, nc)
-            print(f"Phase [1/3]: Processing: {end_row} of {nc} cells.", end='\r')
-            
-            start_idx, end_idx = h5_indptr[i], h5_indptr[end_row]
-            if start_idx == end_idx: continue
-
-            # Load Raw Chunk
-            data_gpu = cp.asarray(h5_data[start_idx:end_idx], dtype=cp.float32)
-            indices_gpu = cp.asarray(h5_indices[start_idx:end_idx])
-            indptr_gpu = cp.asarray(h5_indptr[i:end_row + 1] - start_idx)
-
-            # Expand Size Factors to match Data Structure
-            nnz_in_chunk = indptr_gpu[-1].item()
-            cell_boundary_markers = cp.zeros(nnz_in_chunk, dtype=cp.int32)
-            if len(indptr_gpu) > 1:
-                cell_boundary_markers[indptr_gpu[:-1]] = 1
-            # row_indices maps every data point to its cell index (0 to chunk_size)
-            row_indices = cp.cumsum(cell_boundary_markers, axis=0) - 1
-            
-            # Get size factors for this chunk
-            sf_chunk = cp.asarray(size_factors[i:end_row])
-            
-            # --- THE MAGIC: On-the-Fly Normalization ---
-            # data_norm = data_raw / size_factor
-            data_gpu /= sf_chunk[row_indices]
-            
-            # Accumulate for Variance: E[X^2] and E[X]
-            cp.add.at(sum_x_sq_gpu, indices_gpu, data_gpu**2)
-            cp.add.at(sum_x_gpu, indices_gpu, data_gpu)
-            
-            # Clean up VRAM
-            del data_gpu, indices_gpu, indptr_gpu, row_indices, sf_chunk, cell_boundary_markers
-            cp.get_default_memory_pool().free_all_blocks()
+                # Read data for the chunk
+                data_slice = h5_data[start_idx:end_idx]
+                indices_slice = h5_indices[start_idx:end_idx]
+                indptr_slice = h5_indptr[i:end_row + 1] - start_idx
+                
+                # Move to GPU for fast normalization
+                data_gpu = cp.asarray(data_slice.copy(), dtype=cp.float32)
+                
+                indptr_gpu = cp.asarray(indptr_slice.copy())
+                nnz_in_chunk = indptr_gpu[-1].item()
+                cell_boundary_markers = cp.zeros(nnz_in_chunk, dtype=cp.int32)
+                if len(indptr_gpu) > 1:
+                    cell_boundary_markers[indptr_gpu[:-1]] = 1
+                row_indices = cp.cumsum(cell_boundary_markers, axis=0) - 1
+                
+                size_factors_for_chunk = cp.asarray(size_factors[i:end_row])
+                
+                data_gpu /= size_factors_for_chunk[row_indices]
+                
+                data_cpu = np.round(data_gpu.get())
 
-    print(f"Phase [1/3]: COMPLETE{' '*50}")
+                num_cells_in_chunk = end_row - i
+                chunk_sp = sp_csr_matrix((data_cpu, indices_slice, indptr_slice), 
+                                         shape=(num_cells_in_chunk, ng))
 
-    # 4. Finalize Basic Statistics
-    # Var(X) = E[X^2] - (E[X])^2
-    mean_x_sq_gpu = sum_x_sq_gpu / nc
-    mean_mu_gpu = sum_x_gpu / nc
-    my_rowvar_gpu = mean_x_sq_gpu - mean_mu_gpu**2
-    
-    # Dispersion = Mean^2 / (Var - Mean)
-    size_gpu = mean_mu_gpu**2 / (my_rowvar_gpu - mean_mu_gpu)
+                nnz_chunk = chunk_sp.nnz
+                out_data.resize(current_nnz + nnz_chunk, axis=0)
+                out_data[current_nnz:] = chunk_sp.data
+
+                out_indices.resize(current_nnz + nnz_chunk, axis=0)
+                out_indices[current_nnz:] = chunk_sp.indices
+
+                new_indptr_list = chunk_sp.indptr[1:].astype(np.int64) + current_nnz
+                out_indptr[i + 1 : end_row + 1] = new_indptr_list
+                
+                current_nnz += nnz_chunk
+
+                del data_gpu, row_indices, size_factors_for_chunk, indptr_gpu
+                cp.get_default_memory_pool().free_all_blocks()
+
+    print(f"Phase [1/4]: COMPLETE{' '*50}")
+
+    print("Phase [2/4]: Fitting Basic Model on normalized data...")
     
-    # Safety Clamping
-    max_size_val = cp.nanmax(size_gpu) * 10
-    if cp.isnan(max_size_val): max_size_val = 1000
-    size_gpu[cp.isnan(size_gpu) | (size_gpu <= 0)] = max_size_val
-    size_gpu[size_gpu < 1e-10] = 1e-10
+    # [GOVERNOR INTEGRATION] Calculate chunk size for basic fit on the heavy normalized file
+    chunk_size_basic = get_optimal_chunk_size(basic_norm_filename, multiplier=10.0, is_dense=True)
     
-    # Construct "Basic Fit" Object
-    fit_basic = {
-        'sizes': pd.Series(size_gpu.get(), index=stats['tjs'].index),
-        'vals': stats,
-        'var_obs': pd.Series(my_rowvar_gpu.get(), index=stats['tjs'].index)
-    }
+    stats_basic = hidden_calc_valsGPU(basic_norm_filename) # hidden_calc uses its own governor internally
+    fit_basic = NBumiFitBasicModelGPU(basic_norm_filename, stats_basic, chunk_size=chunk_size_basic)
+    print("Phase [2/4]: COMPLETE")
     
-    # --- Phase 2: Check Fit (Calculate Errors) ---
-    print("Phase [2/3]: Evaluating fit errors on ORIGINAL data...")
+    print("Phase [3/4]: Evaluating fits of both models on ORIGINAL data...")
+    # [GOVERNOR INTEGRATION] Chunk size for check fit
+    chunk_size_check = get_optimal_chunk_size(cleaned_filename, multiplier=5.0, is_dense=True)
     
-    # Check Adjust (M3Drop) - uses its own governor
-    check_adjust = NBumiCheckFitFSGPU(
-        cleaned_filename, fit_adjust, suppress_plot=True
-    )
+    check_adjust = NBumiCheckFitFSGPU(cleaned_filename, fit_adjust, suppress_plot=True, chunk_size=chunk_size_check)
     
-    # Check Basic (Depth-Norm) - uses its own governor
-    check_basic = NBumiCheckFitFSGPU(
-        cleaned_filename, fit_basic, suppress_plot=True
-    )
-    print("Phase [2/3]: COMPLETE")
+    fit_basic_for_eval = {
+        'sizes': fit_basic['sizes'],
+        'vals': stats,
+        'var_obs': fit_basic['var_obs']
+    }
+    check_basic = NBumiCheckFitFSGPU(cleaned_filename, fit_basic_for_eval, suppress_plot=True, chunk_size=chunk_size_check)
+    print("Phase [3/4]: COMPLETE")
 
-    # --- Phase 3: Plotting & Comparison ---
-    print("Phase [3/3]: Generating comparison...")
-    
+    print("Phase [4/4]: Generating final comparison...")
     nc_data = stats['nc']
     mean_expr = stats['tjs'] / nc_data
     observed_dropout = stats['djs'] / nc_data
@@ -408,8 +433,15 @@ def NBumiCompareModelsGPU(
         plt.show()
     
     plt.close()
-    
+    print("Phase [4/4]: COMPLETE")
+
     pipeline_end_time = time.time()
+    
+    # --- ADD THIS LINE TO FIX THE ERROR ---
+    adata_meta.file.close() # Explicitly close the file handle
+    
+    os.remove(basic_norm_filename)
+    print(f"STATUS: Temporary file '{basic_norm_filename}' removed.")
     print(f"Total time: {pipeline_end_time - pipeline_start_time:.2f} seconds.\n")
     
     return {
@@ -424,6 +456,11 @@ def NBumiPlotDispVsMeanGPU(
 ):
     """
     Generates a diagnostic plot of the dispersion vs. mean expression.
+
+    Args:
+        fit (dict): The 'fit' object from NBumiFitModelGPU.
+        suppress_plot (bool): If True, the plot will not be displayed on screen.
+        plot_filename (str, optional): Path to save the plot. If None, not saved.
     """
     print("FUNCTION: NBumiPlotDispVsMean()")
 
@@ -434,6 +471,7 @@ def NBumiPlotDispVsMeanGPU(
     intercept, slope = coeffs[0], coeffs[1]
 
     # --- 2. Calculate the fitted line for plotting ---
+    # Create a smooth, continuous line using the regression coefficients
     log_mean_expr_range = np.linspace(
         np.log(mean_expression[mean_expression > 0].min()),
         np.log(mean_expression.max()),

m3Drop/normalizationGPU.py

@@ -24,9 +24,7 @@ def NBumiPearsonResidualsGPU(
     start_time = time.perf_counter()
     print(f"FUNCTION: NBumiPearsonResiduals() | FILE: {cleaned_filename}")
 
-    # --- SAFETY UPDATE ---
-    # Multiplier 10.0 (Was 6.0): Accounts for Float64 precision (8 bytes) vs Governor default (4 bytes).
-    # 4 matrices * 8 bytes = 32 bytes/cell. Governor 10 * 4 = 40 bytes. Safe buffer established.
+    # Governor for Processing (RAM/VRAM)
     chunk_size = get_optimal_chunk_size(cleaned_filename, multiplier=10.0, is_dense=True)
 
     # --- Phase 1: Initialization ---
@@ -45,16 +43,29 @@ def NBumiPearsonResidualsGPU(
     tis_gpu = cupy.asarray(tis, dtype=cupy.float64)
     sizes_gpu = cupy.asarray(sizes, dtype=cupy.float64)
 
-    # Create Output H5 (Identical structure to cleaned input)
+    # Create Output H5
     adata_in = anndata.read_h5ad(cleaned_filename, backed='r')
     adata_out = anndata.AnnData(obs=adata_in.obs, var=adata_in.var)
     adata_out.write_h5ad(output_filename, compression="gzip") 
     
+    # [FIX] Calculate Safe Storage Chunk Size (~1GB)
+    # HDF5 limit is 4GB. You requested 1GB for optimal speed.
+    bytes_per_row = ng * 4 # float32
+    target_bytes = 1_000_000_000 # 1GB
+    storage_chunk_rows = int(target_bytes / bytes_per_row) 
+    
+    if storage_chunk_rows < 1: storage_chunk_rows = 1
+    # Note: It is okay if storage_chunk > processing_chunk (HDF5 handles this),
+    # but strictly it must be < 4GB total size.
+    
+    print(f"  > Processing Chunk: {chunk_size} rows (RAM)")
+    print(f"  > Storage Chunk:    {storage_chunk_rows} rows (Disk - 1GB Target)")
+
     with h5py.File(output_filename, 'a') as f_out:
         if 'X' in f_out:
             del f_out['X']
-        # Create dataset for dense matrix output (float32)
-        out_x = f_out.create_dataset('X', shape=(nc, ng), chunks=(chunk_size, ng), dtype='float32')
+        # Create dataset with SAFE chunks (Fixes the ValueError)
+        out_x = f_out.create_dataset('X', shape=(nc, ng), chunks=(storage_chunk_rows, ng), dtype='float32')
 
         print("Phase [1/2]: COMPLETE")
 
@@ -77,7 +88,6 @@ def NBumiPearsonResidualsGPU(
                 indptr_slice = h5_indptr[i:end_row+1] - h5_indptr[i]
 
                 # Convert to Dense GPU Matrix
-                # We construct sparse first, then densify on GPU to save bandwidth
                 counts_chunk_sparse_gpu = cp_csr_matrix((
                     cupy.asarray(data_slice, dtype=cupy.float64),
                     cupy.asarray(indices_slice),
@@ -91,24 +101,18 @@ def NBumiPearsonResidualsGPU(
                 mus_chunk_gpu = tjs_gpu[cupy.newaxis, :] * tis_chunk_gpu[:, cupy.newaxis] / total
                 
                 denominator_gpu = cupy.sqrt(mus_chunk_gpu + mus_chunk_gpu**2 / sizes_gpu[cupy.newaxis, :])
-                
-                # --- LOGIC RESTORED: Prevent Division by Zero ---
                 denominator_gpu = cupy.where(denominator_gpu == 0, 1, denominator_gpu)
 
-                # (Counts - Mu) / Sqrt(V)
                 pearson_chunk_gpu = (counts_chunk_dense_gpu - mus_chunk_gpu) / denominator_gpu
                 
                 # Write to Disk
-                # [OPTIMIZATION] Cast to float32 on GPU to halve PCIe transfer time
                 out_x[i:end_row, :] = pearson_chunk_gpu.astype(cupy.float32).get()
                 
-                # Cleanup
                 del counts_chunk_dense_gpu, counts_chunk_sparse_gpu, mus_chunk_gpu, pearson_chunk_gpu, denominator_gpu
                 cupy.get_default_memory_pool().free_all_blocks()
         
         print(f"Phase [2/2]: COMPLETE{' '*50}")
 
-    # --- LOGIC RESTORED: Explicit File Cleanup ---
     if hasattr(adata_in, "file") and adata_in.file is not None:
         adata_in.file.close()
 
@@ -127,8 +131,6 @@ def NBumiPearsonResidualsApproxGPU(
     start_time = time.perf_counter()
     print(f"FUNCTION: NBumiPearsonResidualsApprox() | FILE: {cleaned_filename}")
 
-    # --- HANDSHAKE ---
-    # Multiplier 10.0: Same safety logic as Full residuals.
     chunk_size = get_optimal_chunk_size(cleaned_filename, multiplier=10.0, is_dense=True)
 
     # --- Phase 1: Initialization ---
@@ -150,10 +152,17 @@ def NBumiPearsonResidualsApproxGPU(
     adata_out = anndata.AnnData(obs=adata_in.obs, var=adata_in.var)
     adata_out.write_h5ad(output_filename, compression="gzip") 
     
+    # [FIX] Calculate Safe Storage Chunk Size (~1GB)
+    bytes_per_row = ng * 4 
+    target_bytes = 1_000_000_000 # 1GB
+    storage_chunk_rows = int(target_bytes / bytes_per_row) 
+    if storage_chunk_rows < 1: storage_chunk_rows = 1
+
     with h5py.File(output_filename, 'a') as f_out:
         if 'X' in f_out:
             del f_out['X']
-        out_x = f_out.create_dataset('X', shape=(nc, ng), chunks=(chunk_size, ng), dtype='float32')
+        # Create dataset with SAFE chunks
+        out_x = f_out.create_dataset('X', shape=(nc, ng), chunks=(storage_chunk_rows, ng), dtype='float32')
 
         print("Phase [1/2]: COMPLETE")
 
@@ -185,15 +194,11 @@ def NBumiPearsonResidualsApproxGPU(
                 tis_chunk_gpu = tis_gpu[i:end_row]
                 mus_chunk_gpu = tjs_gpu[cupy.newaxis, :] * tis_chunk_gpu[:, cupy.newaxis] / total
                 
-                # Approx: Denom = Sqrt(Mu)
                 denominator_gpu = cupy.sqrt(mus_chunk_gpu)
-                
-                # --- LOGIC RESTORED: Prevent Division by Zero ---
                 denominator_gpu = cupy.where(denominator_gpu == 0, 1, denominator_gpu)
                 
                 pearson_chunk_gpu = (counts_chunk_dense_gpu - mus_chunk_gpu) / denominator_gpu
                 
-                # [OPTIMIZATION] Cast to float32 on GPU to halve PCIe transfer time
                 out_x[i:end_row, :] = pearson_chunk_gpu.astype(cupy.float32).get()
                 
                 del counts_chunk_dense_gpu, counts_chunk_sparse_gpu, mus_chunk_gpu, pearson_chunk_gpu, denominator_gpu
@@ -201,7 +206,6 @@ def NBumiPearsonResidualsApproxGPU(
         
         print(f"Phase [2/2]: COMPLETE{' '*50}")
 
-    # --- LOGIC RESTORED: Explicit File Cleanup ---
     if hasattr(adata_in, "file") and adata_in.file is not None:
         adata_in.file.close()
 

{m3drop-0.4.38.dist-info → m3drop-0.4.40.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: M3Drop
-Version: 0.4.38
+Version: 0.4.40
 Summary: A Python implementation of the M3Drop single-cell RNA-seq analysis tool.
 Home-page: https://github.com/PragalvhaSharma/m3DropNew
 Author: Tallulah Andrews

m3drop-0.4.40.dist-info/RECORD

@@ -0,0 +1,12 @@
+m3Drop/__init__.py,sha256=yaUXhUArnwgLf01Zlpqa5qm9K1aByGqQupIoCaLYiDw,2462
+m3Drop/coreCPU.py,sha256=3kPYlSVlYrJEhRUCIoVzmR8CYBaHpxVM5nx-3YQI4d4,17204
+m3Drop/coreGPU.py,sha256=k7A06VNgfJ59J8g1VpfKxhTIKrEbW7Bj8pTbQqHaQL8,24571
+m3Drop/diagnosticsCPU.py,sha256=BecOKTz2GDjzjs9ycXYsyrSHi2UVgsM58RBuNE62vmU,14273
+m3Drop/diagnosticsGPU.py,sha256=m_r7mZ4s0h-YwJEriucrACNeDQxWPZHvd8RAmsXQYXE,19980
+m3Drop/normalizationCPU.py,sha256=4ulCrDZZjxVFh2y0i4ayPkNCsZYaOP-Xq2Dnzu9WXtg,5697
+m3Drop/normalizationGPU.py,sha256=r5gvJFkabEfCfIsVdpJzWGqve_Iy57EYsEyiLfDo8Mo,8539
+m3drop-0.4.40.dist-info/licenses/LICENSE,sha256=44Iqpp8Fc10Xzd5T7cT9UhO31Qftk3gBiCjtpwilP_k,1074
+m3drop-0.4.40.dist-info/METADATA,sha256=rL09G9SvQ_JP_OEw-xrMNle-92XQFzn2-cHDyXkPpH4,5161
+m3drop-0.4.40.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+m3drop-0.4.40.dist-info/top_level.txt,sha256=AEULFEFIgFtAwS-KBlIFoYXrqczX_rwqrEcdK46GIrA,7
+m3drop-0.4.40.dist-info/RECORD,,

m3drop-0.4.38.dist-info/RECORD

@@ -1,12 +0,0 @@
-m3Drop/__init__.py,sha256=yaUXhUArnwgLf01Zlpqa5qm9K1aByGqQupIoCaLYiDw,2462
-m3Drop/coreCPU.py,sha256=3kPYlSVlYrJEhRUCIoVzmR8CYBaHpxVM5nx-3YQI4d4,17204
-m3Drop/coreGPU.py,sha256=k7A06VNgfJ59J8g1VpfKxhTIKrEbW7Bj8pTbQqHaQL8,24571
-m3Drop/diagnosticsCPU.py,sha256=BecOKTz2GDjzjs9ycXYsyrSHi2UVgsM58RBuNE62vmU,14273
-m3Drop/diagnosticsGPU.py,sha256=pg_G6VCk6yvSfRzISHZhTJBVvhFA07MQrJqzQ0fehtc,17893
-m3Drop/normalizationCPU.py,sha256=4ulCrDZZjxVFh2y0i4ayPkNCsZYaOP-Xq2Dnzu9WXtg,5697
-m3Drop/normalizationGPU.py,sha256=mHu_Or4ma6qzujGQQQ0oN3D-yoEngLAN4UTknkArRAY,8596
-m3drop-0.4.38.dist-info/licenses/LICENSE,sha256=44Iqpp8Fc10Xzd5T7cT9UhO31Qftk3gBiCjtpwilP_k,1074
-m3drop-0.4.38.dist-info/METADATA,sha256=Pt-cgrYSzffqxPKzzIBEURzG3SSAzeArprgfQjrX1z8,5161
-m3drop-0.4.38.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-m3drop-0.4.38.dist-info/top_level.txt,sha256=AEULFEFIgFtAwS-KBlIFoYXrqczX_rwqrEcdK46GIrA,7
-m3drop-0.4.38.dist-info/RECORD,,