ScreenPro2 0.5.0__py3-none-any.whl

screenpro/plotting/__init__.py

@@ -0,0 +1,9 @@
+## Copyright (c) 2022-2025 ScreenPro2 Development Team.
+## All rights reserved.
+## Gilbart Lab, UCSF / Arc Institute.
+## Multi-Omics Tech Center, Arc Insititue.
+
+import numpy as np
+import scanpy as sc
+from .qc_plots import plotReplicateScatter, plotCountDistribution
+from .pheno_plots import volcano_plot, label_by_color, label_resistance_hit, label_sensitivity_hit

screenpro/plotting/_rank.py

@@ -0,0 +1,88 @@
+import pandas as pd
+import matplotlib.pyplot as plt
+
+from adjustText import adjust_text
+from ._utils import yellow_blue
+
+
+def rank_plot(df, rank_col, color_col=None, name_col='target', highlight_values_dict=None, xlabel='Rank', ylabel='Values', title='Rank Plot', ax=None, dot_size=1.5, highlight_size_factor=100, txt_font_size=8, **args):
+    """
+    Plot the ranks against their values with specified color.
+
+    Args:
+        df (DataFrame): The input DataFrame.
+        rank_col (str): The column name containing the values to be ranked.
+        color_col (str): The column name containing the values to be used for color coding. Default is None.
+        name_col (str, optional): The column name containing the names of the values. Default is 'target'.
+        highlight_values_dict (dict, optional): A dictionary specifying the values to be highlighted. 
+            The keys are the highlight colors and the values are dictionaries with 'genes' and 'text' keys. 
+            'genes' is a list of values to be highlighted and 'text' is a boolean indicating whether to display 
+            the names of the highlighted values. Default is None.
+        xlabel (str, optional): The label for the x-axis. Default is 'Rank'.
+        ylabel (str, optional): The label for the y-axis. Default is 'Values'.
+        title (str, optional): The title of the plot. Default is 'Rank Plot'.
+        ax (matplotlib.axes.Axes, optional): The axis object to plot on. If not provided, a new axis will be created.
+        dot_size (float, optional): The size of the dots in the scatter plot. Default is 1.5.
+        highlight_size_factor (int, optional): The size factor for the highlighted dots. Default is 100.
+        txt_font_size (int, optional): The font size for the text labels. Default is 8.
+        **args: Additional keyword arguments to be passed to the scatter plot.
+
+    Returns:
+        matplotlib.axes.Axes: The axis object containing the plot.
+    """
+    # Create a new DataFrame with the values and their corresponding ranks
+    rank_df = df.copy()
+    rank_df['Rank'] = rank_df[rank_col].rank()
+    rank_df.sort_values('Rank', inplace=True)
+
+    # Use a color that is suitable for publications
+    if color_col is None:
+        color_col = 'darkgray'
+
+    # If no axis is provided, create one
+    if ax is None:
+        _, ax = plt.subplots()
+
+    # Plot the ranks against their values with specified color
+    rank_df.plot.scatter(
+        'Rank', rank_col, marker='o',
+        colormap=yellow_blue,
+        s=dot_size,
+        c=color_col, ax=ax,
+        colorbar=False,
+        **args
+    )
+
+    if highlight_values_dict is not None:
+        for highlight_color, highlight_values in highlight_values_dict.items():
+            highlight_ranks = rank_df[rank_df[name_col].isin(highlight_values['genes'])]
+            ax.plot(highlight_ranks['Rank'], highlight_ranks[rank_col], 'o', color=highlight_color, markersize=dot_size * highlight_size_factor)
+    
+            if highlight_values['text'] is not False:
+                texts = []
+                for i, row in highlight_ranks.iterrows():
+                    t = ax.text(
+                        row['Rank'] + .01, 
+                        row[rank_col] + .001, 
+                        row[name_col], 
+                        fontsize=txt_font_size, 
+                        color=highlight_color, 
+                        ha='right'
+                    )
+                    texts.append(t)
+
+                adjust_text(
+                    texts, 
+                    arrowprops=dict(arrowstyle='-', color=highlight_color, lw=0.5),
+                    ax=ax
+                )
+
+    # Add labels and title
+    ax.set_xlabel(xlabel)
+    ax.set_ylabel(ylabel)
+    ax.set_title(title)
+
+    # Customize the grid lines for a clean look
+    ax.grid(False)
+
+    return rank_df, ax

