fastccc 0.1.1__py3-none-any.whl

fastccc/__init__.py

@@ -0,0 +1,8 @@
+import sys
+from loguru import logger
+
+logger.remove()
+logger.add(sys.stdout, level="INFO", format='<cyan>{time:YYYY-MM-DD HH:mm:ss}</cyan> | <level>{level: <8}</level> | <level>{message}</level>')
+
+from .core import Cauchy_combination_of_statistical_analysis_methods
+from .core import statistical_analysis_method

fastccc/build_reference.py

@@ -0,0 +1,455 @@
+import scanpy as sc
+import numpy as np
+import pandas as pd
+from scipy.sparse import issparse
+from tqdm import tqdm
+from loguru import logger
+from .preprocess import get_interactions
+from . import preproc_utils
+from .core import calculate_cluster_percents, analyze_interactions_percents
+from .distrib_digit import Distribution_digit, get_pmf_array_from_samples_for_digitized_bins,  get_minimum_distribution_for_digit
+from . import dist_complex
+from . import dist_lr
+from . import score
+import itertools
+from scipy.signal import fftconvolve
+from collections import Counter
+import os
+import pickle
+
+def digitize_transform(x, n_bins=50):
+    def _digitize(x: np.ndarray, bins: np.ndarray, side="both") -> np.ndarray:
+        assert x.ndim == 1 and bins.ndim == 1
+        left_digits = np.digitize(x, bins)
+        if side == "one":
+            return left_digits
+        right_digits = np.digitize(x, bins, right=True)
+        rands = np.random.rand(len(x))  # uniform random numbers
+        digits = rands * (right_digits - left_digits) + left_digits
+        digits = np.ceil(digits).astype(np.int64)
+        return digits
+        
+    # non_zero_ids = x.nonzero()
+    # non_zero_row = x[non_zero_ids]
+    '''
+    input x 就是 非0的，直接针对csr，coo数据的
+    '''
+    bins = np.quantile(x, np.linspace(0, 1, n_bins - 1))
+    non_zero_digits = _digitize(x, bins)
+    return non_zero_digits
+    
+
+def calculate_L_R_and_IS_score(mean_counts, interactions):
+    p1_index = []
+    p2_index = []
+    all_index = []
+    for i in itertools.product(sorted(mean_counts.index), sorted(mean_counts.index)):
+        p1_index.append(i[0])
+        p2_index.append(i[1])
+        all_index.append('|'.join(i))
+    p1 = mean_counts.loc[p1_index, interactions['multidata_1_id']]
+    p2 = mean_counts.loc[p2_index, interactions['multidata_2_id']]
+    p1.columns = interactions.index
+    p2.columns = interactions.index
+    p1.index = all_index
+    p2.index = all_index
+    interactions_strength = (p1 + p2)/2 * (p1 > 0) * (p2>0)
+    return p1, p2, interactions_strength
+
+def calculate_L_R_and_IS_percents(cluster_percents, interactions, threshold=0.1, sep='|'):
+    
+    p1_index = []
+    p2_index = []
+    all_index = []
+    for i in itertools.product(sorted(cluster_percents.index), sorted(cluster_percents.index)):
+        p1_index.append(i[0])
+        p2_index.append(i[1])
+        all_index.append(sep.join(i))
+        
+    p1 = cluster_percents.loc[p1_index, interactions['multidata_1_id']]
+    p2 = cluster_percents.loc[p2_index, interactions['multidata_2_id']]
+    p1.columns = interactions.index
+    p2.columns = interactions.index
+    p1.index = all_index
+    p2.index = all_index
+    
+    interactions_strength = (p1>threshold) * (p2>threshold)
+    # print((p1>threshold) * (p2>threshold))
+    
+    return p1, p2, interactions_strength
+
+def calculate_mean_pmfs(counts_df, labels_df, complex_table, gene_pmf_dict, n_fft=100):
+    meta_dict = Counter(labels_df.cell_type)
+    ####### clusters_mean #######
+    clusters_mean_dict = {}
+    for celltype in sorted(meta_dict):
+        clusters_mean_dict[celltype]  = {}
+        n_sum = meta_dict[celltype]
+        if n_sum < n_fft:
+            for gene in counts_df.columns:
+                if gene not in gene_pmf_dict:
+                    continue
+                else:
+                    clusters_mean_dict[celltype][gene] = gene_pmf_dict[gene][n_sum]
+        else:
+            for gene in counts_df.columns:
+                if gene not in gene_pmf_dict:
+                    continue
+                else:
+                    clusters_mean_dict[celltype][gene] = gene_pmf_dict[gene][1] ** n_sum / n_sum
+    mean_pmfs = pd.DataFrame(clusters_mean_dict).T
+    complex_func = get_minimum_distribution_for_digit
+    mean_pmfs = dist_complex.combine_complex_distribution_df(mean_pmfs, complex_table, complex_func)
+    return mean_pmfs
+
+
+def rank_preprocess(adata):
+    np.random.seed(42) # add seed to ensure reproduiablity
+    assert issparse(adata.X), "Anndata.X should be a sparse matrix format."
+    if adata.shape[1] < 5000:
+        logger.warning("Do you use whole transcriptomes? Raw data w\o filtering genes should work better.")
+
+    for i in tqdm(range(adata.shape[0]), desc="Ranking genes for cells", unit="cell", 
+              bar_format="{l_bar}{bar} | {n_fmt}/{total_fmt} cells completed", leave=False):
+        indices = slice(adata.X.indptr[i], adata.X.indptr[i+1])
+        x = adata.X.data[indices]
+        adata.X.data[indices] = digitize_transform(x)
+    logger.success("Rank preprocess done.")
+    return adata
+
+def get_fastccc_input(adata, lrdb_file_path, convert_type = 'hgnc_symbol'):
+    logger.info("Loading LRIs database. hgnc_symbol as gene name is requested.")
+    interactions = get_interactions(lrdb_file_path)
+    ##### gene_table ########
+    gene_table = pd.read_csv(os.path.join(lrdb_file_path, 'gene_table.csv'))
+    protein_table = pd.read_csv(os.path.join(lrdb_file_path, 'protein_table.csv'))
+    gene_table = gene_table.merge(protein_table, left_on='protein_id', right_on='id_protein')
+    #########################
+
+
+    ##### complex_table ######
+    complex_composition = pd.read_csv(os.path.join(lrdb_file_path, 'complex_composition_table.csv'))
+    complex_table = pd.read_csv(os.path.join(lrdb_file_path, 'complex_table.csv'))
+    complex_table = complex_table.merge(complex_composition, left_on='complex_multidata_id', right_on='complex_multidata_id')
+
+    # 让我们只关注 'complex_multidata_id'，'protein_multidata_id'
+    complex_table = complex_table[['complex_multidata_id','protein_multidata_id']]
+    '''
+    complex_table(pandas.DataFrame):
+    =======================================================
+            | complex_multidata_id   |  protein_multidata_id
+    -------------------------------------------------------
+    0      |             1355       |          1134
+    1      |             1356       |          1175
+    2      |             1357       |          1167
+    =======================================================
+    '''
+    ##########################
+
+    ##### feature to id conversion  ######
+    # 不在 标准列表 里的 gene 就不要了
+    tmp = gene_table[[convert_type, 'protein_multidata_id']]
+    tmp = tmp.drop_duplicates()
+    tmp.set_index('protein_multidata_id', inplace=True)
+
+    select_columns = []
+    columns_names = []
+    for foo, boo in zip(tmp.index, tmp[convert_type]):
+        if boo in adata.var_names:#counts.columns:
+            select_columns.append(boo)
+            columns_names.append(foo)
+
+    reduced_counts = adata[:, select_columns].to_df()
+    reduced_counts.columns = columns_names
+    reduced_counts = reduced_counts.T.groupby(reduced_counts.columns).mean().T
+    # FutureWarning: DataFrame.groupby with axis=1 is deprecated. Do `frame.T.groupby(...)` without axis instead.
+    # reduced_counts = reduced_counts.groupby(reduced_counts.columns, axis=1).mean()
+    ######################################
+
+    ########## filter genes  ############
+    # gene 在 所有 cell 上为 0 不要
+    reduced_counts = preproc_utils.filter_empty_genes(reduced_counts)
+    ######################################
+    
+    ######################################################################
+    #                      3.Other DF filtered                       #
+    ######################################################################
+    # 一个 interaction 可能只有 partA 存在，但是 partB 不存在
+    # 只有 如果 任意一部分不存在， 另一部分没必要参与后续计算
+
+    ##### delete item not involved interactions ####
+
+    foo_dict = complex_table.groupby('complex_multidata_id').apply(lambda x: list(x['protein_multidata_id'].values), include_groups=False).to_dict()
+    '''
+    dictionary complex_id: [protein_id_1, pid2, pid3, ...]
+    foo_dict = {
+        1355: [1134],
+        1356: [1175],
+        xxxx: [AAAA, BBBB, CCCC],
+    }
+    '''
+
+    def __content__(key):
+        if key not in foo_dict:
+            return [key]
+        else:
+            return foo_dict[key]
+
+    def __exist__(key, df):
+        # 目前的 complex 策略就是 全部都要有
+        # 经测试，这是cpdb用的策略
+        for item in __content__(key):
+            if item not in df.columns:
+                return False
+        return True
+
+    temp_list = []
+    temp_dict = {}
+    for item in reduced_counts.columns:
+        temp_dict[item] = False
+
+    # 注释是为了验证 interactions 的过滤策略， 完全一致
+    # print(interactions)
+    select_index = []
+    for partA, partB in zip(interactions.multidata_1_id, interactions.multidata_2_id):
+        if __exist__(partA, reduced_counts) and __exist__(partB, reduced_counts):
+            temp_list.extend([partA, partB])
+            select_index.append(True)
+        else:
+            select_index.append(False)
+    interactions_filtered = interactions[select_index]
+
+    for item in temp_list:
+        for subitem in __content__(item):
+            if subitem in temp_dict:
+                temp_dict[subitem] = True
+    select_index = [key for key in temp_dict if temp_dict[key]]
+    reduced_counts = reduced_counts[select_index]
+
+    counts_df = reduced_counts
+    temp_list = set(temp_list)
+    select_index = [True if item in temp_list else False for item in complex_table.complex_multidata_id]
+    complex_table = complex_table[select_index]
+    interactions = interactions_filtered
+    logger.success("Requested data for fastccc is prepared.")
+    return counts_df, complex_table, interactions
+
+
+def fastccc_for_reference(reference_name, save_path, counts_df, labels_df, complex_table, interactions, min_percentile = 0.1, ref_debug_mode=False, query_debug_mode=False, for_uploading=False):
+    logger.info("Running FastCCC.")
+    mean_counts = score.calculate_cluster_mean(counts_df, labels_df)
+    complex_func = score.calculate_complex_min_func
+    mean_counts = score.combine_complex_distribution_df(mean_counts, complex_table, complex_func)
+    percents = calculate_cluster_percents(counts_df, labels_df, complex_table)
+
+    n_bins = 50
+    precision_digit = 0.01
+    pmf_bins_digit = np.arange(0, n_bins+precision_digit - 1e-10, precision_digit)
+
+    ####### 
+    logger.info("Calculating null distributions.")
+    n_fft = 100
+    gene_sum_pmf_dict = {}
+    basic_info_dict = {}
+    for gene in counts_df.columns:
+        samples = counts_df[gene].values
+
+        loc = np.mean(samples)
+        scale = np.std(samples)
+        basic_info_dict[gene] = {'loc':loc, 'scale':scale}
+
+        gene_sum_pmf_dict[gene] = {1: get_pmf_array_from_samples_for_digitized_bins(samples)}
+        basic_info_dict[gene]['expr_dist'] = gene_sum_pmf_dict[gene][1]
+
+        for item in range(2,n_fft):
+            gene_sum_pmf_dict[gene][item] = fftconvolve(gene_sum_pmf_dict[gene][item-1], gene_sum_pmf_dict[gene][1])
+
+    gene_pmf_dict = {}
+    for gene in counts_df.columns:
+        gene_pmf_dict[gene] = {}
+        loc = basic_info_dict[gene]['loc']
+        scale = basic_info_dict[gene]['scale']
+        for item in range(1,n_fft):
+            pmf = gene_sum_pmf_dict[gene][item]
+            cdf = np.cumsum(pmf)
+            pmf_array = np.diff(cdf[np.int64(pmf_bins_digit * item)],prepend=0)
+            if item == 1:
+                gene_pmf_dict[gene][item] = Distribution_digit('other', pmf_array=pmf_array, loc=loc, scale=scale, is_align=True)
+            else:
+                gene_pmf_dict[gene][item] = Distribution_digit('other', pmf_array=pmf_array, is_align=True)
+
+    if ref_debug_mode or query_debug_mode:
+        p1_index = []
+        p2_index = []
+        all_index = []
+        for i in itertools.product(sorted(mean_counts.index), sorted(mean_counts.index)):
+            p1_index.append(i[0])
+            p2_index.append(i[1])
+            all_index.append('|'.join(i))
+        p1 = mean_counts.loc[p1_index, interactions['multidata_1_id']]
+        p2 = mean_counts.loc[p2_index, interactions['multidata_2_id']]
+        p1.columns = interactions.index
+        p2.columns = interactions.index
+        p1.index = all_index
+        p2.index = all_index
+        interactions_strength = (p1 + p2)/2 * (p1 > 0) * (p2>0)
+        L_perc, R_perc, percents_analysis = calculate_L_R_and_IS_percents(percents, interactions, threshold=min_percentile)
+        
+        meta_dict = Counter(labels_df.cell_type)
+        ####### clusters_mean #######
+        clusters_mean_dict = {}
+        for celltype in sorted(meta_dict):
+            clusters_mean_dict[celltype]  = {}
+            n_sum = meta_dict[celltype]
+            if n_sum < n_fft:
+                for gene in counts_df.columns:
+                    clusters_mean_dict[celltype][gene] = gene_pmf_dict[gene][n_sum]
+            else:
+                for gene in counts_df.columns:
+                    clusters_mean_dict[celltype][gene] = gene_pmf_dict[gene][1] ** n_sum / n_sum
+        mean_pmfs = pd.DataFrame(clusters_mean_dict).T
+        complex_func = get_minimum_distribution_for_digit
+        mean_pmfs = dist_complex.combine_complex_distribution_df(mean_pmfs, complex_table, complex_func)
+
+        logger.info("Calculating sig. LRIs.")
+        pvals = dist_lr.calculate_key_interactions_pvalue(
+            mean_pmfs, interactions, interactions_strength, percents_analysis, method='Arithmetic'
+        )
+
+        if query_debug_mode:
+            pvals.to_csv(f'{save_path}/debug_pvals.txt', sep='\t')
+            return
+
+        if ref_debug_mode:
+            pvals.to_csv(f'{save_path}/ref_pvals.txt', sep='\t')
+            percents_analysis.to_csv(f'{save_path}/ref_percents_analysis.txt', sep='\t')
+            L_perc.to_csv(f'{save_path}/ref_percents_L.txt', sep='\t')
+            R_perc.to_csv(f'{save_path}/ref_percents_R.txt', sep='\t')
+            # interactions_strength.to_csv(f'{save_path}/ref_interactions_strength.csv')
+            p1.to_csv(f'{save_path}/ref_interactions_strength_L.txt', sep='\t')
+            p2.to_csv(f'{save_path}/ref_interactions_strength_R.txt', sep='\t')
+
+    ####### save reference results #######
+    logger.info("Saving reference.")
+    if for_uploading:
+        with open(f'{save_path}/basic_info_dict.pkl', 'wb') as f:
+            pickle.dump(basic_info_dict, f)
+    else:
+        with open(f'{save_path}/ref_gene_pmf_dict.pkl', 'wb') as f:
+            pickle.dump(gene_pmf_dict, f)
+    with open(f'{save_path}/ref_percents.pkl', 'wb') as f:
+        pickle.dump(percents, f)
+    with open(f'{save_path}/ref_mean_counts.pkl', 'wb') as f:
+        pickle.dump(mean_counts, f)
+    with open(f'{save_path}/complex_table.pkl', 'wb') as f:
+        pickle.dump(complex_table, f)
+    with open(f'{save_path}/interactions.pkl', 'wb') as f:
+        pickle.dump(interactions, f)
+
+
+def record_hk_genes(adata):
+    from .hk_genes import housekeeping_genes
+    select_index = [item for item in adata.var_names if item in housekeeping_genes]
+    hk_adata = adata[:, select_index]
+    mean_hk_rnk = hk_adata.X.mean(axis=0)
+    return mean_hk_rnk, select_index
+
+def record_adjustment_info(adata, save_path):
+    mean_hk_rnk, gene_index = record_hk_genes(adata)
+    ref_hk = pd.DataFrame(np.array(mean_hk_rnk).flatten(), index=gene_index, columns=['ref_hk'])
+    ref_hk.to_csv(f'{save_path}/ref_hk.txt', sep='\t')
+
+
+reference_config = {}
+
+from datetime import date
+
+def dumps(toml_dict, table=""):
+    document = []
+    for key, value in toml_dict.items():
+        match value:
+            case dict():
+                table_key = f"{table}.{key}" if table else key
+                document.append(
+                    f"\n[{table_key}]\n{_dumps_dict(value)}"
+                )
+            case _:
+                document.append(f"{key} = {_dumps_value(value)}")
+    return "\n".join(document)
+
+def _dumps_dict(toml_dict):
+    document = []
+    for key, value in toml_dict.items():
+        key = f'"{key}"'
+        document.append(f"{key} = {_dumps_value(value)}")
+    return "\n".join(document)
+
+def _dumps_value(value):
+    match value:
+        case bool():
+            return "true" if value else "false"
+        case float() | int():
+            return str(value)
+        case str():
+            return f'"{value}"'
+        case date():
+            return value.isoformat()
+        case list():
+            return f"[{', '.join(_dumps_value(v) for v in value)}]"
+        case _:
+            raise TypeError(
+                f"{type(value).__name__} {value!r} is not supported"
+            )
+
+def save_config(save_path):
+    logger.info("Saving reference config.")
+    save_content = dumps(reference_config)
+    with open(f'{save_path}/config.toml', 'w') as f:
+        f.write(save_content) 
+
+
+def build_reference_workflow(database_file_path, reference_counts_file_path, celltype_file_path, reference_name, save_path, meta_key=None, min_percentile = 0.1, debug_mode=False, for_uploading=False):
+    logger.info(f"Start building CCC reference.")
+
+    reference_config['reference_name'] = reference_name
+    reference_config['min_percentile'] = min_percentile
+    if database_file_path.endswith('/'):
+        reference_config['LRI_database'] = database_file_path[:-1].split('/')[-1]
+    else:
+        reference_config['LRI_database'] = database_file_path.split('/')[-1]
+
+    logger.info(f"Reference_name = {reference_config['reference_name']}")
+    logger.info(f"min_percentile = {reference_config['min_percentile']}")
+    logger.info(f"LRI database = {reference_config['LRI_database']}")
+
+    save_path = os.path.join(save_path, reference_name)
+    if not os.path.exists(save_path):
+        os.makedirs(save_path)
+        logger.success(f"Reference save dir {save_path} is created.")
+    else:
+        logger.warning(f"{save_path} already exists, all files will be overwritten")
+
+    reference = sc.read_h5ad(reference_counts_file_path)
+    sc.pp.filter_cells(reference, min_genes=50)
+    logger.info(f"Reading reference adata, {reference.shape[0]} cells x {reference.shape[1]} genes.")
+
+    if meta_key is not None:
+        labels_df = pd.DataFrame(reference.obs[meta_key])
+        labels_df.columns = ['cell_type']
+        labels_df.index.name = 'barcode_sample'
+    else:
+        labels_df = pd.read_csv(celltype_file_path, sep='\t', index_col=0)
+        for barcode in reference.obs_names:
+            assert barcode in labels_df.index, "The index of query data doesn't match the index of labels"
+        labels_df = labels_df.loc[reference.obs_names, :]
+    
+    ct_counter = Counter(labels_df['cell_type'])
+    reference_config['celltype'] = ct_counter
+    
+    reference = rank_preprocess(reference)
+    record_adjustment_info(reference, save_path)
+    counts_df, complex_table, interactions = get_fastccc_input(reference, database_file_path)
+    fastccc_for_reference(reference_name, save_path, counts_df, labels_df, complex_table, interactions, min_percentile, ref_debug_mode=debug_mode, for_uploading=for_uploading)
+    save_config(save_path)
+    logger.success(f"Reference '{reference_name}' is built.")
+

