docs: def smooth(self, factors, channel=None, verbose=True) -> "Data":
          """Smooth a channel using an n-dimenional kaiser window.
  
          Note, all arrays are loaded into memory.
  
          For more info see `Kaiser_window`__ wikipedia entry.
  
          __ https://en.wikipedia.org/wiki/Kaiser_window
  
          Parameters
          ----------
          factors : int or list of int
              The smoothing factor. You may provide a list of smoothing factors
              for each axis.
          channel : int or str or None (optional)
              The channel to smooth. If None, all channels will be smoothed.
              Default is None.
          verbose : bool (optional)
              Toggle talkback. Default is True.
          """
          warnings.warn("smooth", category=wt_exceptions.EntireDatasetInMemoryWarning)
          # get factors -----------------------------------------------------------------------------
  
          if isinstance(factors, list):
              pass
          else:
              dummy = np.zeros(len(self._axes))
              dummy[::] = factors
              factors = list(dummy)
          # get channels ----------------------------------------------------------------------------
          if channel is None:
              channels = self.channels
          else:
              if isinstance(channel, int):
                  channel_index = channel
              elif isinstance(channel, str):
                  channel_index = self.channel_names.index(channel)
              else:
                  raise TypeError("channel: expected {int, str}, got %s" % type(channel))
              channels = [self.channels[channel_index]]
          # smooth ----------------------------------------------------------------------------------
          for channel in channels:
              values = channel[:]
              for axis_index in range(len(factors)):
                  factor = factors[axis_index]
                  # transpose so the axis of interest is last
                  transpose_order = range(len(values.shape))
                  # replace axis_index with zero
                  transpose_order = [
                      len(values.shape) - 1 if i == axis_index else i for i in transpose_order
                  ]
                  transpose_order[len(values.shape) - 1] = axis_index
                  values = values.transpose(transpose_order)
                  # get kaiser window
                  beta = 5.0
                  w = np.kaiser(2 * factor + 1, beta)
                  # for all slices...
                  for index in np.ndindex(values[..., 0].shape):
                      current_slice = values[index]
                      temp_slice = np.pad(current_slice, int(factor), mode=str("edge"))
                      values[index] = np.convolve(temp_slice, w / w.sum(), mode=str("valid"))
                  # transpose out
                  values = values.transpose(transpose_order)
              # return array to channel object
              channel[:] = values
          if verbose:
              print("smoothed data")