docs: def get(self, spike_ids, channels=None):
          """Load the waveforms of the specified spikes."""
          if isinstance(spike_ids, slice):
              spike_ids = _range_from_slice(spike_ids,
                                            start=0,
                                            stop=self.n_spikes,
                                            )
          if not hasattr(spike_ids, '__len__'):
              spike_ids = [spike_ids]
          if channels is None:
              channels = slice(None, None, None)
              nc = self.n_channels
          else:
              channels = np.asarray(channels, dtype=np.int32)
              assert np.all(channels < self.n_channels)
              nc = len(channels)
  
          # Ensure a list of time samples are being requested.
          spike_ids = _as_array(spike_ids)
          n_spikes = len(spike_ids)
  
          # Initialize the array.
          # NOTE: last dimension is time to simplify things.
          shape = (n_spikes, nc, self._n_samples_extract)
          waveforms = np.zeros(shape, dtype=np.float32)
  
          # No traces: return null arrays.
          if self.n_samples_trace == 0:
              return np.transpose(waveforms, (0, 2, 1))
  
          # Load all spikes.
          for i, spike_id in enumerate(spike_ids):
              assert 0 <= spike_id < self.n_spikes
              time = self._spike_samples[spike_id]
  
              # Extract the waveforms on the unmasked channels.
              try:
                  w = self._load_at(time, channels)
              except ValueError as e:  # pragma: no cover
                  logger.warn("Error while loading waveform: %s", str(e))
                  continue
  
              assert w.shape == (self._n_samples_extract, nc)
  
              waveforms[i, :, :] = w.T
  
          # Filter the waveforms.
          waveforms_f = waveforms.reshape((-1, self._n_samples_extract))
          # Only filter the non-zero waveforms.
          unmasked = waveforms_f.max(axis=1) != 0
          waveforms_f[unmasked] = self._filter(waveforms_f[unmasked], axis=1)
          waveforms_f = waveforms_f.reshape((n_spikes, nc,
                                             self._n_samples_extract))
  
          # Remove the margin.
          margin_before, margin_after = self._filter_margin
          if margin_after > 0:
              assert margin_before >= 0
              waveforms_f = waveforms_f[:, :, margin_before:-margin_after]
  
          assert waveforms_f.shape == (n_spikes,
                                       nc,
                                       self.n_samples_waveforms,
                                       )
  
          # NOTE: we transpose before returning the array.
          return np.transpose(waveforms_f, (0, 2, 1))