fastccc/cauchy_combine.py

@@ -0,0 +1,55 @@
+import sys
+import os, glob
+import math
+import getopt
+import numpy as np
+import pandas as pd
+import pickle as pkl
+from loguru import logger
+
+def cauthy_combine(fastCCC_dir, task_id=None):
+    if task_id is None:
+        logger.warning("No task_id is provided, all pvals files will be combined.")
+        pval_paths = glob.glob(fastCCC_dir+os.sep+'*pvals.tsv')
+    else:
+        logger.info(f"Task ID for combining is :{task_id}")
+        pval_paths = glob.glob(fastCCC_dir+os.sep+f'{task_id}*pvals.tsv')
+    logger.info(f"There are {len(pval_paths)} pval files.")
+    joined_path = '\n'.join(pval_paths)
+    logger.debug(f"\n{joined_path}")
+
+    ct_pairs, cpis = None, None
+    comb_dict = dict()
+    for pval_path in pval_paths:
+        comb = os.path.basename(pval_path)
+        comb = comb.replace('pvals.tsv', '')
+        pval_df = pd.read_csv(pval_path, header=0, index_col=0, sep='\t')
+        if ct_pairs is None:
+            ct_pairs = pval_df.index.tolist()
+        if cpis is None:
+            cpis = pval_df.columns.tolist()
+        comb_dict[comb] = pval_df.values
+
+    pval_mat = []
+    for comb, values in comb_dict.items():
+        pval_mat.append(np.expand_dims(values, axis=1))
+    pval_mat = np.concatenate(pval_mat, axis=1)
+    weight = np.ones(len(comb_dict)) / len(comb_dict)
+    T = pval_mat.copy()
+    T[np.where(pval_mat == 1)] = np.tan(-np.pi/2)
+    T[foo] = np.tan(np.pi*(0.5 - T[(foo:=np.where(pval_mat != 1))]))
+    T =  weight @ T
+    P = 0.5 - np.arctan(T) / np.pi
+
+    T_df = pd.DataFrame(T, index=ct_pairs, columns=cpis)
+    P_df = pd.DataFrame(P, index=ct_pairs, columns=cpis)
+
+    if task_id is None:
+        T_df.to_csv(fastCCC_dir+os.sep+'Cauchy_stats.tsv', sep='\t')
+        P_df.to_csv(fastCCC_dir+os.sep+'Cauchy_pvals.tsv', sep='\t')
+    else:
+        T_df.to_csv(fastCCC_dir+os.sep+f'{task_id}_Cauchy_stats.tsv', sep='\t')
+        P_df.to_csv(fastCCC_dir+os.sep+f'{task_id}_Cauchy_pvals.tsv', sep='\t')
+
+# if __name__ == "__main__":
+#     cauthy_combine(fastCCC_dir)

