class_docstr: Epochs Array object from KIT SQD file.
  
  Parameters
  ----------
  input_fname : path-like
      Path to the sqd file.
  events : array of int, shape (n_events, 3) | path-like
      The array of :term:`events`. The first column contains the event time
      in samples, with :term:`first_samp` included. The third column contains
      the event id. If a path, must yield a ``.txt`` file containing the
      events.
      If some events don't match the events of interest as specified by
      ``event_id``, they will be marked as ``IGNORED`` in the drop log.
  %(event_id)s
  tmin : float
      Start time before event.
  %(baseline_epochs)s
  %(reject_epochs)s
  %(flat)s
  %(epochs_reject_tmin_tmax)s
  %(kit_mrk)s
  %(kit_elp)s
  %(kit_hsp)s
  allow_unknown_format : bool
      Force reading old data that is not officially supported. Alternatively,
      read and re-save the data with the KIT MEG Laboratory application.
  %(standardize_names)s
  %(verbose)s
  
  Notes
  -----
  ``elp`` and ``hsp`` are usually the exported text files (*.txt) from the
  Polhemus FastScan system. hsp refers to the headshape surface points. elp
  refers to the points in head-space that corresponds to the HPI points.
  Currently, '*.elp' and '*.hsp' files are NOT supported.
  
  See Also
  --------
  mne.Epochs : Documentation of attributes and methods.
code: def __init__(
      self,
      input_fname,
      events,
      event_id=None,
      tmin=0,
      baseline=None,
      reject=None,
      flat=None,
      reject_tmin=None,
      reject_tmax=None,
      mrk=None,
      elp=None,
      hsp=None,
      allow_unknown_format=False,
      standardize_names=None,
      verbose=None,
  ):
      if isinstance(events, (str, PathLike, Path)):
          events = read_events(events)
  
      input_fname = str(
          _check_fname(
              fname=input_fname, must_exist=True, overwrite="read"
          )
      )
      logger.info("Extracting KIT Parameters from %s..." % input_fname)
      self.info, kit_info = get_kit_info(
          input_fname, allow_unknown_format, standardize_names
      )
      kit_info.update(input_fname=input_fname)
      self._raw_extras = [kit_info]
      self._filenames = []
      if len(events) != self._raw_extras[0]["n_epochs"]:
          raise ValueError(
              "Event list does not match number of epochs."
          )
  
      if self._raw_extras[0]["acq_type"] == KIT.EPOCHS:
          self._raw_extras[0]["data_length"] = KIT.INT
      else:
          raise TypeError(
              "SQD file contains raw data, not epochs or "
              "average. Wrong reader."
          )
  
      if event_id is None:  # convert to int to make typing-checks happy
          event_id = {str(e): int(e) for e in np.unique(events[:, 2])}
  
      for key, val in event_id.items():
          if val not in events[:, 2]:
              raise ValueError(
                  "No matching events found for %s "
                  "(event id %i)" % (key, val)
              )
  
      data = self._read_kit_data()
      assert data.shape == (
          self._raw_extras[0]["n_epochs"],
          self.info["nchan"],
          self._raw_extras[0]["frame_length"],
      )
      tmax = ((data.shape[2] - 1) / self.info["sfreq"]) + tmin
      super().__init__(
          self.info,
          data,
          events,
          event_id,
          tmin,
          tmax,
          baseline,
          reject=reject,
          flat=flat,
          reject_tmin=reject_tmin,
          reject_tmax=reject_tmax,
          filename=input_fname,
          verbose=verbose,
      )
      self.info = _call_digitization(
          info=self.info, mrk=mrk, elp=elp, hsp=hsp, kit_info=kit_info
      )
      logger.info("Ready.")
  
imports: from collections import OrderedDict, defaultdict
  from math import cos, sin
  from os import SEEK_CUR, PathLike
  from os import path
  from pathlib import Path
  import numpy
  from ..._fiff.constants import FIFF
  from ..._fiff.meas_info import _empty_info
  from ..._fiff.pick import pick_types
  from ..._fiff.utils import _mult_cal_one
  from ...epochs import BaseEpochs
  from ...event import read_events
  from ...transforms import als_ras_trans, apply_trans
  from ...utils import _check_fname, _check_option, _stamp_to_dt, fill_doc, logger, verbose, warn
  from ..base import BaseRaw
  from .constants import KIT, LEGACY_AMP_PARAMS
  from .coreg import _set_dig_kit, read_mrk
label_desc: Use image node_id 1 to create a new EpochsKIT object from inherited base classes: BaseEpochs with example: obj = EpochsKIT(input_fname, events, event_id, tmin, baseline, reject, flat, reject_tmin, reject_tmax, mrk, elp, hsp, allow_unknown_format, standardize_names, verbose)