sciv 0.0.96__tar.gz → 0.0.97__tar.gz

{sciv-0.0.96 → sciv-0.0.97}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sciv
-Version: 0.0.96
+Version: 0.0.97
 Summary: Unveiling the pivotal cell types involved in variant function regulation at a single-cell resolution
 Project-URL: github, https://github.com/YuZhengM/sciv
 Author-email: Zheng-Min Yu <yuzmbio@163.com>

{sciv-0.0.96 → sciv-0.0.97}/pyproject.toml

@@ -3,7 +3,7 @@ requires = ["hatchling"]
 build-backend = "hatchling.build"
 [project]
 name = "sciv"
-version = "0.0.96"
+version = "0.0.97"
 authors = [
     { name = "Zheng-Min Yu", email = "yuzmbio@163.com" },
 ]

{sciv-0.0.96 → sciv-0.0.97}/src/sciv/model/_core_.py

@@ -81,7 +81,7 @@ def core(
     weight: float = 0.1,
     kernel: Literal["laplacian", "gaussian"] = "gaussian",
     local_k: int = 10,
-    kernel_gamma: Optional[float, collection] = None,
+    kernel_gamma: Optional[Union[float, collection]] = None,
     epsilon: float = 1e-05,
     gamma: float = 0.05,
     enrichment_gamma: float = 0.05,
@@ -481,7 +481,7 @@ def core(
             )
 
     else:
-        overlap_adata: AnnData = overlap_sum(adata, variants, trait_info)
+        overlap_adata: AnnData = overlap_sum(adata, variants, trait_info, n_jobs=n_jobs)
 
     del variants, trait_info
 

{sciv-0.0.96 → sciv-0.0.97}/src/sciv/tool/_algorithm_.py

@@ -7,6 +7,8 @@ from typing import Union, Tuple, Literal, Optional
 from scipy import sparse
 from scipy.stats import norm
 from tqdm import tqdm
+from joblib import Parallel, delayed
+import multiprocessing
 
 import numpy as np
 from anndata import AnnData
@@ -516,7 +518,7 @@ def semi_mutual_knn_weight(
     adj_weight = (1 - weight) * adj_and.astype(np.float32) + weight * adj_or.astype(np.float32)
 
     # Ensure full connectivity if required
-    if is_mknn_fully_connected and (or_neighbors == 0 or weight == 0):
+    if is_mknn_fully_connected:
         adj_1nn = _knn(new_data, 1)
 
         if sparse.issparse(adj_and):
@@ -824,16 +826,17 @@ def _overlap_(regions_sort: DataFrame, variants: DataFrame) -> DataFrame:
         if chr_a in chr_keys:
             # get chr variant
             variants_chr_type_position_list = variants_position_list[chr_a]
+
             # judge start and end position
             if start <= variants_chr_type_position_list[-1] and end >= variants_chr_type_position_list[0]:
                 # get index
-                start_index = get_index(start, variants_chr_type_position_list)
-                end_index = get_index(end, variants_chr_type_position_list)
+                start_index = get_index(start, variants_chr_type_position_list, False)
+                end_index = get_index(end, variants_chr_type_position_list, False)
 
                 # Determine whether it is equal, Equality means there is no overlap
                 if start_index != end_index:
-                    start_index = start_index if isinstance(start_index, number) else start_index[1]
-                    end_index = end_index + 1 if isinstance(end_index, number) else end_index[1]
+                    start_index = start_index if isinstance(start_index, int) else start_index[1]
+                    end_index = end_index + 1 if isinstance(end_index, int) else end_index[1]
 
                     if start_index > end_index:
                         ul.log(__name__).error("The end index in the region is greater than the start index.")
@@ -894,13 +897,14 @@ def overlap(regions: DataFrame, variants: DataFrame) -> DataFrame:
     return _overlap_(regions_sort, variants)
 
 
-def overlap_sum(regions: AnnData, variants: dict, trait_info: DataFrame) -> AnnData:
+def overlap_sum(regions: AnnData, variants: dict, trait_info: DataFrame, n_jobs: int = -1) -> AnnData:
     """
     Overlap regional data and mutation data and sum the PP values of all mutations in a region as the values for that
     region.
     :param regions: peaks data
     :param variants: variants data
     :param trait_info: traits information
+    :param n_jobs: The maximum number of concurrently running jobs
     :return: overlap data
     """
 
@@ -916,8 +920,6 @@ def overlap_sum(regions: AnnData, variants: dict, trait_info: DataFrame) -> AnnD
 
     trait_names = trait_info["id"].tolist()
     n_trait = len(trait_names)
-    # Pre-allocate sparse matrix, fill column by column, then convert to csc and then csr for efficiency
-    row_indices, col_indices, data_vals = [], [], []
 
     # Check column existence once
     required = {"chr", "start", "end"}
@@ -941,13 +943,18 @@ def overlap_sum(regions: AnnData, variants: dict, trait_info: DataFrame) -> AnnD
 
     ul.log(__name__).info("Obtain peak-trait/disease matrix. (overlap variant information)")
 
-    # The outer loop can be further accelerated by parallelizing over traits; here we keep it single-threaded for now.
-    for col_idx, trait_name in enumerate(tqdm(trait_names)):
+    # Function to process a single trait
+    def _process_trait_(trait_name, col_idx):
+
+        local_data_vals = []
+        local_row_indices = []
+        local_col_indices = []
+
         variant: AnnData = variants[trait_name]
         overlap_df: DataFrame = _overlap_(regions_df, variant.obs)
 
         if overlap_df.empty:
-            continue
+            return local_data_vals, local_row_indices, local_col_indices
 
         # Sum at once: first group by label and collect variant_id into a list
         label_var_ids = (
@@ -972,15 +979,37 @@ def overlap_sum(regions: AnnData, variants: dict, trait_info: DataFrame) -> AnnD
             if matrix_sum.size == 1:
                 val = float(matrix_sum)
                 if val != 0:
-                    row_indices.append(row_idx)
-                    col_indices.append(col_idx)
-                    data_vals.append(val)
+                    local_row_indices.append(row_idx)
+                    local_col_indices.append(col_idx)
+                    local_data_vals.append(val)
             else:
                 for t_idx, v in enumerate(matrix_sum):
                     if v != 0:
-                        row_indices.append(row_idx)
-                        col_indices.append(col_idx + t_idx)
-                        data_vals.append(float(v))
+                        local_row_indices.append(row_idx)
+                        local_col_indices.append(col_idx + t_idx)
+                        local_data_vals.append(float(v))
+
+        return local_data_vals, local_row_indices, local_col_indices
+
+    # Use Parallel to process traits in parallel
+    results = Parallel(n_jobs=n_jobs)(
+        delayed(_process_trait_)(trait_name, col_idx) for col_idx, trait_name in enumerate(trait_names)
+    )
+
+    # Preallocate length to avoid list dynamic expansion
+    total = sum(len(ld) for ld, _, _ in results)
+    row_indices = np.empty(total, dtype=np.int32)
+    col_indices = np.empty(total, dtype=np.int32)
+    data_vals  = np.empty(total, dtype=np.float32)
+
+    ptr = 0
+
+    for local_data, local_rows, local_cols in results:
+        n = len(local_data)
+        row_indices[ptr:ptr+n] = local_rows
+        col_indices[ptr:ptr+n] = local_cols
+        data_vals[ptr:ptr+n] = local_data
+        ptr += n
 
     # Build sparse matrix, then convert to csr format
     overlap_sparse = sparse.csc_matrix(
@@ -1253,7 +1282,7 @@ def obtain_cell_cell_network(
     weight: float = 0.1,
     kernel: Literal["laplacian", "gaussian"] = "gaussian",
     local_k: int = 10,
-    gamma: Optional[float, collection] = None,
+    gamma: Optional[Union[float, collection]] = None,
     is_simple: bool = True
 ) -> AnnData:
     """

{sciv-0.0.96 → sciv-0.0.97}/src/sciv/util/_core_.py

@@ -90,17 +90,20 @@ def sum_min_max(data: matrix_data, axis: int = 1) -> Tuple[number, number]:
     return min(rows_sum), max(rows_sum)
 
 
-def get_index(position: number, positions_list: list) -> Union[number, Tuple[number, number]]:
+def get_index(position: number, positions_list: list, is_sort: bool = True) -> Union[int, Tuple[int, int]]:
     """
     Search for position information. Similar to half search.
         If the position exists in the list, return the index.
         If it does not exist, return the index located between the two indexes
     :param position: position
     :param positions_list: position list
+    :param is_sort: True
     :return: position index
     """
-    # sort
-    positions_list.sort()
+
+    if is_sort:
+        positions_list.sort()
+
     # search
     position_size: int = len(positions_list)
     left, right = 0, position_size - 1
@@ -441,7 +444,6 @@ def plot_end(
     close: bool = False,
     dpi: float = 300
 ):
-
     if title is not None:
         plt.title(title)