ScreenPro2 0.5.0__py3-none-any.whl

screenpro/ngs/cas12.py

@@ -0,0 +1,206 @@
+import biobear as bb
+import polars as pl
+from time import time
+
+
+def fastq_to_count_merged_reads(
+        fastq_file_path:str, 
+        verbose: bool=False) -> pl.DataFrame:
+    if verbose: ('count unique sequences ...')
+    t0 = time()
+    
+    session = bb.connect()
+    
+    sql_cmd = f"""
+    SELECT f.sequence AS sequence, COUNT(*) as count
+    FROM fastq_scan('{fastq_file_path}') f
+    GROUP BY sequence
+    """
+    
+    df_count = session.sql(sql_cmd).to_polars()
+
+    if verbose: print("done in %0.3fs" % (time() - t0))
+
+    return df_count
+        
+
+def get_spacers_cas12(df_count,DRref):
+
+    # get 1st spacer sequence
+    df_count = df_count.with_columns(
+            DR1_loc = df_count['sequence'].str.find(DRref['DR-1']),
+        ).with_columns(
+            pl.col('sequence').str.slice(
+                pl.col("DR1_loc")-23, 23
+            ).alias("SP1_sequence")
+        )
+
+    # get 2ed+ spacer sequence
+    
+    for DR_key, DR_seq in DRref.items():
+        DR_n = int(DR_key[-1]) # get the number of the DR
+        spacer_i = DR_n+1 # get the spacer number, 3' of the DR sequence
+        df_count = df_count.with_columns(
+            df_count['sequence'].str.find(DR_seq).alias(f"DR{DR_n}_loc")
+        ).with_columns(
+            pl.col('sequence').str.slice(
+                pl.col(f"DR{DR_n}_loc")+19, 23
+            ).alias(f"SP{spacer_i}_sequence")
+        )
+
+    out = df_count.select([
+        f'SP{i}_sequence' for i in range(1,len(DRref)+2)
+    ]+ ['count']).group_by([
+        f'SP{i}_sequence' for i in range(1,len(DRref)+2)
+    ]).sum()
+
+    return df_count, out
+
+
+def map_to_cas12_pairs_library(df_count,library,DR1_seq, get_recombinant=False, verbose=False):
+    
+    t0 = time()
+    
+    df_count, df_count_split = get_spacers_cas12(df_count, DRref = {'DR-1': DR1_seq})
+    
+    if verbose:
+        perc_DR1 = df_count.with_columns(
+            pl.col('DR1_loc').fill_null(0).gt(0)
+        ).filter(
+            pl.col('DR1_loc')
+        ).get_column('count').sum() / df_count['count'].sum() * 100
+        
+        print(f"% counts with DR1: {perc_DR1}")
+
+    df_res = pl.DataFrame(library[['SP1_sequence','SP2_sequence']].reset_index()).join(
+        df_count_split, 
+        on=["SP1_sequence","SP2_sequence"], how="left"
+    )
+    
+    if verbose:
+        perc_mapped = df_res['count'].drop_nulls().sum() / df_count['count'].sum() * 100
+        
+        print(f"% counts mapped to library: {perc_mapped}")
+        
+
+    if get_recombinant:
+        df_res_unmap = df_count_split.join(
+            pl.DataFrame(
+                library[['SP1_sequence','SP2_sequence']].reset_index()
+            ), on=["SP1_sequence","SP2_sequence"], how="anti"
+        )
+
+        df_res_unmap_remapped_sp1 = df_res_unmap.join(
+            pl.DataFrame(library[['SP1_name','SP1_id','SP1_sequence']]), on=["SP1_sequence"], how="left"
+        )
+
+        df_res_unmap_remapped_sp1_sp2 = df_res_unmap_remapped_sp1.join(
+            pl.DataFrame(library[['SP2_name','SP2_id','SP2_sequence']]),
+            on=["SP2_sequence"], how="left"
+        ).drop_nulls().unique().with_columns(
+            recombinant_name=pl.concat_str(
+                [
+                    pl.col("SP1_name"),
+                    pl.col("SP1_id"),
+                    pl.col("SP2_name"),
+                    pl.col("SP2_id"),
+                ],
+                separator="_"
+            )
+        ).select(['recombinant_name','SP1_sequence','SP2_sequence','count'])
+            
+        if verbose:
+            perc_remapped = df_res_unmap_remapped_sp1_sp2['count'].drop_nulls().sum() / df_count['count'].sum() * 100
+            
+            print(f"% counts remapped to library: {perc_remapped} [fully remapped recombination events]")
+            
+        if verbose: print("done in %0.3fs" % (time() - t0))
+        
+        return df_res, df_res_unmap_remapped_sp1_sp2
+    
+    else:
+        if verbose: print("done in %0.3fs" % (time() - t0))
+
+        return df_res
+
+
+def map_to_cas12_triplets_library(df_count,library,DR1_seq, DR2_seq, get_recombinant=False, verbose=False):
+    
+    t0 = time()
+    
+    df_count, df_count_split = get_spacers_cas12(df_count, DRref = {'DR-1': DR1_seq, 'DR-2': DR2_seq})
+    
+    if verbose:
+        perc_DR1 = df_count.with_columns(
+            pl.col('DR1_loc').fill_null(0).gt(0)
+        ).filter(
+            pl.col('DR1_loc')
+        ).get_column('count').sum() / df_count['count'].sum() * 100
+        
+        print(f"% counts with DR1: {perc_DR1}")
+
+        perc_DR2 = df_count.with_columns(
+            pl.col('DR2_loc').fill_null(0).gt(0)
+        ).filter(
+            pl.col('DR2_loc')
+        ).get_column('count').sum() / df_count['count'].sum() * 100
+
+        print(f"% counts with DR2: {perc_DR2}")
+    
+    df_res = pl.DataFrame(library[['SP1_sequence','SP2_sequence','SP3_sequence']].reset_index()).join(
+        df_count_split, 
+        on=["SP1_sequence","SP2_sequence","SP3_sequence"], how="left"
+    )
+
+    if verbose:
+        perc_mapped = df_res['count'].drop_nulls().sum() / df_count['count'].sum() * 100
+        
+        print(f"% counts mapped to library: {perc_mapped}")
+
+    if get_recombinant:
+        df_res_unmap = df_count_split.join(
+            pl.DataFrame(
+                library[['SP1_sequence','SP2_sequence','SP3_sequence']].reset_index()
+            ), on=["SP1_sequence","SP2_sequence","SP3_sequence"], how="anti"
+        )
+
+        df_res_unmap_remapped_sp1 = df_res_unmap.join(
+            pl.DataFrame(library[['SP1_name','SP1_id','SP1_sequence']]), on=["SP1_sequence"], how="left"
+        )
+
+        df_res_unmap_remapped_sp1_sp2 = df_res_unmap_remapped_sp1.join(
+            pl.DataFrame(library[['SP2_name','SP2_id','SP2_sequence']]),
+            on=["SP2_sequence"], how="left"
+        )
+
+        df_res_unmap_remapped_sp1_sp2_sp3 = df_res_unmap_remapped_sp1_sp2.join(
+            pl.DataFrame(library[['SP3_name','SP3_id','SP3_sequence']]),
+            on=["SP3_sequence"], how="left"
+        ).drop_nulls().unique().with_columns(
+            recombinant_name=pl.concat_str(
+                [
+                    pl.col("SP1_name"),
+                    pl.col("SP1_id"),
+                    pl.col("SP2_name"),
+                    pl.col("SP2_id"),
+                    pl.col("SP3_name"),
+                    pl.col("SP3_id"),
+                ],
+                separator="_"
+            )
+        ).select(['recombinant_name','SP1_sequence','SP2_sequence','SP3_sequence','count'])
+
+        if verbose:
+            perc_remapped = df_res_unmap_remapped_sp1_sp2_sp3['count'].drop_nulls().sum() / df_count['count'].sum() * 100
+            
+            print(f"% counts remapped to library: {perc_remapped} [fully remapped recombination events]")
+
+        if verbose: print("done in %0.3fs" % (time() - t0))
+
+        return df_res, df_res_unmap_remapped_sp1_sp2_sp3
+    
+    else:
+        
+        if verbose: print("done in %0.3fs" % (time() - t0))
+
+        return df_res

