masster 0.3.10__py3-none-any.whl → 0.3.11__py3-none-any.whl

masster/sample/sciex.py

@@ -146,7 +146,7 @@ def dot_net_array_to_np_array(src):
         src_ptr = src_hndl.AddrOfPinnedObject().ToInt64()
         buf_type = ctypes.c_double * len(src)
         cbuf = buf_type.from_address(src_ptr)
-        dest = np.frombuffer(cbuf, dtype='float64').copy()  # type: ignore[call-overload]
+        dest = np.frombuffer(cbuf, dtype="float64").copy()  # type: ignore[call-overload]
     finally:
         if src_hndl.IsAllocated:
             src_hndl.Free()
@@ -156,19 +156,19 @@ def dot_net_array_to_np_array(src):
 class SciexWiff2FileReader:
     """
     Specialized reader for Sciex WIFF2 files using optimal DLL combination.
-    
+
     WIFF2 is a newer format from Sciex that may have enhanced capabilities
     compared to the original WIFF format. This reader is optimized specifically
     for WIFF2 files and uses the most appropriate DLLs for maximum information extraction.
-    
+
     Based on comprehensive DLL analysis, WIFF2 files require specific handling and
     may use different underlying storage mechanisms than regular WIFF files.
     """
-    
+
     def __init__(self, filename: str):
         """
         Initialize WIFF2 reader with file path.
-        
+
         Parameters
         ----------
         filename : str
@@ -177,44 +177,45 @@ class SciexWiff2FileReader:
         if not HAS_DOTNET:
             raise ValueError(
                 "Dotnet-based dependencies are required for reading Sciex WIFF2 files. "
-                "Install pythonnet and ensure alpharaw DLLs are available."
+                "Install pythonnet and ensure alpharaw DLLs are available.",
             )
-        
+
         self.filename = filename
         self.ext_dir = self._find_dll_directory()
         self._ensure_wiff2_dlls_loaded()
-        
+
         # Try different initialization strategies for WIFF2
         self._initialize_wiff2_reader()
-    
+
     def _find_dll_directory(self):
         """Find the alpharaw DLL directory using the same discovery pattern."""
         for site_dir in site.getsitepackages():
             potential_ext_dir = os.path.join(site_dir, "alpharaw", "ext", "sciex")
             if os.path.exists(potential_ext_dir):
                 return potential_ext_dir
-        
+
         # Fallback to alpharaw module location
         try:
             import alpharaw
+
             alpharaw_dir = os.path.dirname(alpharaw.__file__)
             return os.path.join(alpharaw_dir, "ext", "sciex")
         except ImportError:
             raise ImportError("Could not find alpharaw DLL directory")
-    
+
     def _ensure_wiff2_dlls_loaded(self):
         """Ensure all necessary WIFF2 DLLs are loaded."""
         # Key DLLs identified through comprehensive analysis
         required_dlls = [
             "Clearcore2.Data.Wiff2.dll",  # Primary WIFF2 support
-            "Clearcore2.Data.AnalystDataProvider.dll", 
+            "Clearcore2.Data.AnalystDataProvider.dll",
             "Clearcore2.Data.dll",
             "Clearcore2.Data.Common.dll",
             "Clearcore2.Data.Core.dll",
             "Clearcore2.StructuredStorage.dll",  # For WIFF2 storage format
-            "WiffOps4Python.dll"
+            "WiffOps4Python.dll",
         ]
-        
+
         for dll in required_dlls:
             dll_path = os.path.join(self.ext_dir, dll)
             if os.path.exists(dll_path):
@@ -224,77 +225,77 @@ class SciexWiff2FileReader:
                     pass  # May already be loaded
             else:
                 warnings.warn(f"WIFF2 DLL not found: {dll}", stacklevel=2)
-    
+
     def _initialize_wiff2_reader(self):
         """
         Initialize WIFF2 reader with fallback strategies.
