code: def source_band_induced_power(
      epochs,
      inverse_operator,
      bands,
      label=None,
      lambda2=1.0 / 9.0,
      method="dSPM",
      nave=1,
      n_cycles=5,
      df=1,
      use_fft=False,
      decim=1,
      baseline=None,
      baseline_mode="logratio",
      pca=True,
      n_jobs=None,
      prepared=False,
      method_params=None,
      use_cps=True,
      *,
      verbose=None,
  ):
      """Compute source space induced power in given frequency bands.
  
      Parameters
      ----------
      epochs : instance of Epochs
          The epochs.
      inverse_operator : instance of InverseOperator
          The inverse operator.
      bands : dict
          Example : bands = dict(alpha=[8, 9]).
      label : Label | list of Label
          Restricts the source estimates to a given label or list of labels. If
          labels are provided in a list, power will be averaged over vertices.
      lambda2 : float
          The regularization parameter of the minimum norm.
      method : "MNE" | "dSPM" | "sLORETA" | "eLORETA"
          Use minimum norm, dSPM (default), sLORETA, or eLORETA.
      nave : int
          The number of averages used to scale the noise covariance matrix.
      n_cycles : float | array of float
          Number of cycles. Fixed number or one per frequency.
      df : float
          Delta frequency within bands.
      use_fft : bool
          Do convolutions in time or frequency domain with FFT.
      decim : int
          Temporal decimation factor.
      baseline : None (default) or tuple, shape (2,)
          The time interval to apply 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.
      baseline_mode : 'mean' | 'ratio' | 'logratio' | 'percent' | 'zscore' | 'zlogratio'
          Perform baseline correction by
  
          - subtracting the mean of baseline values ('mean')
          - dividing by the mean of baseline values ('ratio')
          - dividing by the mean of baseline values and taking the log
            ('logratio')
          - subtracting the mean of baseline values followed by dividing by
            the mean of baseline values ('percent')
          - subtracting the mean of baseline values and dividing by the
            standard deviation of baseline values ('zscore')
          - dividing by the mean of baseline values, taking the log, and
            dividing by the standard deviation of log baseline values
            ('zlogratio')
  
      pca : bool
          If True, the true dimension of data is estimated before running
          the time-frequency transforms. It reduces the computation times
          e.g. with a dataset that was maxfiltered (true dim is 64).
      %(n_jobs)s
      prepared : bool
          If True, do not call :func:`prepare_inverse_operator`.
      method_params : dict | None
          Additional options for eLORETA. See Notes of :func:`apply_inverse`.
  
          .. versionadded:: 0.16
      %(use_cps_restricted)s
  
          .. versionadded:: 0.20
      %(verbose)s
  
      Returns
      -------
      stcs : dict of SourceEstimate (or VolSourceEstimate)
          The estimated source space induced power estimates in shape
          (n_vertices, n_frequencies, n_samples) if label=None or label=label.
          For lists of one or more labels, the induced power estimate has shape
          (n_labels, n_frequencies, n_samples).
      """  # noqa: E501
      _check_option("method", method, INVERSE_METHODS)
  
      freqs = np.concatenate(
          [
              np.arange(band[0], band[1] + df / 2.0, df)
              for _, band in bands.items()
          ]
      )
  
      powers, _, vertno = _source_induced_power(
          epochs,
          inverse_operator,
          freqs,
          label=label,
          lambda2=lambda2,
          method=method,
          nave=nave,
          n_cycles=n_cycles,
          decim=decim,
          use_fft=use_fft,
          pca=pca,
          n_jobs=n_jobs,
          with_plv=False,
          prepared=prepared,
          method_params=method_params,
          use_cps=use_cps,
      )
  
      Fs = epochs.info["sfreq"]  # sampling in Hz
      stcs = dict()
  
      subject = _subject_from_inverse(inverse_operator)
      _log_rescale(baseline, baseline_mode)  # for early failure
      for name, band in bands.items():
          idx = [
              k for k, f in enumerate(freqs) if band[0] <= f <= band[1]
          ]
  
          # average power in band + mean over epochs
          power = np.mean(powers[:, idx, :], axis=1)
  
          # Run baseline correction
          power = rescale(
              power,
              epochs.times[::decim],
              baseline,
              baseline_mode,
              copy=False,
              verbose=False,
          )
  
          tmin = epochs.times[0]
          tstep = float(decim) / Fs
          stc = _make_stc(
              power,
              vertices=vertno,
              tmin=tmin,
              tstep=tstep,
              subject=subject,
              src_type=inverse_operator["src"].kind,
          )
          stcs[name] = stc
  
          logger.info("[done]")
  
      return stcs
  
imports: import numpy
  from .._fiff.constants import FIFF
  from .._fiff.pick import pick_info
  from ..baseline import _log_rescale, rescale
  from ..epochs import Epochs
  from ..event import make_fixed_length_events
  from ..evoked import EvokedArray
  from ..fixes import _safe_svd
  from ..label import BiHemiLabel, Label
  from ..parallel import parallel_func
  from ..source_estimate import _make_stc
  from ..time_frequency.multitaper import _compute_mt_params, _mt_spectra, _psd_from_mt, _psd_from_mt_adaptive
  from ..time_frequency.tfr import cwt, morlet
  from ..utils import ProgressBar, _check_option, _pl, _validate_type, logger, verbose
  from .inverse import INVERSE_METHODS, _assemble_kernel, _check_or_prepare, _check_ori, _pick_channels_inverse_operator, _subject_from_inverse, combine_xyz
label_desc: Use image node_id 3 for calling a global function with example usage: source_band_induced_power(epochs, inverse_operator, bands, label, lambda2, method, nave, n_cycles, df, use_fft, decim, baseline, baseline_mode, pca, n_jobs, prepared, method_params, use_cps) and returns: stcs