masster 0.5.16__py3-none-any.whl → 0.5.18__py3-none-any.whl

masster/sample/sciex.py

@@ -2,12 +2,11 @@
 Standalone Sciex WIFF file reader module.
 
 This module provides a standalone implementation of Sciex WIFF file reading
-functionality that uses the DLLs from alpharaw's ext/sciex directory directly
-without importing from the alpharaw package.
+functionality that uses the Sciex DLLs directly.
 
 Requirements:
 - pythonnet (pip install pythonnet)
-- alpharaw package must be installed to access the DLLs in site-packages/alpharaw/ext/sciex/
+- Sciex DLLs must be available in the ext/sciex directory
 - On Linux/macOS: mono runtime must be installed
 
 The .NET imports (System, Clearcore2, WiffOps4Python) will only work when
@@ -32,6 +31,20 @@ def naive_centroid(
 ) -> tuple[np.ndarray, np.ndarray]:
     """
     Simplified naive centroiding implementation.
+    
+    Parameters
+    ----------
+    peak_mzs : np.ndarray
+        Array of m/z values
+    peak_intensities : np.ndarray  
+        Array of intensity values
+    centroiding_ppm : float, default 20.0
+        PPM tolerance for combining peaks
+        
+    Returns
+    -------
+    tuple[np.ndarray, np.ndarray]
+        Centroided m/z and intensity arrays
     """
     if len(peak_mzs) == 0:
         return np.array([]), np.array([])
@@ -134,10 +147,24 @@ except Exception as e:
     HAS_DOTNET = False
 
 
-def dot_net_array_to_np_array(src):
+def dot_net_array_to_np_array(src) -> np.ndarray:
     """
     Convert .NET array to NumPy array.
-    See https://mail.python.org/pipermail/pythondotnet/2014-May/001527.html
+    
+    Parameters
+    ----------
+    src : .NET array or None
+        Source .NET array to convert
+        
+    Returns
+    -------
+    np.ndarray
+        Converted NumPy array
+        
+    Notes
+    -----
+    Based on approach from: 
+    https://mail.python.org/pipermail/pythondotnet/2014-May/001527.html
     """
     if src is None:
         return np.array([], dtype=np.float64)
@@ -153,482 +180,9 @@ def dot_net_array_to_np_array(src):
         return dest  # noqa: B012
 
 
-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
-            Path to the WIFF2 file
-        """
-        if not HAS_DOTNET:
-            raise ValueError(
-                "Dotnet-based dependencies are required for reading Sciex WIFF2 files. "
-                "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.dll",
-            "Clearcore2.Data.Common.dll",
-            "Clearcore2.Data.Core.dll",
-            "Clearcore2.StructuredStorage.dll",  # For WIFF2 storage format
-            "WiffOps4Python.dll",
-        ]
-
-        for dll in required_dlls:
-            dll_path = os.path.join(self.ext_dir, dll)
-            if os.path.exists(dll_path):
-                try:
-                    clr.AddReference(dll_path)
-                except:
-                    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_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(
-                    "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(
-                f"WIFF2 file format is not supported by the current DLL combination. "
-                f"Error code -2147286960 (0x80030050) indicates format incompatibility. "
-                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}",
-            )
-        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.",
-            )
-
-    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,
-            )
-
-        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
-        }
-
-        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()
-
-                # Add alpharaw-specific metadata
-                for attr in ["creation_time", "instrument_model", "ms_levels"]:
-                    if hasattr(self._alpharaw_reader, attr):
-                        try:
-                            value = getattr(self._alpharaw_reader, attr)
-                            if callable(value):
-                                metadata[attr] = value()
-                            else:
-                                metadata[attr] = value
-                        except:
-                            pass
-
-            except Exception as e:
-                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]),
-                    }
-
-                    if hasattr(sample, "Details"):
-                        details = sample.Details
-                        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)
-
-            except Exception as 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
-            Comprehensive spectral data dictionary
-        """
-        if self.initialization_method == "alpharaw":
-            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),
-        }
-
-        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",
-                },
-            }
-
-            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
-        }
-
-        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})")
-
-        # 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] = []
-        peak_intensity_list: list[np.ndarray] = []
-        rt_list: list[float] = []
-        ms_level_list: list[int] = []
-        precursor_mz_list: list[float] = []
-        precursor_charge_list: list[int] = []
-        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]
-                mass_spectrum = exp.GetMassSpectrum(j)
-                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"]
-                ):
-                    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"]:
-                    mz_array, int_array = naive_centroid(
-                        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"] :]
-                    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))
-                    isolation_lower_list.append(center_mz - isolation_window / 2)
-                    isolation_upper_list.append(center_mz + isolation_window / 2)
-                else:
-                    precursor_mz_list.append(-1.0)
-                    precursor_charge_list.append(0)
-                    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",
-            },
-        }
-
-    def close(self):
-        """Close the WIFF2 file and clean up resources."""
-        if hasattr(self, "_wiffDataProvider"):
-            try:
-                self._wiffDataProvider.Close()
-            except:
-                pass
-
-        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})"
-
-
 class SciexWiffFileReader:
     """
-    Direct implementation of Sciex WIFF file reader using the DLLs without alpharaw dependency.
+    Direct implementation of Sciex WIFF file reader using the Sciex DLLs.
     """
 
     def __init__(self, filename: str):