-        
+
         WIFF2 files may require different initialization approaches than WIFF files.
         We try multiple strategies based on the comprehensive DLL analysis.
         """
         initialization_errors = []
-        
+
         # Strategy 1: Try standard AnalystDataProvider (may work for some WIFF2)
         try:
             from Clearcore2.Data.AnalystDataProvider import AnalystDataProviderFactory
             from Clearcore2.Data.AnalystDataProvider import AnalystWiffDataProvider
-            
+
             self._wiffDataProvider = AnalystWiffDataProvider()
             self._wiff_file = AnalystDataProviderFactory.CreateBatch(
                 self.filename,
                 self._wiffDataProvider,
             )
-            
+
             self.sample_names = self._wiff_file.GetSampleNames()
             self.sample_count = len(self.sample_names)
             self.initialization_method = "AnalystDataProvider"
             return
-            
+
         except Exception as e:
             initialization_errors.append(f"AnalystDataProvider: {e}")
-        
+
         # Strategy 2: Try alpharaw's SciexWiffData (correct API)
         try:
             from alpharaw.sciex import SciexWiffData
-            
+
             self._alpharaw_reader = SciexWiffData()
             self._alpharaw_reader.import_raw(self.filename)
-            
+
             # Extract basic information (SciexWiffData doesn't have sample_names property)
-            self.sample_names = ['Sample_0']  # Default since WIFF2 format needs investigation
+            self.sample_names = ["Sample_0"]  # Default since WIFF2 format needs investigation
             self.sample_count = 1
             self.initialization_method = "alpharaw_SciexWiffData"
-            
+
             # Store the reader for later use
             self._wiff_data = self._alpharaw_reader
             return
-            
+
         except Exception as e:
             initialization_errors.append(f"alpharaw_SciexWiffData: {e}")
-        
+
         # Strategy 3: Try direct WIFF2 DLL approach
         try:
             # Check if file is recognized as WIFF2
             from Clearcore2.Data.AnalystDataProvider import DataProviderHelper
-            
+
             is_wiff2 = DataProviderHelper.IsMdWiffFile(self.filename)
             if is_wiff2:
                 # Try specialized WIFF2 handling
                 warnings.warn(
-                    f"File detected as WIFF2 format but specialized reader not fully implemented. "
-                    f"Consider using alpharaw.ms_data_from_file() directly.",
-                    stacklevel=2
+                    "File detected as WIFF2 format but specialized reader not fully implemented. "
+                    "Consider using alpharaw.ms_data_from_file() directly.",
+                    stacklevel=2,
                 )
                 # For now, fall back to treating as regular WIFF with enhanced parameters
                 self._initialize_as_enhanced_wiff()
                 return
-            
+
         except Exception as e:
             initialization_errors.append(f"WIFF2 detection: {e}")
-        
+
         # If all strategies fail, provide comprehensive error information with helpful suggestions
         error_summary = "; ".join(initialization_errors)
-        
+
         # Check if this is a WIFF2 format issue specifically
         if "could not be opened (result = -2147286960)" in error_summary:
             raise RuntimeError(
@@ -303,61 +304,60 @@ class SciexWiff2FileReader:
                 f"The file '{self.filename}' appears to be a valid WIFF2 file but requires "
                 f"newer or different DLLs than currently available. "
                 f"Try converting the WIFF2 file to WIFF format or use alternative tools. "
-                f"Full error details: {error_summary}"
+                f"Full error details: {error_summary}",
             )
         else:
             raise RuntimeError(
                 f"Failed to initialize WIFF2 reader with any strategy. "
                 f"Errors: {error_summary}. "
-                f"The file may be corrupted, locked, or require different dependencies."
+                f"The file may be corrupted, locked, or require different dependencies.",
             )
-    
+
     def _initialize_as_enhanced_wiff(self):
         """Fallback: Initialize as enhanced WIFF with WIFF2-optimized parameters."""
         # Use the same initialization as regular WIFF but with warnings
         try:
             from Clearcore2.Data.AnalystDataProvider import AnalystDataProviderFactory
             from Clearcore2.Data.AnalystDataProvider import AnalystWiffDataProvider
-            
+
             self._wiffDataProvider = AnalystWiffDataProvider()
             self._wiff_file = AnalystDataProviderFactory.CreateBatch(
                 self.filename,
                 self._wiffDataProvider,
             )
-            
+
             self.sample_names = self._wiff_file.GetSampleNames()
             self.sample_count = len(self.sample_names)
             self.initialization_method = "enhanced_wiff_fallback"
-            
+
             warnings.warn(
-                "WIFF2 file opened using WIFF reader fallback. "
-                "Some WIFF2-specific features may not be available.",
-                stacklevel=2
+                "WIFF2 file opened using WIFF reader fallback. Some WIFF2-specific features may not be available.",
+                stacklevel=2,
             )
-            
+
         except Exception as e:
             raise RuntimeError(f"Enhanced WIFF fallback also failed: {e}")
 
     def get_file_metadata(self) -> dict[str, Any]:
         """Get comprehensive file metadata for WIFF2 format."""
         metadata: dict[str, Any] = {
-            'format': 'WIFF2',
-            'sample_count': self.sample_count,
-            'sample_names': list(self.sample_names),
-            'file_size': os.path.getsize(self.filename),
-            'file_path': self.filename,
-            'initialization_method': self.initialization_method,
-            'samples': []  # Initialize samples list
+            "format": "WIFF2",
+            "sample_count": self.sample_count,
+            "sample_names": list(self.sample_names),
+            "file_size": os.path.getsize(self.filename),
+            "file_path": self.filename,
+            "initialization_method": self.initialization_method,
+            "samples": [],  # Initialize samples list
         }
-        
+
         if self.initialization_method == "alpharaw":
             # Get metadata from alpharaw reader
             try:
-                if hasattr(self._alpharaw_reader, 'get_spectrum_count'):
-                    metadata['total_spectra'] = self._alpharaw_reader.get_spectrum_count()
-                
+                if hasattr(self._alpharaw_reader, "get_spectrum_count"):
+                    metadata["total_spectra"] = self._alpharaw_reader.get_spectrum_count()
+
                 # Add alpharaw-specific metadata
-                for attr in ['creation_time', 'instrument_model', 'ms_levels']:
+                for attr in ["creation_time", "instrument_model", "ms_levels"]:
                     if hasattr(self._alpharaw_reader, attr):
                         try:
                             value = getattr(self._alpharaw_reader, attr)
@@ -367,47 +367,47 @@ class SciexWiff2FileReader:
                                 metadata[attr] = value
                         except:
                             pass
-                            
+
             except Exception as e:
-                metadata['metadata_error'] = str(e)
-        
-        elif hasattr(self, '_wiff_file'):
+                metadata["metadata_error"] = str(e)
+
+        elif hasattr(self, "_wiff_file"):
             # Get metadata from standard WIFF reader
             try:
                 for i in range(self.sample_count):
                     sample = self._wiff_file.GetSample(i)
                     sample_info = {
-                        'index': i,
-                        'name': str(self.sample_names[i]),
+                        "index": i,
+                        "name": str(self.sample_names[i]),
                     }
-                    
-                    if hasattr(sample, 'Details'):
+
+                    if hasattr(sample, "Details"):
                         details = sample.Details
-                        if hasattr(details, 'AcquisitionDateTime'):
-                            sample_info['acquisition_time'] = str(details.AcquisitionDateTime.ToString("O"))
-                    
-                    if hasattr(sample, 'MassSpectrometerSample'):
+                        if hasattr(details, "AcquisitionDateTime"):
+                            sample_info["acquisition_time"] = str(details.AcquisitionDateTime.ToString("O"))
+
+                    if hasattr(sample, "MassSpectrometerSample"):
                         ms_sample = sample.MassSpectrometerSample
-                        sample_info['experiment_count'] = ms_sample.ExperimentCount
-                    
-                    metadata['samples'].append(sample_info)
-                    
+                        sample_info["experiment_count"] = ms_sample.ExperimentCount
+
+                    metadata["samples"].append(sample_info)
+
             except Exception as e:
-                metadata['metadata_error'] = str(e)
-        
+                metadata["metadata_error"] = str(e)
+
         return metadata
 
     def load_sample(self, sample_id: int = 0, **kwargs):
         """
         Load sample data with WIFF2-optimized settings.
