sciv 0.0.94__py3-none-any.whl → 0.0.96__py3-none-any.whl

sciv/plot/_bar_.py

@@ -302,7 +302,8 @@ def bar_significance(
     :param color_step_size: Step size when cycling through palette
     :param color_type: Name of seaborn palette to use
     :param test: Statistical test for pairwise comparisons
-        {"t-test_ind", "t-test_welch", "t-test_paired", "Mann-Whitney", "Mann-Whitney-gt", "Mann-Whitney-ls", "Levene", "Wilcoxon", "Kruskal", "Brunner-Munzel"}
+        {"t-test_ind", "t-test_welch", "t-test_paired", "Mann-Whitney", "Mann-Whitney-gt", "Mann-Whitney-ls",
+         "Levene", "Wilcoxon", "Kruskal", "Brunner-Munzel"}
     :param ci: Confidence interval type or value
     :param capsize: Width of the error-bar caps
     :param errcolor: Color of the error bars

sciv/plot/_scatter_.py

@@ -8,6 +8,7 @@ import numpy as np
 import pandas as pd
 from anndata import AnnData
 from matplotlib import pyplot as plt
+from matplotlib.colors import ListedColormap
 from pandas import DataFrame
 import seaborn as sns
 
@@ -165,8 +166,10 @@ def scatter_3d(
     title: str = None,
     width: float = 7,
     height: float = 7,
-    bottom: float = 0,
-    cmap: str = 'tab20',
+    elev: float = 30,
+    azim: float = -60,
+    is_add_legend: bool = True,
+    cmap: Union[str, ListedColormap] = 'tab20',
     font_size: int = 14,
     edge_color: str = None,
     size: Union[float, collection] = 0.1,
@@ -180,8 +183,8 @@ def scatter_3d(
         ul.log(__name__).error(f"At least one of the `output` and `show` parameters is required")
         raise ValueError(f"At least one of the `output` and `show` parameters is required")
 
-    fig, ax = plt.subplots(figsize=(width, height))
-    fig.subplots_adjust(bottom=bottom, projection='3d')
+    fig = plt.figure(figsize=(width, height))
+    ax = fig.add_subplot(projection='3d')
 
     hue_cat = pd.Categorical(df[hue])
 
@@ -196,6 +199,9 @@ def scatter_3d(
         **kwargs
     )
 
+    # angle of view
+    ax.view_init(elev=elev, azim=azim)
+
     if x_name is not None:
         ax.set_xlabel(x_name, fontsize=font_size)
 
@@ -208,16 +214,17 @@ def scatter_3d(
     if title is not None:
         ax.set_title(title, fontsize=font_size)
 
-    unique_types = hue_cat.categories
-    legend_elements = [
-        plt.Line2D(
-            [0], [0], marker='o', color='w', label=type_,
-            markerfacecolor=scatter.cmap(scatter.norm(i))
-        )
-        for i, type_ in enumerate(unique_types)
-    ]
-
-    ax.legend(handles=legend_elements, title=legend_name, loc='upper left')
+    if is_add_legend:
+        unique_types = hue_cat.categories
+        legend_elements = [
+            plt.Line2D(
+                [0], [0], marker='o', color='w', label=type_,
+                markerfacecolor=scatter.cmap(scatter.norm(i))
+            )
+            for i, type_ in enumerate(unique_types)
+        ]
+
+        ax.legend(handles=legend_elements, title=legend_name, loc='upper left')
 
     plot_end(fig, None, None, None, output, show, close)
 

sciv/preprocessing/_scanpy_.py

@@ -1,5 +1,5 @@
 # -*- coding: UTF-8 -*-
-
+import time
 import warnings
 from typing import Optional, Literal
 
@@ -45,6 +45,10 @@ def filter_data(
     :param is_min_peak: Whether to screen peaks
     :return: scATAC-seq data
     """
+
+    # start time
+    start_time = time.time()
+
     import scanpy as sc
 
     ul.log(__name__).info("Filter scATAC-seq data")
@@ -105,6 +109,8 @@ def filter_data(
     )
     ul.log(__name__).info(f"Size of filtered scATAC-seq data: {filter_adata.shape}")
     filter_adata.uns["step"] = 0
+    filter_adata.uns["elapsed_time"] = time.time() - start_time
+
     return filter_adata
 
 

sciv/preprocessing/_scvi_.py

@@ -1,6 +1,7 @@
 # -*- coding: UTF-8 -*-
 
 import os
+import time
 import warnings
 from typing import Optional
 
@@ -49,6 +50,8 @@ def poisson_vi(
     """
     ul.log(__name__).info("Start PoissonVI")
 
+    start_time = time.time()
+
     import scvi
     import scanpy as sc
 
@@ -232,11 +235,14 @@ def poisson_vi(
 
     obs = pd.DataFrame(clusters_list, columns=["id"])
     obs.index = obs["id"].astype(str)
+
     da_peaks_adata = AnnData(matrix_ee, obs=obs, var=adata.var)
     da_peaks_adata.layers["bayes_factor"] = matrix_bf
     da_peaks_adata.layers["emp_prob1"] = matrix_ep1
     da_peaks_adata.uns["latent_name"] = latent_name
     da_peaks_adata.uns["dp_delta"] = dp_delta
+    da_peaks_adata.uns["elapsed_time"] = time.time() - start_time
 
     adata.uns["step"] = 1
+
     return da_peaks_adata

sciv/tool/_algorithm_.py

@@ -1,6 +1,7 @@
 # -*- coding: UTF-8 -*-
 
 import random
+import time
 from typing import Union, Tuple, Literal, Optional
 
 from scipy import sparse
@@ -903,6 +904,8 @@ def overlap_sum(regions: AnnData, variants: dict, trait_info: DataFrame) -> AnnD
     :return: overlap data
     """
 
+    start_time = time.time()
+
     # Unique feature set
     label_all = regions.var.index.tolist()
     # Peak number
@@ -988,6 +991,8 @@ def overlap_sum(regions: AnnData, variants: dict, trait_info: DataFrame) -> AnnD
 
     overlap_adata = AnnData(overlap_sparse, var=trait_info, obs=regions.var)
     overlap_adata.uns["is_overlap"] = True
+    overlap_adata.uns["elapsed_time"] = time.time() - start_time
+
     return overlap_adata
 
 
@@ -1069,6 +1074,7 @@ def calculate_init_score_weight(
     adata: AnnData,
     da_peaks_adata: AnnData,
     overlap_adata: AnnData,
+    layer: Optional[str] = "fragments",
     diff_peak_value: difference_peak_optional = 'emp_effect',
     is_simple: bool = True,
     block_size: int = -1
@@ -1078,6 +1084,7 @@ def calculate_init_score_weight(
     :param adata: scATAC-seq data;
     :param da_peaks_adata: Differential peak data;
     :param overlap_adata: Peaks-traits/diseases data;
+    :param layer: The layer value of scATAC-seq data;
     :param diff_peak_value: Specify the correction value in peak correction of clustering type differences.
         {'emp_effect', 'bayes_factor', 'emp_prob1', 'all'}
     :param is_simple: True represents not adding unnecessary intermediate variables, only adding the final result. It
@@ -1087,17 +1094,30 @@ def calculate_init_score_weight(
         If the value is less than or equal to zero, no block operation will be performed
     :return: Initial TRS with weight.
     """
+
+    start_time = time.time()
+
     if "is_overlap" not in overlap_adata.uns:
         ul.log(__name__).warning(
-            "The `is_overlap` is not in `overlap_data.uns`. (Suggest using the 'tl.overlap_stum' function to obtain the result.)"
+            "The `is_overlap` is not in `overlap_data.uns`. "
+            "(Suggest using the 'tl.overlap_stum' function to obtain the result.)"
         )
 
     if "dp_delta" not in da_peaks_adata.uns:
         ul.log(__name__).warning(
-            "The `dp_delta` is not in `da_peaks_adata.uns`. (Suggest using the 'pp.poisson_vi' function to obtain the result.)"
+            "The `dp_delta` is not in `da_peaks_adata.uns`. "
+            "(Suggest using the 'pp.poisson_vi' function to obtain the result.)"
         )
 
-    fragments = adata.layers["fragments"]
+    if layer is not None and layer not in adata.layers:
+        ul.log(__name__).error(
+            f"The `layer` parameter is empty or one of the element values of `adata.layers` ({adata.layers})."
+        )
+        raise ValueError(
+            f"The `layer` parameter is empty or one of the element values of `adata.layers` ({adata.layers})."
+        )
+
+    fragments = adata.layers[layer] if layer is not None else adata.X
     cell_anno = adata.obs
     del adata
 
@@ -1174,7 +1194,8 @@ def calculate_init_score_weight(
     del _cluster_weight_
 
     ul.log(__name__).info("Broadcasting the weight factor to the cellular level")
-    _cell_type_weight_ = np.zeros((cell_anno.shape[0], da_peaks_adata.obsm["cluster_weight"].shape[1]), dtype=np.float32)
+    _cell_type_weight_ = np.zeros((cell_anno.shape[0], da_peaks_adata.obsm["cluster_weight"].shape[1]),
+                                  dtype=np.float32)
 
     cluster_series = cell_anno["clusters"]
 
@@ -1195,15 +1216,44 @@ def calculate_init_score_weight(
     del _init_trs_ncw_, _cell_type_weight_
 
     init_trs_adata.uns["is_sample"] = is_simple
+    init_trs_adata.uns["elapsed_time"] = time.time() - start_time
     return init_trs_adata
 
 
+def adaptive_gamma_knn(data: matrix_data, k: int = 10):
+    """
+    Adaptive gamma parameter based on k-nearest neighbors
+    :param data: Data matrix (n_samples, n_features)
+    :param k: Number of neighbors, usually select 5-20
+    :return: Gamma value for each sample (n_samples,)
+    """
+
+    from sklearn.neighbors import NearestNeighbors
+
+    # Calculate the distance from each point to its k-th nearest neighbor
+    knn = NearestNeighbors(n_neighbors=k + 1).fit(data)  # +1 because it includes itself
+    distances, _ = knn.kneighbors(data)
+
+    # Take the distance of the k-th nearest neighbor (index k, because 0 is itself)
+    kth_distances = distances[:, k]
+
+    # Avoid division by zero (if the distance is 0, set it to a very small value)
+    kth_distances[kth_distances == 0] = np.finfo(float).eps
+
+    # Calculate local gamma: gamma = 1 / (2 * sigma^2), where sigma = kth_distance
+    gammas = 1.0 / (kth_distances ** 2)
+
+    return gammas
+
+
 def obtain_cell_cell_network(
     adata: AnnData,
     k: int = 30,
     or_k: int = 1,
     weight: float = 0.1,
-    gamma: Optional[float] = None,
+    kernel: Literal["laplacian", "gaussian"] = "gaussian",
+    local_k: int = 10,
+    gamma: Optional[float, collection] = None,
     is_simple: bool = True
 ) -> AnnData:
     """
@@ -1212,14 +1262,19 @@ def obtain_cell_cell_network(
     :param k: When building an M-KNN network, the number of nodes connected by each node (and);
     :param or_k: When building an M-KNN network, the number of nodes connected by each node (or);
     :param weight: The weight of interactions or operations;
-    :param gamma: If None, defaults to 1.0 / n_features. Otherwise, it should be strictly positive;
+    :param local_k: Determining the number of neighbors for the adaptive kernel;
+    :param kernel: Determine the kernel function to be used;
+    :param gamma: If None, it defaults to the adaptive value obtained through the local information of
+        parameter `local_k`. Otherwise, it should be strictly positive;
     :param is_simple: True represents not adding unnecessary intermediate variables, only adding the final result.
         It is worth noting that when set to `True`, the `is_ablation` parameter will become invalid, and when set to
         `False`, `is_ablation` will only take effect;
     :return: Cell similarity data.
     """
 
-    from sklearn.metrics.pairwise import laplacian_kernel
+    start_time = time.time()
+
+    from sklearn.metrics.pairwise import laplacian_kernel, rbf_kernel
 
     # data
     if "poisson_vi" not in adata.uns.keys():
@@ -1232,6 +1287,14 @@ def obtain_cell_cell_network(
             "the `poisson_vi` function."
         )
 
+    if kernel not in ["laplacian", "gaussian"]:
+        ul.log(__name__).error("Parameter `kernel` only supports two values, `laplacian` and `gaussian`.")
+        raise ValueError("Parameter `kernel` only supports two values, `laplacian` and `gaussian`.")
+
+    if local_k <= 0:
+        ul.log(__name__).error("The `local_k` parameter must be a natural number greater than 0.")
+        raise ValueError("The `local_k` parameter must be a natural number greater than 0.")
+
     _latent_name_ = "latent" if adata.uns["poisson_vi"]["latent_name"] is None \
         else adata.uns["poisson_vi"]["latent_name"]
 
@@ -1240,9 +1303,15 @@ def obtain_cell_cell_network(
     cell_anno = adata.obs
     del adata
 
-    ul.log(__name__).info("Laplacian kernel")
-    # Laplacian kernel
-    cell_affinity = laplacian_kernel(latent, gamma=gamma).astype(np.float32)
+    if gamma is None:
+        gamma = adaptive_gamma_knn(latent, k=local_k)
+
+    if kernel == "kernel":
+        ul.log(__name__).info("Laplacian kernel")
+        cell_affinity = laplacian_kernel(latent, gamma=gamma).astype(np.float32)
+    else:
+        ul.log(__name__).info("Gaussian (RBF) kernel")
+        cell_affinity = rbf_kernel(latent, gamma=gamma).astype(np.float32)
 
     # Define KNN network
     cell_mutual_knn_weight, cell_mutual_knn = semi_mutual_knn_weight(
@@ -1262,6 +1331,8 @@ def obtain_cell_cell_network(
     if not is_simple:
         cc_data.layers["cell_mutual_knn"] = to_sparse(cell_mutual_knn)
 
+    cc_data.uns["elapsed_time"] = time.time() - start_time
+
     return cc_data
 
 

sciv/tool/_matrix_.py

@@ -506,6 +506,7 @@ def vector_multiply_block_storage(
         data = np.zeros((n, q))
 
     total_steps = len(n_range) * len(q_range)
+
     with tqdm(total=total_steps) as pbar:
         for i in n_range:
             for j in q_range:

sciv/tool/_random_walk_.py

@@ -1,6 +1,7 @@
 # -*- coding: UTF-8 -*-
 
 import math
+import time
 from typing import Union, Tuple, Literal
 
 import torch
@@ -222,7 +223,9 @@ def random_walk(
 
             return np.column_stack(results)
     else:
-        ul.log(__name__).error(f'The `device` ({device}) is not supported. Only supports "cpu", "gpu", and "auto" values.')
+        ul.log(__name__).error(
+            f'The `device` ({device}) is not supported. Only supports "cpu", "gpu", and "auto" values.'
+        )
         raise ValueError(f'The `device` ({device}) is not supported. Only supports "cpu", "gpu", and "auto" values.')
 
 
@@ -267,17 +270,20 @@ class RandomWalk:
         :param max_seed_cell_rate: The maximum percentage of seed cells in all cells.
         :param credible_threshold: The threshold for determining the credibility of enriched cells in the context of
             enrichment, i.e. the threshold for judging enriched cells;
-        :param enrichment_threshold: Only by setting a threshold for the standardized output TRS can a portion of the enrichment
-            results be obtained. Parameters support string types {'golden', 'half', 'e', 'pi', 'none'}, or valid floating-point types
-            within the range of (0, log1p(1)).
-        :param is_ablation: True represents obtaining the results of the ablation experiment. This parameter is limited by
-            the `is_simple` parameter, and its effectiveness requires setting `is_simple` to `False`;
+        :param enrichment_threshold: Only by setting a threshold for the standardized output TRS can a portion of the
+            enrichment results be obtained. Parameters support string types {'golden', 'half', 'e', 'pi', 'none'}, or
+            valid floating-point types within the range of (0, log1p(1)).
+        :param is_ablation: True represents obtaining the results of the ablation experiment. This parameter is limited
+            by the `is_simple` parameter, and its effectiveness requires setting `is_simple` to `False`;
         :param is_simple: True represents not adding unnecessary intermediate variables, only adding the final result.
-            It is worth noting that when set to `True`, the `is_ablation` parameter will become invalid, and when set to
-            `False`, `is_ablation` will only take effect;
+            It is worth noting that when set to `True`, the `is_ablation` parameter will become invalid, and when set
+            to `False`, `is_ablation` will only take effect;
         :return: Stable distribution score.
         """
         ul.log(__name__).info("Random walk.")
+
+        start_time = time.time()
+
         # judge length
         if cc_adata.shape[0] != init_status.shape[0]:
             ul.log(__name__).error(
@@ -311,8 +317,12 @@ class RandomWalk:
             raise ValueError("The parameter of `epsilon` must be greater than zero.")
 
         if "clusters" not in init_status.obs.columns:
-            ul.log(__name__).error("Unsupervised clustering information must be included in column `clusters` of `init_datus.obs`.")
-            raise ValueError("Unsupervised clustering information must be included in column `clusters` of `init_datus.obs`.")
+            ul.log(__name__).error(
+                "Unsupervised clustering information must be included in column `clusters` of `init_datus.obs`."
+            )
+            raise ValueError(
+                "Unsupervised clustering information must be included in column `clusters` of `init_datus.obs`."
+            )
 
         init_status.obs["clusters"] = init_status.obs["clusters"].astype(str)
 
@@ -339,8 +349,13 @@ class RandomWalk:
         if isinstance(enrichment_threshold, float):
 
             if enrichment_threshold <= 0 or enrichment_threshold >= np.log1p(1):
-                ul.log(__name__).warning("The `enrichment_threshold` parameter is not set within the range of (0, log1p(1)), this parameter will become invalid.")
-                ul.log(__name__).warning("It is recommended to set the `enrichment_threshold` parameter to the 'golden' value.")
+                ul.log(__name__).warning(
+                    "The `enrichment_threshold` parameter is not set within the range of (0, log1p(1)), "
+                    "this parameter will become invalid."
+                )
+                ul.log(__name__).warning(
+                    "It is recommended to set the `enrichment_threshold` parameter to the 'golden' value."
+                )
 
             self.enrichment_threshold = enrichment_threshold
         elif enrichment_threshold == "golden":
@@ -356,8 +371,9 @@ class RandomWalk:
             self.enrichment_threshold = np.log1p(1)
         else:
             raise ValueError(
-                f"Invalid enrichment settings. The string type in the `enrichment_threshold` parameter only supports the following parameter "
-                f"'golden', 'half', 'e', 'pi',  Alternatively, input a floating-point type value within the range of (0, log1p(1))"
+                "Invalid enrichment settings. The string type in the `enrichment_threshold` parameter only supports "
+                "the following parameter 'golden', 'half', 'e', 'pi',  Alternatively, input a floating-point type "
+                "value within the range of (0, log1p(1))"
             )
 
         # Enrichment judgment
@@ -443,6 +459,8 @@ class RandomWalk:
         del self.cell_affinity
         del init_status
 
+        self.elapsed_time = time.time() - start_time
+
     def _random_walk_(
         self,
         seed_cell_data: matrix_data,
@@ -465,13 +483,19 @@ class RandomWalk:
             w = weight
 
         if not self.is_gpu_available:
-            return random_walk(seed_cell_data, weight=w, gamma=gamma, epsilon=self.epsilon, p=self.p, n_jobs=self.n_jobs, device='cpu')
+            return random_walk(
+                seed_cell_data, weight=w, gamma=gamma, epsilon=self.epsilon, p=self.p, n_jobs=self.n_jobs, device='cpu'
+            )
 
         try:
-            _data_ = random_walk(seed_cell_data, weight=w, gamma=gamma, epsilon=self.epsilon, p=self.p, n_jobs=self.n_jobs, device=device)
+            _data_ = random_walk(
+                seed_cell_data, weight=w, gamma=gamma, epsilon=self.epsilon, p=self.p, n_jobs=self.n_jobs, device=device
+            )
         except Exception as e:
             ul.log(__name__).warning(f"GPU failed to run, try to switch to CPU running.\n {e}")
-            _data_ = random_walk(seed_cell_data, weight=w, gamma=gamma, epsilon=self.epsilon, p=self.p, n_jobs=self.n_jobs, device='cpu')
+            _data_ = random_walk(
+                seed_cell_data, weight=w, gamma=gamma, epsilon=self.epsilon, p=self.p, n_jobs=self.n_jobs, device='cpu'
+            )
 
         return _data_
 
@@ -548,8 +572,9 @@ class RandomWalk:
 
     def _get_seed_cell_clustering_weight_(self, seed_cell_index: collection) -> Tuple[collection, dict]:
         """
-        This function is used to obtain the percentage of seed cells that occupy this cell type, i.e., the seed cell clustering weight.
-        The purpose of this weight is to provide fair enrichment opportunities for those with fewer cell numbers in cell clustering types.
+        This function is used to obtain the percentage of seed cells that occupy this cell type, i.e., the seed cell
+        clustering weight. The purpose of this weight is to provide fair enrichment opportunities for those with fewer
+        cell numbers in cell clustering types.
         :param seed_cell_index: Index of seed cells.
         :return: The seed cell clustering weight, equity factor.
         """
@@ -604,14 +629,17 @@ class RandomWalk:
         :param info: Log information about seed cells
         :return:
             1. Set seed cell thresholds for each trait or disease.
-            2. Seed cell weights obtained for each trait or disease based on the `init_data` parameter, with each seed cell assigned the same weight.
-                Note that this only takes effect when `is_simple` is true.
-            3. Seed cell weights obtained for each trait or disease based on the init_data parameter, and the weight of each seed cell will be assigned based on the similarity between cells.
+            2. Seed cell weights obtained for each trait or disease based on the `init_data` parameter, with each seed
+                cell assigned the same weight. Note that this only takes effect when `is_simple` is true.
+            3. Seed cell weights obtained for each trait or disease based on the init_data parameter, and the weight of
+                each seed cell will be assigned based on the similarity between cells.
             4. Seed cell index, which will be used for later knockout or knockdown prediction.
-            5. Based on the init_data parameter, a reference seed cell weight is obtained for enrichment analysis assistance for each trait or disease, and each seed cell is assigned the same weight.
+            5. Based on the init_data parameter, a reference seed cell weight is obtained for enrichment analysis
+                assistance for each trait or disease, and each seed cell is assigned the same weight.
                 Note that this only takes effect when `is_simple` is true.
-            6. Reference seed cell weights for auxiliary enrichment analysis of each trait or disease based on the init_data parameter,
-                and the weight of each seed cell will be assigned based on the similarity between cells.
+            6. Reference seed cell weights for auxiliary enrichment analysis of each trait or disease based on the
+                init_data parameter, and the weight of each seed cell will be assigned based on the similarity
+                between cells.
         """
 
         if init_data is None:
@@ -633,7 +661,9 @@ class RandomWalk:
             seed_cell_matrix = np.zeros((1, 1))
             seed_cell_matrix_en = np.zeros((1, 1))
 
-        ul.log(__name__).info(f"Calculate {n_traits} traits/diseases for seed cells information.{f' ({info})' if info else ''}")
+        ul.log(__name__).info(
+            f"Calculate {n_traits} traits/diseases for seed cells information.{f' ({info})' if info else ''}"
+        )
 
         trait_values_all = to_dense(init_data.X, is_array=True)
 

{sciv-0.0.94.dist-info → sciv-0.0.96.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: sciv
-Version: 0.0.94
+Version: 0.0.96
 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.94.dist-info → sciv-0.0.96.dist-info}/RECORD

@@ -3,9 +3,9 @@ sciv/file/__init__.py,sha256=8cYLG0S0nilblmyX46CWFrbLr-rmLbO1EEO477pZ-gk,520
 sciv/file/_read_.py,sha256=UZJpN3_5hBiTjzEYO6YXORcE_dqA8HmLpV80nqTLNSo,30554
 sciv/file/_write_.py,sha256=W3M9CmPi7BuKAffz1fdi-vA5DzAFZ7wmcggp33N9Xtg,7848
 sciv/model/__init__.py,sha256=k8SO9FpJaGn2ANqJyaz3HXMas7jH9toPVtpw703kOqg,149
-sciv/model/_core_.py,sha256=qGnBPBqnoEeemPm9WLedwgqb0SmbLe5QVk9fOmFMo_k,52840
+sciv/model/_core_.py,sha256=3GjKG5w-cTBF53LpSrFrMFnqwtgMI2_BkSlLGFMMMj8,33255
 sciv/plot/__init__.py,sha256=2tRNT6TZNz9r38lnna712RGsH7OJ2QkGa37XKgzejHQ,1865
-sciv/plot/_bar_.py,sha256=XgRl8kZvMxnErMdJDu3TfhLAYZH8-YX0YuRP17Q2OU4,14345
+sciv/plot/_bar_.py,sha256=xWpFbJTHgQMLuUSXa4uE69RGHXSCGinapxL-1imdDcU,14355
 sciv/plot/_barcode_.py,sha256=RDOedQ8ZtXWFyJ2c772RDfqO4TMIpHMvcMZMAVqky90,5073
 sciv/plot/_box_.py,sha256=485YNmSBj2IB7JlRHaKHMVj0yr0Pz02B3-r57SJqtMk,6009
 sciv/plot/_bubble_.py,sha256=vwBs-voOdkBfyMho5w4Rt68b8_Dw1C3NClLdauonC4U,1066
@@ -16,24 +16,24 @@ sciv/plot/_kde_.py,sha256=9VC6DKHbQAzKenz4DoiL5LgUzEJBtAWXXPCLxOV74kY,2459
 sciv/plot/_line_.py,sha256=P944YoGxSocHncjtme4n_iIPK9sghNW3-Xee6Tyy4HE,3850
 sciv/plot/_pie_.py,sha256=OVPv85MdjkjABh-uP5Y-KVk1VygFIzz87QT3OE1hZjU,6399
 sciv/plot/_radar_.py,sha256=g_abzmzibJIR6it59TendUI236inbzYl0IzzdoA3Uuc,6304
-sciv/plot/_scatter_.py,sha256=anBkPEZM-mmIsHwNUqUeOZhvqqWA8KhjpwhgTQ6f2yA,16771
+sciv/plot/_scatter_.py,sha256=HPy1eFqDk4vksAiKjn_Qk00fYO4GyqRs1O3ZZh44Ezw,16998
 sciv/plot/_venn_.py,sha256=TfNTuxog2pT7sicKBEEMtleoHXwnenbl3CMWJu9c2vs,2675
 sciv/plot/_violin_.py,sha256=40LYeHFYyNL1XbKHTjmwLT0zzh7o5emqN9Gl2sbl-DA,6458
 sciv/preprocessing/__init__.py,sha256=56RgDai5I3sZ4hl3aaV80ogOeUscYsU3nJUWE80jZ-k,742
 sciv/preprocessing/_anndata_.py,sha256=3d1cHFs1YA9UZkIPE089nZHFi-DjK-c1fRyi2shfSh4,6302
 sciv/preprocessing/_gencode_.py,sha256=HKhRgK76khGepdv4FaKiOvTys1uJTbvIyrKUta5W0K8,2108
 sciv/preprocessing/_gsea_.py,sha256=AH_PpUNfMN7WkF0pqAuUhEC6qZwKrtQm6VaaYu6JLfI,3803
-sciv/preprocessing/_scanpy_.py,sha256=flC10W5YPgJE5Ccxt5hP8qW3Q3cOi8DZ36Z1j9D3oNA,11481
-sciv/preprocessing/_scvi_.py,sha256=Og-o9JGQ4qyT9GKvR_uOroRgv4a0T9wA20kByHuaptY,10664
+sciv/preprocessing/_scanpy_.py,sha256=tB8BD2wpLAU8_YxdqrgNtcjpNXNRo-JCdm2lxaKDBLc,11611
+sciv/preprocessing/_scvi_.py,sha256=7QxwPA2kR_g15X28aEak7AFA4kyQ-UbtpiLH-rc5Ksg,10780
 sciv/preprocessing/_snapatac_.py,sha256=Dq8CHF7Psl3CQszaEokQYO56Oe2uzyWOy_cGlaOywfc,27798
 sciv/tool/__init__.py,sha256=WXzHkWt6RgBC3qqD-98nR5wQmt6oC850ox_VpMrapSU,2468
-sciv/tool/_algorithm_.py,sha256=yTImeGMWK6Y2gxygR90bqRF1vkvU857l5M9A_Q_VoZI,49839
-sciv/tool/_matrix_.py,sha256=O1EAhA9wxh06P_eOxEBesK7kO7IExKlhH6uJzGh1HBM,24322
-sciv/tool/_random_walk_.py,sha256=lnMiJyDuqDB75l9IkFLr7bIgKYhWxlBdIcExSErpQNw,48374
+sciv/tool/_algorithm_.py,sha256=uzA__knaIgIMcnFK-JwKT4sIbCETh94eYH-2WB_BpXc,52728
+sciv/tool/_matrix_.py,sha256=SnC3sXic_ufuEXStcD_HncvYH6apBdNK6nhG6jFLmjA,24324
+sciv/tool/_random_walk_.py,sha256=JOB97XLxlZYHvlIST1wlXgA0mw6fybkWnJGq6X_kbsk,48871
 sciv/util/__init__.py,sha256=nOxZ8if27X7AUJ6hZwTwxOJwIBJb0obWlHjqCzjg_Gc,1964
 sciv/util/_constant_.py,sha256=w0wKQd8guLd1ZTW24_5aECrWsIWDiNQmEpLsWlHar1A,3000
 sciv/util/_core_.py,sha256=hF33ybPcoVlapZsm-2Etem-p_rQUqXlsdaQgZv5jD7w,14867
-sciv-0.0.94.dist-info/METADATA,sha256=g-CN3-jgeDFTw0PYmoOB5CT2OvDBa86XrbStZh-xk8I,3465
-sciv-0.0.94.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
-sciv-0.0.94.dist-info/licenses/LICENSE,sha256=4UvHVf3qCOZjHLs4LkYz8u96XRpXnZrpTKrkUQPs5_A,1075
-sciv-0.0.94.dist-info/RECORD,,
+sciv-0.0.96.dist-info/METADATA,sha256=xLbV5NRQL7Q3aA25Peb8Idk1PjZ7rM6yXlJsH7VM_OI,3465
+sciv-0.0.96.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+sciv-0.0.96.dist-info/licenses/LICENSE,sha256=4UvHVf3qCOZjHLs4LkYz8u96XRpXnZrpTKrkUQPs5_A,1075
+sciv-0.0.96.dist-info/RECORD,,