screenpro/ngs/cas9.py

@@ -0,0 +1,276 @@
+from time import time
+import pandas as pd
+import polars as pl
+import biobear as bb
+
+
+def fastq_to_count_single_guide(
+        fastq_file_path:str, 
+        trim5p_start:int=None, trim5p_length:int=None, 
+        verbose: bool=False) -> pl.DataFrame:
+    """
+    Count the occurrences of unique sequences in single-end FASTQ files to a DataFrame containing counts of unique sequences.
+    e.g. single-guide design R1: protospacer
+
+    Args:
+        fastq_file_path (str): The path to the FASTQ file.
+        trim5p_start (int, optional): The starting position for trimming the 5' end of the sequences. Defaults to None.
+        trim5p_length (int, optional): The length of the trimmed sequences. Defaults to None.
+        verbose (bool, optional): Whether to print verbose output. Defaults to False.
+
+    Returns:
+        pl.DataFrame: A DataFrame containing the unique sequences and their respective counts.
+    """
+    
+    if verbose: ('count unique sequences ...')
+    t0 = time()
+    
+    session = bb.connect()
+    
+    if trim5p_start and trim5p_length:
+        sql_cmd = f"""
+        SELECT substr(f.sequence, {trim5p_start}, {trim5p_length}) AS protospacer, COUNT(*) as count
+        FROM fastq_scan('{fastq_file_path}') f
+        GROUP BY protospacer
+        """
+    else:
+        sql_cmd = f"""
+        SELECT f.sequence AS protospacer, COUNT(*) as count
+        FROM fastq_scan('{fastq_file_path}') f
+        GROUP BY protospacer
+        """
+    
+    df_count = session.sql(sql_cmd).to_polars()
+
+    if verbose: print("done in %0.3fs" % (time() - t0))
+
+    return df_count
+
+
+def fastq_to_count_dual_guide(
+        R1_fastq_file_path:str, R2_fastq_file_path:str,
+        trim5p_pos1_start:int=None, trim5p_pos1_length:int=None,
+        trim5p_pos2_start:int=None, trim5p_pos2_length:int=None,
+        verbose: bool=False) -> pl.DataFrame:
+    """
+    Count the occurrences of unique sequences in paired-end FASTQ files to a DataFrame containing counts of unique pairs of sequences.
+    e.g. dual-guide design R1: protospacer_A, R2: protospacer_B
+    
+    Args:
+        R1_fastq_file_path (str): File path of the R1 FASTQ file.
+        R2_fastq_file_path (str): File path of the R2 FASTQ file.
+        trim5p_pos1_start (int, optional): Start position for trimming the 5' end of the R1 sequences. Defaults to None.
+        trim5p_pos1_length (int, optional): Length of the trimmed R1 sequences. Defaults to None.
+        trim5p_pos2_start (int, optional): Start position for trimming the 5' end of the R2 sequences. Defaults to None.
+        trim5p_pos2_length (int, optional): Length of the trimmed R2 sequences. Defaults to None.
+        verbose (bool, optional): Whether to print verbose output. Defaults to False.
+    
+    Returns:
+        pl.DataFrame: DataFrame containing counts of unique sequences with columns 'protospacer_A', 'protospacer_B', and 'count'.
+    
+    Raises:
+        ValueError: If trim5p_pos1_start, trim5p_pos1_length, trim5p_pos2_start, and trim5p_pos2_length are not provided concurrently.
+    """
+    
+    if verbose: ('count unique sequences ...')
+    t0 = time()
+
+    session = bb.connect()
+
+    if trim5p_pos1_start and trim5p_pos1_length and trim5p_pos2_start and trim5p_pos2_length:
+        sql_cmd = f"""
+            WITH pos1 AS (
+                SELECT REPLACE(name, '_R1', '') trimmed_name, *
+                FROM fastq_scan('{R1_fastq_file_path}')
+            ), pos2 AS (
+                SELECT REPLACE(name, '_R2', '') trimmed_name, *
+                FROM fastq_scan('{R2_fastq_file_path}')
+            )
+            SELECT substr(pos1.sequence, {trim5p_pos1_start}, {trim5p_pos1_length}) protospacer_A, reverse_complement(substr(pos2.sequence, {trim5p_pos2_start}, {trim5p_pos2_length})) protospacer_B, COUNT(*) count
+            FROM pos1
+            JOIN pos2
+                ON pos1.name = pos2.name
+            GROUP BY protospacer_A, protospacer_B
+        """
+    elif trim5p_pos1_start==None and trim5p_pos1_length==None and trim5p_pos2_start==None and trim5p_pos2_length==None:
+        sql_cmd = f"""
+            WITH pos1 AS (
+                SELECT REPLACE(name, '_R1', '') trimmed_name, *
+                FROM fastq_scan('{R1_fastq_file_path}')
+            ), pos2 AS (
+                SELECT REPLACE(name, '_R2', '') trimmed_name, *
+                FROM fastq_scan('{R2_fastq_file_path}')
+            )
+            SELECT pos1.sequence protospacer_A, reverse_complement(pos2.sequence) protospacer_B, COUNT(*) count
+            FROM pos1
+            JOIN pos2
+                ON pos1.name = pos2.name
+            GROUP BY protospacer_A, protospacer_B
+        """
+    else:
+        raise ValueError("trim5p_pos1_start, trim5p_pos1_length, \
+                         trim5p_pos2_start, and trim5p_pos2_length \
+                         must be provided concurrently!")
+
+    df_count = session.sql(sql_cmd).to_polars()
+
+    if verbose: print("done in %0.3fs" % (time() - t0))
+
+    return df_count
+
+
+def map_to_library_single_guide(df_count, library, return_type='all', verbose=False):
+    """
+    Map the counts of unique sequences to a library DataFrame containing sgRNA sequences.
+    User can choose to return mapped reads, unmapped reads, or both.
+
+    Args:
+        df_count (pandas.DataFrame): The input DataFrame containing counts.
+        library (pandas.DataFrame): The library DataFrame to map to.
+        return_type (str, optional): The type of result to return. Defaults to 'all'.
+        verbose (bool, optional): Whether to print verbose information. Defaults to False.
+
+    Returns:
+        dict or pandas.DataFrame: The mapped result based on the return_type parameter.
+
+    Raises:
+        ValueError: If the return_type parameter is invalid.
+    """
+    # get counts for given input
+    res = df_count.clone() #cheap deepcopy/clone
+    res = res.sort('count', descending=True)
+
+    res = res.with_columns(
+        pl.col("protospacer").alias("sequence"),
+    )
+
+    res_map = pl.DataFrame(library).join(
+        res, on="sequence", how="left"
+    )
+
+    if return_type == 'unmapped' or return_type == 'all':
+        res_unmap = res.join(
+            pl.DataFrame(library), on="sequence", how="anti"
+        )
+
+    if verbose:
+        print("% mapped reads",
+            100 * \
+            res_map.to_pandas()['count'].fillna(0).sum() / \
+            int(res.select(pl.sum("count")).to_pandas()['count'])
+        )
+    
+    if return_type == 'unmapped':
+        return res_unmap
+    elif return_type == 'mapped':
+        return res_map
+    elif return_type == 'all':
+        return {'full': res, 'mapped': res_map, 'unmapped': res_unmap}
+    else:
+        raise ValueError("return_type must be either 'unmapped', 'mapped', or 'all'")
+
+
+def map_to_library_dual_guide(df_count, library, get_recombinant=False, return_type='all', verbose=False):
+    """
+    Map the counts of unique sequences to a library DataFrame containing dual-guide sgRNA sequences. 
+    Optionally, the function can capture recombinant events.
+    User can choose to return mapped reads, unmapped reads, recombinant events, or all.
+
+    Args:
+        df_count (pandas.DataFrame): The input DataFrame containing the counts.
+        library (pandas.DataFrame): The library of sequences to map against.
+        get_recombinant (bool, optional): Whether to calculate recombinant events. Defaults to False.
+        return_type (str, optional): The type of reads to return. Can be 'unmapped', 'mapped', 'recombinant', or 'all'. Defaults to 'all'.
+        verbose (bool, optional): Whether to print verbose output. Defaults to False.
+
+    Returns:
+        pandas.DataFrame or dict: The mapped reads based on the specified return_type.
+
+    Raises:
+        ValueError: If return_type is not one of 'unmapped', 'mapped', 'recombinant', or 'all'.
+        ValueError: If get_recombinant is False and return_type is 'recombinant'.
+
+    """
+    # get counts for given input
+    res = df_count.clone() #cheap deepcopy/clone
+    res = res.rename(
+        {'protospacer_a':'protospacer_A','protospacer_b':'protospacer_B'}
+    )
+    res = res.sort('count', descending=True)
+    res = res.with_columns(
+        pl.concat_str(
+            [
+                pl.col("protospacer_A"),
+                pl.col("protospacer_B")
+            ],
+            separator=";",
+        ).alias("sequence"),
+    )
+
+    # map to library
+    res_map = pl.DataFrame(library).join(
+            res, on="sequence", how="left"
+        )
+
+    # get unmapped reads to the library
+    if get_recombinant or return_type == 'unmapped' or return_type == 'all':
+        res_unmap = res.join(
+            pl.DataFrame(library), on="sequence", how="anti"
+        )
+
+    if verbose:
+        print("% mapped reads",
+            100 * \
+            res_map.to_pandas()['count'].fillna(0).sum() / \
+            int(res.select(pl.sum("count")).to_pandas()['count'])
+        )
+    
+    if get_recombinant:
+
+        if verbose:
+            print("% unmapped reads",
+                100 * \
+                res_unmap.to_pandas()['count'].fillna(0).sum() / \
+                int(res.select(pl.sum("count")).to_pandas()['count'])
+            )
+        
+        sgRNA_table = pd.concat([
+            library.to_pandas()[['sgID_A','protospacer_A']].rename(columns={'sgID_A':'sgID','protospacer_A':'protospacer'}),
+            library.to_pandas()[['sgID_B', 'protospacer_B']].rename(columns={'sgID_B':'sgID','protospacer_B':'protospacer'})
+        ]).drop_duplicates(keep='first')
+
+        res_unmap_remapped_a = res_unmap.join(
+            pl.DataFrame(sgRNA_table.rename(
+                columns={'protospacer':'protospacer_A','sgID':'sgID_A'})[['sgID_A','protospacer_A']]),
+            on=["protospacer_A"], how="left"
+        )
+
+        res_recomb_events = res_unmap_remapped_a.join(
+            pl.DataFrame(sgRNA_table.rename(
+                columns={'protospacer':'protospacer_B','sgID':'sgID_B'})[['sgID_B','protospacer_B']]),
+            on=["protospacer_B"], how="left"
+        )
+        if verbose:
+            print("% fully remapped recombination events",
+                100 * \
+                res_recomb_events.drop_nulls().to_pandas()['count'].fillna(0).sum() / \
+                int(res.select(pl.sum("count")).to_pandas()['count'])
+            )
+    
+    if return_type == 'unmapped':
+        # TODO: add option to return only unmapped reads after mapping recombinant events
+        return res_unmap
+    elif return_type == 'mapped':
+        return res_map
+    elif return_type == 'recombinant':
+        if get_recombinant:
+            return res_recomb_events
+        else:
+            raise ValueError("get_recombinant must be set to True to calculate recombinant events")
+    elif return_type == 'all':
+        if get_recombinant:
+            return {'full': res,'mapped': res_map,'recombinant': res_recomb_events, 'unmapped': res_unmap}
+        else:
+            return {'full': res,'mapped': res_map, 'unmapped': res_unmap}
+    else:
+        raise ValueError("return_type must be either 'unmapped', 'mapped', 'recombinant', or 'all'")