-        
+
         Parameters
         ----------
         sample_id : int
             Sample index to load
         **kwargs
             Additional parameters for data loading
-        
+
         Returns
         -------
         dict
@@ -417,69 +417,73 @@ class SciexWiff2FileReader:
             return self._load_sample_alpharaw(sample_id, **kwargs)
         else:
             return self._load_sample_standard(sample_id, **kwargs)
-    
+
     def _load_sample_alpharaw(self, sample_id: int, **kwargs):
         """Load sample using alpharaw reader."""
         # Enhanced parameters for WIFF2
         enhanced_params = {
-            'centroid': kwargs.get('centroid', True),
-            'centroid_ppm': kwargs.get('centroid_ppm', 15.0),
-            'keep_k_peaks': kwargs.get('keep_k_peaks', 3000),
+            "centroid": kwargs.get("centroid", True),
+            "centroid_ppm": kwargs.get("centroid_ppm", 15.0),
+            "keep_k_peaks": kwargs.get("keep_k_peaks", 3000),
         }
-        
+
         try:
             # Use alpharaw's data extraction
             spectrum_df = self._alpharaw_reader.spectrum_df
             peak_df = self._alpharaw_reader.peak_df
-            
+
             # Convert to the expected format
             spectral_data = {
-                'peak_indices': spectrum_df[['peak_start_idx', 'peak_stop_idx']].values.flatten(),
-                'peak_mz': peak_df['mz'].values,
-                'peak_intensity': peak_df['intensity'].values,
-                'rt': spectrum_df['rt'].values,
-                'ms_level': spectrum_df['ms_level'].values,
-                'precursor_mz': spectrum_df.get('precursor_mz', np.full(len(spectrum_df), -1.0)).values,
-                'precursor_charge': spectrum_df.get('precursor_charge', np.full(len(spectrum_df), 0)).values,
-                'isolation_lower_mz': spectrum_df.get('isolation_lower_mz', np.full(len(spectrum_df), -1.0)).values,
-                'isolation_upper_mz': spectrum_df.get('isolation_upper_mz', np.full(len(spectrum_df), -1.0)).values,
-                'nce': spectrum_df.get('nce', np.full(len(spectrum_df), 0.0)).values,
-                'metadata': {
-                    'format': 'WIFF2',
-                    'sample_id': sample_id,
-                    'sample_name': str(self.sample_names[sample_id]) if sample_id < len(self.sample_names) else f'Sample_{sample_id}',
-                    'loading_params': enhanced_params,
-                    'total_spectra': len(spectrum_df),
-                    'total_peaks': len(peak_df),
-                    'ms1_count': np.sum(spectrum_df['ms_level'] == 1),
-                    'ms2_count': np.sum(spectrum_df['ms_level'] > 1),
-                    'rt_range': [float(spectrum_df['rt'].min()), float(spectrum_df['rt'].max())] if len(spectrum_df) > 0 else [0, 0],
-                    'reader_method': 'alpharaw'
-                }
+                "peak_indices": spectrum_df[["peak_start_idx", "peak_stop_idx"]].values.flatten(),
+                "peak_mz": peak_df["mz"].values,
+                "peak_intensity": peak_df["intensity"].values,
+                "rt": spectrum_df["rt"].values,
+                "ms_level": spectrum_df["ms_level"].values,
+                "precursor_mz": spectrum_df.get("precursor_mz", np.full(len(spectrum_df), -1.0)).values,
+                "precursor_charge": spectrum_df.get("precursor_charge", np.full(len(spectrum_df), 0)).values,
+                "isolation_lower_mz": spectrum_df.get("isolation_lower_mz", np.full(len(spectrum_df), -1.0)).values,
+                "isolation_upper_mz": spectrum_df.get("isolation_upper_mz", np.full(len(spectrum_df), -1.0)).values,
+                "nce": spectrum_df.get("nce", np.full(len(spectrum_df), 0.0)).values,
+                "metadata": {
+                    "format": "WIFF2",
+                    "sample_id": sample_id,
+                    "sample_name": str(self.sample_names[sample_id])
+                    if sample_id < len(self.sample_names)
+                    else f"Sample_{sample_id}",
+                    "loading_params": enhanced_params,
+                    "total_spectra": len(spectrum_df),
+                    "total_peaks": len(peak_df),
+                    "ms1_count": np.sum(spectrum_df["ms_level"] == 1),
+                    "ms2_count": np.sum(spectrum_df["ms_level"] > 1),
+                    "rt_range": [float(spectrum_df["rt"].min()), float(spectrum_df["rt"].max())]
+                    if len(spectrum_df) > 0
+                    else [0, 0],
+                    "reader_method": "alpharaw",
+                },
             }
