masster 0.5.7__py3-none-any.whl → 0.5.9__py3-none-any.whl

masster/_version.py

@@ -1,7 +1,7 @@
 from __future__ import annotations
 
 
-__version__ = "0.5.7"
+__version__ = "0.5.9"
 
 
 def get_version():

masster/logger.py

@@ -3,15 +3,15 @@
 Simple logger system for masster Study and Sample instances.
 Uses basic Python logging                timestamp = dt.strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]
 
-                # Loguru-style colors for different log levels
+                # Universal colors compatible with both dark and light themes
                 level_colors = {
-                    'TRACE': '\x1b[34m',      # blue
-                    'DEBUG': '\x1b[36m',      # cyan
-                    'INFO': '\x1b[37m',       # white
-                    'SUCCESS': '\x1b[32m',    # green
-                    'WARNING': '\x1b[33m',    # yellow
-                    'ERROR': '\x1b[31m',      # red
-                    'CRITICAL': '\x1b[35m',   # magenta
+                    'TRACE': '\x1b[94m',      # bright blue (readable on both dark/light)
+                    'DEBUG': '\x1b[96m',      # bright cyan (readable on both dark/light)  
+                    'INFO': '\x1b[90m',       # bright black/gray (readable on both dark/light)
+                    'SUCCESS': '\x1b[92m',    # bright green (readable on both dark/light)
+                    'WARNING': '\x1b[93m',    # bright yellow (readable on both dark/light)
+                    'ERROR': '\x1b[91m',      # bright red (readable on both dark/light)
+                    'CRITICAL': '\x1b[95m',   # bright magenta (readable on both dark/light)
                 }
 
                 level_str = record.levelname.ljust(8)complex loguru filtering.
@@ -102,19 +102,19 @@ class MassterLogger:
                 dt = datetime.datetime.fromtimestamp(record.created)
                 timestamp = dt.strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]  # Remove last 3 digits for milliseconds
 
-                # Loguru-style colors for different log levels
+                # Universal colors compatible with both dark and light themes
                 level_colors = {
-                    "TRACE": "\x1b[34m",  # blue
-                    "DEBUG": "\x1b[36m",  # cyan
-                    "INFO": "\x1b[37m",  # white
-                    "SUCCESS": "\x1b[32m",  # green
-                    "WARNING": "\x1b[33m",  # yellow
-                    "ERROR": "\x1b[31m",  # red
-                    "CRITICAL": "\x1b[35m",  # magenta
+                    "TRACE": "\x1b[94m",  # bright blue (readable on both dark/light)
+                    "DEBUG": "\x1b[96m",  # bright cyan (readable on both dark/light)
+                    "INFO": "\x1b[90m",   # bright black/gray (readable on both dark/light)
+                    "SUCCESS": "\x1b[92m",  # bright green (readable on both dark/light)
+                    "WARNING": "\x1b[93m",  # bright yellow (readable on both dark/light)
+                    "ERROR": "\x1b[91m",    # bright red (readable on both dark/light)
+                    "CRITICAL": "\x1b[95m", # bright magenta (readable on both dark/light)
                 }
 
                 level_str = record.levelname.ljust(8)
-                level_color = level_colors.get(record.levelname, "\x1b[37m")  # default white
+                level_color = level_colors.get(record.levelname, "\x1b[90m")  # default to gray instead of white
                 label_part = self.label + " | " if self.label else ""
 
                 # For DEBUG and TRACE levels, add module/location information
@@ -133,9 +133,9 @@ class MassterLogger:
                         f"\x1b[90m{module_name}:{func_name}:{line_no}\x1b[0m | "  # dim gray for location info
                     )
 
-                # Loguru-style format: <white>timestamp</white> | <level>LEVEL</level> | <location> | <cyan>label</cyan> - <level>message</level>
+                # Universal format: timestamp | level | location | label - message
                 return (
-                    f"\x1b[37m{timestamp}\x1b[0m | "  # white timestamp
+                    f"\x1b[90m{timestamp}\x1b[0m | "  # gray timestamp (universal for both themes)
                     f"{level_color}{level_str}\x1b[0m | "  # colored level
                     f"{location_info}"  # location info for DEBUG/TRACE
                     f"{level_color}{label_part}\x1b[0m"  # colored label
@@ -181,19 +181,19 @@ class MassterLogger:
                 dt = datetime.datetime.fromtimestamp(record.created)
                 timestamp = dt.strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
 
-                # Loguru-style colors for different log levels
+                # Universal colors compatible with both dark and light themes
                 level_colors = {
-                    "TRACE": "\x1b[34m",  # blue
-                    "DEBUG": "\x1b[36m",  # cyan
-                    "INFO": "\x1b[37m",  # white
-                    "SUCCESS": "\x1b[32m",  # green
-                    "WARNING": "\x1b[33m",  # yellow
-                    "ERROR": "\x1b[31m",  # red
-                    "CRITICAL": "\x1b[35m",  # magenta
+                    "TRACE": "\x1b[94m",  # bright blue (readable on both dark/light)
+                    "DEBUG": "\x1b[96m",  # bright cyan (readable on both dark/light)
+                    "INFO": "\x1b[90m",   # bright black/gray (readable on both dark/light)
+                    "SUCCESS": "\x1b[92m",  # bright green (readable on both dark/light)
+                    "WARNING": "\x1b[93m",  # bright yellow (readable on both dark/light)
+                    "ERROR": "\x1b[91m",    # bright red (readable on both dark/light)
+                    "CRITICAL": "\x1b[95m", # bright magenta (readable on both dark/light)
                 }
 
                 level_str = record.levelname.ljust(8)
-                level_color = level_colors.get(record.levelname, "\x1b[37m")  # default white
+                level_color = level_colors.get(record.levelname, "\x1b[90m")  # default to gray instead of white
                 label_part = self.label + " | " if self.label else ""
 
                 # For DEBUG and TRACE levels, add module/location information
@@ -212,9 +212,9 @@ class MassterLogger:
                         f"\x1b[90m{module_name}:{func_name}:{line_no}\x1b[0m | "  # dim gray for location info
                     )
 
-                # Loguru-style format: <white>timestamp</white> | <level>LEVEL</level> | <location> | <cyan>label</cyan> - <level>message</level>
+                # Universal format: timestamp | level | location | label - message  
                 return (
-                    f"\x1b[37m{timestamp}\x1b[0m | "  # white timestamp
+                    f"\x1b[90m{timestamp}\x1b[0m | "  # gray timestamp (universal for both themes)
                     f"{level_color}{level_str}\x1b[0m | "  # colored level
                     f"{location_info}"  # location info for DEBUG/TRACE
                     f"{level_color}{label_part}\x1b[0m"  # colored label
@@ -245,19 +245,19 @@ class MassterLogger:
                 dt = datetime.datetime.fromtimestamp(record.created)
                 timestamp = dt.strftime("%Y-%m-%d %H:%M:%S.%f")[:-3]
 
-                # Loguru-style colors for different log levels
+                # Universal colors compatible with both dark and light themes
                 level_colors = {
-                    "TRACE": "\x1b[34m",  # blue
-                    "DEBUG": "\x1b[36m",  # cyan
-                    "INFO": "\x1b[37m",  # white
-                    "SUCCESS": "\x1b[32m",  # green
-                    "WARNING": "\x1b[33m",  # yellow
-                    "ERROR": "\x1b[31m",  # red
-                    "CRITICAL": "\x1b[35m",  # magenta
+                    "TRACE": "\x1b[94m",  # bright blue (readable on both dark/light)
+                    "DEBUG": "\x1b[96m",  # bright cyan (readable on both dark/light)
+                    "INFO": "\x1b[90m",   # bright black/gray (readable on both dark/light)
+                    "SUCCESS": "\x1b[92m",  # bright green (readable on both dark/light)
+                    "WARNING": "\x1b[93m",  # bright yellow (readable on both dark/light)
+                    "ERROR": "\x1b[91m",    # bright red (readable on both dark/light)
+                    "CRITICAL": "\x1b[95m", # bright magenta (readable on both dark/light)
                 }
 
                 level_str = record.levelname.ljust(8)
-                level_color = level_colors.get(record.levelname, "\x1b[37m")  # default white
+                level_color = level_colors.get(record.levelname, "\x1b[90m")  # default to gray instead of white
                 label_part = self.label + " | " if self.label else ""
 
                 # For DEBUG and TRACE levels, add module/location information
@@ -276,9 +276,9 @@ class MassterLogger:
                         f"\x1b[90m{module_name}:{func_name}:{line_no}\x1b[0m | "  # dim gray for location info
                     )
 
-                # Loguru-style format: <white>timestamp</white> | <level>LEVEL</level> | <location> | <cyan>label</cyan> - <level>message</level>
+                # Universal format: timestamp | level | location | label - message  
                 return (
-                    f"\x1b[37m{timestamp}\x1b[0m | "  # white timestamp
+                    f"\x1b[90m{timestamp}\x1b[0m | "  # gray timestamp (universal for both themes)
                     f"{level_color}{level_str}\x1b[0m | "  # colored level
                     f"{location_info}"  # location info for DEBUG/TRACE
                     f"{level_color}{label_part}\x1b[0m"  # colored label
@@ -332,8 +332,22 @@ class MassterLogger:
         self.logger_instance.info(message, *args, **kwargs)
 
     def success(self, message: str, *args, **kwargs):
-        """Log a SUCCESS level message (mapped to INFO)."""
-        self.info(message, *args, **kwargs)
+        """Log a SUCCESS level message (custom level)."""
+        # Create a custom log record with SUCCESS level
+        import logging
+        
+        # Create a LogRecord manually with SUCCESS level
+        record = self.logger_instance.makeRecord(
+            self.logger_instance.name,
+            logging.INFO,  # Use INFO level for Python's filtering
+            "", 0, message, args, None, func="success"
+        )
+        # Override the levelname for display
+        record.levelname = "SUCCESS"
+        
+        # Handle the record directly through our handler
+        if self.handler:
+            self.handler.handle(record)
 
     def warning(self, message: str, *args, **kwargs):
         """Log a WARNING level message."""
@@ -372,3 +386,4 @@ class MassterLogger:
 
     def __repr__(self):
         return f"MassterLogger(type={self.instance_type}, id={self.instance_id}, level={self.level})"
+

masster/sample/h5.py

@@ -295,7 +295,7 @@ def _save_sample5(
 
         # Store lib and lib_match - removed (no longer saving lib data)
 
-    self.logger.info(f"Sample saved to {filename}")
+    self.logger.success(f"Sample saved to {filename}")
     if save_featurexml:
         # Get or recreate the feature map if needed
         feature_map = self._get_feature_map()

masster/sample/plot.py

@@ -234,7 +234,7 @@ def _handle_sample_plot_output(self, plot_obj, filename=None, plot_type="bokeh")
                 from bokeh.io import save
                 output_file(filename)
                 save(plot_obj)
-            self.logger.info(f"Plot saved to: {abs_filename}")
+            self.logger.success(f"Plot saved to: {abs_filename}")
         elif filename.endswith(".png"):
             try:
                 if plot_type == "bokeh":
@@ -243,7 +243,7 @@ def _handle_sample_plot_output(self, plot_obj, filename=None, plot_type="bokeh")
                 elif plot_type in ["panel", "holoviews"]:
                     import holoviews as hv
                     hv.save(plot_obj, filename, fmt="png")
-                self.logger.info(f"Plot saved to: {abs_filename}")
+                self.logger.success(f"Plot saved to: {abs_filename}")
             except Exception:
                 # Fall back to HTML if PNG export not available
                 html_filename = filename.replace('.png', '.html')
@@ -268,7 +268,7 @@ def _handle_sample_plot_output(self, plot_obj, filename=None, plot_type="bokeh")
                 elif plot_type in ["panel", "holoviews"]:
                     import holoviews as hv
                     hv.save(plot_obj, filename, fmt="pdf")
-                self.logger.info(f"Plot saved to: {abs_filename}")
+                self.logger.success(f"Plot saved to: {abs_filename}")
             except ImportError:
                 # Fall back to HTML if PDF export not available
                 html_filename = filename.replace('.pdf', '.html')
@@ -296,7 +296,7 @@ def _handle_sample_plot_output(self, plot_obj, filename=None, plot_type="bokeh")
                 from bokeh.io import save
                 output_file(filename)
                 save(plot_obj)
-            self.logger.info(f"Plot saved to: {abs_filename}")
+            self.logger.success(f"Plot saved to: {abs_filename}")
     else:
         # Show in notebook when no filename provided
         if plot_type == "panel":

masster/sample/processing.py

@@ -796,7 +796,7 @@ def find_features(self, **kwargs):
 
     self.features_df = df
     #self._features_sync()
-    self.logger.info(f"Feature detection completed. Total features: {len(df)}")
+    self.logger.success(f"Feature detection completed. Total features: {len(df)}")
 
     # store params
     self.update_history(["find_features"], params.to_dict())
@@ -1263,7 +1263,7 @@ def find_ms2(self, **kwargs):
         )
 
     # Log completion
-    self.logger.info(
+    self.logger.success(
         f"MS2 linking completed. Total features with MS2 data: {c}",
     )
     self.features_df = features_df
@@ -1425,7 +1425,7 @@ def find_iso(self, rt_tolerance: float = 0.1, **kwargs):
     
     # Log results
     non_null_count = len([spec for spec in ms1_specs if spec is not None])
-    self.logger.info(f"Extracted isotopic distributions for {non_null_count}/{len(ms1_specs)} features.")
+    self.logger.success(f"Extracted isotopic distributions for {non_null_count}/{len(ms1_specs)} features.")
     
     # Store parameters in history
     params_dict = {"rt_tolerance": rt_tolerance}

masster/sample/save.py

@@ -148,10 +148,10 @@ def export_features(self, filename="features.csv"):
     )
     if filename.lower().endswith((".xls", ".xlsx")):
         clean_df.to_pandas().to_excel(filename, index=False)
-        self.logger.info(f"Features exported to {filename} (Excel format)")
+        self.logger.success(f"Features exported to {filename} (Excel format)")
     else:
         clean_df.write_csv(filename)
-        self.logger.info(f"Features exported to {filename}")
+        self.logger.success(f"Features exported to {filename}")
 
 
 def export_mgf(
@@ -649,7 +649,7 @@ def export_mgf(
                             elif result == "empty_ms2":
                                 empty_ms2_count += 1
 
-    self.logger.info(f"Exported {ms1_spec_used_count} MS1 spectra and {c} MS2 spectra to {filename}")
+    self.logger.success(f"Exported {ms1_spec_used_count} MS1 spectra and {c} MS2 spectra to {filename}")
     if empty_ms2_count > 0:
         self.logger.info(f"Skipped {empty_ms2_count} empty MS2 spectra")
     if ms1_fallback_count > 0:
@@ -824,7 +824,7 @@ def export_dda_stats(self, filename="stats.csv"):
         for line in lines:
             f.write(line + "\n")
 
-    self.logger.info(f"DDA statistics exported to {filename}")
+    self.logger.success(f"DDA statistics exported to {filename}")
 
 
 def export_xlsx(self, filename="features.xlsx"):
@@ -877,7 +877,7 @@ def export_xlsx(self, filename="features.xlsx"):
     pandas_df = clean_df.to_pandas()
     pandas_df.to_excel(filename, index=False)
     
-    self.logger.info(f"Features exported to {filename} (Excel format)")
+    self.logger.success(f"Features exported to {filename} (Excel format)")
     self.logger.debug(f"Exported {len(clean_df)} features with {len(exportable_columns)} columns")
 
 

masster/study/h5.py

@@ -1738,7 +1738,7 @@ def _save_study5(self, filename):
                 )
                 pbar.update(1)
 
-    self.logger.info(f"Study saved successfully to {filename}")
+    self.logger.success(f"Study saved successfully to {filename}")
     self.logger.debug(f"Save completed for {filename}")
     self.logger.debug(f"Save completed for {filename}")
 

masster/study/helpers.py

@@ -1440,7 +1440,7 @@ def compress(self, features=True, ms2=True, chrom=False, ms2_max=5):
         self.compress_ms2(max_replicates=ms2_max)
     if chrom:
         self.compress_chrom()
-    self.logger.info("Compression completed")
+    self.logger.success("Compression completed")
 
 
 def compress_features(self):
@@ -1886,7 +1886,7 @@ def restore_chrom(self, samples=None, mz_tol=0.010, rt_tol=10.0):
             self.logger.error(f"Failed to gap-fill sample {sample_name}: {e}")
             continue
 
-    self.logger.info(f"Phase 2 complete: Gap-filled {filled_count} chromatograms")
+    self.logger.success(f"Phase 2 complete: Gap-filled {filled_count} chromatograms")
 
     # Final summary
     final_non_null = self.features_df.filter(pl.col("chrom").is_not_null()).height
@@ -2051,7 +2051,7 @@ def sample_name_replace(self, replace_dict):
         pl.Series("sample_name", new_names).alias("sample_name"),
     )
 
-    self.logger.info(f"Successfully replaced {replaced_count} sample names")
+    self.logger.success(f"Successfully replaced {replaced_count} sample names")
 
 
 def sample_name_reset(self):
@@ -2956,6 +2956,17 @@ def consensus_select(
     rt_delta_mean=None,
     id_top_score=None,
     identified=None,
+    # New adduct filter parameters
+    adduct_top=None,
+    adduct_charge_top=None,
+    adduct_mass_neutral_top=None,
+    adduct_mass_shift_top=None,
+    adduct_group=None,
+    adduct_of=None,
+    # New identification filter parameters
+    id_top_name=None,
+    id_top_class=None,
+    id_top_adduct=None,
     sortby=None,
     descending=True,
 ):
@@ -2990,6 +3001,17 @@ def consensus_select(
             - True: select only rows with id_top_name not null
             - False: select only rows with id_top_name null
             - None: no filtering (default)
+        # New adduct filter parameters
+        adduct_top: adduct type filter (list or single string value, e.g. "[M+H]+", "[M+Na]+")
+        adduct_charge_top: adduct charge filter (tuple for range, single value for exact match)
+        adduct_mass_neutral_top: neutral mass filter (tuple for range, single value for minimum)
+        adduct_mass_shift_top: adduct mass shift filter (tuple for range, single value for minimum)
+        adduct_group: adduct group ID filter (list, single value, or tuple for range)
+        adduct_of: adduct representative UID filter (list, single value, or tuple for range)
+        # New identification filter parameters
+        id_top_name: identification name filter (list or single string value for compound names)
+        id_top_class: identification class filter (list or single string value for compound classes)
+        id_top_adduct: identification adduct filter (list or single string value for identified adducts)
         sortby: column name(s) to sort by (string, list of strings, or None for no sorting)
         descending: sort direction (True for descending, False for ascending, default is True)
 
@@ -3004,7 +3026,10 @@ def consensus_select(
     filter_params = [mz, rt, inty_mean, consensus_uid, consensus_id, number_samples, 
                     number_ms2, quality, bl, chrom_coherence_mean, chrom_prominence_mean,
                     chrom_prominence_scaled_mean, chrom_height_scaled_mean, 
-                    rt_delta_mean, id_top_score, identified]
+                    rt_delta_mean, id_top_score, identified,
+                    # New adduct and identification parameters
+                    adduct_top, adduct_charge_top, adduct_mass_neutral_top, adduct_mass_shift_top,
+                    adduct_group, adduct_of, id_top_name, id_top_class, id_top_adduct]
     
     if all(param is None for param in filter_params) and sortby is None:
         return self.consensus_df.clone()
@@ -3132,6 +3157,126 @@ def consensus_select(
         else:
             warnings.append("'id_top_name' column not found in consensus_df")
 
+    # Handle adduct_top filter (string or list)
+    if adduct_top is not None:
+        if "adduct_top" in available_columns:
+            if isinstance(adduct_top, list):
+                filter_conditions.append(pl.col("adduct_top").is_in(adduct_top))
+            else:
+                filter_conditions.append(pl.col("adduct_top") == adduct_top)
+        else:
+            warnings.append("'adduct_top' column not found in consensus_df")
+
+    # Handle adduct_charge_top filter (single value, range tuple, or list)
+    if adduct_charge_top is not None:
+        if "adduct_charge_top" in available_columns:
+            if isinstance(adduct_charge_top, tuple) and len(adduct_charge_top) == 2:
+                filter_conditions.append(
+                    (pl.col("adduct_charge_top") >= adduct_charge_top[0]) &
+                    (pl.col("adduct_charge_top") <= adduct_charge_top[1])
+                )
+            elif isinstance(adduct_charge_top, list):
+                filter_conditions.append(pl.col("adduct_charge_top").is_in(adduct_charge_top))
+            else:
+                filter_conditions.append(pl.col("adduct_charge_top") == adduct_charge_top)
+        else:
+            warnings.append("'adduct_charge_top' column not found in consensus_df")
+
+    # Handle adduct_mass_neutral_top filter (single value, range tuple, or list)
+    if adduct_mass_neutral_top is not None:
+        if "adduct_mass_neutral_top" in available_columns:
+            if isinstance(adduct_mass_neutral_top, tuple) and len(adduct_mass_neutral_top) == 2:
+                filter_conditions.append(
+                    (pl.col("adduct_mass_neutral_top") >= adduct_mass_neutral_top[0]) &
+                    (pl.col("adduct_mass_neutral_top") <= adduct_mass_neutral_top[1])
+                )
+            elif isinstance(adduct_mass_neutral_top, list):
+                filter_conditions.append(pl.col("adduct_mass_neutral_top").is_in(adduct_mass_neutral_top))
+            else:
+                filter_conditions.append(pl.col("adduct_mass_neutral_top") == adduct_mass_neutral_top)
+        else:
+            warnings.append("'adduct_mass_neutral_top' column not found in consensus_df")
+
+    # Handle adduct_mass_shift_top filter (single value, range tuple, or list)
+    if adduct_mass_shift_top is not None:
+        if "adduct_mass_shift_top" in available_columns:
+            if isinstance(adduct_mass_shift_top, tuple) and len(adduct_mass_shift_top) == 2:
+                filter_conditions.append(
+                    (pl.col("adduct_mass_shift_top") >= adduct_mass_shift_top[0]) &
+                    (pl.col("adduct_mass_shift_top") <= adduct_mass_shift_top[1])
+                )
+            elif isinstance(adduct_mass_shift_top, list):
+                filter_conditions.append(pl.col("adduct_mass_shift_top").is_in(adduct_mass_shift_top))
+            else:
+                filter_conditions.append(pl.col("adduct_mass_shift_top") == adduct_mass_shift_top)
+        else:
+            warnings.append("'adduct_mass_shift_top' column not found in consensus_df")
+
+    # Handle adduct_group filter (single value or list)
+    if adduct_group is not None:
+        if "adduct_group" in available_columns:
+            if isinstance(adduct_group, list):
+                filter_conditions.append(pl.col("adduct_group").is_in(adduct_group))
+            else:
+                filter_conditions.append(pl.col("adduct_group") == adduct_group)
+        else:
+            warnings.append("'adduct_group' column not found in consensus_df")
+
+    # Handle adduct_of filter (single value or list)
+    if adduct_of is not None:
+        if "adduct_of" in available_columns:
+            if isinstance(adduct_of, list):
+                filter_conditions.append(pl.col("adduct_of").is_in(adduct_of))
+            else:
+                filter_conditions.append(pl.col("adduct_of") == adduct_of)
+        else:
+            warnings.append("'adduct_of' column not found in consensus_df")
+
+    # Handle id_top_name filter (string or list)
+    if id_top_name is not None:
+        if "id_top_name" in available_columns:
+            if isinstance(id_top_name, list):
+                filter_conditions.append(pl.col("id_top_name").is_in(id_top_name))
+            else:
+                filter_conditions.append(pl.col("id_top_name") == id_top_name)
+        else:
+            warnings.append("'id_top_name' column not found in consensus_df")
+
+    # Handle id_top_class filter (string or list)
+    if id_top_class is not None:
+        if "id_top_class" in available_columns:
+            if isinstance(id_top_class, list):
+                filter_conditions.append(pl.col("id_top_class").is_in(id_top_class))
+            else:
+                filter_conditions.append(pl.col("id_top_class") == id_top_class)
+        else:
+            warnings.append("'id_top_class' column not found in consensus_df")
+
+    # Handle id_top_adduct filter (string or list)
+    if id_top_adduct is not None:
+        if "id_top_adduct" in available_columns:
+            if isinstance(id_top_adduct, list):
+                filter_conditions.append(pl.col("id_top_adduct").is_in(id_top_adduct))
+            else:
+                filter_conditions.append(pl.col("id_top_adduct") == id_top_adduct)
+        else:
+            warnings.append("'id_top_adduct' column not found in consensus_df")
+
+    # Handle id_top_score filter (single value, range tuple, or list)
+    if id_top_score is not None:
+        if "id_top_score" in available_columns:
+            if isinstance(id_top_score, tuple) and len(id_top_score) == 2:
+                filter_conditions.append(
+                    (pl.col("id_top_score") >= id_top_score[0]) &
+                    (pl.col("id_top_score") <= id_top_score[1])
+                )
+            elif isinstance(id_top_score, list):
+                filter_conditions.append(pl.col("id_top_score").is_in(id_top_score))
+            else:
+                filter_conditions.append(pl.col("id_top_score") == id_top_score)
+        else:
+            warnings.append("'id_top_score' column not found in consensus_df")
+
     # Log warnings once
     for warning in warnings:
         self.logger.warning(warning)
@@ -4477,7 +4622,7 @@ def decompress(self, features=True, ms2=True, chrom=True, samples=None, **kwargs
 
             self.restore_ms2(samples=samples, **ms2_kwargs)
 
-        self.logger.info("Adaptive decompression completed successfully")
+        self.logger.success("Adaptive decompression completed successfully")
 
     except Exception as e:
         self.logger.error(f"Decompression failed: {e}")

masster/study/id.py

@@ -1093,7 +1093,7 @@ def id_reset(study):
         del study.history["identify"]
 
     if logger:
-        logger.info("Identification data reset completed")
+        logger.success("Identification data reset completed")
 
 
 def lib_reset(study):
@@ -1198,10 +1198,10 @@ def lib_reset(study):
             del study.history["lib_to_consensus"]
 
     if logger:
-        logger.info("Library and identification data reset completed")
+        logger.success("Library and identification data reset completed")
 
 
-def _get_adducts(study, adducts_list: list = None, **kwargs):
+def _get_adducts(study, adducts_list: list | None = None, **kwargs):
     """
     Generate comprehensive adduct specifications for study-level adduct filtering.
 
@@ -1978,4 +1978,4 @@ def lib_to_consensus(study, chrom_fhwm: float = 5.0, mz_tol: float = 0.01, rt_to
             logger.warning(f"find_ms2 failed: {e}")
     
     if logger:
-        logger.info(f"lib_to_consensus completed: {len(consensus_metadata)} features added")
+        logger.success(f"lib_to_consensus completed: {len(consensus_metadata)} features added")