@@ -636,7 +190,7 @@ class SciexWiffFileReader:
             raise ValueError(
                 "Dotnet-based dependencies are required for reading Sciex files. "
                 "Do you have pythonnet and/or mono installed? "
-                "See the alpharaw documentation for details.",
+                "Please ensure pythonnet and Sciex DLLs are properly installed.",
             )
 
         self._wiffDataProvider = AnalystWiffDataProvider()
@@ -646,10 +200,18 @@ class SciexWiffFileReader:
         )
         self.sample_names = self._wiff_file.GetSampleNames()
 
-    def close(self):
+    def close(self) -> None:
         """Close the file and clean up resources."""
         self._wiffDataProvider.Close()
 
+    def __enter__(self) -> 'SciexWiffFileReader':
+        """Context manager entry."""
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        """Context manager exit."""
+        self.close()
+
     def load_sample(
         self,
         sample_id: int,
@@ -690,6 +252,7 @@ class SciexWiffFileReader:
         peak_intensity_array_list: list[np.ndarray] = []
         rt_list: list[float] = []
         ms_level_list: list[int] = []
+        polarity_list: list[str] = []
         precursor_mz_list: list[float] = []
         precursor_charge_list: list[int] = []
         ce_list: list[float] = []
@@ -708,6 +271,13 @@ class SciexWiffFileReader:
 
                 if ms_level > 1 and not details.IsSwath and mass_spectrum.NumDataPoints <= 0 and ignore_empty_scans:
                     continue
+                if exp.Details.Polarity == exp.Details.Polarity.Positive:
+                    pol = 'positive'
+                elif exp.Details.Polarity == exp.Details.Polarity.Negative:
+                    pol = 'negative'
+                else:
+                    pol = ''
+                polarity_list.append(pol)
 
                 mz_array = dot_net_array_to_np_array(mass_spectrum.GetActualXValues())
                 int_array = dot_net_array_to_np_array(
@@ -768,6 +338,7 @@ class SciexWiffFileReader:
             "peak_intensity": np.concatenate(peak_intensity_array_list),
             "rt": np.array(rt_list, dtype=np.float64),
             "ms_level": np.array(ms_level_list, dtype=np.int8),
+            "polarity": np.array(polarity_list, dtype="U8"),
             "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_mz_list),
@@ -778,14 +349,15 @@ class SciexWiffFileReader:
 
 class SciexWiffData:
     """
-    Standalone Sciex WIFF data reader class that mimics alpharaw.sciex.SciexWiffData
-    functionality but uses DLLs directly without importing from alpharaw.
+    Standalone Sciex WIFF data reader class that provides WIFF data reading
+    functionality using Sciex DLLs directly.
     """
 
     # Column data types mapping
     column_dtypes: ClassVar[dict[str, Any]] = {
         "rt": np.float64,
         "ms_level": np.int8,
+        "polarity": "U8",
         "precursor_mz": np.float64,
         "isolation_lower_mz": np.float64,
         "isolation_upper_mz": np.float64,
@@ -795,20 +367,17 @@ class SciexWiffData:
         "activation": "U",
     }
 
-    def __init__(self, centroided: bool = True, save_as_hdf: bool = False, **kwargs):
+    def __init__(self, centroided: bool = True) -> None:
         """
         Parameters
         ----------
         centroided : bool, optional
             If peaks will be centroided after loading, by default True.
-        save_as_hdf : bool, optional
-            Automatically save hdf after load raw data, by default False.
         """
         self.spectrum_df: pd.DataFrame = pd.DataFrame()
         self.peak_df: pd.DataFrame = pd.DataFrame()
         self._raw_file_path = ""
         self.centroided = centroided
-        self._save_as_hdf = save_as_hdf
         self.creation_time = ""
         self.file_type = "sciex"
         self.instrument = "sciex"
@@ -953,42 +522,12 @@ class SciexWiffData:
         tuple
             (mz_array, intensity_array)
         """
-        start, end = self.spectrum_df[["peak_start_idx", "peak_stop_idx"]].values[
-            spec_idx,
-            :,
-        ]
+        start, end = self.spectrum_df.iloc[spec_idx][["peak_start_idx", "peak_stop_idx"]].values
         return (
             self.peak_df.mz.values[start:end],
             self.peak_df.intensity.values[start:end],
         )
 
-    def save_hdf(self, hdf_file_path: str) -> None:
-        """
-        Save data to HDF5 file (placeholder implementation).
-
-        Parameters
-        ----------
-        hdf_file_path : str
-            Path to save the HDF5 file
-        """
-        # This would require implementing HDF5 saving functionality
-        # For now, just save as pickle or implement as needed
-        import pickle
-
-        with open(hdf_file_path.replace(".hdf", ".pkl"), "wb") as f:
-            pickle.dump(
-                {
-                    "spectrum_df": self.spectrum_df,
-                    "peak_df": self.peak_df,
-                    "creation_time": self.creation_time,
-                    "raw_file_path": self.raw_file_path,
-                    "file_type": self.file_type,
-                    "centroided": self.centroided,
-                    "instrument": self.instrument,
-                },
-                f,
-            )
-
     def __repr__(self) -> str:
         return f"SciexWiffData(file_path='{self.raw_file_path}', spectra={len(self.spectrum_df)})"
 
@@ -1014,92 +553,7 @@ def load_wiff_file(filename: str, **kwargs) -> SciexWiffData:
     wiff_data.import_raw(filename)
     return wiff_data
 
-
-def load_wiff2_file(filename: str, **kwargs) -> dict[str, Any]:
-    """
-    Load a WIFF2 file and return spectral data.
-
-    Note: WIFF2 format support is limited with current DLL versions.
-    If you encounter format incompatibility errors, try using the regular
-    WIFF file instead or convert WIFF2 to WIFF format.
-
-    Parameters
-    ----------
-    filename : str
-        Path to the WIFF2 file
-    **kwargs
-        Additional arguments for WIFF2 loading (sample_id, centroid, etc.)
-
-    Returns
-    -------
-    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)
-
-    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")
-            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.",
-                ) from e
-            else:
-                raise RuntimeError(
-                    f"WIFF2 format not supported and no corresponding WIFF file found. Original error: {e}",
-                ) from e
-        else:
-            raise
-
-
-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.
-
-    Parameters
-    ----------
-    filename : str
-        Path to the WIFF or WIFF2 file
-    **kwargs
-        Additional arguments for loading (sample_id, centroid, etc.)
-
-    Returns
-    -------
-    dict
-        Spectral data dictionary
-    """
-    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")
-                if os.path.exists(wiff_file):
-                    warnings.warn(
-                        f"WIFF2 format not supported, falling back to WIFF file: {wiff_file}",
-                        stacklevel=2,
-                    )
-                    return load_wiff_file(wiff_file, **kwargs)
-            raise
-    else:
-        return load_wiff_file(filename, **kwargs)
-
-
-def get_sample_names(filename: str) -> list:
+def get_sample_names(filename: str) -> list[str]:
     """
     Get the sample names from a WIFF file.
 
@@ -1110,51 +564,11 @@ def get_sample_names(filename: str) -> list:
 
     Returns
     -------
-    list
+    list[str]
         List of sample names
     """
-    reader = SciexWiffFileReader(filename)
-    try:
+    with SciexWiffFileReader(filename) as reader:
         return list(reader.sample_names)
-    finally:
-        reader.close()
-
-
-def get_wiff2_sample_names(filename: str) -> list:
-    """
-    Get the sample names from a WIFF2 file.
-
-    Parameters
-    ----------
-    filename : str
-        Path to the WIFF2 file
-
-    Returns
-    -------
-    list
-        List of sample names
-    """
-    with SciexWiff2FileReader(filename) as reader:
-        return list(reader.sample_names)
-
-
-def get_wiff2_metadata(filename: str) -> dict[str, Any]:
-    """
-    Get comprehensive metadata from a WIFF2 file.
-
-    Parameters
-    ----------
-    filename : str
-        Path to the WIFF2 file
-
-    Returns
-    -------
-    dict
-        Comprehensive WIFF2 file metadata
-    """
-    with SciexWiff2FileReader(filename) as reader:
-        return reader.get_file_metadata()  # type: ignore[no-any-return]
-
 
 # Example usage and testing
 if __name__ == "__main__":