-            
+
             return spectral_data
-            
+
         except Exception as e:
             raise RuntimeError(f"Failed to load WIFF2 sample via alpharaw: {e}")
-    
+
     def _load_sample_standard(self, sample_id: int, **kwargs):
         """Load sample using standard WIFF reader with WIFF2 enhancements."""
         # Use enhanced parameters optimized for WIFF2
         enhanced_params = {
-            'centroid': kwargs.get('centroid', True),
-            'centroid_ppm': kwargs.get('centroid_ppm', 15.0),  # Tighter for WIFF2
-            'ignore_empty_scans': kwargs.get('ignore_empty_scans', True),
-            'keep_k_peaks': kwargs.get('keep_k_peaks', 3000),  # More peaks for WIFF2
+            "centroid": kwargs.get("centroid", True),
+            "centroid_ppm": kwargs.get("centroid_ppm", 15.0),  # Tighter for WIFF2
+            "ignore_empty_scans": kwargs.get("ignore_empty_scans", True),
+            "keep_k_peaks": kwargs.get("keep_k_peaks", 3000),  # More peaks for WIFF2
         }
-        
+
         if sample_id < 0 or sample_id >= self.sample_count:
-            raise ValueError(f"Sample ID {sample_id} out of range (0-{self.sample_count-1})")
-        
+            raise ValueError(f"Sample ID {sample_id} out of range (0-{self.sample_count - 1})")
+
         # Use the same loading approach as SciexWiffFileReader but with enhancements
         sample = self._wiff_file.GetSample(sample_id)
         ms_sample = sample.MassSpectrometerSample
