update for pyopenms==3.2.0

rename PeakPickerMRM to PeakPickerChromatogram

massdash/peakPickers/MRMTransitionGroupPicker.py

@@ -41,17 +41,17 @@ def setDefaults(self):
         params.setValue( b'compute_peak_shape_metrics', 'false')
         params.setValue( b'compute_total_mi', 'false')
         params.setValue( b'boundary_selection_method', 'largest')
-        params.setValue( b'PeakPickerMRM:sgolay_frame_length', 11)
-        params.setValue( b'PeakPickerMRM:sgolay_polynomial_order', 3)
-        params.setValue( b'PeakPickerMRM:gauss_width', 50.0)
-        params.setValue( b'PeakPickerMRM:use_gauss', 'false')
-        params.setValue( b'PeakPickerMRM:peak_width', -1.0)
-        params.setValue( b'PeakPickerMRM:signal_to_noise', 0.001)
-        params.setValue( b'PeakPickerMRM:sn_win_len', 1000.0)
-        params.setValue( b'PeakPickerMRM:sn_bin_count', 30)
-        params.setValue( b'PeakPickerMRM:write_sn_log_messages', 'false')
-        params.setValue( b'PeakPickerMRM:remove_overlapping_peaks', 'true')
-        params.setValue( b'PeakPickerMRM:method', 'corrected')
+        params.setValue( b'PeakPickerChromatogram:sgolay_frame_length', 11)
+        params.setValue( b'PeakPickerChromatogram:sgolay_polynomial_order', 3)
+        params.setValue( b'PeakPickerChromatogram:gauss_width', 50.0)
+        params.setValue( b'PeakPickerChromatogram:use_gauss', 'false')
+        params.setValue( b'PeakPickerChromatogram:peak_width', -1.0)
+        params.setValue( b'PeakPickerChromatogram:signal_to_noise', 0.001)
+        params.setValue( b'PeakPickerChromatogram:sn_win_len', 1000.0)
+        params.setValue( b'PeakPickerChromatogram:sn_bin_count', 30)
+        params.setValue( b'PeakPickerChromatogram:write_sn_log_messages', 'false')
+        params.setValue( b'PeakPickerChromatogram:remove_overlapping_peaks', 'true')
+        params.setValue( b'PeakPickerChromatogram:method', 'corrected')
         params.setValue( b'PeakIntegrator:integration_type', 'intensity_sum')
         params.setValue( b'PeakIntegrator:baseline_type', 'base_to_base')
         params.setValue( b'PeakIntegrator:fit_EMG', 'false')
@@ -63,16 +63,16 @@ def setDefaults(self):
     def setSmoother(self, smoother, sgolay_frame_length=11, sgolay_polynomial_order=3, gauss_width=50.0):
         ''' Set the smoother, can be one of ["original", "guassian", "sgolay"] '''
         if smoother == 'original':
-            self.params.setValue(b'PeakPickerMRM:method','legacy')
+            self.params.setValue(b'PeakPickerChromatogram:method','legacy')
         elif smoother == 'gauss':
-            self.params.setValue(b'PeakPickerMRM:method','corrected')
-            self.params.setValue(b'PeakPickerMRM:use_gauss','true')
-            self.params.setValue(b'PeakPickerMRM:gauss_width', gauss_width)
+            self.params.setValue(b'PeakPickerChromatogram:method','corrected')
+            self.params.setValue(b'PeakPickerChromatogram:use_gauss','true')
+            self.params.setValue(b'PeakPickerChromatogram:gauss_width', gauss_width)
         elif smoother == 'sgolay':
-            self.params.setValue(b'PeakPickerMRM:method','corrected')
-            self.params.setValue(b'PeakPickerMRM:use_gauss','false')
-            self.params.setValue(b'PeakPickerMRM:sgolay_frame_length', sgolay_frame_length)
-            self.params.setValue(b'PeakPickerMRM:sgolay_polynomial_order', sgolay_polynomial_order)
+            self.params.setValue(b'PeakPickerChromatogram:method','corrected')
+            self.params.setValue(b'PeakPickerChromatogram:use_gauss','false')
+            self.params.setValue(b'PeakPickerChromatogram:sgolay_frame_length', sgolay_frame_length)
+            self.params.setValue(b'PeakPickerChromatogram:sgolay_polynomial_order', sgolay_polynomial_order)
         else:
             raise ValueError("Smoother must be one of ['original', 'gauss', 'sgolay']")
 