screenpro/plotting/_utils.py

@@ -0,0 +1,81 @@
+import matplotlib.pyplot as plt
+import matplotlib
+import numpy as np
+import pandas as pd
+
+# variables
+almost_black = '#111111'
+dark2 = ['#1b9e77',
+         '#d95f02',
+         '#7570b3',
+         '#e7298a',
+         '#66a61e',
+         '#e6ab02',
+         '#a6761d',
+         '#666666']
+blue_yellow = matplotlib.colors.LinearSegmentedColormap.from_list(
+    'BuYl', [(0, '#ffff00'), (.49, '#000000'), (.51, '#000000'), (1, '#0000ff')])
+blue_yellow.set_bad('#999999', 1)
+yellow_blue = matplotlib.colors.LinearSegmentedColormap.from_list(
+    'YlBu', [(0, '#0000ff'), (.49, '#000000'), (.51, '#000000'), (1, '#ffff00')])
+yellow_blue.set_bad('#999999', 1)
+
+
+# plt.rcParams['font.sans-serif'] = [
+#     'Helvetica', 'Arial', 'Verdana', 'Bitstream Vera Sans'
+# ]
+# plt.rcParams['font.size'] = 8
+# plt.rcParams['font.weight'] = 'regular'
+# plt.rcParams['text.color'] = almost_black
+#
+# axisLineWidth = .5
+# plt.rcParams['axes.linewidth'] = axisLineWidth
+# plt.rcParams['lines.linewidth'] = 1.5
+#
+# plt.rcParams['axes.facecolor'] = 'white'
+# plt.rcParams['axes.edgecolor'] = almost_black
+# plt.rcParams['axes.labelcolor'] = almost_black
+# # plt.rcParams['axes.color_cycle'] = dark2_all
+#
+# plt.rcParams['patch.edgecolor'] = 'none'
+# plt.rcParams['patch.linewidth'] = .25
+# # plt.rcParams['patch.facecolor'] = dark2_all[0]
+#
+# plt.rcParams['savefig.dpi'] = 1000
+# plt.rcParams['savefig.format'] = 'svg'
+#
+# plt.rcParams['legend.frameon'] = False
+# plt.rcParams['legend.handletextpad'] = .25
+# plt.rcParams['legend.fontsize'] = 8
+# plt.rcParams['legend.numpoints'] = 1
+# plt.rcParams['legend.scatterpoints'] = 1
+#
+# plt.rcParams['ytick.direction'] = 'out'
+# plt.rcParams['ytick.color'] = almost_black
+# plt.rcParams['ytick.major.width'] = axisLineWidth
+# plt.rcParams['xtick.direction'] = 'out'
+# plt.rcParams['xtick.color'] = almost_black
+# plt.rcParams['xtick.major.width'] = axisLineWidth
+
+
+def cleanAxes(ax, top=False, right=False, bottom=True, left=True):
+    ax.grid('off')
+    ax.spines['top'].set_visible(top)
+    ax.spines['right'].set_visible(right)
+    ax.spines['left'].set_visible(left)
+    ax.spines['bottom'].set_visible(bottom)
+
+    #turn off all ticks
+    ax.yaxis.set_ticks_position('none')
+    ax.xaxis.set_ticks_position('none')
+
+    #now re-enable visibles
+    if top:
+        ax.xaxis.tick_top()
+    if bottom:
+        ax.xaxis.tick_bottom()
+    if left:
+        ax.yaxis.tick_left()
+    if right:
+        ax.yaxis.tick_right()
+

screenpro/plotting/pheno_plots.py