-        
+
         # Process data (same as SciexWiffFileReader.load_sample but with enhanced params)
         _peak_indices: list[int] = []
         peak_mz_list: list[np.ndarray] = []
@@ -491,9 +495,9 @@ class SciexWiff2FileReader:
         nce_list: list[float] = []
         isolation_lower_list: list[float] = []
         isolation_upper_list: list[float] = []
-        
+
         exp_list = [ms_sample.GetMSExperiment(i) for i in range(ms_sample.ExperimentCount)]
-        
+
         for j in range(exp_list[0].Details.NumberOfScans):
             for i in range(ms_sample.ExperimentCount):
                 exp = exp_list[i]
@@ -501,52 +505,58 @@ class SciexWiff2FileReader:
                 mass_spectrum_info = exp.GetMassSpectrumInfo(j)
                 details = exp.Details
                 ms_level = mass_spectrum_info.MSLevel
-                
-                if (ms_level > 1 and not details.IsSwath and 
-                    mass_spectrum.NumDataPoints <= 0 and enhanced_params['ignore_empty_scans']):
+
+                if (
+                    ms_level > 1
+                    and not details.IsSwath
+                    and mass_spectrum.NumDataPoints <= 0
+                    and enhanced_params["ignore_empty_scans"]
+                ):
                     continue
-                
+
                 mz_array = dot_net_array_to_np_array(mass_spectrum.GetActualXValues())
                 int_array = dot_net_array_to_np_array(mass_spectrum.GetActualYValues()).astype(np.float32)
-                
-                if enhanced_params['centroid']:
+
+                if enhanced_params["centroid"]:
                     mz_array, int_array = naive_centroid(
-                        mz_array, int_array, 
-                        centroiding_ppm=enhanced_params['centroid_ppm']
+                        mz_array,
+                        int_array,
+                        centroiding_ppm=enhanced_params["centroid_ppm"],
                     )
-                
-                if len(mz_array) > enhanced_params['keep_k_peaks']:
-                    top_indices = np.argsort(int_array)[-enhanced_params['keep_k_peaks']:]
+
+                if len(mz_array) > enhanced_params["keep_k_peaks"]:
+                    top_indices = np.argsort(int_array)[-enhanced_params["keep_k_peaks"] :]
                     top_indices = np.sort(top_indices)
                     mz_array = mz_array[top_indices]
                     int_array = int_array[top_indices]
