docs: def get_snippets(self, *, reference_frames, snippet_len, channel_ids=None):
          '''This function returns data snippets from the given channels that
          are starting on the given frames and are the length of the given snippet
          lengths before and after.
  
          Parameters
          ----------
          snippet_len: int or tuple
              If int, the snippet will be centered at the reference frame and
              and return half before and half after of the length. If tuple,
              it will return the first value of before frames and the second value
              of after frames around the reference frame (allows for asymmetry)
          reference_frames: array_like
              A list or array of frames that will be used as the reference frame of
              each snippet
          channel_ids: array_like
              A list or array of channel ids (ints) from which each trace will be
              extracted.
  
          Returns
          ----------
          snippets: numpy.ndarray
              Returns a list of the snippets as numpy arrays.
              The length of the list is len(reference_frames)
              Each array has dimensions: (num_channels x snippet_len)
              Out-of-bounds cases should be handled by filling in zeros in the snippet.
          '''
          # Default implementation
          if isinstance(snippet_len, (tuple, list, np.ndarray)):
              snippet_len_before = snippet_len[0]
              snippet_len_after = snippet_len[1]
          else:
              snippet_len_before = int((snippet_len + 1) / 2)
              snippet_len_after = snippet_len - snippet_len_before
  
          if channel_ids is None:
              channel_ids = self.get_channel_ids()
  
          num_snippets = len(reference_frames)
          num_channels = len(channel_ids)
          num_frames = self.get_num_frames()
          snippet_len_total = snippet_len_before + snippet_len_after
          # snippets = []
          snippets = np.zeros((num_snippets, num_channels, snippet_len_total))
          #TODO extract all waveforms in a chunk
          pad_first = False
          pad_last = False
          pad_samples_first = 0
          pad_samples_last = 0
          snippet_idxs = np.array([], dtype=int)
          for i in range(num_snippets):
              snippet_chunk = np.zeros((num_channels, snippet_len_total))
              if (0 <= reference_frames[i]) and (reference_frames[i] < num_frames):
                  snippet_range = np.array(
                      [int(reference_frames[i]) - snippet_len_before, int(reference_frames[i]) + snippet_len_after])
                  snippet_buffer = np.array([0, snippet_len_total])
                  # The following handles the out-of-bounds cases
                  if snippet_range[0] < 0:
                      snippet_buffer[0] -= snippet_range[0]
                      snippet_range[0] -= snippet_range[0]
                  if snippet_range[1] >= num_frames:
                      snippet_buffer[1] -= snippet_range[1] - num_frames
                      snippet_range[1] -= snippet_range[1] - num_frames
                  snippet_chunk[:, snippet_buffer[0]:snippet_buffer[1]] = self.get_traces(channel_ids=channel_ids,
                                                                                         start_frame=snippet_range[0],
                                                                                         end_frame=snippet_range[1])
              snippets[i] = snippet_chunk
          return snippets