@@ -105,7 +105,7 @@ def setGeneralParameters(self, **kwargs):
                 raise ValueError(f"Parameter {k} is not valid or is not currently supported")
             else:
                 if k in mrmParams:
-                    self.params.setValue(bytes('PeakPickerMRM:'+k, encoding='utf-8'), val)
+                    self.params.setValue(bytes('PeakPickerChromatogram:'+k, encoding='utf-8'), val)
                 elif k in bools_to_str:
                     if k:
                         self.params.setValue(bytes(k, encoding='utf-8'), 'true')

massdash/peakPickers/pyMRMTransitionGroupPicker.py

@@ -18,11 +18,11 @@ class pyMRMTransitionGroupPicker:
     This is a python implementation based on OpenMS peak picker
     '''
 
-    def __init__(self, level: str='ms1ms2', sgolay_frame_length: Optional[int]=11, sgolay_polynomial_order: Optional[int]=3, peak_picker: Optional[po.PeakPickerMRM]=None):
+    def __init__(self, level: str='ms1ms2', sgolay_frame_length: Optional[int]=11, sgolay_polynomial_order: Optional[int]=3, peak_picker: Optional[po.PeakPickerChromatogram]=None):
         self.level = level
         self.top_n_features = 5
         if peak_picker is None:
-            self.peak_picker = po.PeakPickerMRM()
+            self.peak_picker = po.PeakPickerChromatogram()
             ##### Set the pyopenms peak picker parameters
             params = self.peak_picker.getDefaults()
             params.setValue(b'sgolay_frame_length', sgolay_frame_length)
@@ -48,7 +48,7 @@ def _resolveLevel(self, transitionGroup):
 
     def find_peak_boundaries(self, chrom: Chromatogram) -> List[TransitionFeature]:
         """
-        Find peak boundaries using the PeakPickerMRM algorithm.
+        Find peak boundaries using the PeakPickerChromatogram algorithm.
 
         Args:
             rt_arr (np.array): Array of retention times.

massdash/server/ExtractedIonChromatogramAnalysisServer.py

@@ -131,21 +131,21 @@ def main(self):
                 with time_block() as elapsed_time:
                     tr_group_feature_data = self.xic_data.loadTransitionGroupFeatures(transition_list_ui.transition_settings.selected_peptide, transition_list_ui.transition_settings.selected_charge)
                 st.write(f"Loading Feature File Peak Boundaries... Elapsed time: {elapsed_time()}")
-            elif peak_picking_settings.do_peak_picking == 'pyPeakPickerMRM':
+            elif peak_picking_settings.do_peak_picking == 'pyPeakPickerChromatogram':
                 with time_block() as elapsed_time:
                     # Peak picking using pyMRMTransitionGroupPicker
                     if peak_picking_settings.peak_pick_on_displayed_chrom:
                         mslevel = get_string_mslevels_from_bool({'ms1':chrom_plot_settings.include_ms1, 'ms2':chrom_plot_settings.include_ms2})
                     else:
                         mslevel = peak_picking_settings.peak_picker_algo_settings.mslevels
-                    peak_picker_param = peak_picking_settings.peak_picker_algo_settings.PeakPickerMRMParams
+                    peak_picker_param = peak_picking_settings.peak_picker_algo_settings.PeakPickerChromatogramParams
 
                     tr_group_feature_data = {}
                     for file, tr_group in tr_group_data.items():
                         peak_picker = pyMRMTransitionGroupPicker(mslevel, peak_picker=peak_picker_param.peak_picker)
                         peak_features = peak_picker.pick(tr_group)
                         tr_group_feature_data[file] = peak_features
-                st.write(f"Performing pyPeakPickerMRM Peak Picking... Elapsed time: {elapsed_time()}")
+                st.write(f"Performing pyPeakPickerChromatogram Peak Picking... Elapsed time: {elapsed_time()}")
             elif peak_picking_settings.do_peak_picking == 'MRMTransitionGroupPicker':
                 with time_block() as elapsed_time:
                     # Peak picking using MRMTransitionGroupPicker

massdash/server/FeatureMapPlotterServer.py

@@ -97,7 +97,7 @@ def generate_one_dimensional_plots(self):
                 tr_group_feature_data = self.chrom_loader.loadTransitionGroupFeatures(self.transition_list_ui.transition_settings.selected_peptide,
                     self.transition_list_ui.transition_settings.selected_charge)
 
-            elif self.peak_picking_settings.do_peak_picking in ['pyPeakPickerMRM', 'MRMTransitionGroupPicker', 'Conformer']:
+            elif self.peak_picking_settings.do_peak_picking in ['pyPeakPickerChromatogram', 'MRMTransitionGroupPicker', 'Conformer']:
                 # Perform peak picking if enabled
                 peak_picker = PeakPickingServer(self.peak_picking_settings, self.chrom_plot_settings)
                 tr_group_feature_data = peak_picker.perform_peak_picking(tr_group_data=chromatograms, 
@@ -106,7 +106,7 @@ def generate_one_dimensional_plots(self):
                 tr_group_feature_data = TransitionGroupFeatureCollection()
 
             else:
-                raise ValueError(f"Invalid peak picking algorithm: {self.peak_picking_settings.do_peak_picking}. Valid options are 'Feature File Boundaries', 'pyPeakPickerMRM', 'MRMTransitionGroupPicker', and 'Conformer'.")
+                raise ValueError(f"Invalid peak picking algorithm: {self.peak_picking_settings.do_peak_picking}. Valid options are 'Feature File Boundaries', 'pyPeakPickerChromatogram', 'MRMTransitionGroupPicker', and 'Conformer'.")
 
             plot_settings_dict = self._get_plot_settings('Retention Time (s)', 'Intensity', 'chromatogram')
             self._generate_plots_helper(chromatograms, plot_settings_dict, tr_group_feature_data)

massdash/server/PeakPickingServer.py

@@ -36,7 +36,7 @@ def __init__(self, peak_picking_settings: PeakPickingUISettings, chrom_plot_sett
 
     def perform_pypeakpicker_mrm_peak_picking(self, tr_group_data: TransitionGroupCollection) -> TransitionGroupFeatureCollection:
         """
-        Performs peak picking using pyPeakPickerMRM algorithm.
+        Performs peak picking using pyPeakPickerChromatogram algorithm.
 
         Args:
             tr_group_data (TransitionGroupCollection): The transition group data collection
@@ -51,15 +51,15 @@ def perform_pypeakpicker_mrm_peak_picking(self, tr_group_data: TransitionGroupCo
                 )
             else:
                 mslevel = self.peak_picking_settings.peak_picker_algo_settings.mslevels
-            peak_picker_param = self.peak_picking_settings.peak_picker_algo_settings.PeakPickerMRMParams
+            peak_picker_param = self.peak_picking_settings.peak_picker_algo_settings.PeakPickerChromatogramParams
 
             tr_group_feature_data = TransitionGroupFeatureCollection()
             for file, tr_group in tr_group_data.items():
                 peak_picker = pyMRMTransitionGroupPicker(mslevel, peak_picker=peak_picker_param.peak_picker)
                 peak_features = peak_picker.pick(tr_group)
                 tr_group_feature_data[file] = peak_features
 
-        st.write(f"Performing pyPeakPickerMRM Peak Picking... Elapsed time: {elapsed_time()}")
+        st.write(f"Performing pyPeakPickerChromatogram Peak Picking... Elapsed time: {elapsed_time()}")
         return tr_group_feature_data
 
     def perform_mrmtransitiongrouppicker_peak_picking(self, tr_group_data: TransitionGroupFeatureCollection) -> TransitionGroupFeatureCollection:
@@ -131,7 +131,7 @@ def perform_peak_picking(self,
         tr_group_feature_data = {}
 
         # Perform peak picking based on the selected method
-        if self.peak_picking_settings.do_peak_picking == 'pyPeakPickerMRM':
+        if self.peak_picking_settings.do_peak_picking == 'pyPeakPickerChromatogram':
             tr_group_feature_data = self.perform_pypeakpicker_mrm_peak_picking(tr_group_data)
         elif self.peak_picking_settings.do_peak_picking == 'MRMTransitionGroupPicker':
             tr_group_feature_data = self.perform_mrmtransitiongrouppicker_peak_picking(tr_group_data)

massdash/ui/PeakPickingUISettings.py

@@ -7,7 +7,7 @@
 
 # UI
 from .ChromatogramPlotUISettings import ChromatogramPlotUISettings
-from .pyPeakPickerMRMUISettings import pyPeakPickerMRMUISettings
+from .pyPeakPickerChromatogramUISettings import pyPeakPickerChromatogramUISettings
 from .ConformerPickerUISettings import ConformerPickerUISettings
 from .MRMTransitionGroupPickerUISettings import MRMTransitionGroupPickerUISettings
 
@@ -20,7 +20,7 @@ class PeakPickingUISettings:
         The type of peak picking to perform. Defaults to 'none'.
     peak_pick_on_displayed_chrom : bool
         Whether to perform peak picking on the displayed chromatogram. Defaults to True.
-    peak_picker_algo_settings : pyPeakPickerMRMUISettings/MRMTransitionGroupPickerUISettings
+    peak_picker_algo_settings : pyPeakPickerChromatogramUISettings/MRMTransitionGroupPickerUISettings
     isStreamlitCloud (bool): Set to True if running (or emulate running) on streamlit cloud, if False not on the cloud
     
     Methods:
@@ -47,14 +47,14 @@ def create_ui(self, plot_settings: ChromatogramPlotUISettings):
         st.sidebar.title("Peak Picking")
 
         ## Perform Peak Picking
-        self.do_peak_picking = st.sidebar.selectbox("Peak Picking", ['none', 'Feature File Boundaries', 'pyPeakPickerMRM', 'MRMTransitionGroupPicker', 'Conformer'], help="Peak picking method to use.")
+        self.do_peak_picking = st.sidebar.selectbox("Peak Picking", ['none', 'Feature File Boundaries', 'pyPeakPickerChromatogram', 'MRMTransitionGroupPicker', 'Conformer'], help="Peak picking method to use.")
 
         if self.do_peak_picking != 'none':
             ## Perform peak picking on displayed chromatogram, or adjust smoothing separately for peak picking?
             self.peak_pick_on_displayed_chrom = st.sidebar.checkbox("Peak Pick with Displayed Chromatogram", value=True, help="If checked, peak picking will be performed on the displayed chromatogram. If unchecked, peak picking will be performed on the raw chromatogram or you set different smoothing parameters for peak picking.") 
 
-        if self.do_peak_picking == "pyPeakPickerMRM":
-            self.peak_picker_algo_settings = pyPeakPickerMRMUISettings(self)
+        if self.do_peak_picking == "pyPeakPickerChromatogram":
+            self.peak_picker_algo_settings = pyPeakPickerChromatogramUISettings(self)
             self.peak_picker_algo_settings.create_ui(plot_settings)
         elif self.do_peak_picking == "Feature File Boundaries":
             pass

massdash/ui/__init__.py

@@ -16,7 +16,7 @@
 from .MassDashGUI import MassDashGUI
 from .MRMTransitionGroupPickerUISettings import MRMTransitionGroupPickerUISettings
 from .PeakPickingUISettings import PeakPickingUISettings
-from .pyPeakPickerMRMUISettings import pyPeakPickerMRMUISettings
+from .pyPeakPickerChromatogramUISettings import pyPeakPickerChromatogramUISettings
 from .RawTargetedExtractionAnalysisFormUI import RawTargetedExtractionAnalysisFormUI
 from .RawTargetedExtractionAnalysisUI import RawTargetedExtractionAnalysisUI
 from .TransitionListUISettings import TransitionListUISettings
@@ -33,7 +33,7 @@
             "MassDashGUI",
             "MRMTransitionGroupPickerUISettings",
             "PeakPickingUISettings",
-            "pyPeakPickerMRMUISettings",
+            "pyPeakPickerChromatogramUISettings",
             "RawTargetedExtractionAnalysisFormUI",
             "RawTargetedExtractionAnalysisUI",
             "TransitionListUISettings" ]