corems.mass_spectra.input.mzml

  1from collections import defaultdict
  2from pathlib import Path
  3from typing import Optional, Union, List, Tuple
  4
  5import numpy as np
  6import pandas as pd
  7import pymzml
  8import datetime
  9
 10from corems.encapsulation.constant import Labels
 11from corems.encapsulation.factory.parameters import default_parameters
 12from corems.mass_spectra.factory.lc_class import LCMSBase, MassSpectraBase
 13from corems.mass_spectra.input.parserbase import SpectraParserInterface
 14from corems.mass_spectrum.factory.MassSpectrumClasses import (
 15    MassSpecCentroid,
 16    MassSpecProfile,
 17)
 18
 19
 20class MZMLSpectraParser(SpectraParserInterface):
 21    """A class for parsing mzml spectrometry data files into MassSpectraBase or LCMSBase objects
 22
 23    Parameters
 24    ----------
 25    file_location : str or Path
 26        The path to the RAW file to be parsed.
 27    analyzer : str, optional
 28        The type of mass analyzer used in the instrument. Default is "Unknown".
 29    instrument_label : str, optional
 30        The name of the instrument used to acquire the data. Default is "Unknown".
 31    sample_name : str, optional
 32        The name of the sample being analyzed. If not provided, the stem of the file_location path will be used.
 33
 34    Attributes
 35    ----------
 36    file_location : Path
 37        The path to the RAW file being parsed.
 38    analyzer : str
 39        The type of mass analyzer used in the instrument.
 40    instrument_label : str
 41        The name of the instrument used to acquire the data.
 42    sample_name : str
 43        The name of the sample being analyzed.
 44
 45    Methods
 46    -------
 47    * load().
 48        Load mzML file using pymzml.run.Reader and return the data as a numpy array.
 49    * run(spectra=True).
 50        Parses the mzml file and returns a dictionary of mass spectra dataframes and a scan metadata dataframe.
 51    * get_mass_spectrum_from_scan(scan_number, polarity, auto_process=True)
 52        Parses the mzml file and returns a MassSpecBase object from a single scan.
 53    * get_mass_spectra_obj().
 54        Parses the mzml file and instantiates a MassSpectraBase object.
 55    * get_lcms_obj().
 56        Parses the mzml file and instantiates an LCMSBase object.
 57    * get_instrument_info().
 58        Return instrument information from the mzML file.
 59    * get_creation_time().
 60        Return the creation time of the mzML file as a datetime object.
 61
 62    Inherits from ThermoBaseClass and SpectraParserInterface
 63    """
 64
 65    def __init__(
 66        self,
 67        file_location,
 68        analyzer="Unknown",
 69        instrument_label="Unknown",
 70        sample_name=None,
 71    ):
 72        # implementation details
 73        if isinstance(file_location, str):
 74            # if obj is a string it defaults to create a Path obj, pass the S3Path if needed
 75            file_location = Path(file_location)
 76        if not file_location.exists():
 77            raise FileExistsError("File does not exist: " + str(file_location))
 78        self.file_location = file_location
 79        self.analyzer = analyzer
 80        self.instrument_label = instrument_label
 81
 82        if sample_name:
 83            self.sample_name = sample_name
 84        else:
 85            self.sample_name = file_location.stem
 86
 87    def load(self):
 88        """
 89        Load mzML file using pymzml.run.Reader and return the data as a numpy array.
 90
 91        Returns
 92        -------
 93        numpy.ndarray
 94            The mass spectra data as a numpy array.
 95        """
 96        data = pymzml.run.Reader(self.file_location)
 97        return data
 98
 99    def get_scan_df(
100        self,
101        data=None,
102        time_range: Optional[
103            Union[Tuple[float, float], List[Tuple[float, float]]]
104        ] = None,
105    ):
106        """
107        Return scan data as a pandas DataFrame.
108
109        Parameters
110        ----------
111        data : pymzml.run.Reader, optional
112            The mass spectra data. If None, will load the data.
113        time_range : tuple or list of tuples, optional
114            Retention time range(s) to filter scans. Can be:
115            - Single range: (start_time, end_time) in minutes
116            - Multiple ranges: [(start1, end1), (start2, end2), ...] in minutes
117            If None, returns all scans.
118
119        Returns
120        -------
121        pandas.DataFrame
122            A pandas DataFrame containing metadata for each scan, including scan number, MS level, polarity, and scan time.
123        """
124        if data is None:
125            data = self.load()
126        # Scan dict
127        # instatinate scan dict, with empty lists of size of scans
128        n_scans = data.get_spectrum_count()
129        scan_dict = {
130            "scan": np.empty(n_scans, dtype=np.int32),
131            "scan_time": np.empty(n_scans, dtype=np.float32),
132            "ms_level": [None] * n_scans,
133            "polarity": [None] * n_scans,
134            "precursor_mz": [None] * n_scans,
135            "scan_text": [None] * n_scans,
136            "scan_window_lower": np.empty(n_scans, dtype=np.float32),
137            "scan_window_upper": np.empty(n_scans, dtype=np.float32),
138            "scan_precision": [None] * n_scans,
139            "tic": np.empty(n_scans, dtype=np.float32),
140            "ms_format": [None] * n_scans,
141        }
142
143        # First pass: loop through scans to get scan info
144        for i, spec in enumerate(data):
145            scan_dict["scan"][i] = spec.ID
146            scan_dict["ms_level"][i] = spec.ms_level
147            scan_dict["scan_precision"][i] = spec._measured_precision
148            scan_dict["tic"][i] = spec.TIC
149            if spec.selected_precursors:
150                scan_dict["precursor_mz"][i] = spec.selected_precursors[0].get(
151                    "mz", None
152                )
153            if spec["negative scan"] is not None:
154                scan_dict["polarity"][i] = "negative"
155            if spec["positive scan"] is not None:
156                scan_dict["polarity"][i] = "positive"
157            if spec["negative scan"] is not None and spec["positive scan"] is not None:
158                raise ValueError(
159                    "Error: scan {0} has both negative and positive polarity".format(
160                        spec.ID
161                    )
162                )
163
164            scan_dict["scan_time"][i] = spec.get("MS:1000016")
165            scan_dict["scan_text"][i] = spec.get("MS:1000512")
166            scan_dict["scan_window_lower"][i] = spec.get("MS:1000501")
167            scan_dict["scan_window_upper"][i] = spec.get("MS:1000500")
168            if spec.get("MS:1000128"):
169                scan_dict["ms_format"][i] = "profile"
170            elif spec.get("MS:1000127"):
171                scan_dict["ms_format"][i] = "centroid"
172            else:
173                scan_dict["ms_format"][i] = None
174
175        scan_df = pd.DataFrame(scan_dict)
176
177        # Remove any non-mass spectra scans (e.g., MS level 0 or None)
178        scan_df = scan_df[
179            scan_df.ms_level.notnull() & (scan_df.ms_level > 0)
180        ].reset_index(drop=True)
181
182        # Apply time range filtering if specified
183        if time_range is not None:
184            time_ranges = self._normalize_time_range(time_range)
185            # Create a mask for scans within any of the time ranges
186            mask = np.zeros(len(scan_df), dtype=bool)
187            for start_time, end_time in time_ranges:
188                mask |= (scan_df["scan_time"] >= start_time) & (
189                    scan_df["scan_time"] <= end_time
190                )
191            scan_df = scan_df[mask].reset_index(drop=True)
192
193        return scan_df
194
195    def get_ms_raw(
196        self,
197        spectra,
198        scan_df,
199        data=None,
200        time_range: Optional[
201            Union[Tuple[float, float], List[Tuple[float, float]]]
202        ] = None,
203    ):
204        """Return a dictionary of mass spectra data as a pandas DataFrame.
205
206        Parameters
207        ----------
208        spectra : str
209            Which mass spectra data to include in the output.
210            Options: None, "ms1", "ms2", "all".
211        scan_df : pandas.DataFrame
212            Scan dataframe. Output from get_scan_df().
213        data : pymzml.run.Reader, optional
214            The mass spectra data. If None, will load the data.
215        time_range : tuple or list of tuples, optional
216            Retention time range(s) to filter scans. Can be:
217            - Single range: (start_time, end_time) in minutes
218            - Multiple ranges: [(start1, end1), (start2, end2), ...] in minutes
219            If None, returns all scans. Note: filtering is typically done at scan_df level.
220
221        Returns
222        -------
223        dict
224            A dictionary containing the mass spectra data as pandas DataFrames, with keys corresponding to the MS level.
225
226        """
227        if data is None:
228            data = self.load()
229        if spectra == "all":
230            scan_df_forspec = scan_df
231        elif spectra == "ms1":
232            scan_df_forspec = scan_df[scan_df.ms_level == 1]
233        elif spectra == "ms2":
234            scan_df_forspec = scan_df[scan_df.ms_level == 2]
235        else:
236            raise ValueError("spectra must be 'all', 'ms1', or 'ms2'")
237
238        # Result container
239        res = {}
240
241        # Row count container
242        counter = {}
243
244        # Column name container
245        cols = {}
246
247        # set at float32
248        dtype = np.float32
249
250        # First pass: get nrows
251        N = defaultdict(lambda: 0)
252        for i, spec in enumerate(data):
253            if spec.ID in scan_df_forspec.scan.values:
254                # Get ms level
255                level = "ms{}".format(spec.ms_level)
256
257                # Number of rows
258                N[level] += spec.mz.shape[0]
259
260        # Second pass: parse
261        for i, spec in enumerate(data):
262            if spec.ID in scan_df_forspec.scan.values:
263                # Number of rows
264                n = spec.mz.shape[0]
265
266                # No measurements
267                if n == 0:
268                    continue
269
270                # Dimension check
271                if len(spec.mz) != len(spec.i):
272                    # raise an error if the mz and intensity arrays are not the same length
273                    raise ValueError("m/z and intensity array dimension mismatch")
274
275                # Scan/frame info
276                id_dict = spec.id_dict
277
278                # Get ms level
279                level = "ms{}".format(spec.ms_level)
280
281                # Columns
282                cols[level] = list(id_dict.keys()) + ["mz", "intensity"]
283                m = len(cols[level])
284
285                # Subarray init
286                arr = np.empty((n, m), dtype=dtype)
287                inx = 0
288
289                # Populate scan/frame info
290                for k, v in id_dict.items():
291                    arr[:, inx] = v
292                    inx += 1
293
294                # Populate m/z
295                arr[:, inx] = spec.mz
296                inx += 1
297
298                # Populate intensity
299                arr[:, inx] = spec.i
300                inx += 1
301
302                # Initialize output container
303                if level not in res:
304                    res[level] = np.empty((N[level], m), dtype=dtype)
305                    counter[level] = 0
306
307                # Insert subarray
308                res[level][counter[level] : counter[level] + n, :] = arr
309                counter[level] += n
310
311        # Construct ms1 and ms2 mz dataframes
312        for level in res.keys():
313            res[level] = pd.DataFrame(res[level], columns=cols[level]).drop(
314                columns=["controllerType", "controllerNumber"],
315            )
316
317        return res
318
319    def run(
320        self,
321        spectra="all",
322        scan_df=None,
323        time_range: Optional[
324            Union[Tuple[float, float], List[Tuple[float, float]]]
325        ] = None,
326    ):
327        """Parse the mzML file and return a dictionary of spectra dataframes and a scan metadata dataframe.
328
329        Parameters
330        ----------
331        spectra : str, optional
332            Which mass spectra data to include in the output. Default is "all".
333            Other options: None, "ms1", "ms2".
334        scan_df : pandas.DataFrame, optional
335            Scan dataframe.  If not provided, the scan dataframe is created from the mzML file.
336        time_range : tuple or list of tuples, optional
337            Retention time range(s) to load. Can be:
338            - Single range: (start_time, end_time) in minutes
339            - Multiple ranges: [(start1, end1), (start2, end2), ...] in minutes
340            If None, loads all scans.
341
342        Returns
343        -------
344        tuple
345            A tuple containing two elements:
346            - A dictionary containing the mass spectra data as numpy arrays, with keys corresponding to the MS level.
347            - A pandas DataFrame containing metadata for each scan, including scan number, MS level, polarity, and scan time.
348        """
349
350        # Open file
351        data = self.load()
352
353        if scan_df is None:
354            scan_df = self.get_scan_df(data, time_range=time_range)
355
356        if spectra != "none":
357            res = self.get_ms_raw(spectra, scan_df, data)
358
359        else:
360            res = None
361
362        return res, scan_df
363
364    def get_mass_spectrum_from_scan(
365        self, scan_number, spectrum_mode, auto_process=True
366    ):
367        """Instatiate a mass spectrum object from the mzML file.
368
369        Parameters
370        ----------
371        scan_number : int
372            The scan number to be parsed.
373        spectrum_mode : str
374            The type of spectrum to instantiate.  Must be'profile' or 'centroid'.
375        polarity : int
376            The polarity of the scan.  Must be -1 or 1.
377        auto_process : bool, optional
378            If True, process the mass spectrum. Default is True.
379
380        Returns
381        -------
382        MassSpecProfile | MassSpecCentroid
383            The MassSpecProfile or MassSpecCentroid object containing the parsed mass spectrum.
384        """
385        # Use the batch function and return the first result
386        result_list = self.get_mass_spectra_from_scan_list(
387            [scan_number], spectrum_mode, auto_process
388        )
389        return result_list[0] if result_list else None
390
391    def get_mass_spectra_from_scan_list(
392        self, scan_list, spectrum_mode, auto_process=True
393    ):
394        """Instatiate mass spectrum objects from the mzML file.
395
396        Parameters
397        ----------
398        scan_list : list of int
399            The scan numbers to be parsed.
400        spectrum_mode : str
401            The type of spectrum to instantiate.  Must be'profile' or 'centroid'.
402        auto_process : bool, optional
403            If True, process the mass spectrum. Default is True.
404
405        Returns
406        -------
407        list of MassSpecProfile | MassSpecCentroid
408            List of MassSpecProfile or MassSpecCentroid objects containing the parsed mass spectra.
409        """
410
411        def set_metadata(
412            scan_number: int,
413            polarity: int,
414            file_location: str,
415            label=Labels.thermo_profile,
416        ):
417            """
418            Set the output parameters for creating a MassSpecProfile or MassSpecCentroid object.
419
420            Parameters
421            ----------
422            scan_number : int
423                The scan number.
424            polarity : int
425                The polarity of the data.
426            file_location : str
427                The file location.
428            label : str, optional
429                The label for the mass spectrum. Default is Labels.thermo_profile.
430
431            Returns
432            -------
433            dict
434                The output parameters ready for creating a MassSpecProfile or MassSpecCentroid object.
435            """
436            d_params = default_parameters(file_location)
437            d_params["label"] = label
438            d_params["polarity"] = polarity
439            d_params["filename_path"] = file_location
440            d_params["scan_number"] = scan_number
441
442            return d_params
443
444        # Open file
445        data = self.load()
446
447        mass_spectrum_objects = []
448        scan_set = set(scan_list)
449        # Materialize peak data during iteration. Do not retain live pymzml
450        # spectrum objects, and do not overwrite the first valid MS spectrum for
451        # a scan ID.
452        #
453        # Thermo multi-controller mzML files often reuse scan numbers across
454        # controllers (e.g. controllerType=0 MS data and controllerType=3
455        # auxiliary traces). pymzml exposes only the integer scan number as
456        # spec.ID, so sequential iteration can yield the same ID twice. Keeping
457        # the last yield (or random-access data[scan]) can replace real MS
458        # spectra with non-MS controller spectra and then fail centroid/profile
459        # checks with "spectrum is not centroided".
460        #
461        # Direct random-access via data[scan_number] also uses pymzml's
462        # byte-offset index, which is unreliable on Windows (CRLF vs LF).
463        collected = {}
464
465        for spec in data:
466            scan_id = spec.ID
467            if scan_id not in scan_set or scan_id in collected:
468                continue
469
470            # Skip non-MS / auxiliary-controller spectra that share scan numbers
471            ms_level = spec.ms_level
472            if ms_level is None or ms_level <= 0:
473                continue
474
475            if spec["negative scan"] is not None:
476                polarity = -1
477            elif spec["positive scan"] is not None:
478                polarity = 1
479            else:
480                polarity = None
481
482            mz = np.asarray(spec.mz)
483            abundance = np.asarray(spec.i)
484            collected[scan_id] = {
485                "mz": mz,
486                "abundance": abundance,
487                "polarity": polarity,
488                "is_profile": bool(spec.get("MS:1000128")),
489                "is_centroid": bool(spec.get("MS:1000127")),
490            }
491
492        for scan_number in scan_list:
493            entry = collected.get(scan_number)
494            if entry is None:
495                raise ValueError("Scan number %d not found in mzML file" % scan_number)
496
497            polarity = entry["polarity"]
498            mz = entry["mz"]
499            abundance = entry["abundance"]
500
501            # Get mass spectrum
502            if spectrum_mode == "profile":
503                # Check if profile
504                if not entry["is_profile"]:
505                    raise ValueError("spectrum is not profile")
506                data_dict = {
507                    Labels.mz: mz,
508                    Labels.abundance: abundance,
509                }
510                d_params = set_metadata(
511                    scan_number,
512                    polarity,
513                    self.file_location,
514                    label=Labels.simulated_profile,
515                )
516                mass_spectrum_obj = MassSpecProfile(
517                    data_dict, d_params, auto_process=auto_process
518                )
519            elif spectrum_mode == "centroid":
520                # Check if centroided
521                if not entry["is_centroid"]:
522                    raise ValueError("spectrum is not centroided")
523                data_dict = {
524                    Labels.mz: mz,
525                    Labels.abundance: abundance,
526                    Labels.rp: [np.nan] * len(mz),
527                    Labels.s2n: [np.nan] * len(abundance),
528                }
529                d_params = set_metadata(
530                    scan_number,
531                    polarity,
532                    self.file_location,
533                    label=Labels.corems_centroid,
534                )
535                mass_spectrum_obj = MassSpecCentroid(
536                    data_dict, d_params, auto_process=auto_process
537                )
538            else:
539                raise ValueError(
540                    "spectrum_mode must be 'profile' or 'centroid', got %r"
541                    % spectrum_mode
542                )
543
544            mass_spectrum_objects.append(mass_spectrum_obj)
545
546        return mass_spectrum_objects
547
548    def get_mass_spectra_obj(
549        self,
550        time_range: Optional[
551            Union[Tuple[float, float], List[Tuple[float, float]]]
552        ] = None,
553    ):
554        """Instatiate a MassSpectraBase object from the mzML file.
555
556        Parameters
557        ----------
558        time_range : tuple or list of tuples, optional
559            Retention time range(s) to load. Can be:
560            - Single range: (start_time, end_time) in minutes
561            - Multiple ranges: [(start1, end1), (start2, end2), ...] in minutes
562            If None, loads all scans.
563
564        Returns
565        -------
566        MassSpectraBase
567            The MassSpectra object containing the parsed mass spectra.
568            The object is instatiated with the mzML file, analyzer, instrument, sample name, and scan dataframe.
569        """
570        _, scan_df = self.run(spectra=False, time_range=time_range)
571        mass_spectra_obj = MassSpectraBase(
572            self.file_location,
573            self.analyzer,
574            self.instrument_label,
575            self.sample_name,
576            self,
577        )
578        scan_df = scan_df.set_index("scan", drop=False)
579        mass_spectra_obj.scan_df = scan_df
580
581        return mass_spectra_obj
582
583    def get_lcms_obj(
584        self,
585        spectra="all",
586        time_range: Optional[
587            Union[Tuple[float, float], List[Tuple[float, float]]]
588        ] = None,
589    ):
590        """Instatiates a LCMSBase object from the mzML file.
591
592        Parameters
593        ----------
594        spectra : str, optional
595            Which mass spectra data to include in the output. Default is all.  Other options: none, ms1, ms2.
596        time_range : tuple or list of tuples, optional
597            Retention time range(s) to load. Can be:
598            - Single range: (start_time, end_time) in minutes
599            - Multiple ranges: [(start1, end1), (start2, end2), ...] in minutes
600            If None, loads all scans. Useful for targeted workflows to improve performance.
601
602        Returns
603        -------
604        LCMSBase
605            LCMS object containing mass spectra data.
606            The object is instatiated with the mzML file, analyzer, instrument, sample name, scan dataframe,
607            and mz dataframe(s), as well as lists of scan numbers, retention times, and TICs.
608        """
609        _, scan_df = self.run(
610            spectra="none", time_range=time_range
611        )  # first run it to just get scan info
612        if spectra != "none":
613            res, scan_df = self.run(
614                scan_df=scan_df, spectra=spectra, time_range=time_range
615            )  # second run to parse data
616        lcms_obj = LCMSBase(
617            self.file_location,
618            self.analyzer,
619            self.instrument_label,
620            self.sample_name,
621            self,
622        )
623        if spectra != "none":
624            for key in res:
625                key_int = int(key.replace("ms", ""))
626                res[key] = res[key][res[key].intensity > 0]
627                res[key] = (
628                    res[key].sort_values(by=["scan", "mz"]).reset_index(drop=True)
629                )
630                lcms_obj._ms_unprocessed[key_int] = res[key]
631        lcms_obj.scan_df = scan_df.set_index("scan", drop=False)
632        # Check if polarity is mixed
633        if len(set(scan_df.polarity)) > 1:
634            raise ValueError("Mixed polarities detected in scan data")
635        # Use iloc for positional access (Series.__getitem__ is label-based;
636        # safer across pandas 2.x and 3.x).
637        lcms_obj.polarity = scan_df.polarity.iloc[0]
638        lcms_obj._scans_number_list = list(scan_df.scan)
639        lcms_obj._retention_time_list = list(scan_df.scan_time)
640        lcms_obj._tic_list = list(scan_df.tic)
641
642        return lcms_obj
643
644    def get_scans_in_time_range(
645        self,
646        time_range: Union[Tuple[float, float], List[Tuple[float, float]]],
647        ms_level: Optional[int] = None,
648    ) -> List[int]:
649        """
650        Return scan numbers within specified retention time range(s).
651
652        This method provides efficient filtering of scans by retention time,
653        which is particularly useful for targeted workflows where only specific
654        time windows are of interest.
655
656        Parameters
657        ----------
658        time_range : tuple or list of tuples
659            Retention time range(s) in minutes. Can be:
660            - Single range: (start_time, end_time)
661            - Multiple ranges: [(start1, end1), (start2, end2), ...]
662        ms_level : int, optional
663            If specified, only return scans of this MS level (e.g., 1 for MS1, 2 for MS2).
664            If None, returns scans of all MS levels.
665
666        Returns
667        -------
668        list of int
669            List of scan numbers within the specified time range(s) and MS level.
670
671        Examples
672        --------
673        Get MS1 scans between 1.0 and 2.0 minutes:
674
675        >>> scans = parser.get_scans_in_time_range((1.0, 2.0), ms_level=1)
676
677        Get scans in multiple time windows:
678
679        >>> scans = parser.get_scans_in_time_range([(0.5, 1.5), (3.0, 4.0)])
680        """
681        # Get scan dataframe filtered by time range
682        scan_df = self.get_scan_df(time_range=time_range)
683
684        # Further filter by MS level if specified
685        if ms_level is not None:
686            scan_df = scan_df[scan_df.ms_level == ms_level]
687
688        # Return list of scan numbers
689        return scan_df.scan.tolist()
690
691    def get_instrument_info(self):
692        """
693        Return instrument information.
694
695        Returns
696        -------
697        dict
698            A dictionary with the keys 'model' and 'serial_number'.
699        """
700        # Load the pymzml data
701        data = self.load()
702        instrument_info = data.info.get("referenceable_param_group_list_element")[0]
703        cv_params = instrument_info.findall("{http://psi.hupo.org/ms/mzml}cvParam")
704
705        # Extract details from each cvParam
706        params = []
707        for param in cv_params:
708            accession = param.get("accession")  # Get 'accession' attribute
709            name = param.get("name")  # Get 'name' attribute
710            value = param.get("value")  # Get 'value' attribute
711            params.append({"accession": accession, "name": name, "value": value})
712
713        # Loop through params and try to find the relevant information
714        instrument_dict = {"model": "Unknown", "serial_number": "Unknown"}
715
716        # Assuming there are only two paramters here - one is for the serial number (agnostic to the model) and the other is for the model
717        # If there are more than two, we raise an error
718        if len(params) < 2:
719            raise ValueError(
720                "Not enough parameters found in the instrument info, cannot parse."
721            )
722        if len(params) > 2:
723            raise ValueError(
724                "Too many parameters found in the instrument info, cannot parse."
725            )
726        for param in params:
727            if param["accession"] == "MS:1000529":
728                instrument_dict["serial_number"] = param["value"]
729            else:
730                instrument_dict["model"] = data.OT[param["accession"]]
731
732        return instrument_dict
733
734    def get_creation_time(self) -> datetime.datetime:
735        """
736        Return the creation time of the mzML file.
737        """
738        data = self.load()
739        write_time = data.info.get("start_time")
740        if write_time:
741            # Convert the write time to a datetime object
742            return datetime.datetime.strptime(write_time, "%Y-%m-%dT%H:%M:%SZ")
743        else:
744            raise ValueError(
745                "Creation time is not available in the mzML file. "
746                "Please ensure the file contains the 'start_time' information."
747            )