docs: def _timestamp_regulator(self):
          """
          Makes a dictionary whose keys are audio file basenames and whose
          values are a list of word blocks from unregulated timestamps and
          updates the main timestamp attribute. After all done, purges
          unregulated ones.
          In case the audio file was large enough to be splitted, it adds seconds
          to correct timing and in case the timestamp was manually loaded, it
          leaves it alone.
  
          Note that the difference between self.__timestamps and
          self.__timestamps_unregulated is that in the regulated version,
          right after the word, a list of word blocks must appear. However in the
          unregulated version, after a word, a list of individual splits
          containing word blocks would appear!
          """
          unified_timestamps = _PrettyDefaultDict(list)
          staged_files = self._list_audio_files(sub_dir="staging")
          for timestamp_basename in self.__timestamps_unregulated:
              if len(self.__timestamps_unregulated[timestamp_basename]) > 1:
                  # File has been splitted
                  timestamp_name = ''.join(timestamp_basename.split('.')[:-1])
                  staged_splitted_files_of_timestamp = list(
                      filter(lambda staged_file: (
                          timestamp_name == staged_file[:-3] and
                          all([(x in set(map(str, range(10))))
                               for x in staged_file[-3:]])), staged_files))
                  if len(staged_splitted_files_of_timestamp) == 0:
                      self.__errors[(time(), timestamp_basename)] = {
                          "reason": "Missing staged file",
                          "current_staged_files": staged_files}
                      continue
                  staged_splitted_files_of_timestamp.sort()
                  unified_timestamp = list()
                  for staging_digits, splitted_file in enumerate(
                          self.__timestamps_unregulated[timestamp_basename]):
                      prev_splits_sec = 0
                      if int(staging_digits) != 0:
                          prev_splits_sec = self._get_audio_duration_seconds(
                              "{}/staging/{}{:03d}".format(
                                  self.src_dir, timestamp_name,
                                  staging_digits - 1))
                      for word_block in splitted_file:
                          unified_timestamp.append(
                              _WordBlock(
                                  word=word_block.word,
                                  start=round(word_block.start +
                                              prev_splits_sec, 2),
                                  end=round(word_block.end +
                                            prev_splits_sec, 2)))
                  unified_timestamps[
                      str(timestamp_basename)] += unified_timestamp
              else:
                  unified_timestamps[
                      timestamp_basename] += self.__timestamps_unregulated[
                          timestamp_basename][0]
  
          self.__timestamps.update(unified_timestamps)
          self.__timestamps_unregulated = _PrettyDefaultDict(list)