ScreenPro2 0.2.2__py2.py3-none-any.whl → 0.2.2.dev0__py2.py3-none-any.whl

{ScreenPro2-0.2.2.dist-info → ScreenPro2-0.2.2.dev0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: ScreenPro2
-Version: 0.2.2
+Version: 0.2.2.dev0
 Summary: Analyze pooled CRISPR screens
 Requires-Python: >=3.8
 License-File: LICENSE

ScreenPro2-0.2.2.dev0.dist-info/RECORD

@@ -0,0 +1,9 @@
+screenpro/__init__.py,sha256=W5BLfOHj3Erjw5RRqw6q4ofJikfy2kW-wUBflZmNqeQ,4547
+screenpro/__version__.py,sha256=fOKWLKpu5Xtkvy8PKHXIlkrE5ExJD3i6TGBg_27cSG0,26
+screenpro/load.py,sha256=M6d7jEWp_MIj2e6zK9X0DmthMTKHH3TIaWx3EQ1LP0U,2009
+screenpro/phenoScore.py,sha256=R-jassjPokhbnzHJHyclYjr2CPHdiBiQAH8tRty2zyo,6494
+ScreenPro2-0.2.2.dev0.dist-info/LICENSE,sha256=IHBn522sDxLGxi5EfDS9CZdqnW11ZeDrUxqkRfIbJR4,1072
+ScreenPro2-0.2.2.dev0.dist-info/METADATA,sha256=ONEbQhfYXGi7Y1EGAu-qyZ-yOS6eZHdREoijxBiA-GA,144
+ScreenPro2-0.2.2.dev0.dist-info/WHEEL,sha256=bb2Ot9scclHKMOLDEHY6B2sicWOgugjFKaJsT7vwMQo,110
+ScreenPro2-0.2.2.dev0.dist-info/top_level.txt,sha256=uOEhN69bjK8D-lUo9aFehqGZQiGp8ouTSdzTDvZ4aek,10
+ScreenPro2-0.2.2.dev0.dist-info/RECORD,,

screenpro/__init__.py

@@ -1,2 +1,111 @@
+import pandas as pd
 from .__version__ import __version__
-from . import phenoScore
+from .phenoScore import seqDepthNormalization, matrixStat, matrixTest
+
+
+def runPhenoScoreByReps(adata,
+                        cond1, cond2, growth_rate=1, n_reps=2,
+                        ctrl_label='negCtrl', test='ttest', math='log2(x+1)'):
+    """Calculate phenotype score and p-values comparing `cond2` vs `cond1`
+    """
+    result_name = f'{cond2}_vs_{cond1}'
+    print(f'\t{cond2} vs {cond1}')
+
+    count_layer = 'seq_depth_norm'
+    # check if count_layer exists
+    if 'seq_depth_norm' not in adata.layers.keys():
+        seqDepthNormalization(adata)
+    # prep counts for phenoScore calculation
+    df_cond1 = adata[adata.obs.query(f'condition=="{cond1}"').index[:n_reps], ].to_df(count_layer).T
+    df_cond2 = adata[adata.obs.query(f'condition=="{cond2}"').index[:n_reps], ].to_df(count_layer).T
+
+    x = df_cond1.to_numpy()
+    y = df_cond2.to_numpy()
+
+    x_ctrl = df_cond1[adata.var.targetType.eq(ctrl_label)].to_numpy()
+    y_ctrl = df_cond2[adata.var.targetType.eq(ctrl_label)].to_numpy()
+
+    # calculate growth score and p_value
+    scores, p_values = matrixTest(
+        x=x, y=y, x_ctrl=x_ctrl, y_ctrl=y_ctrl,
+        math=math, ave_reps=True, test=test, growth_rate=growth_rate
+    )
+
+    return scores, p_values, result_name
+
+
+def runPhenoScoreByGuideSet(adata,
+                            cond1, cond2, growth_rate=1, n_reps=2,
+                            ctrl_label='negCtrl', test='ttest', math='log2(x+1)'
+                            ):
+    """Calculate phenotype score and p-values comparing `cond2` vs `cond1`
+    """
+    print(f'\t{cond2} vs {cond1}')
+
+    count_layer = 'seq_depth_norm'
+    # check if count_layer exists
+    if 'seq_depth_norm' not in adata.layers.keys():
+        seqDepthNormalization(adata)
+    # prep counts for phenoScore calculation
+    pass
+
+
+def convertResultsToDataFrame(adata, targets, scores, pvalues):
+    return pd.concat([
+        pd.Series(targets, index=adata.var.index, name='target'),
+        pd.Series(scores, index=adata.var.index, name='score'),
+        pd.Series(pvalues, index=adata.var.index, name='pvalue')
+    ], axis=1)
+
+
+class ScreenPro(object):
+    """`ScreenPro` class for processing CRISPR screen datasets
+    """
+
+    def __init__(self, adata, math='log2(x+1)'):
+        self.phenotypes = {}
+        self.adata = adata
+        self.math = math
+
+    def __repr__(self):
+        descriptions = ''
+        for scoreLevel in self.phenotypes.keys():
+            scores = "', '".join(self.phenotypes[scoreLevel].columns.get_level_values(0).unique().to_list())
+            descriptions += f"Phenotypes in scoreLevel = '{scoreLevel}':\n    scores: '{scores}'\n"
+
+        return f'obs->samples\nvar->oligos\n\n{self.adata.__repr__()}\n\n{descriptions}'
+
+    def calculateDrugScreen(self,
+                            t0, untreated, treated, growth_rate,
+                            scoreLevel, method):
+        """Calculate gamma, rho, and tau phenotype scores using given `method` in `scoreLevel`
+        """
+        if method == 'ByReps':
+            gamma, gamma_pv, gamma_name= runPhenoScoreByReps(
+                self.adata, cond1=t0, cond2=untreated, growth_rate=growth_rate, math=self.math)
+            tau, tau_pv, tau_name = runPhenoScoreByReps(
+                self.adata, cond1=t0, cond2=treated, growth_rate=growth_rate, math=self.math)
+            rho, rho_pv, rho_name = runPhenoScoreByReps(
+                self.adata, cond1=untreated, cond2=treated, growth_rate=growth_rate, math=self.math)
+            targets = self.adata.var.index.str.split('_[-,+]_').str[0].to_list()
+
+            self.phenotypes[scoreLevel] = pd.concat({
+                f'rho:{rho_name}': convertResultsToDataFrame(self.adata, targets, rho, rho_pv),
+                f'gamma:{gamma_name}': convertResultsToDataFrame(self.adata, targets, gamma, gamma_pv),
+                f'tau:{tau_name}': convertResultsToDataFrame(self.adata, targets, tau, tau_pv)
+            }, axis=1)
+
+        elif method == 'ByGuideSet':
+            pass
+
+        else:
+            raise ValueError('Method not recognized')
+
+    # adata.var[f'condition_{cond2}_vs_{cond1}_pvalue'] = pvalues
+    # adata.var[f'condition_{cond2}_vs_{cond1}_delta'] = phenotype_score
+    ## calculate FDR
+    # Calculate the adjusted p-values using the Benjamini-Hochberg method
+    # _, adj_pvalues, _, _ = multipletests(adata.var[f'condition_{cond1}_vs_{cond2}_pvalue'], alpha=0.05, method='fdr_bh')
+    # adata.var[f'condition_{cond1}_vs_{cond2}_adj_pvalue'] = adj_pvalues
+
+

screenpro/__version__.py

@@ -1 +1 @@
-__version__ = "0.2.2"
+__version__ = "0.2.2-dev"

screenpro/phenoScore.py

@@ -3,7 +3,6 @@
 
 import numpy as np
 import pandas as pd
-import anndata as ad
 
 from pydeseq2 import preprocessing
 from scipy.stats import ttest_rel
@@ -12,64 +11,147 @@ from scipy.stats import ttest_rel
 
 
 def seqDepthNormalization(adata):
+    """Normalize counts by sequencing depth
+    """
     norm_counts, size_factors = preprocessing.deseq2_norm(adata.X)
 
     adata.obs['size_factors'] = size_factors
     adata.layers['seq_depth_norm'] = norm_counts
 
     
-def getDelta(x, y, math='log2'):
-    """log ratio of y / x, averaged across replicates 
+def addPseudoCount():
+    pass
+    # # pseudocount
+    # if pseudocountBehavior == 'default' or pseudocountBehavior == 'zeros only':
+    #     def defaultBehavior(row):
+    #         return row if min(
+    #             row) != 0 else row + pseudocountValue
+    #
+    #     combinedCountsPseudo = combinedCounts.apply(defaultBehavior, axis=1)
+    # elif pseudocountBehavior == 'all values':
+    #     combinedCountsPseudo = combinedCounts.apply(
+    #         lambda row: row + pseudocountValue, axis=1)
+    # elif pseudocountBehavior == 'filter out':
+    #     combinedCountsPseudo = combinedCounts.copy()
+    #     zeroRows = combinedCounts.apply(lambda row: min(row) <= 0, axis=1)
+    #     combinedCountsPseudo.loc[zeroRows, :] = np.nan
+    # else:
+    #     raise ValueError(
+    #         'Pseudocount behavior not recognized or not implemented')
+
+
+def getDelta(x, y, math, ave):
+    """log ratio of y / x
+    `ave` == 'all' – i.e. averaged across all values, oligo and replicates
+    `ave` == 'col' – i.e. averaged across columns, replicates)
+    """
+    if ave == 'all':
+        # average across all values
+        if math == 'log2(x+1)':
+            return np.mean(np.log2(y+1) - np.log2(x+1))
+        elif math == 'log10':
+            return np.mean(np.log10(y) - np.log10(x))
+        elif math == 'log1p':
+            return np.mean(np.log1p(y) - np.log1p(x))
+    elif ave == 'row':
+        # average across rows
+        if math == 'log2(x+1)':
+            return np.mean(np.log2(y+1) - np.log2(x+1), axis=0)
+        elif math == 'log10':
+            return np.mean(np.log10(y) - np.log10(x), axis=0)
+        elif math == 'log1p':
+            return np.mean(np.log1p(y) - np.log1p(x), axis=0)
+    elif ave == 'col':
+        # average across columns
+        if math == 'log2(x+1)':
+            return np.mean(np.log2(y+1) - np.log2(x+1), axis=1)
+        elif math == 'log10':
+            return np.mean(np.log10(y) - np.log10(x), axis=1)
+        elif math == 'log1p':
+            return np.mean(np.log1p(y) - np.log1p(x), axis=1)
+
+
+def getScore(x, y, x_ctrl, y_ctrl, growth_rate, math, ave):
+    """Calculate phenotype score normalized by negative control and growth rate
     """
-    if math == 'log2':
-        return np.mean(np.log2(y) - np.log2(x), axis=1)
-    elif math == 'log10':
-        return np.mean(np.log10(y) - np.log10(x), axis=1)
-    elif math == 'log1p':
-        return np.mean(np.log1p(y) - np.log1p(x), axis=1)
+    ctrl_std = np.std(getDelta(x=x_ctrl, y=y_ctrl, math=math, ave=ave))
+    ctrl_median = np.median(getDelta(x=x_ctrl, y=y_ctrl, math=math, ave=ave))
+    delta = getDelta(x=x, y=y, math=math, ave=ave)
+
+    return ((delta - ctrl_median) / growth_rate) / ctrl_std
 
 
-def getScore(x, y, x_ctrl, y_ctrl, growth_rate):
+def generatePseudoGeneLabels(adata, num_pseudogenes=None, ctrl_label='negCtrl'):
+    """Generate new labels per `num_pseudogenes` randomly selected non targeting oligo in `adata.var`
     """
+    if num_pseudogenes is None:
+        num_pseudogenes = len(adata.var[adata.var.targetType.eq(ctrl_label)]) // 2
+    # get non-targeting oligos
+    ctrl_oligos = adata.var[adata.var.targetType.eq(ctrl_label)].index
+    adata.var['pseudoLabel'] = ''
+    # check if there are more than 1 non-targeting oligos to label as pseudogenes
+    if len(ctrl_oligos) / 2 <= num_pseudogenes:
+        raise TypeError("Define `num_pseudogenes` to be less than total number of non-targeting oligos / 2")
+    else:
+        while len(ctrl_oligos) > num_pseudogenes:
+            # randomly select `num` non-targeting oligos
+            pseudo_oligos = np.random.choice(ctrl_oligos, num_pseudogenes, replace=False)
+            # generate new labels
+            pseudo_labels = [f'pseudo_{i}' for i in range(num_pseudogenes)]
+            # update adata.var
+            adata.var.loc[pseudo_oligos, 'pseudoLabel'] = pseudo_labels
+            # ...
+            ctrl_oligos = ctrl_oligos.drop(pseudo_oligos)
+
+        adata.var.loc[adata.var.targetType.eq('gene'), 'pseudoLabel'] = 'gene'
+        adata.var.loc[adata.var.pseudoLabel.eq(''), 'pseudoLabel'] = np.nan
+
+
+def matrixStat(x, y, test, ave_reps):
+    """Get p-values comparing `y` vs `x` matrices
     """
-    ctrl_std = np.std(getDelta(x_ctrl, y_ctrl))
-    ctrl_median = np.median(getDelta(x_ctrl, y_ctrl))
+    # calculate p-values
+    if test == 'MW':
+        # run Mann-Whitney U rank test
+        pass
+    elif test == 'ttest':
+        # run ttest
+        if ave_reps:
+            p_value = ttest_rel(y, x, axis=1)[1]
 
-    return ((getDelta(x,y) - ctrl_median) / growth_rate) / ctrl_std
+        else:
+            p_value = ttest_rel(y, x)[1]
 
+        return p_value
+    else:
+        raise ValueError(f'Test "{test}" not recognized')
 
-def runPhenoScore(adata, cond1, cond2, growth_rate=1, n_reps=2, test='ttest', layer='seq_depth_norm'):
-    # prep fqcounter
-    df_cond1 = adata[adata.obs.query(f'condition=="{cond1}"').index[:n_reps], ].to_df(layer).T
-    df_cond2 = adata[adata.obs.query(f'condition=="{cond2}"').index[:n_reps], ].to_df(layer).T
 
-    x = df_cond1.to_numpy()
-    y = df_cond2.to_numpy()
+def matrixTest(x, y, x_ctrl, y_ctrl, math, ave_reps, test = 'ttest', growth_rate = 1):
+    """Calculate phenotype score and p-values comparing `y` vs `x` matrices
+    """
+    if ave_reps:
+        ave = 'col'
+    else:
+        ave = 'all'
 
-    x_ctrl = df_cond1[adata.var.targetType.eq('negCtrl')].to_numpy()
-    y_ctrl = df_cond2[adata.var.targetType.eq('negCtrl')].to_numpy()
-    
     # calculate growth score
-    phenotype_score = getScore(x, y, x_ctrl, y_ctrl, growth_rate)
-    
-    adata.var[f'condition_{cond2}_vs_{cond1}_delta'] = phenotype_score
-    
-    # calculate p-values
-    if test == 'MW':
-        # run Mann-Whitney U rank test on replicates
-        pass
-    if test == 'ttest':
-        # run ttest on replicates
-        pvalues = ttest_rel(y, x, axis=1)[1]
-        adata.var[f'condition_{cond2}_vs_{cond1}_pvalue'] = pvalues
-
-    ## calculate FDR
-    # Calculate the adjusted p-values using the Benjamini-Hochberg method
-    # _, adj_pvalues, _, _ = multipletests(adata.var[f'condition_{cond1}_vs_{cond2}_pvalue'], alpha=0.05, method='fdr_bh')
-    # adata.var[f'condition_{cond1}_vs_{cond2}_adj_pvalue'] = adj_pvalues
-    
-    
+    scores = getScore(
+        x = x, y = y, x_ctrl = x_ctrl, y_ctrl = y_ctrl,
+        growth_rate = growth_rate, math = math,
+        ave = ave
+    )
+
+    # compute p-value
+    p_values = matrixStat(x, y, test=test, ave_reps=ave_reps)
+
+    return scores, p_values
+
+
 def ann_score_df(df_in, up_hit='resistance_hit', down_hit='sensitivity_hit', ctrl_label='non-targeting', threshold=10):
+    """Annotate score dataframe with hit labels using given `threshold`
+       (i.e. `score/pseudo_sd * -np.log10(pvalue) >= threshold`)
+    """
     df = df_in.copy()
 
     df.columns = ['target', 'score', 'pvalue']
@@ -78,8 +160,7 @@ def ann_score_df(df_in, up_hit='resistance_hit', down_hit='sensitivity_hit', ctr
 
     pseudo_sd = df[df['target'].str.contains(ctrl_label)]['score'].tolist()
     pseudo_sd = np.std(pseudo_sd)
-    # print (pseudo_sd)
-    
+
     df['label'] = '.'
 
     df.loc[

ScreenPro2-0.2.2.dist-info/RECORD

@@ -1,9 +0,0 @@
-screenpro/__init__.py,sha256=heNcvrsJwuisUqdpi4kljd2pzC9om9eW-RR7SYGLdfs,62
-screenpro/__version__.py,sha256=m6kyaNpwBcP1XYcqrelX2oS3PJuOnElOcRdBa9pEb8c,22
-screenpro/load.py,sha256=M6d7jEWp_MIj2e6zK9X0DmthMTKHH3TIaWx3EQ1LP0U,2009
-screenpro/phenoScore.py,sha256=ruEXInaG0DRAdJk2nM7Jt6Wh36GEq7_6tbkFqswiQ5k,3418
-ScreenPro2-0.2.2.dist-info/LICENSE,sha256=IHBn522sDxLGxi5EfDS9CZdqnW11ZeDrUxqkRfIbJR4,1072
-ScreenPro2-0.2.2.dist-info/METADATA,sha256=D842Yk9uKPUM5Kg6wfTi5vd9vqbV7lGSS0sRpffFGOU,139
-ScreenPro2-0.2.2.dist-info/WHEEL,sha256=bb2Ot9scclHKMOLDEHY6B2sicWOgugjFKaJsT7vwMQo,110
-ScreenPro2-0.2.2.dist-info/top_level.txt,sha256=uOEhN69bjK8D-lUo9aFehqGZQiGp8ouTSdzTDvZ4aek,10
-ScreenPro2-0.2.2.dist-info/RECORD,,