class_docstr: Estimator to filter data array along the last dimension.
  
  Applies a zero-phase low-pass, high-pass, band-pass, or band-stop
  filter to the channels.
  
  l_freq and h_freq are the frequencies below which and above which,
  respectively, to filter out of the data. Thus the uses are:
  
      - l_freq < h_freq: band-pass filter
      - l_freq > h_freq: band-stop filter
      - l_freq is not None, h_freq is None: low-pass filter
      - l_freq is None, h_freq is not None: high-pass filter
  
  See :func:`mne.filter.filter_data`.
  
  Parameters
  ----------
  l_freq : float | None
      Low cut-off frequency in Hz. If None the data are only low-passed.
  h_freq : float | None
      High cut-off frequency in Hz. If None the data are only
      high-passed.
  sfreq : float, default 1.0
      Sampling frequency in Hz.
  filter_length : str | int, default 'auto'
      Length of the FIR filter to use (if applicable):
  
          * int: specified length in samples.
          * 'auto' (default in 0.14): the filter length is chosen based
            on the size of the transition regions (7 times the reciprocal
            of the shortest transition band).
          * str: (default in 0.13 is "10s") a human-readable time in
            units of "s" or "ms" (e.g., "10s" or "5500ms") will be
            converted to that number of samples if ``phase="zero"``, or
            the shortest power-of-two length at least that duration for
            ``phase="zero-double"``.
  
  l_trans_bandwidth : float | str
      Width of the transition band at the low cut-off frequency in Hz
      (high pass or cutoff 1 in bandpass). Can be "auto"
      (default in 0.14) to use a multiple of ``l_freq``::
  
          min(max(l_freq * 0.25, 2), l_freq)
  
      Only used for ``method='fir'``.
  h_trans_bandwidth : float | str
      Width of the transition band at the high cut-off frequency in Hz
      (low pass or cutoff 2 in bandpass). Can be "auto"
      (default in 0.14) to use a multiple of ``h_freq``::
  
          min(max(h_freq * 0.25, 2.), info['sfreq'] / 2. - h_freq)
  
      Only used for ``method='fir'``.
  n_jobs : int | str, default 1
      Number of jobs to run in parallel.
      Can be 'cuda' if ``cupy`` is installed properly and method='fir'.
  method : str, default 'fir'
      'fir' will use overlap-add FIR filtering, 'iir' will use IIR
      forward-backward filtering (via filtfilt).
  iir_params : dict | None, default None
      Dictionary of parameters to use for IIR filtering.
      See mne.filter.construct_iir_filter for details. If iir_params
      is None and method="iir", 4th order Butterworth will be used.
  fir_window : str, default 'hamming'
      The window to use in FIR design, can be "hamming", "hann",
      or "blackman".
  fir_design : str
      Can be "firwin" (default) to use :func:`scipy.signal.firwin`,
      or "firwin2" to use :func:`scipy.signal.firwin2`. "firwin" uses
      a time-domain design technique that generally gives improved
      attenuation using fewer samples than "firwin2".
  
      .. versionadded:: 0.15
  %(verbose)s
  
  See Also
  --------
  FilterEstimator
  Vectorizer
  mne.filter.filter_data
code: def __init__(
      self,
      l_freq=None,
      h_freq=None,
      sfreq=1.0,
      filter_length="auto",
      l_trans_bandwidth="auto",
      h_trans_bandwidth="auto",
      n_jobs=None,
      method="fir",
      iir_params=None,
      fir_window="hamming",
      fir_design="firwin",
      *,
      verbose=None,
  ):
      self.l_freq = l_freq
      self.h_freq = h_freq
      self.sfreq = sfreq
      self.filter_length = filter_length
      self.l_trans_bandwidth = l_trans_bandwidth
      self.h_trans_bandwidth = h_trans_bandwidth
      self.n_jobs = n_jobs
      self.method = method
      self.iir_params = iir_params
      self.fir_window = fir_window
      self.fir_design = fir_design
  
      if not isinstance(self.n_jobs, int) and self.n_jobs == "cuda":
          raise ValueError(
              'n_jobs must be int or "cuda", got %s instead.'
              % type(self.n_jobs)
          )
  
imports: import numpy
  from .._fiff.pick import _pick_data_channels, _picks_by_type, _picks_to_idx, pick_info, pick_types
  from ..cov import _check_scalings_user
  from ..filter import filter_data
  from ..time_frequency import psd_array_multitaper
  from ..utils import _check_option, _validate_type, fill_doc, verbose
  from .base import BaseEstimator
  from .mixin import TransformerMixin
label_desc: Use image node_id 1 to create a new TemporalFilter object from inherited base classes: TransformerMixin with example: obj = TemporalFilter(l_freq, h_freq, sfreq, filter_length, l_trans_bandwidth, h_trans_bandwidth, n_jobs, method, iir_params, fir_window, fir_design)