screenpro/phenoscore/__init__.py

@@ -0,0 +1,148 @@
+## Copyright (c) 2022-2025 ScreenPro2 Development Team.
+## All rights reserved.
+## Gilbart Lab, UCSF / Arc Institute.
+## Multi-Omics Tech Center, Arc Insititue.
+
+"""phenoscore module
+
+This module contains functions for calculating relative phenotypes from CRISPR screens
+datasets.
+"""
+
+import numpy as np
+import anndata as ad
+import pandas as pd
+
+from .delta import (
+    compareByReplicates, compareByTargetGroup,
+    getPhenotypeData,
+    calculateDelta,
+    getBestTargetByTSS,
+    generatePseudoGeneAnnData
+)
+from .deseq import runDESeq, extractDESeqResults
+from ._annotate import annotateScoreTable
+from .phenostat import matrixStat, multipleTestsCorrection
+
+
+def runPhenoScore(adata, cond_ref, cond_test, score_level, 
+                  var_names='target', collapse_var=False,
+                  test='ttest', growth_rate=1, n_reps='auto', keep_top_n = None, 
+                  num_pseudogenes='auto', pseudogene_size='auto',
+                  count_layer=None, count_filter_type='mean', count_filter_threshold=40,
+                  ctrl_label='negative_control'
+                  ):
+    """Calculate phenotype score and p-values when comparing `cond_test` vs `cond_ref`.
+
+    Args:
+        adata (AnnData): AnnData object
+        cond_ref (str): condition reference
+        cond_test (str): condition test
+        score_level (str): score level
+        var_names (str): variable names to use as index in the result dataframe
+        collapse_var (str): variable to use for `getBestTargetByTSS` function, default is False
+        test (str): test to use for calculating p-value ('MW': Mann-Whitney U rank; 'ttest' : t-test)
+        growth_rate (int): growth rate
+        n_reps (int): number of replicates
+        keep_top_n (int): number of top guides to keep per target
+        num_pseudogenes (int): number of pseudogenes to generate
+        pseudogene_size (int): number of sgRNA elements in each pseudogene
+        count_layer (str): count layer to use for calculating score, default is None (use default count layer in adata.X)
+        count_filter_type (str): filter type for counts, default is 'mean'
+        count_filter_threshold (int): filter threshold for counts, default is 40
+        ctrl_label (str): control label, default is 'negative_control'
+    
+    Returns:
+        str: result name
+        pd.DataFrame: result dataframe
+    """
+    adat = adata.copy()
+
+    if 'condition' not in adat.obs.columns:
+        raise ValueError("The AnnData object must have a 'condition' column in its obs.")
+
+    # format result name
+    result_name = f'{cond_test}_vs_{cond_ref}'
+    print(f'\t{cond_test} vs {cond_ref}')
+    
+    # set n_reps if not provided
+    if n_reps == 'auto':
+        n_reps = min(
+            adat.obs.query(f'condition=="{cond_ref}"').shape[0], 
+            adat.obs.query(f'condition=="{cond_test}"').shape[0]
+        )
+
+    # check if count_layer exists
+    if count_layer is None:
+        pass
+    elif count_layer not in adat.layers.keys():
+        raise ValueError(f"Layer '{count_layer}' not found in adata.layers.keys().")
+    elif count_layer in adat.layers.keys():
+        adat.X = adat.layers[count_layer].copy()
+    
+    # calc phenotype score and p-value
+    if score_level in ['compare_reps']:
+
+        # prep counts for phenoScore calculation
+        df_cond_ref = adat[adat.obs.query(f'condition=="{cond_ref}"').index[:n_reps],].to_df(count_layer).T
+        df_cond_test = adat[adat.obs.query(f'condition=="{cond_test}"').index[:n_reps],].to_df(count_layer).T
+
+        result = compareByReplicates(
+            adata=adat, 
+            df_cond_ref=df_cond_ref, 
+            df_cond_test=df_cond_test,
+            var_names=var_names,
+            test=test,
+            ctrl_label=ctrl_label,
+            growth_rate=growth_rate,
+            filter_type=count_filter_type,
+            filter_threshold=count_filter_threshold
+        )
+    
+    elif score_level in ['compare_guides']:
+
+        # prep counts for phenoScore calculation
+        df_cond_ref = adat[adat.obs.query(f'condition=="{cond_ref}"').index].to_df().T
+        df_cond_test = adat[adat.obs.query(f'condition=="{cond_test}"').index].to_df().T
+        del df_cond_ref, df_cond_test
+        
+        adat_pseudo = generatePseudoGeneAnnData(adat, num_pseudogenes=num_pseudogenes, pseudogene_size=pseudogene_size, ctrl_label=ctrl_label)
+        if 'transcript' in var_names: adat_pseudo.var['transcript'] = 'na'
+
+        adat_test = ad.concat([adat[:,~adat.var.targetType.eq(ctrl_label)], adat_pseudo], axis=1)
+        adat_test.obs = adat.obs.copy()
+
+        # prep counts for phenoScore calculation
+        df_cond_ref = adat_test[adat_test.obs.query(f'condition=="{cond_ref}"').index].to_df().T
+        df_cond_test = adat_test[adat_test.obs.query(f'condition=="{cond_test}"').index].to_df().T
+        
+        result = compareByTargetGroup(
+            adata=adat_test, 
+            df_cond_ref=df_cond_ref, 
+            df_cond_test=df_cond_test,
+            keep_top_n=keep_top_n,
+            var_names=var_names,
+            test=test,
+            ctrl_label=ctrl_label,
+            growth_rate=growth_rate,
+            filter_type=count_filter_type,
+            filter_threshold=count_filter_threshold
+        )
+
+        # get the best transcript as lowest p-value for each target
+        if collapse_var not in [False, None]:
+            if collapse_var not in result.columns:
+                raise ValueError(f'collapse_var "{collapse_var}" not found in result columns.')
+            else:
+                result = getBestTargetByTSS(
+                    score_df=result, target_col=collapse_var, pvalue_col=f'{test} pvalue'
+                )
+                result.index.name = None
+        
+        # change target name to control label if it is a pseudo gene
+        result['target'] = result['target'].apply(lambda x: ctrl_label if 'pseudo' in x else x).to_list()
+        
+    else:
+        raise ValueError(f'score_level "{score_level}" not recognized. Currently, "compare_reps" and "compare_guides" are supported.')
+    
+    return result_name, result