-                
+
                 peak_mz_list.append(mz_array)
                 peak_intensity_list.append(int_array)
                 _peak_indices.append(len(peak_mz_list[-1]))
-                
+
                 rt_list.append(exp.GetRTFromExperimentCycle(j))
                 ms_level_list.append(ms_level)
-                
+
                 # Enhanced precursor handling for WIFF2
                 center_mz = -1.0
                 isolation_window = 0.0
-                
+
                 if ms_level > 1:
                     if details.IsSwath and details.MassRangeInfo.Length > 0:
                         try:
                             from WiffOps4Python import WiffOps as DotNetWiffOps
+
                             center_mz = DotNetWiffOps.get_center_mz(details)
                             isolation_window = DotNetWiffOps.get_isolation_window(details)
                         except:
                             center_mz = mass_spectrum_info.ParentMZ
                             isolation_window = 3.0
-                    
+
                     if isolation_window <= 0:
                         isolation_window = 3.0
                     if center_mz <= 0:
                         center_mz = mass_spectrum_info.ParentMZ
-                    
+
                     precursor_mz_list.append(center_mz)
                     precursor_charge_list.append(mass_spectrum_info.ParentChargeState)
                     nce_list.append(float(mass_spectrum_info.CollisionEnergy))
@@ -558,58 +568,60 @@ class SciexWiff2FileReader:
                     nce_list.append(0.0)
                     isolation_lower_list.append(-1.0)
                     isolation_upper_list.append(-1.0)
-        
+
         # Finalize arrays
         peak_indices = np.empty(len(rt_list) + 1, np.int64)
         peak_indices[0] = 0
         peak_indices[1:] = np.cumsum(_peak_indices)
-        
+
         return {
-            'peak_indices': peak_indices,
-            'peak_mz': np.concatenate(peak_mz_list) if peak_mz_list else np.array([]),
-            'peak_intensity': np.concatenate(peak_intensity_list) if peak_intensity_list else np.array([]),
-            'rt': np.array(rt_list, dtype=np.float64),
-            'ms_level': np.array(ms_level_list, dtype=np.int8),
-            'precursor_mz': np.array(precursor_mz_list, dtype=np.float64),
-            'precursor_charge': np.array(precursor_charge_list, dtype=np.int8),
-            'isolation_lower_mz': np.array(isolation_lower_list, dtype=np.float64),
-            'isolation_upper_mz': np.array(isolation_upper_list, dtype=np.float64),
-            'nce': np.array(nce_list, dtype=np.float32),
-            'metadata': {
-                'format': 'WIFF2',
-                'sample_id': sample_id,
-                'sample_name': str(self.sample_names[sample_id]),
-                'loading_params': enhanced_params,
-                'total_spectra': len(rt_list),
-                'total_peaks': sum(_peak_indices),
-                'ms1_count': np.sum(np.array(ms_level_list) == 1),
-                'ms2_count': np.sum(np.array(ms_level_list) > 1),
-                'rt_range': [float(np.min(rt_list)), float(np.max(rt_list))] if rt_list else [0, 0],
-                'creation_time': str(sample.Details.AcquisitionDateTime.ToString("O")) if hasattr(sample, 'Details') else '',
-                'reader_method': 'standard_enhanced'
-            }
+            "peak_indices": peak_indices,
+            "peak_mz": np.concatenate(peak_mz_list) if peak_mz_list else np.array([]),
+            "peak_intensity": np.concatenate(peak_intensity_list) if peak_intensity_list else np.array([]),
+            "rt": np.array(rt_list, dtype=np.float64),
+            "ms_level": np.array(ms_level_list, dtype=np.int8),
+            "precursor_mz": np.array(precursor_mz_list, dtype=np.float64),
+            "precursor_charge": np.array(precursor_charge_list, dtype=np.int8),
+            "isolation_lower_mz": np.array(isolation_lower_list, dtype=np.float64),
+            "isolation_upper_mz": np.array(isolation_upper_list, dtype=np.float64),
+            "nce": np.array(nce_list, dtype=np.float32),
+            "metadata": {
+                "format": "WIFF2",
+                "sample_id": sample_id,
+                "sample_name": str(self.sample_names[sample_id]),
+                "loading_params": enhanced_params,
+                "total_spectra": len(rt_list),
+                "total_peaks": sum(_peak_indices),
+                "ms1_count": np.sum(np.array(ms_level_list) == 1),
+                "ms2_count": np.sum(np.array(ms_level_list) > 1),
+                "rt_range": [float(np.min(rt_list)), float(np.max(rt_list))] if rt_list else [0, 0],
+                "creation_time": str(sample.Details.AcquisitionDateTime.ToString("O"))
+                if hasattr(sample, "Details")
+                else "",
+                "reader_method": "standard_enhanced",
+            },
         }
 
     def close(self):
         """Close the WIFF2 file and clean up resources."""
-        if hasattr(self, '_wiffDataProvider'):
+        if hasattr(self, "_wiffDataProvider"):
             try:
                 self._wiffDataProvider.Close()
             except:
                 pass
-        
-        if hasattr(self, '_alpharaw_reader'):
+
+        if hasattr(self, "_alpharaw_reader"):
             try:
                 self._alpharaw_reader.close()
             except:
                 pass
-    
+
     def __enter__(self):
         return self
-    
+
     def __exit__(self, exc_type, exc_val, exc_tb):
         self.close()
-    
+
     def __repr__(self):
         return f"SciexWiff2FileReader(file='{self.filename}', samples={self.sample_count}, method={self.initialization_method})"
 
@@ -1022,30 +1034,29 @@ def load_wiff2_file(filename: str, **kwargs) -> dict[str, Any]:
     -------
     dict
         Spectral data dictionary with enhanced WIFF2 information
-        
+
     Raises
     ------
     RuntimeError
         If WIFF2 format is not supported by current DLL combination
     """
-    sample_id = kwargs.pop('sample_id', 0)
-    
+    sample_id = kwargs.pop("sample_id", 0)
+
     try:
         with SciexWiff2FileReader(filename) as reader:
             return reader.load_sample(sample_id, **kwargs)  # type: ignore[no-any-return]
     except RuntimeError as e:
         if "format is not supported" in str(e):
             # Suggest using regular WIFF file if available
-            wiff_file = filename.replace('.wiff2', '.wiff')
+            wiff_file = filename.replace(".wiff2", ".wiff")
             if os.path.exists(wiff_file):
                 raise RuntimeError(
                     f"WIFF2 format not supported. However, a regular WIFF file was found: "
-                    f"'{wiff_file}'. Try using load_wiff_file('{wiff_file}') instead."
+                    f"'{wiff_file}'. Try using load_wiff_file('{wiff_file}') instead.",
                 ) from e
             else:
                 raise RuntimeError(
-                    f"WIFF2 format not supported and no corresponding WIFF file found. "
-                    f"Original error: {e}"
+                    f"WIFF2 format not supported and no corresponding WIFF file found. Original error: {e}",
                 ) from e
         else:
             raise
@@ -1054,7 +1065,7 @@ def load_wiff2_file(filename: str, **kwargs) -> dict[str, Any]:
 def load_wiff_file_smart(filename: str, **kwargs) -> dict[str, Any] | SciexWiffData:
     """
     Smart WIFF file loader that automatically handles WIFF and WIFF2 formats.
-    
+
     This function will first try to load the file as specified, and if it's a WIFF2
     file that fails due to format incompatibility, it will suggest alternatives.
 
@@ -1070,17 +1081,17 @@ def load_wiff_file_smart(filename: str, **kwargs) -> dict[str, Any] | SciexWiffD
     dict
         Spectral data dictionary
     """
-    if filename.lower().endswith('.wiff2'):
+    if filename.lower().endswith(".wiff2"):
         try:
             return load_wiff2_file(filename, **kwargs)
         except RuntimeError as e:
             if "format is not supported" in str(e):
                 # Check if regular WIFF file exists
-                wiff_file = filename.replace('.wiff2', '.wiff')
+                wiff_file = filename.replace(".wiff2", ".wiff")
                 if os.path.exists(wiff_file):
                     warnings.warn(
                         f"WIFF2 format not supported, falling back to WIFF file: {wiff_file}",
-                        stacklevel=2
+                        stacklevel=2,
                     )
                     return load_wiff_file(wiff_file, **kwargs)
             raise