discotoolkit 1.1.2__tar.gz → 1.1.4__tar.gz

{discotoolkit-1.1.2 → discotoolkit-1.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: discotoolkit
-Version: 1.1.2
+Version: 1.1.4
 Summary: DISCOtoolkit is an python package that allows users to access data and use the tools provided by the DISCO database.
 Home-page: http://www.immunesinglecell.org/
 Author: Li Mengwei, Rom Uddamvathanak

{discotoolkit-1.1.2 → discotoolkit-1.1.4}/README.md

@@ -8,7 +8,7 @@
 -->
 [![Documentation Status](https://readthedocs.org/projects/discotoolkit-py/badge/?version=latest)](https://discotoolkit-py.readthedocs.io/en/latest/?badge=latest) [![Downloads](https://static.pepy.tech/personalized-badge/discotoolkit?period=total&units=international_system&left_color=black&right_color=orange&left_text=Downloads)](https://pepy.tech/project/discotoolkit) [![PyPI version](https://img.shields.io/pypi/v/discotoolkit)](https://pypi.org/project/discotoolkit)
 
-# DISCOtoolkit 1.1.2
+# DISCOtoolkit 1.1.4
 
 DISCOtoolkit is an python package that allows users to access data and use the tools provided by the [DISCO database](https://www.immunesinglecell.org/). Read the documentation [DISCOtoolkit](https://discotoolkit-py.readthedocs.io/en/latest/). It provides the following functions:
 

{discotoolkit-1.1.2 → discotoolkit-1.1.4}/discotoolkit/CELLiD.py

@@ -9,10 +9,11 @@ import os
 import hashlib
 import requests
 from scipy import stats
+
 # from fast_fisher import fast_fisher_exact, odds_ratio
 from scipy.stats.contingency import odds_ratio
-from joblib import Parallel, delayed # multiprocessing library
-from pandarallel import pandarallel # multiprocessing library
+from joblib import Parallel, delayed  # multiprocessing library
+from pandarallel import pandarallel  # multiprocessing library
 
 pd.options.mode.chained_assignment = None
 
@@ -24,17 +25,45 @@ from .GetMetadata import check_in_list
 """
 CELLiD cell type annotation function block.
 """
-# get the total atlas from DISCO website for the user to select which atlas to use
-def get_atlas(ref_data = None, ref_path = None):
 
+
+def generate_correlation_map(x, y):
+    """Correlate each n with each m.
+
+    Parameters
+    ----------
+    x : np.array
+      Shape N X T.
+
+    y : np.array
+      Shape M X T.
+
+    Returns
+    -------
+    np.array
+      N X M array in which each element is a correlation coefficient.
+
+    """
+    mu_x = x.mean(1)
+    mu_y = y.mean(1)
+    n = x.shape[1]
+    if n != y.shape[1]:
+        raise ValueError("x and y must " + "have the same number of timepoints.")
+    s_x = x.std(1, ddof=n - 1)
+    s_y = y.std(1, ddof=n - 1)
+    cov = np.dot(x, y.T) - n * np.dot(mu_x[:, np.newaxis], mu_y[np.newaxis, :])
+    return cov / np.dot(s_x[:, np.newaxis], s_y[np.newaxis, :])
+
+
+# get the total atlas from DISCO website for the user to select which atlas to use
+def get_atlas(ref_data=None, ref_path=None):
     """get the all the atlas string from the DISCO website and return to the user
 
     Returns:
         List: return list of string
-    """    
+    """
     # Download reference data and ref_deg if missing
     if ref_data is None:
-
         # check for the data path
         if ref_path is None:
             ref_path = "DISCOtmp"
@@ -42,19 +71,33 @@ def get_atlas(ref_data = None, ref_path = None):
         # if the path does not exist, we create a default directory
         if not os.path.exists(ref_path):
             os.mkdir(ref_path)
-        
+
         # download reference data from the server in pickle extension and read as pandas dataframe
         if ref_data is None:
-            if not(os.path.exists(ref_path + "/ref_data.pkl")):
+            if not (os.path.exists(ref_path + "/ref_data.pkl")):
                 logging.info("Downloading reference dataset...")
-                response = requests.get(url=prefix_disco_url +"/getRefPkl", timeout=timeout)
+                response = requests.get(
+                    url=prefix_disco_url + "toolkit/getRef?type=pkl", timeout=timeout
+                )
                 open(ref_path + "/ref_data.pkl", "wb").write(response.content)
-            ref_data = pd.read_pickle(ref_path + "/ref_data.pkl", compression = {'method':'gzip','compresslevel':6})
+            ref_data = pd.read_pickle(
+                ref_path + "/ref_data.pkl",
+                compression={"method": "gzip", "compresslevel": 6},
+            )
 
     all_atlas = [each.split("--")[1] for each in ref_data.columns]
     return list(set(all_atlas))
 
-def CELLiD_cluster(rna, ref_data : pd.DataFrame = None, ref_deg : pd.DataFrame = None, atlas : str = None, n_predict : int = 1, ref_path : str = None, ncores : int = 10):
+
+def CELLiD_cluster(
+    rna,
+    ref_data: pd.DataFrame = None,
+    ref_deg: pd.DataFrame = None,
+    atlas: str = None,
+    n_predict: int = 1,
+    ref_path: str = None,
+    ncores: int = 10,
+):
     """Cell type annotation using reference data and compute the correlation between the user cell gene expression as compare
         to the reference data. The celltype with highest correlation will be concluded as the celltype
 
@@ -73,20 +116,21 @@ def CELLiD_cluster(rna, ref_data : pd.DataFrame = None, ref_deg : pd.DataFrame =
 
     # initialize the pandarallel for parallel processing
     pandarallel.initialize(nb_workers=ncores)
-    
+
     # check for the input data
-    if not(isinstance(rna, pd.DataFrame) or isinstance(rna, np.ndarray)):
+    if not (isinstance(rna, pd.DataFrame) or isinstance(rna, np.ndarray)):
         logging.error("the rna must be a pandas DataFrame or Numpy Array")
 
     # check for number of prediction of celltypes and set the largest number to 3 only
     if n_predict is not None:
         if n_predict > 3:
-            logging.info("Any value of n_predict that exceeds 3 will be automatically adjusted to 3.")
+            logging.info(
+                "Any value of n_predict that exceeds 3 will be automatically adjusted to 3."
+            )
             n_predict = 3
-    
+
     # Download reference data and ref_deg if missing
     if (ref_data is None) or (ref_deg is None):
-
         # check for the data path
         if ref_path is None:
             ref_path = "DISCOtmp"
@@ -94,42 +138,60 @@ def CELLiD_cluster(rna, ref_data : pd.DataFrame = None, ref_deg : pd.DataFrame =
         # if the path does not exist, we create a default directory
         if not os.path.exists(ref_path):
             os.mkdir(ref_path)
-        
+
         # download reference data from the server in pickle extension and read as pandas dataframe
         if ref_data is None:
-            if not(os.path.exists(ref_path + "/ref_data.pkl")):
+            if not (os.path.exists(ref_path + "/ref_data.pkl")):
                 logging.info("Downloading reference dataset...")
-                response = requests.get(url=prefix_disco_url +"/getRefPkl", timeout=timeout)
+                response = requests.get(
+                    url=prefix_disco_url + "toolkit/getRef?type=pkl", timeout=timeout
+                )
                 open(ref_path + "/ref_data.pkl", "wb").write(response.content)
-            ref_data = pd.read_pickle(ref_path + "/ref_data.pkl", compression = {'method':'gzip','compresslevel':6})
+            ref_data = pd.read_pickle(
+                ref_path + "/ref_data.pkl",
+                compression={"method": "gzip", "compresslevel": 6},
+            )
 
         # similarly do the same for the DEG reference
         if ref_deg is None:
-            if not(os.path.exists(ref_path + "/ref_deg.pkl")):
+            if not (os.path.exists(ref_path + "/ref_deg.pkl")):
                 logging.info("Downloading deg dataset...")
-                response = requests.get(url=prefix_disco_url +"/getRefDegPkl", timeout=timeout)
+                response = requests.get(
+                    url=prefix_disco_url + "toolkit/getRefDeg?type=pkl", timeout=timeout
+                )
                 open(ref_path + "/ref_deg.pkl", "wb").write(response.content)
-            ref_deg = pd.read_pickle(ref_path + "/ref_deg.pkl", compression = {'method':'gzip','compresslevel':6})
-    
+            ref_deg = pd.read_pickle(
+                ref_path + "/ref_deg.pkl",
+                compression={"method": "gzip", "compresslevel": 6},
+            )
+
     ####
     # write list of atlas function
     # we can write a function to get all the atlas from disco to the users
     # subsetting to the selected atlas by the user
     if atlas is not None:
-        select_ref = [index for index, each in enumerate(ref_data.columns) if each.split("--")[1] in list(atlas)]
+        select_ref = [
+            index
+            for index, each in enumerate(ref_data.columns)
+            if each.split("--")[1] in list(atlas)
+        ]
         ref_data = ref_data.iloc[:, select_ref]
-    
+
     # get the intersection of the gene for the user data and the reference data
     genes = set.intersection(set(rna.index), set(ref_data.index))
 
     # give an error as 2000 genes are very low
     if len(genes) <= 2000:
-        logging.error("Less than 2000 genes are shared between the input data and the reference dataset!")
+        logging.error(
+            "Less than 2000 genes are shared between the input data and the reference dataset!"
+        )
 
     # give a warning to the user
     if len(genes) <= 5000:
-        logging.warning("The input data and reference dataset have a limited number of overlapping genes, which may potentially impact the accuracy of the CELLiD.")
-    
+        logging.warning(
+            "The input data and reference dataset have a limited number of overlapping genes, which may potentially impact the accuracy of the CELLiD."
+        )
+
     # subsetting the dataframe to the common genes across data and the reference
     rna = rna.loc[list(genes)]
     ref_data = ref_data.loc[list(genes)]
@@ -137,7 +199,7 @@ def CELLiD_cluster(rna, ref_data : pd.DataFrame = None, ref_deg : pd.DataFrame =
     # nested apply function to compute correlation for each cell type between the user and reference database
     def each_ref_correlation(input, ref_data):
         input = list(input)
-        res = ref_data.parallel_apply(basic_correlation, input = input, axis = 0)
+        res = ref_data.parallel_apply(basic_correlation, input=input, axis=0)
         return res
 
     # apply the correlation to all the columns in user data
@@ -148,9 +210,14 @@ def CELLiD_cluster(rna, ref_data : pd.DataFrame = None, ref_deg : pd.DataFrame =
         predicted = pd.Series(list(ref)).corr(pd.Series(list(input)), method="spearman")
 
         return predicted
-  
+
     # get the predicted correlation as in pandas DataFrame
-    predicted_cell = rna.apply(each_ref_correlation, result_type = "expand", axis = 0, ref_data = ref_data)
+    # predicted_cell = pd.DataFrame(
+    #     generate_correlation_map(ref_data.to_numpy().T, rna.to_numpy().T)
+    # )
+    predicted_cell = rna.apply(
+        each_ref_correlation, result_type="expand", axis=0, ref_data=ref_data
+    )
     predicted_cell = pd.DataFrame(predicted_cell)
 
     # set the index to be the celltype based on the reference_data
@@ -161,60 +228,84 @@ def CELLiD_cluster(rna, ref_data : pd.DataFrame = None, ref_deg : pd.DataFrame =
     # define a function to apply to each column of the dataframe
     def get_top_5_indices(col):
         # get the indices of the top 5 values in the column
-        indices = np.where(col.rank(method='min', ascending=False) <= 5)[0]
+        indices = np.where(col.rank(method="min", ascending=False) <= 5)[0]
         # convert to numeric and return
-        return pd.Series(indices).astype('int')
-    
-    ct = predicted_cell.apply(get_top_5_indices)
-
-    # ct = pd.DataFrame(predicted_cell.parallel_apply(lambda x: [index for index, each in enumerate(x.rank()) if each <= 5], axis = 0, result_type = "expand"))
+        return pd.Series(indices).astype("int")
 
+    ct = predicted_cell.apply(get_top_5_indices)
     # compute the correleration based on the genes set that is intersection between the user data and reference dataset
+
     def second_correlation(i, ref_data, rna, ct):
-        ref = ref_data.iloc[:,ct[i]].copy()
-        g = set(ref_deg.iloc[check_in_list(ref_deg["group"], ref.columns)].copy()["gene"])
+        ref = ref_data.iloc[:, list(ct[str(i)])].copy()
+        g = set(
+            ref_deg.iloc[check_in_list(ref_deg["group"], ref.columns)].copy()["gene"]
+        )
         g = set.intersection(set(ref.index), g)
         ref = ref.loc[list(g)].copy()
-        input = rna.loc[list(g), i].copy()
+        # print(rna.loc[list(g), str(i)])
+        input = rna.loc[list(g), str(i)].copy()
         # predict = ref.apply(lambda i: np.round(stats.spearmanr(pd.to_numeric(i), pd.to_numeric(input), nan_policy='omit')[0], 3))
-        predict = ref.apply(lambda i: np.round(pd.Series(i).corr(pd.Series(input), method='spearman'), 3)) # trying with pandas correlation
+        predict = ref.apply(
+            lambda i: np.round(
+                pd.Series(i).corr(pd.Series(input), method="spearman"), 3
+            )
+        )  # trying with pandas correlation
         predict = pd.DataFrame(predict)
         predict.columns = ["cor"]
-        predict = predict.sort_values(["cor"], ascending = False)
-        res = [[each.split("--")[0], each.split("--")[1], predict["cor"][index], i] for index, each in enumerate(predict.index) if index < n_predict]
-        res = pd.DataFrame(res, columns =['cell_type', 'atlas', "score", "input_index"])
+        predict = predict.sort_values(["cor"], ascending=False)
+        res = [
+            [each.split("--")[0], each.split("--")[1], predict["cor"][index], i]
+            for index, each in enumerate(predict.index)
+            if index < n_predict
+        ]
+        res = pd.DataFrame(res, columns=["cell_type", "atlas", "score", "input_index"])
         return res  # return list in the format cell_type, atlas, score, input_index
 
     # get a data in the format of cell_type, atlas, score, input_index
-    predicted_cell = Parallel(n_jobs=ncores, batch_size=32, verbose = 2)(delayed(second_correlation)(int(y), ref_data, rna, ct) for y in range(rna.shape[1]))
+    predicted_cell = Parallel(n_jobs=ncores, batch_size=32, verbose=2)(
+        delayed(second_correlation)(int(y), ref_data, rna, ct)
+        for y in range(rna.shape[1])
+    )
 
     # first concatenate in row wise manner
     predicted_cell = pd.concat(predicted_cell)
 
-    pivot = pd.pivot_table(predicted_cell, index='input_index', columns=predicted_cell.groupby('input_index').cumcount()+1, 
-                       values=['cell_type', 'atlas', 'score'], aggfunc='first')
+    pivot = pd.pivot_table(
+        predicted_cell,
+        index="input_index",
+        columns=predicted_cell.groupby("input_index").cumcount() + 1,
+        values=["cell_type", "atlas", "score"],
+        aggfunc="first",
+    )
 
-    pivot = pivot[["cell_type", "atlas", "score"]] 
+    pivot = pivot[["cell_type", "atlas", "score"]]
 
     # flatten multi-level column index
-    pivot.columns = ['_'.join(map(str, col)).strip() for col in pivot.columns.values]
+    pivot.columns = ["_".join(map(str, col)).strip() for col in pivot.columns.values]
 
     # rename columns
     column_names = {}
     for i in range(n_predict):
-        column_names[f'cell_type_{i+1}'] = f'predicted_cell_type_{i+1}'
-        column_names[f'atlas_{i+1}'] = f'source_atlas_{i+1}'
-        column_names[f'score_{i+1}'] = f'score_{i+1}'
-        
+        column_names[f"cell_type_{i+1}"] = f"predicted_cell_type_{i+1}"
+        column_names[f"atlas_{i+1}"] = f"source_atlas_{i+1}"
+        column_names[f"score_{i+1}"] = f"score_{i+1}"
+
     pivot = pivot.rename(columns=column_names)
 
-    return pivot# return pandas dataframe in the format the same original R package
+    return pivot  # return pandas dataframe in the format the same original R package
+
 
 """
 Geneset enrichment analysis using DISCO data
 """
 
-def CELLiD_enrichment(input : pd.DataFrame, reference : pd.DataFrame = None, ref_path : str = None, ncores : int = 1):
+
+def CELLiD_enrichment(
+    input: pd.DataFrame,
+    reference: pd.DataFrame = None,
+    ref_path: str = None,
+    ncores: int = 1,
+):
     """Function to generate enrichment analysis based on the reference gene sets and following the DISCO pipeline.
 
     Args:
@@ -229,7 +320,7 @@ def CELLiD_enrichment(input : pd.DataFrame, reference : pd.DataFrame = None, ref
 
     # check input data
     # check if the input type is a DataFrame
-    if not(isinstance(input, pd.DataFrame)):
+    if not (isinstance(input, pd.DataFrame)):
         logging.error("The input must be a dataframe")
 
     # check if the user provide more than the needed column which are gene and fc
@@ -240,7 +331,7 @@ def CELLiD_enrichment(input : pd.DataFrame, reference : pd.DataFrame = None, ref
     if input.shape[1] == 2:
         input_shape = 2
         input.columns = ["gene", "fc"]
-    
+
     # else we can just take a gene list for the enrichment
     else:
         input_shape = 1
@@ -248,7 +339,6 @@ def CELLiD_enrichment(input : pd.DataFrame, reference : pd.DataFrame = None, ref
 
     # if the user does not provide reference geneset list
     if reference is None:
-
         # check for the data path if it is provided by the user
         if ref_path is None:
             ref_path = "DISCOtmp"
@@ -256,31 +346,45 @@ def CELLiD_enrichment(input : pd.DataFrame, reference : pd.DataFrame = None, ref
         # if the path does not exist, we create a default directory
         if not os.path.exists(ref_path):
             os.mkdir(ref_path)
-        
+
         # check if the file does not exist
         if not (os.path.exists(ref_path + "/ref_geneset.pkl")):
             # downloading the geneset data from disco database
-            response = requests.get(url=prefix_disco_url +"/getGeneSetPkl", timeout=timeout)
+            response = requests.get(
+                url=prefix_disco_url + "/getGeneSetPkl", timeout=timeout
+            )
             open(ref_path + "/ref_geneset.pkl", "wb").write(response.content)
-            reference = pd.read_pickle(ref_path + "/ref_geneset.pkl", compression = {'method':'gzip','compresslevel':6})
+            reference = pd.read_pickle(
+                ref_path + "/ref_geneset.pkl",
+                compression={"method": "gzip", "compresslevel": 6},
+            )
 
         else:
             # read the data into pandas dataframe for subsequent analysis
-            reference = pd.read_pickle(ref_path + "/ref_geneset.pkl", compression = {'method':'gzip','compresslevel':6})
+            reference = pd.read_pickle(
+                ref_path + "/ref_geneset.pkl",
+                compression={"method": "gzip", "compresslevel": 6},
+            )
 
     # rename the name data to include the reference atlas
     reference["name"] = reference["name"] + " in " + reference["atlas"]
-    input["gene"] = input["gene"].str.upper() # convert all the gene to upper string as the reference gene name is in uppercase
+    input["gene"] = input[
+        "gene"
+    ].str.upper()  # convert all the gene to upper string as the reference gene name is in uppercase
     # condition when the user provide the fold change for the enrichment analysis
     if input_shape == 2:
-        input["fc"] = 2 ** input["fc"] # 2 to the power of fc
-        input = input.set_index("gene", drop = False) # set index to the gene
-        input = input.loc[list(set(reference["gene"]) & set(input['gene']))] # only get the common genes for comparison
+        input["fc"] = 2 ** input["fc"]  # 2 to the power of fc
+        input = input.set_index("gene", drop=False)  # set index to the gene
+        input = input.loc[
+            list(set(reference["gene"]) & set(input["gene"]))
+        ]  # only get the common genes for comparison
 
     # else we only look at the ranked gene list
     else:
-        input = input.set_index("gene", drop = False)
-        input = input.loc[list(set(reference["gene"]) & set(input['gene']))] # only get the common genes for comparison
+        input = input.set_index("gene", drop=False)
+        input = input.loc[
+            list(set(reference["gene"]) & set(input["gene"]))
+        ]  # only get the common genes for comparison
     # filter to get only the geneset that contain the input genes from the user
     # this might good different result from the website so lets remove it for
     # unique_names = reference[reference["gene"].isin(input["gene"])]["name"].unique()
@@ -291,8 +395,8 @@ def CELLiD_enrichment(input : pd.DataFrame, reference : pd.DataFrame = None, ref
     # optimise the CELLiD_enrichment function
     atlas_dict = {}
     name_dict = {}
-    reference_atlas = reference['atlas']
-    reference_name = reference['name']
+    reference_atlas = reference["atlas"]
+    reference_name = reference["name"]
 
     # pre compute the parameters of the fisher exact test for the reference data
     for rownum in range(len(reference)):
@@ -305,57 +409,105 @@ def CELLiD_enrichment(input : pd.DataFrame, reference : pd.DataFrame = None, ref
             name_dict[reference_name[rownum]] = [rownum]
         else:
             name_dict[reference_name[rownum]].append(rownum)
-    
+
     # apply function to the dataframe
-    def process_unique_name(reference_filter, input, atlas_dfs, input_shape, atlas_dict):
+    def process_unique_name(
+        reference_filter, input, atlas_dfs, input_shape, atlas_dict
+    ):
         # use the compile`d pattern to search for matches
-        unique_name = reference_filter['name'].head(1).values[0]
-        atlas = reference_filter['atlas'].head(1).values
+        unique_name = reference_filter["name"].head(1).values[0]
+        atlas = reference_filter["atlas"].head(1).values
         # print(unique_name)
         reference_full = atlas_dfs[list(atlas_dict.keys()).index(atlas)]
         # reference_filter = reference.iloc[name_dict[unique_name]].copy() # subset the reference data
         # reference_full = reference.iloc[atlas_dict[atlas]].copy() # full reference to the atlas
-        reference_filter = reference_filter.set_index(["gene"], drop = False) # set gene as the index
+        reference_filter = reference_filter.set_index(
+            ["gene"], drop=False
+        )  # set gene as the index
         # reference_filter["gene"] = reference_filter.index
-        input_filter = input.loc[list(set(reference_full["gene"]) & set(input["gene"]))] # subset the input genes
+        input_filter = input.loc[
+            list(set(reference_full["gene"]) & set(input["gene"]))
+        ]  # subset the input genes
 
         # condition for no passed gene set
         if input_filter.empty:
             return None
-        
+
         # different computation to either include the fold change in the fisher exact test
         if input_shape == 2:
-            a = (reference_filter.loc[np.intersect1d(reference_filter["gene"], (input_filter["gene"]))].iloc[:, 0] * input_filter.loc[np.intersect1d(input_filter["gene"], reference_filter["gene"]), "fc"]).sum() + 1
-            b = input_filter.loc[np.setdiff1d(input_filter["gene"], reference_filter["gene"]), "fc"].sum() + 1
-            c = reference_filter.loc[np.setdiff1d(reference_filter["gene"], input_filter["gene"])].iloc[:, 0].sum() + 1
-            d = len(set(reference_full["gene"])) - len(set(reference_filter["gene"]).union(set(input_filter["gene"])))
+            a = (
+                reference_filter.loc[
+                    np.intersect1d(reference_filter["gene"], (input_filter["gene"]))
+                ].iloc[:, 0]
+                * input_filter.loc[
+                    np.intersect1d(input_filter["gene"], reference_filter["gene"]), "fc"
+                ]
+            ).sum() + 1
+            b = (
+                input_filter.loc[
+                    np.setdiff1d(input_filter["gene"], reference_filter["gene"]), "fc"
+                ].sum()
+                + 1
+            )
+            c = (
+                reference_filter.loc[
+                    np.setdiff1d(reference_filter["gene"], input_filter["gene"])
+                ]
+                .iloc[:, 0]
+                .sum()
+                + 1
+            )
+            d = len(set(reference_full["gene"])) - len(
+                set(reference_filter["gene"]).union(set(input_filter["gene"]))
+            )
         else:
             a = len(np.intersect1d(reference_filter["gene"], input_filter["gene"])) + 1
             b = len(np.setdiff1d(input_filter["gene"], reference_filter["gene"])) + 1
             c = len(np.setdiff1d(reference_filter["gene"], input_filter["gene"])) + 1
             d = len(set(reference_full["gene"])) - a - b - c
-        
+
         # get both value from the fisher exact test
         # pval = pvalue(a, b, c, d).two_tail
         _, pval = stats.fisher_exact(np.array([[a, b], [c, d]]))
-        odds = (a * d)/(b * c)
+        odds = (a * d) / (b * c)
         # only get the significant p_value
         # we can make changes to the p_value as in like we allow the user to specify it so that they have more control on the result they can obtain
         if pval < 0.01:
-            return pd.Series({"pval": pval, "or": odds, "name": unique_name,
-                            "gene": ",".join(reference_filter.loc[reference_filter["gene"].isin(input_filter["gene"]), "gene"]),
-                            "background": len(set(reference_full["gene"])), "overlap": len(reference_filter.loc[reference_filter["gene"].isin(input_filter["gene"])]), "geneset": len(reference_filter)})
+            return pd.Series(
+                {
+                    "pval": pval,
+                    "or": odds,
+                    "name": unique_name,
+                    "gene": ",".join(
+                        reference_filter.loc[
+                            reference_filter["gene"].isin(input_filter["gene"]), "gene"
+                        ]
+                    ),
+                    "background": len(set(reference_full["gene"])),
+                    "overlap": len(
+                        reference_filter.loc[
+                            reference_filter["gene"].isin(input_filter["gene"])
+                        ]
+                    ),
+                    "geneset": len(reference_filter),
+                }
+            )
         else:
             return None
 
     # Split them into cores
     unique_name_dfs = [reference.iloc[name_dict[key], :] for key in name_dict.keys()]
     atlas_dfs = [reference.iloc[atlas_dict[key], :] for key in atlas_dict.keys()]
-    
+
     # return unique_name_dfs, atlas_dfs, input, input_shape
     # return unique_name_dfs, atlas_dfs
     # using joblib to apply multiprocessing
-    results = Parallel(n_jobs=ncores, verbose = 2, batch_size = 64)(delayed(process_unique_name)(unique_name_df, input, atlas_dfs, input_shape, atlas_dict) for unique_name_df in unique_name_dfs)
+    results = Parallel(n_jobs=ncores, verbose=2, batch_size=64)(
+        delayed(process_unique_name)(
+            unique_name_df, input, atlas_dfs, input_shape, atlas_dict
+        )
+        for unique_name_df in unique_name_dfs
+    )
     results = [res for res in results if res is not None]
 
     # concatenate the result into the dataframe to the user
@@ -363,8 +515,9 @@ def CELLiD_enrichment(input : pd.DataFrame, reference : pd.DataFrame = None, ref
         res_df = pd.concat(results, axis=1).transpose()
         res_df["pval"] = res_df["pval"].astype(float).round(3)
         res_df["or"] = res_df["or"].astype(float).round(3)
-        res_df = res_df.sort_values(by=["pval", "or"], ascending=[True, False]).head(min(50, len(results)))
+        res_df = res_df.sort_values(by=["pval", "or"], ascending=[True, False]).head(
+            min(50, len(results))
+        )
         return res_df
     else:
         return None
-    

{discotoolkit-1.1.2 → discotoolkit-1.1.4}/discotoolkit/DiscoClass.py

@@ -6,10 +6,10 @@ class Filter:
     """
     Filter class object to save the attributes for filtering the dataset from DISCO
 
-    sample                      String    e.g. GSM3891625_3;
-    project                     String;
-    tissue                      String    e.g. Lung, Bladder;
-    disease                     String    e.g. PDAC;
+    sample_id                      String    e.g. ERX2757110;
+    project_id                     String;
+    tissue                      String    e.g. lung, bladder;
+    disease                     String    e.g. COVID-19;
     platform                    String    e.g. 10x3';
     sample_type                 String;
     cell_type                   String;
@@ -20,12 +20,12 @@ class Filter:
     return Class object
     """
 
-    def __init__(self, sample = None, project = None, tissue = None, disease = None, platform = None, sample_type = None,
+    def __init__(self, sample_id = None, project_id = None, tissue = None, disease = None, platform = None, sample_type = None,
                  cell_type = None, cell_type_confidence : str = "medium", include_cell_type_children : bool = True, min_cell_per_sample : int = 100):
         
         # handling for string and list input
-        self.sample = self.convert_to_list(sample) # sample id
-        self.project = self.convert_to_list(project) # project, lab, or dataset from different author
+        self.sample_id = self.convert_to_list(sample_id) # sample id
+        self.project_id = self.convert_to_list(project_id) # project, lab, or dataset from different author
         self.tissue = self.convert_to_list(tissue) # organ tissue 
         self.disease = self.convert_to_list(disease) # cancer or non cancer, or COVID-1e9 disease
         self.platform = self.convert_to_list(platform) # sequencing platform