class_docstr: Parser for Elekta data acquisition settings.
  
  This class parses parameters (e.g. events and averaging categories) that
  are defined in the Elekta TRIUX/VectorView data acquisition software (DACQ)
  and stored in ``info['acq_pars']``. It can be used to reaverage raw data
  according to DACQ settings and modify original averaging settings if
  necessary.
  
  Parameters
  ----------
  %(info_not_none)s This is where the DACQ parameters will be taken from.
  
  Attributes
  ----------
  categories : list
      List of averaging categories marked active in DACQ.
  events : list
      List of events that are in use (referenced by some averaging category).
  reject : dict
      Rejection criteria from DACQ that can be used with mne.Epochs.
      Note that mne does not support all DACQ rejection criteria
      (e.g. spike, slope).
  flat : dict
      Flatness rejection criteria from DACQ that can be used with mne.Epochs.
  acq_dict : dict
      All DACQ parameters.
  
  See Also
  --------
  mne.io.Raw.acqparser : Access the parser through a Raw attribute.
  
  Notes
  -----
  Any averaging category (also non-active ones) can be accessed by indexing
  as ``acqparserfif['category_name']``.
code: def __init__(self, info):
      acq_pars = info["acq_pars"]
      if not acq_pars:
          raise ValueError("No acquisition parameters")
      self.acq_dict = dict(self._acqpars_gen(acq_pars))
      if "ERFversion" in self.acq_dict:
          self.compat = False  # DACQ ver >= 3.4
      elif "ERFncateg" in self.acq_dict:  # probably DACQ < 3.4
          self.compat = True
      else:
          raise ValueError("Cannot parse acquisition parameters")
      dacq_vars = (
          self._dacq_vars_compat if self.compat else self._dacq_vars
      )
      # set instance variables
      for var in dacq_vars:
          val = self.acq_dict["ERF" + var]
          if var[:3] in ["mag", "meg", "eeg", "eog", "ecg"]:
              val = float(val)
          elif var in ["ncateg", "nevent"]:
              val = int(val)
          setattr(self, var.lower(), val)
      self.stimsource = (
          "Internal" if self.stimsource == "1" else "External"
      )
      # collect all events and categories
      self._events = self._events_from_acq_pars()
      self._categories = self._categories_from_acq_pars()
      # mark events that are used by a category
      for cat in self._categories.values():
          if cat["event"]:
              self._events[cat["event"]]["in_use"] = True
          if cat["reqevent"]:
              self._events[cat["reqevent"]]["in_use"] = True
      # make mne rejection dicts based on the averager parameters
      self.reject = {
          "grad": self.megmax,
          "eeg": self.eegmax,
          "eog": self.eogmax,
          "ecg": self.ecgmax,
      }
      if not self.compat:
          self.reject["mag"] = self.magmax
      self.reject = {
          k: float(v) for k, v in self.reject.items() if float(v) > 0
      }
      self.flat = {"grad": self.megmin, "eeg": self.eegmin}
      if not self.compat:
          self.flat["mag"] = self.magmin
      self.flat = {
          k: float(v) for k, v in self.flat.items() if float(v) > 0
      }
  
imports: from collections.abc import Sequence
  from pathlib import Path
  import numpy
  from ._fiff.constants import FIFF
  from ._fiff.open import fiff_open
  from ._fiff.pick import pick_channels
  from ._fiff.tag import read_tag
  from ._fiff.tree import dir_tree_find
  from ._fiff.write import end_block, start_and_end_file, start_block, write_int
  from .utils import _check_fname, _check_integer_or_list, _check_on_missing, _check_option, _get_stim_channel, _on_missing, _pl, _validate_type, check_fname, fill_doc, logger, verbose, warn
label_desc: Use image node_id 1 to create a new AcqParserFIF object  with example: obj = AcqParserFIF(info)