@@ -0,0 +1,196 @@
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+from ._utils import yellow_blue
+from ._rank import rank_plot
+
+
+def volcano_plot(
+            ax, df, up_hit, down_hit,
+            score_col='score', pvalue_col='pvalue',
+            xlabel='phenotype score',
+            ylabel='-log10(pvalue)',
+            dot_size=1,
+            xlims='auto',
+            ylims='auto',
+            ctrl_label='negative_control',
+            **args
+            ):
+        
+        if f'-log10({pvalue_col})' not in df.columns:
+            df[f'-log10({pvalue_col})'] = np.log10(df[pvalue_col]) * -1
+
+        if xlims == 'auto':
+            xlims = (df[score_col].min() - 0.1, df[score_col].max() + 0.1)
+        if ylims == 'auto':
+            ylims = (df[f'-log10({pvalue_col})'].min() - 0.1, df[f'-log10({pvalue_col})'].max() + 0.1)
+        
+        # Scatter plot for each category
+        ax.scatter( df.loc[df['label'] == 'target_non_hit', score_col],
+                    df.loc[df['label'] == 'target_non_hit', f'-log10({pvalue_col})'],
+                    alpha=0.1, s=dot_size, c='black', label='target_non_hit',
+                    **args)
+        
+        ax.scatter( df.loc[df['label'] == up_hit, score_col], 
+                    df.loc[df['label'] == up_hit, f'-log10({pvalue_col})'],
+                    alpha=0.9, s=dot_size, c='#fcae91', label=up_hit,
+                    **args)
+        
+        ax.scatter( df.loc[df['label'] == down_hit, score_col], 
+                    df.loc[df['label'] == down_hit, f'-log10({pvalue_col})'],
+                    alpha=0.9, s=dot_size, c='#bdd7e7', label=down_hit,
+                    **args)
+        
+        ax.scatter( df.loc[df['label'] == ctrl_label, score_col],
+                    df.loc[df['label'] == ctrl_label, f'-log10({pvalue_col})'],
+                    alpha=0.1, s=dot_size, c='gray', label=ctrl_label,
+                    **args)
+
+        # Set x-axis and y-axis labels
+        ax.set_xlabel(xlabel)
+        ax.set_ylabel(ylabel)
+
+        # Set x-axis limits
+        ax.set_xlim(xlims)
+
+        # Set y-axis limits
+        ax.set_ylim(ylims)
+
+        # Add legend
+        ax.legend()
+
+
+def label_by_color(ax, df_in, label,
+                   x_col, y_col,
+                   size=2, size_txt="auto",
+                   edgecolors='black', facecolors='black',
+                   textcolor='black',
+                   t_x=.5, t_y=-0.1, **args):
+
+    if size_txt == 'auto': size_txt = size * 2
+
+    df = df_in.copy()
+    target_data = df[df['target'] == label]
+
+    # Scatter plot for labeled data
+    ax.scatter(
+        target_data[x_col], target_data[y_col],
+        s=size, linewidth=0.5, 
+        edgecolors=edgecolors, 
+        facecolors=facecolors, label='target',
+        **args
+    )
+
+    if size_txt == None:
+        pass
+    else:
+        # Annotate the points
+        for i, _ in enumerate(target_data['target']):
+            txt = target_data['target'].iloc[i]
+            ax.annotate(txt, (target_data[x_col].iloc[i] + t_x, target_data[y_col].iloc[i] + t_y),
+                        color=textcolor, size=size_txt)
+
+
+def label_as_black(ax, df_in, label, 
+                    x_col='score', y_col='-log10(pvalue)',
+                    size=2, size_txt="auto",
+                    t_x=.5, t_y=-0.1,
+                    **args):
+    label_by_color(
+        ax, df_in, label, 
+        x_col=x_col, y_col=y_col,
+        size=size, size_txt=size_txt,
+        edgecolors='black', facecolors='black',
+        textcolor='black',
+        t_x=t_x, t_y=t_y,
+        **args)
+
+
+def label_sensitivity_hit(ax, df_in, label, 
+                            x_col='score', y_col='-log10(pvalue)',
+                            size=2, size_txt="auto",
+                            t_x=.5, t_y=-0.1,
+                            **args):
+    label_by_color(
+        ax, df_in, label, 
+        x_col=x_col, y_col=y_col,
+        size=size, size_txt=size_txt,
+        edgecolors='black', facecolors='#3182bd',
+        textcolor='black',
+        t_x=t_x, t_y=t_y,
+        **args)
+
+
+def label_resistance_hit(ax, df_in, label, 
+                            x_col='score', y_col='-log10(pvalue)',
+                            size=2, size_txt="auto",
+                            t_x=.5, t_y=-0.1,
+                            **args):
+    label_by_color(
+        ax, df_in, label, 
+        x_col=x_col, y_col=y_col,
+        size=size, size_txt=size_txt,
+        edgecolors='black', facecolors='#de2d26',
+        textcolor='black',
+        t_x=t_x, t_y=t_y,
+        **args)
+
+
+# def drawRhoGammaScatter(
+#         self, ax,
+#         rho_df=None, gamma_df=None,
+#         dot_size=1,
+#         score_col='score',
+#         xlabel='auto',
+#         ylabel='auto',
+#         xlims='auto',
+#         ylims='auto',
+#         **args
+#         ):
+#     #TODO: fix by making a single dataframe with both rho and gamma scores
+#     if rho_df is None:
+#         _, _, rho_df = self._prep_data()
+#     if gamma_df is None:
+#         gamma_df, _, _ = self._prep_data()
+
+#     if xlabel == 'auto':
+#         xlabel = self.rho_score_name.replace(':', ': ').replace('_', ' ')
+#     if ylabel == 'auto':
+#         ylabel = self.gamma_score_name.replace(':', ': ').replace('_', ' ')
+    
+#     # color by rho score labels
+#     up_hit = 'resistance_hit'
+#     down_hit = 'sensitivity_hit'
+
+#     # Scatter plot for each category
+#     ax.scatter( rho_df.loc[rho_df['label'] == 'target_non_hit', score_col],
+#                 gamma_df.loc[rho_df['label'] == 'target_non_hit', score_col],
+#                 alpha=0.1, s=dot_size, c='black', label='target_non_hit',
+#                 **args)
+    
+#     ax.scatter( rho_df.loc[rho_df['label'] == up_hit, score_col],
+#                 gamma_df.loc[rho_df['label'] == up_hit, score_col],
+#                 alpha=0.9, s=dot_size, c='#fcae91', label=up_hit,
+#                 **args)
+    
+#     ax.scatter( rho_df.loc[rho_df['label'] == down_hit, score_col],
+#                 gamma_df.loc[rho_df['label'] == down_hit, score_col],
+#                 alpha=0.9, s=dot_size, c='#bdd7e7', label=down_hit,
+#                 **args)
+    
+#     ax.scatter( rho_df.loc[rho_df['label'] == self.ctrl_label, score_col],
+#                 gamma_df.loc[rho_df['label'] == self.ctrl_label, score_col],
+#                 alpha=0.1, s=dot_size, c='gray', label=self.ctrl_label,
+#                 **args)
+    
+#     # Set x-axis and y-axis labels
+#     ax.set_xlabel(xlabel)
+#     ax.set_ylabel(ylabel)
+
+#     # Set x-axis limits
+#     ax.set_xlim(xlims)
+#     ax.set_ylim(ylims)
+
+#     # Add legend
+#     ax.legend()
+    

