Merge pull request #100 from MannLabs/change_minrep_semantics

Fix filtering options in GUI

Author: ammarcsj

alphaquant/diffquant/condpair_analysis.py

@@ -37,7 +37,7 @@ def analyze_condpair(*,runconfig, condpair):
     c1_samples, c2_samples = aqutils.get_samples_used_from_samplemap_df(runconfig.samplemap_df, condpair[0], condpair[1])
 
     try:
-        df_c1, df_c2 = get_per_condition_dataframes(c1_samples, c2_samples, input_df_local,runconfig.minrep_both, runconfig.minrep_either, runconfig.minrep_c1, runconfig.minrep_c2)
+        df_c1, df_c2 = get_per_condition_dataframes(c1_samples, c2_samples, input_df_local, min_valid_values=runconfig.min_valid_values, valid_values_filter_mode=runconfig.valid_values_filter_mode, min_valid_values_c1=runconfig.min_valid_values_c1, min_valid_values_c2=runconfig.min_valid_values_c2)
     except Exception as e:
         LOGGER.info(e)
         return
@@ -153,53 +153,49 @@ def write_out_normed_df(normed_df_1, normed_df_2, pep2prot, results_dir, condpai
     merged_df.to_csv(f"{results_dir}/{aqutils.get_condpairname(condpair)}.normed.tsv", sep = "\t")
 
 
-def get_per_condition_dataframes(samples_c1, samples_c2, unnormed_df, minrep_both =None,  minrep_either = None, minrep_c1 = None, minrep_c2 = None):
+def get_per_condition_dataframes(samples_c1, samples_c2, unnormed_df, min_valid_values, valid_values_filter_mode, min_valid_values_c1, min_valid_values_c2):
 
     min_samples = min(len(samples_c1), len(samples_c2))
 
     if min_samples<2:
         raise Exception(f"condpair has not enough samples: c1:{len(samples_c1)} c2: {len(samples_c2)}, skipping")
 
-    if (minrep_either is not None) or ((minrep_c1 is not None) and (minrep_c2 is not None)): #minrep_both was set as default and should be overruled by minrep_either or minrep_c1 and minrep_c2
-        minrep_both = None
-
-    if minrep_either is not None:
-        minrep_either = np.min([get_minrep_for_cond(samples_c1, minrep_either), get_minrep_for_cond(samples_c2, minrep_either)])
-        passes_minrep_c1 = unnormed_df.loc[:, samples_c1].notna().sum(axis=1) >= minrep_either
-        passes_minrep_c2 = unnormed_df.loc[:, samples_c2].notna().sum(axis=1) >= minrep_either
-        passes_minrep_either = passes_minrep_c1 | passes_minrep_c2
-        unnormed_df = unnormed_df[passes_minrep_either]
+    if valid_values_filter_mode == "either":
+        min_valid_values = np.min([get_min_valid_values_for_cond(samples_c1, min_valid_values), get_min_valid_values_for_cond(samples_c2, min_valid_values)])
+        passes_min_valid_values_c1 = unnormed_df.loc[:, samples_c1].notna().sum(axis=1) >= min_valid_values
+        passes_min_valid_values_c2 = unnormed_df.loc[:, samples_c2].notna().sum(axis=1) >= min_valid_values
+        passes_min_valid_values = passes_min_valid_values_c1 | passes_min_valid_values_c2
+        unnormed_df = unnormed_df[passes_min_valid_values]
         df_c1 = unnormed_df.loc[:, samples_c1]
         df_c2 = unnormed_df.loc[:, samples_c2]
 
+    elif valid_values_filter_mode == "both":
+        min_valid_values_c1 = get_min_valid_values_for_cond(samples_c1, min_valid_values)
+        min_valid_values_c2 = get_min_valid_values_for_cond(samples_c2, min_valid_values)
+        df_c1 = unnormed_df.loc[:, samples_c1].dropna(thresh=min_valid_values_c1, axis=0)
+        df_c2 = unnormed_df.loc[:, samples_c2].dropna(thresh=min_valid_values_c2, axis=0)
+
+    elif valid_values_filter_mode == "per_condition":
+        min_valid_values_c1 = get_min_valid_values_for_cond(samples_c1, min_valid_values_c1)
+        min_valid_values_c2 = get_min_valid_values_for_cond(samples_c2, min_valid_values_c2)
+        df_c1 = unnormed_df.loc[:, samples_c1].dropna(thresh=min_valid_values_c1, axis=0)
+        df_c2 = unnormed_df.loc[:, samples_c2].dropna(thresh=min_valid_values_c2, axis=0)
+    else:
+        raise Exception(f"invalid value set for the variable valid_values_filter_mode: {valid_values_filter_mode}, please ensure that is set to: 'either', 'both' or 'per_condition'")
 
-    elif minrep_both is not None:
-        minrep_c1 = minrep_both
-        minrep_c2 = minrep_both
-
-    if (minrep_c1 is not None) and (minrep_c2 is not None):
-        minrep_c1 = get_minrep_for_cond(samples_c1, minrep_c1)
-        minrep_c2 = get_minrep_for_cond(samples_c2, minrep_c2)
-        df_c1 = unnormed_df.loc[:, samples_c1].dropna(thresh=minrep_c1, axis=0)
-        df_c2 = unnormed_df.loc[:, samples_c2].dropna(thresh=minrep_c2, axis=0)
-        if (len(df_c1.index)<5) | (len(df_c2.index)<5):
-            raise Exception(f"condpair has not enough data for processing c1: {len(df_c1.index)} c2: {len(df_c2.index)}, skipping")
-
-    if (minrep_both is None) and (minrep_either is None) and (minrep_c1 is None) and (minrep_c2 is None):
-        raise Exception("no minrep set, please specify!")
-
-
+    if (len(df_c1.index)<5) | (len(df_c2.index)<5):
+        raise Exception(f"condpair has not enough data for processing c1: {len(df_c1.index)} c2: {len(df_c2.index)}, skipping")
 
     return df_c1, df_c2
 
-def get_minrep_for_cond(c_samples, minrep):
-    if minrep is None: #in the case of None, no nans will be allowed
+def get_min_valid_values_for_cond(c_samples, min_valid_values):
+    if min_valid_values is None: #in the case of None, no nans will be allowed
         return None
     num_samples = len(c_samples)
-    if num_samples<minrep:
+    if num_samples<min_valid_values:
         return num_samples
     else:
-        return minrep
+        return min_valid_values
 
 
 

alphaquant/diffquant/diffutils.py

@@ -69,13 +69,13 @@ def get_samplenames_from_input_df(data):
 
 # Cell
 import numpy as np
-def filter_df_to_minrep(quant_df_wideformat, samples_c1, samples_c2, minrep):
+def filter_df_to_min_valid_values(quant_df_wideformat, samples_c1, samples_c2, min_valid_values):
     """filters dataframe in alphaquant format such that each column has a minimum number of replicates
     """
     quant_df_wideformat = quant_df_wideformat.replace(0, np.nan)
-    df_c1_minrep = quant_df_wideformat[samples_c1].dropna(thresh = minrep, axis = 0)
-    df_c2_minrep = quant_df_wideformat[samples_c2].dropna(thresh = minrep, axis = 0)
-    idxs_both = df_c1_minrep.index.intersection(df_c2_minrep.index)
+    df_c1_min_valid_values = quant_df_wideformat[samples_c1].dropna(thresh = min_valid_values, axis = 0)
+    df_c2_min_valid_values = quant_df_wideformat[samples_c2].dropna(thresh = min_valid_values, axis = 0)
+    idxs_both = df_c1_min_valid_values.index.intersection(df_c2_min_valid_values.index)
     quant_df_reduced = quant_df_wideformat.iloc[idxs_both].reset_index()
     return quant_df_reduced
 

alphaquant/ptm/ptmsite_mapping.py

@@ -673,7 +673,7 @@ def initialize_ptmsite_df(ptmsite_file, samplemap_file):
     ptmsite_df = pd.read_csv(ptmsite_file, sep = "\t")
     return ptmsite_df, samplemap_df
 
-def detect_site_occupancy_change(cond1, cond2, ptmsite_df ,samplemap_df, minrep = 2, threshold_prob = 0.05):
+def detect_site_occupancy_change(cond1, cond2, ptmsite_df ,samplemap_df, min_valid_values = 2, threshold_prob = 0.05):
     """
     uses a PTMsite df with headers "REFPROT", "gene","site", and headers for sample1, sample2, etc and determines
     whether a site appears/dissappears between conditions based on some probability threshold
@@ -708,7 +708,7 @@ def detect_site_occupancy_change(cond1, cond2, ptmsite_df ,samplemap_df, minrep
         numrep_c1 = len(cond1_vals)
         numrep_c2 = len(cond2_vals)
 
-        if(numrep_c1<minrep) | (numrep_c2 < minrep):
+        if(numrep_c1<min_valid_values) | (numrep_c2 < min_valid_values):
             continue
 
         cond1_prob = np.mean(cond1_vals)
@@ -741,7 +741,7 @@ def detect_site_occupancy_change(cond1, cond2, ptmsite_df ,samplemap_df, minrep
 import numpy as np
 import re
 
-def check_site_occupancy_changes_all_diffresults(results_folder = os.path.join(".","results"), siteprobs_filename = "siteprobs.tsv",samplemap_file = "samples.map",condpairs_to_compare = [], threshold_prob = 0.05, minrep = 2):
+def check_site_occupancy_changes_all_diffresults(results_folder = os.path.join(".","results"), siteprobs_filename = "siteprobs.tsv",samplemap_file = "samples.map",condpairs_to_compare = [], threshold_prob = 0.05, min_valid_values = 2):
 
     samplemap_df, _ = get_sample2cond_dataframe(samplemap_file)
     ptmsite_map = os.path.join(results_folder, siteprobs_filename)
@@ -765,7 +765,7 @@ def check_site_occupancy_changes_all_diffresults(results_folder = os.path.join("
         ptmsite_df_cpair = ptmsite_df_cpair.sort_index()
 
         condpairname = utils.get_condpairname(condpair)
-        df_occupancy = detect_site_occupancy_change(cond1, cond2, ptmsite_df_cpair, samplemap_df, minrep = minrep, threshold_prob = threshold_prob)
+        df_occupancy = detect_site_occupancy_change(cond1, cond2, ptmsite_df_cpair, samplemap_df, min_valid_values = min_valid_values, threshold_prob = threshold_prob)
         df_occupancy.to_csv(os.path.join(results_folder, f"{condpairname}.ptm_occupancy_changes.tsv"), sep = "\t", index = None)
 
 

alphaquant/run_pipeline.py

@@ -45,10 +45,10 @@ def run_pipeline(input_file: str,
                 multicond_median_analysis: bool = False,
                 condpairs_list: Optional[List[Tuple[str, str]]] = None,
                 file_has_alphaquant_format: bool = False,
-                minrep_both: int = 2,
-                minrep_either: Optional[int] = None,
-                minrep_c1: Optional[int] = None,
-                minrep_c2: Optional[int] = None,
+                min_valid_values: int = 2,
+                valid_values_filter_mode: str = "either", #options: "either", "and", "per_condition"
+                min_valid_values_c1: int = 0,
+                min_valid_values_c2: int = 0,
                 min_num_ions: int = 1,
                 minpep: int = 1,
                 organism: Optional[str] = None,
@@ -71,7 +71,12 @@ def run_pipeline(input_file: str,
                 protein_subset_for_normalization_file: Optional[str] = None,
                 protnorm_peptides: bool = True,
                 peptides_to_exclude_file: Optional[str] = None,
-                reset_progress_folder: bool = False) -> None:
+                reset_progress_folder: bool = False,
+                minrep_both: Optional[int] = None, #deprecated
+                minrep_either: Optional[int] = None, #deprecated
+                minrep_c1: Optional[int] = None, #deprecated
+                minrep_c2: Optional[int] = None, #deprecated
+                ) -> None:
     """Run differential analyses following the AlphaQuant pipeline. This function processes proteomics data through multiple steps including
         preprocessing, if applicable PTM site mapping, if applicable median condition creation, normalization, statistical testing, visualizations
         and writing of results tables.
@@ -86,10 +91,13 @@ def run_pipeline(input_file: str,
     multicond_median_analysis (bool): Whether to compare all conditions to a median condition. Defaults to False.
     condpairs_list (list): Specific condition pairs to compare. If None, performs all pairwise comparisons.
     file_has_alphaquant_format (bool): Whether the input file is already in AlphaQuant matrix format. Defaults to False.
-    minrep_both (int): Minimum replicate count required in both conditions. Defaults to 2.
-    minrep_either (int): Minimum replicate count required in either condition.
-    minrep_c1 (int): Minimum replicate count required in condition 1.
-    minrep_c2 (int): Minimum replicate count required in condition 2.
+    min_valid_values (int): Minimum number of valid values required across conditions. Defaults to 2.
+    valid_values_filter_mode (str): Strategy for filtering based on valid values. Options:
+        - "either": Include features that have at least 'min_valid_values' valid values in at least one condition.
+        - "both": Include only features that have at least 'min_valid_values' valid values in all conditions.
+        - "per_condition": Include only features that have at least 'min_valid_values_c1' valid values in condition 1 and 'min_valid_values_c2' valid values in condition 2.
+    min_valid_values_c1 (int): Minimum number of valid values required specifically in condition 1.
+    min_valid_values_c2 (int): Minimum number of valid values required specifically in condition 2.
     min_num_ions (int): Minimum number of ions required per peptide. Defaults to 1.
     minpep (int): Minimum number of peptides required per protein. Defaults to 1.
     organism (str): Organism name for PTM mapping (e.g., 'human', 'mouse'). Required if perform_ptm_mapping is True.
@@ -115,6 +123,27 @@ def run_pipeline(input_file: str,
     reset_progress_folder (bool): Clear and recreate the progress folder. Defaults to False.
     """
     LOGGER.info("Starting AlphaQuant")
+
+    #########################################################
+    # TODO: this backwards compatibility can be removed beginning of 2026
+    # to ensure backwards compatibility: in case the minrep paramters are set, we need to convert them to the min_valid_values and valid_values_filter_mode parameters
+    if minrep_both is not None:
+        min_valid_values = minrep_both
+        valid_values_filter_mode = "both"
+        LOGGER.warning("you set the parameter 'minrep_both', which is deprecated. Please use 'min_valid_values' and 'valid_values_filter_mode' instead.")
+    if minrep_either is not None:
+        min_valid_values = minrep_either
+        valid_values_filter_mode = "either"
+        LOGGER.warning("you set the parameter 'minrep_either', which is deprecated. Please use 'min_valid_values' and 'valid_values_filter_mode' instead.")
+    if minrep_c1 is not None and minrep_c2 is not None:
+        min_valid_values_c1 = minrep_c1
+        min_valid_values_c2 = minrep_c2
+        valid_values_filter_mode = "per_condition"
+        LOGGER.warning("you set the parameter 'minrep_c1' and 'minrep_c2', which is deprecated. Please use 'min_valid_values_c1' and 'min_valid_values_c2' instead.")
+    #########################################################
+
+
+
     input_file_original = input_file
     check_input_consistency(input_file_original, samplemap_file, samplemap_df)
     create_progress_folder_if_applicable(input_file_original, reset_progress_folder)

alphaquant/ui/dashboad_parts_plots_basic.py

@@ -176,7 +176,12 @@ def _extract_condpairs(self):
             self.condpairname_select.options = ["No conditions"]
             return
 
-        pattern = os.path.join(self.results_dir, "*_VS_*.results.tsv")
+        # Ensure directory path ends with separator for Windows compatibility
+        dir_path = self.results_dir
+        if not dir_path.endswith(os.sep):
+            dir_path += os.sep
+
+        pattern = os.path.join(dir_path, "*_VS_*.results.tsv")
         files = glob.glob(pattern)
 
         for f in files: