masster 0.4.18__py3-none-any.whl → 0.4.20__py3-none-any.whl

masster/__init__.py

@@ -27,5 +27,4 @@ __all__ = [
     "Study",
     "Wizard",
     "__version__",
-    #    "get_version",
 ]

masster/_version.py

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

masster/logger.py

@@ -55,6 +55,9 @@ class MassterLogger:
         # Convert string sink to actual object
         if sink == "sys.stdout" or sink is None:
             self.sink = sys.stdout
+        elif isinstance(sink, str) and sink != "sys.stdout":
+            # If it's a file path string, open the file for writing
+            self.sink = open(sink, "a", encoding="utf-8")
         else:
             self.sink = sink
 
@@ -67,6 +70,21 @@ class MassterLogger:
         # Remove any existing handlers to prevent duplicates
         if self.logger_instance.hasHandlers():
             self.logger_instance.handlers.clear()
+        
+        # Also ensure no duplicate handlers on parent loggers
+        parent = self.logger_instance.parent
+        while parent:
+            if parent.name == "masster" and parent.hasHandlers():
+                # Remove duplicate handlers from masster parent logger
+                unique_handlers = []
+                handler_types = set()
+                for handler in parent.handlers:
+                    handler_type = type(handler)
+                    if handler_type not in handler_types:
+                        unique_handlers.append(handler)
+                        handler_types.add(handler_type)
+                parent.handlers = unique_handlers
+            parent = parent.parent
 
         self.logger_instance.setLevel(getattr(logging, self.level))
 
@@ -129,6 +147,17 @@ class MassterLogger:
 
         # Prevent propagation to avoid duplicate messages
         self.logger_instance.propagate = False
+        
+        # Additional fix: ensure no duplicate handlers in the entire logging hierarchy
+        masster_logger = logging.getLogger("masster")
+        if masster_logger.hasHandlers():
+            # Keep only one handler per type
+            unique_handlers = {}
+            for handler in masster_logger.handlers:
+                handler_key = (type(handler).__name__, getattr(handler, 'stream', None))
+                if handler_key not in unique_handlers:
+                    unique_handlers[handler_key] = handler
+            masster_logger.handlers = list(unique_handlers.values())
 
     def update_level(self, level: str):
         """Update the logging level."""
@@ -326,7 +355,20 @@ class MassterLogger:
         """Remove this logger's handler."""
         if self.handler:
             self.logger_instance.removeHandler(self.handler)
+            # Close the file handle if it's not stdout
+            if hasattr(self.sink, 'close') and self.sink != sys.stdout:
+                try:
+                    self.sink.close()
+                except Exception:
+                    pass  # Ignore close errors
             self.handler = None
 
+    def __del__(self):
+        """Cleanup when the logger is destroyed."""
+        try:
+            self.remove()
+        except Exception:
+            pass  # Ignore cleanup errors during destruction
+
     def __repr__(self):
         return f"MassterLogger(type={self.instance_type}, id={self.instance_id}, level={self.level})"

masster/sample/load.py

@@ -37,21 +37,22 @@ See Also:
 """
 
 import os
-
+import warnings
 from datetime import datetime
 
 import numpy as np
 import pandas as pd
 import polars as pl
-import pyopenms as oms
-
 from tqdm import tqdm
 
 from masster.chromatogram import Chromatogram
-
-# Parameters removed - using hardcoded defaults
 from masster.spectrum import Spectrum
 
+# Import pyopenms with suppressed warnings
+with warnings.catch_warnings():
+    warnings.filterwarnings("ignore", message="Warning: OPENMS_DATA_PATH environment variable already exists.*", category=UserWarning)
+    import pyopenms as oms
+
 
 def load(
     self,

masster/sample/sample.py

@@ -56,15 +56,6 @@ from masster.sample.helpers import _estimate_memory_usage
 from masster.sample.helpers import _get_scan_uids
 from masster.sample.helpers import _get_feature_uids
 from masster.sample.helpers import _features_sync
-
-# from masster.sample.helpers import _parse_adduct_specs
-# from masster.sample.helpers import _calculate_adduct_mass_shift
-# from masster.sample.helpers import _parse_formula_expression
-# from masster.sample.helpers import _calculate_molecular_mass
-# from masster.sample.helpers import _parse_legacy_adduct_format
-# from masster.sample.helpers import _extract_adduct_probability
-# from masster.sample.helpers import _detect_adduct_groups_direct
-# from masster.sample.helpers import _check_adduct_relationship
 from masster.sample.adducts import _get_adducts
 from masster.sample.adducts import find_adducts
 from masster.sample.helpers import features_delete

masster/study/defaults/merge_def.py

@@ -1,7 +1,7 @@
 """Parameter class for Study merge method."""
 
 from dataclasses import dataclass, field
-from typing import Any
+from typing import Any, Optional
 
 
 @dataclass
@@ -36,6 +36,9 @@ class merge_defaults:
     max_nr_conflicts: int = 0
     link_ms2: bool = True
     
+    # Parallel processing parameters
+    threads: Optional[int] = None
+    
     # KD-Strict specific parameters
     optimize_rt_tol: bool = False
     rt_tol_range: tuple = (0.5, 4.0)  
@@ -115,6 +118,14 @@ class merge_defaults:
                 "description": "Whether to link MS2 spectra to consensus features",
                 "default": True,
             },
+            # Parallel processing parameters
+            "threads": {
+                "dtype": [int, type(None)],
+                "description": "Number of parallel threads/processes for chunked methods (None=original sequential)",
+                "default": None,
+                "min_value": 1,
+                "max_value": 32,
+            },
             # KD-Strict specific parameters
             "optimize_rt_tol": {
                 "dtype": bool,
@@ -217,7 +228,37 @@ class merge_defaults:
         metadata = self._param_metadata[param_name]
         expected_dtype = metadata["dtype"]
 
-        # Type checking
+        # Handle Optional types (list of types including None)
+        if isinstance(expected_dtype, list):
+            # Check if value matches any of the allowed types
+            valid_type = False
+            for dtype in expected_dtype:
+                if dtype is type(None) and value is None:
+                    return True  # None is explicitly allowed
+                elif dtype is int and isinstance(value, int):
+                    valid_type = True
+                    break
+                elif dtype is float and isinstance(value, (int, float)):
+                    valid_type = True
+                    break
+                elif dtype is bool and isinstance(value, bool):
+                    valid_type = True
+                    break
+                elif dtype is str and isinstance(value, str):
+                    valid_type = True
+                    break
+            
+            if not valid_type:
+                return False
+            
+            # For None values, skip further validation
+            if value is None:
+                return True
+            
+            # Use the first non-None type for range validation
+            expected_dtype = next((dt for dt in expected_dtype if dt is not type(None)), expected_dtype[0])
+
+        # Type checking for non-Optional types
         if expected_dtype is int:
             if not isinstance(value, int):
                 try:

masster/study/helpers.py

@@ -641,20 +641,61 @@ def get_gaps_stats(self, uids=None):
 
 
 # TODO is uid not supposed to be a list anymore?
-def get_consensus_matches(self, uids=None):
+def get_consensus_matches(self, uids=None, filled=True):
+    """
+    Get feature matches for consensus UIDs with optimized join operation.
+    
+    Parameters:
+        uids: Consensus UID(s) to get matches for. Can be:
+              - None: get matches for all consensus features
+              - int: single consensus UID (converted to list)
+              - list: multiple consensus UIDs
+        filled (bool): Whether to include filled rows (True) or exclude them (False).
+                      Default is True to maintain backward compatibility.
+    
+    Returns:
+        pl.DataFrame: Feature matches for the specified consensus UIDs
+    """
+    # Handle single int by converting to list
+    if isinstance(uids, int):
+        uids = [uids]
+    
     uids = self._get_consensus_uids(uids)
-
-    # find all rows in consensus_mapping_df with consensus_id=id - use Polars filtering
-    fid = (
-        self.consensus_mapping_df.filter(
-            pl.col("consensus_uid").is_in(uids),
+    
+    if not uids:
+        return pl.DataFrame()
+    
+    # Early validation checks
+    if self.consensus_mapping_df is None or self.consensus_mapping_df.is_empty():
+        self.logger.warning("No consensus mapping data available")
+        return pl.DataFrame()
+    
+    if self.features_df is None or self.features_df.is_empty():
+        self.logger.warning("No feature data available")
+        return pl.DataFrame()
+    
+    # Build the query with optional filled filter
+    features_query = self.features_df.lazy()
+    
+    # Apply filled filter if specified
+    if not filled and "filled" in self.features_df.columns:
+        features_query = features_query.filter(~pl.col("filled"))
+    
+    # Optimized single-pass operation using join instead of two separate filters
+    # This avoids creating intermediate Python lists and leverages Polars' optimized joins
+    matches = (
+        features_query
+        .join(
+            self.consensus_mapping_df
+            .lazy()
+            .filter(pl.col("consensus_uid").is_in(uids))
+            .select("feature_uid"),  # Only select what we need for the join
+            on="feature_uid",
+            how="inner"
         )
-        .select("feature_uid")
-        .to_series()
-        .to_list()
+        .collect(streaming=True)  # Use streaming for memory efficiency with large datasets
     )
-    # select all rows in features_df with uid in fid
-    matches = self.features_df.filter(pl.col("feature_uid").is_in(fid)).clone()
+    
     return matches