screenpro/plotting/qc_plots.py

@@ -0,0 +1,45 @@
+import numpy as np
+import scanpy as sc
+from ._utils import almost_black
+
+
+## Histogram of guide counts distribution
+def plotCountDistribution(ax, adat, title, **args):
+    pass
+
+
+## Scatter plot of replicates
+def plotReplicateScatter(ax, adat_in, x, y, title, min_val=None, max_val=None, log_transform=True, **args):
+    adat = adat_in[[x, y], :].copy()
+
+    adat.obs.index = [f'Replicate {str(r)}' for r in adat.obs.replicate.to_list()]
+    x_lab, y_lab = [f'Replicate {str(r)}' for r in adat.obs.replicate.to_list()]
+
+    if log_transform:
+        adat.X = np.log10(adat.X+1)
+    
+    if min_val is None:
+        min_val = min([adat.to_df().loc[x_lab,:].min(), adat.to_df().loc[y_lab,:].min()])
+        min_val = min_val * 1.1 
+    if max_val is None:
+        max_val = max([adat.to_df().loc[x_lab,:].max(), adat.to_df().loc[y_lab,:].max()])
+        max_val = max_val * 1.1
+    
+    sc.pl.scatter(
+        adat,
+        x_lab, y_lab,
+        legend_fontsize='xx-large',
+        palette=[almost_black, '#BFBFBF'],
+        color='targetType',
+        title=title,
+        size=5,
+        show=False,
+        ax=ax,
+        **args
+    )
+    ax.set_ylim(min_val, max_val)
+    ax.set_xlim(min_val, max_val)
+    ax.tick_params(axis='both', labelsize=10)
+    ax.get_legend().remove()
+
+    ax.grid(False)