fastccc/ccc_utils.py

@@ -0,0 +1,75 @@
+import numpy as np
+import pandas as pd
+import os
+import psutil
+
+
+def create_significant_interactions_df(
+    pvals, 
+    LRI_db_path, 
+    save = False, 
+    save_path = './temp/', 
+    save_file = 'significant_interaction_list', 
+    seperator = '|'
+):
+
+    from . import preprocess
+    interactions = preprocess.get_interactions(LRI_db_path)
+    id2symbol_dict = (pd.read_csv(f'{LRI_db_path}/gene_table.csv')[['protein_id', 'hgnc_symbol']]\
+    .set_index('protein_id')['hgnc_symbol']).to_dict()
+    ##### complex_table ######
+    complex_composition = pd.read_csv(os.path.join(LRI_db_path, 'complex_composition_table.csv'))
+    complex_table = pd.read_csv(os.path.join(LRI_db_path, 'complex_table.csv'))
+    complex_table = complex_table.merge(complex_composition, left_on='complex_multidata_id', right_on='complex_multidata_id')
+    foo_dict = complex_table.groupby('complex_multidata_id').apply(lambda x: list(x['protein_multidata_id'].values), include_groups=False).to_dict()
+    for key in foo_dict:
+        value = ','.join([id2symbol_dict[item] for item in foo_dict[key]])
+        id2symbol_dict[key] = value
+
+    x, y = np.where(pvals.values<0.05)
+    lines = []
+    for subx, suby in zip(x,y):
+        celltype_A, celltype_B = pvals.index[subx].split(seperator)
+        interaction_ID = pvals.columns[suby]
+        lines.append((celltype_A, celltype_B, interaction_ID, pvals.iloc[subx, suby]))
+
+    output_df = pd.DataFrame(lines, columns=['sender_celltype', 'receiver_celltype', 'LRI_ID', 'p-value'])
+    output_df = output_df.merge(interactions, left_on='LRI_ID', right_index=True, how='left')
+
+    output_df.multidata_1_id = [id2symbol_dict[ligand_gene_name] for ligand_gene_name in output_df.multidata_1_id.tolist()]
+    output_df.multidata_2_id = [id2symbol_dict[receptor_gene_name] for receptor_gene_name in output_df.multidata_2_id.tolist()]
+
+    output_df = output_df[['sender_celltype', 'receiver_celltype', 'LRI_ID', 'multidata_1_id', 'multidata_2_id', 'p-value']]
+    output_df = output_df.rename(columns={'multidata_1_id': 'ligand', 'multidata_2_id': 'receptor'})
+
+    save_file = os.path.join(save_path, save_file)
+    if save:
+        output_df.to_excel(f'{save_file}.xlsx')
+    return output_df
+
+
+def create_significant_interactions_with_flag_df(pvals, significant_flag, interactions, save_path='./temp/', save_file='significant_interaction_list'):
+    seperator = '|'
+    x, y = np.where(pvals.values<0.05)
+    lines = []
+    for subx, suby in zip(x,y):
+        if not significant_flag.iloc[subx, suby]:
+            continue
+        celltype_A, celltype_B = pvals.index[subx].split(seperator)
+        interaction_ID = pvals.columns[suby]
+        lines.append((celltype_A, celltype_B, interaction_ID, pvals.iloc[subx, suby]))
+    output_df = pd.DataFrame(lines, columns=['Ligand_celltype', 'Receptor_celltype', 'Interaction_ID', 'P-val'])
+    output_df = output_df.merge(interactions, left_on='Interaction_ID', right_index=True, how='left')
+    save_file = os.path.join(save_path, save_file)
+    output_df.to_excel(f'{save_file}.xlsx')
+    return output_df
+
+def get_current_memory():
+    """
+    获取当前内存占用
+    usage:
+    current_memory = get_current_memory()
+    print("当前内存占用: {:.2f} MB".format(current_memory))
+    """
+    process = psutil.Process()
+    return process.memory_info().rss / (1024 * 1024)  # 转换为MB