code: def create_eog_epochs(
      raw,
      ch_name=None,
      event_id=998,
      picks=None,
      tmin=-0.5,
      tmax=0.5,
      l_freq=1,
      h_freq=10,
      reject=None,
      flat=None,
      baseline=None,
      preload=True,
      reject_by_annotation=True,
      thresh=None,
      decim=1,
      verbose=None,
  ):
      """Conveniently generate epochs around EOG artifact events.
  
      %(create_eog_epochs)s
  
      Parameters
      ----------
      raw : instance of Raw
          The raw data.
      %(ch_name_eog)s
      event_id : int
          The index to assign to found events.
      %(picks_all)s
      tmin : float
          Start time before event.
      tmax : float
          End time after event.
      l_freq : float
          Low pass frequency to apply to the EOG channel while finding events.
      h_freq : float
          High pass frequency to apply to the EOG channel while finding events.
      reject : dict | None
          Rejection parameters based on peak-to-peak amplitude.
          Valid keys are 'grad' | 'mag' | 'eeg' | 'eog' | 'ecg'.
          If reject is None then no rejection is done. Example::
  
              reject = dict(grad=4000e-13, # T / m (gradiometers)
                            mag=4e-12, # T (magnetometers)
                            eeg=40e-6, # V (EEG channels)
                            eog=250e-6 # V (EOG channels)
                            )
  
      flat : dict | None
          Rejection parameters based on flatness of signal.
          Valid keys are 'grad' | 'mag' | 'eeg' | 'eog' | 'ecg', and values
          are floats that set the minimum acceptable peak-to-peak amplitude.
          If flat is None then no rejection is done.
      baseline : tuple or list of length 2, or None
          The time interval to apply rescaling / baseline correction.
          If None do not apply it. If baseline is (a, b)
          the interval is between "a (s)" and "b (s)".
          If a is None the beginning of the data is used
          and if b is None then b is set to the end of the interval.
          If baseline is equal to (None, None) all the time
          interval is used. If None, no correction is applied.
      preload : bool
          Preload epochs or not.
      %(reject_by_annotation_epochs)s
  
          .. versionadded:: 0.14.0
      thresh : float
          Threshold to trigger EOG event.
      %(decim)s
  
          .. versionadded:: 0.21.0
      %(verbose)s
  
      Returns
      -------
      eog_epochs : instance of Epochs
          Data epoched around EOG events.
  
      See Also
      --------
      find_eog_events
      compute_proj_eog
  
      Notes
      -----
      Filtering is only applied to the EOG channel while finding events.
      The resulting ``eog_epochs`` will have no filtering applied (i.e., have
      the same filter properties as the input ``raw`` instance).
      """
      events = find_eog_events(
          raw,
          ch_name=ch_name,
          event_id=event_id,
          l_freq=l_freq,
          h_freq=h_freq,
          reject_by_annotation=reject_by_annotation,
          thresh=thresh,
      )
  
      # create epochs around EOG events
      eog_epochs = Epochs(
          raw,
          events=events,
          event_id=event_id,
          tmin=tmin,
          tmax=tmax,
          proj=False,
          reject=reject,
          flat=flat,
          picks=picks,
          baseline=baseline,
          preload=preload,
          reject_by_annotation=reject_by_annotation,
          decim=decim,
      )
      return eog_epochs
  
file_path: mne-python/mne/preprocessing/eog.py
imports: import numpy
  from .._fiff.pick import pick_channels, pick_types
  from ..epochs import Epochs
  from ..filter import filter_data
  from ..utils import _pl, _validate_type, logger, verbose
  from ._peak_finder import peak_finder
label_desc: Use image node_id 4 for calling a global function with example usage: create_eog_epochs(raw, ch_name, event_id, picks, tmin, tmax, l_freq, h_freq, reject, flat, baseline, preload, reject_by_annotation, thresh, decim, verbose) and returns: eog_epochs