screenpro/preprocessing.py

@@ -0,0 +1,98 @@
+import pandas as pd
+import numpy as np
+from pydeseq2 import preprocessing
+
+
+def findLowCounts(adata, filter_type, minimum_reads, verbose=True):
+    """
+    Label variables with low counts in either or all samples.
+
+    Parameters:
+        adata (AnnData): AnnData object containing the counts to be filtered.
+        filter_type (str): specify the filter type. Possible values are: 'all', or 'sum'.
+        minimum_reads (int): minimum number of reads.
+        verbose (bool): print the number of removed variables. Default is True.
+
+    Returns:
+        None
+    """
+    count_bin = adata.X >= minimum_reads
+ 
+    if filter_type == 'all':
+        out = adata[:, count_bin.all(axis=0)].copy()
+    elif filter_type == 'sum':
+        out = adata[:, adata.to_df().sum(axis=0) >= minimum_reads].copy()
+    else:
+        raise ValueError(f'filter_type "{filter_type}" not recognized. Use "all", or "sum".')
+    
+    if verbose:
+        n_removed = adata.shape[1] - out.shape[1]
+        # print the number of removed variables
+        print(
+            f"{n_removed} variables with less than {minimum_reads} reads (filter_type: '{filter_type}')"
+        )
+
+    adata.var['low_count'] = ~adata.var.index.isin(out.var.index.to_list())
+
+
+def addPseudoCount(adata, behavior, value, inplace=True):
+    """
+    Add pseudocounts to the given counts based on the specified behavior.
+
+    Args:
+        adata (AnnData): AnnData object containing the counts to which pseudocounts will be added.
+        behavior (str): The behavior for adding pseudocounts. Possible values are:
+            - 'default' or 'zeros_only': Add pseudocounts only to rows with at least one zero value.
+            - 'all_values': Add pseudocounts to all rows.
+            - 'filter_out': Set rows with at least one zero value to NaN.
+        value (float): The value of the pseudocount to be added.
+        inplace (bool): If True, the pseudocounts will replace the original counts in the AnnData object.
+
+    Returns:
+        DataFrame: The counts DataFrame with pseudocounts added based on the specified behavior.
+
+    Raises:
+        ValueError: If the pseudocount behavior is not recognized or not implemented.
+    """
+    ## possible pseudocount behaviors
+    # 1. remove 0
+    # 2. add pseudocount
+    # 3. impute 0 (it's hard)
+    
+    # Source:
+    # https://github.com/mhorlbeck/ScreenProcessing/blob/0ee5192ecc17348665bd1387ddfa9037efb7964f/process_experiments.py#L485
+    
+    counts = adata.to_df()
+    
+    # pseudocount
+    if behavior == 'default' or behavior == 'zeros_only':
+        counts_pseudo = counts.replace(0, value)
+
+    elif behavior == 'all_values':
+        counts_pseudo = counts + value
+    elif behavior == 'filter_out':
+        counts_pseudo = counts.replace(0, np.nan)
+    else:
+        raise ValueError(
+            'Pseudocount behavior not recognized or not implemented')
+
+    if inplace:
+        adata.X = counts_pseudo.to_numpy()
+    else:
+        return counts_pseudo
+
+
+def normalizeSeqDepth(adata):
+    """
+    Normalize counts by sequencing depth and update the adata object.
+    This function uses the PyDESeq2 normalization method.
+
+    Args:
+        adata (AnnData): AnnData object containing the counts to be normalized.
+    """
+    # normalize counts by sequencing depth
+    norm_counts, size_factors = preprocessing.deseq2_norm(adata.X)
+    # update adata object
+    adata.obs['size_factors'] = size_factors
+    adata.layers['seq_depth_norm'] = norm_counts
+    adata.X = adata.layers['seq_depth_norm']

screenpro2-0.5.0.dist-info/LICENSE

@@ -0,0 +1,25 @@
+MIT License
+
+Copyright (c) 2022-2024 ScreenPro2 Development Team.
+All rights reserved.
+Gilbart Lab, UCSF / Arc Institute.
+Multi-Omics Tech Center, Arc Insititue.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+