class_docstr: Raw data in FIF format.
  
  Parameters
  ----------
  fname : path-like | file-like
      The raw filename to load. For files that have automatically been split,
      the split part will be automatically loaded. Filenames not ending with
      ``raw.fif``, ``raw_sss.fif``, ``raw_tsss.fif``, ``_meg.fif``,
      ``_eeg.fif``,  or ``_ieeg.fif`` (with or without an optional additional
      ``.gz`` extension) will generate a warning. If a file-like object is
      provided, preloading must be used.
  
      .. versionchanged:: 0.18
         Support for file-like objects.
  allow_maxshield : bool | str (default False)
      If True, allow loading of data that has been recorded with internal
      active compensation (MaxShield). Data recorded with MaxShield should
      generally not be loaded directly, but should first be processed using
      SSS/tSSS to remove the compensation signals that may also affect brain
      activity. Can also be "yes" to load without eliciting a warning.
  %(preload)s
  %(on_split_missing)s
  %(verbose)s
  
  Attributes
  ----------
  %(info_not_none)s
  ch_names : list of string
      List of channels' names.
  n_times : int
      Total number of time points in the raw file.
  times :  ndarray
      Time vector in seconds. Starts from 0, independently of `first_samp`
      value. Time interval between consecutive time samples is equal to the
      inverse of the sampling frequency.
  preload : bool
      Indicates whether raw data are in memory.
  %(verbose)s
code: def __init__(
      self,
      fname,
      allow_maxshield=False,
      preload=False,
      on_split_missing="raise",
      verbose=None,
  ):
      raws = []
      do_check_ext = not _file_like(fname)
      next_fname = fname
      while next_fname is not None:
          raw, next_fname, buffer_size_sec = self._read_raw_file(
              next_fname, allow_maxshield, preload, do_check_ext
          )
          do_check_ext = False
          raws.append(raw)
          if next_fname is not None:
              if not op.exists(next_fname):
                  msg = (
                      f"Split raw file detected but next file {next_fname} "
                      "does not exist. Ensure all files were transferred "
                      "properly and that split and original files were not "
                      "manually renamed on disk (split files should be "
                      "renamed by loading and re-saving with MNE-Python to "
                      "preserve proper filename linkage)."
                  )
                  _on_missing(
                      on_split_missing, msg, name="on_split_missing"
                  )
                  break
      if _file_like(fname):
          # avoid serialization error when copying file-like
          fname = None  # noqa
  
      _check_raw_compatibility(raws)
      super().__init__(
          copy.deepcopy(raws[0].info),
          False,
          [r.first_samp for r in raws],
          [r.last_samp for r in raws],
          [r.filename for r in raws],
          [r._raw_extras for r in raws],
          raws[0].orig_format,
          None,
          buffer_size_sec=buffer_size_sec,
          verbose=verbose,
      )
  
      # combine annotations
      self.set_annotations(raws[0].annotations, emit_warning=False)
  
      # Add annotations for in-data skips
      for extra in self._raw_extras:
          mask = [ent is None for ent in extra["ent"]]
          start = extra["bounds"][:-1][mask]
          stop = extra["bounds"][1:][mask] - 1
          duration = (stop - start + 1.0) / self.info["sfreq"]
          annot = Annotations(
              onset=(start / self.info["sfreq"]),
              duration=duration,
              description="BAD_ACQ_SKIP",
              orig_time=self.info["meas_date"],
          )
  
          self._annotations += annot
  
      if preload:
          self._preload_data(preload)
      else:
          self.preload = False
      # If using a file-like object, fix the filenames to be representative
      # strings now instead of the file-like objects
      self._filenames = [
          _get_fname_rep(fname) for fname in self._filenames
      ]
  
imports: import copy
  import os
  import os.path
  import numpy
  from ..._fiff.constants import FIFF
  from ..._fiff.meas_info import read_meas_info
  from ..._fiff.open import _fiff_get_fid, _get_next_fname, fiff_open
  from ..._fiff.tag import _call_dict, read_tag
  from ..._fiff.tree import dir_tree_find
  from ..._fiff.utils import _mult_cal_one
  from ...annotations import Annotations, _read_annotations_fif
  from ...channels import fix_mag_coil_types
  from ...event import AcqParserFIF
  from ...utils import _check_fname, _file_like, _on_missing, check_fname, fill_doc, logger, verbose, warn
  from ..base import BaseRaw, _check_maxshield, _check_raw_compatibility, _get_fname_rep, _RawShell
label_desc: Use image node_id 1 to create a new Raw object from inherited base classes: BaseRaw with example: obj = Raw(fname, allow_maxshield, preload, on_split_missing, verbose)