code: def fill_archives(src, dst, startFrom, endAt=0, overwrite=False,
                    lock_writes=False):
      
      if lock_writes is False:
          whisper.LOCK = False
      elif whisper.CAN_LOCK and lock_writes is True:
          whisper.LOCK = True
  
      header = whisper.info(dst)
      archives = header['archives']
      archives = sorted(archives, key=lambda t: t['retention'])
  
      for archive in archives:
          fromTime = max(endAt, time.time() - archive['retention'])
          if fromTime >= startFrom:
              continue
  
          (timeInfo, values) = whisper.fetch(dst, fromTime, untilTime=startFrom)
          (start, end, step) = timeInfo
          gapstart = None
          for value in values:
              has_value = bool(value and not overwrite)
              if not has_value and not gapstart:
                  gapstart = start
              elif has_value and gapstart:
                  if (start - gapstart) >= archive['secondsPerPoint']:
                      fill(src, dst, gapstart - step, start)
                  gapstart = None
              start += step
          # fill if this gap continues to the end
          if gapstart:
              fill(src, dst, gapstart - step, end - step)
  
          # The next archive only needs to be filled up to the latest point
          # in time we updated.
          startFrom = fromTime
docs: Fills gaps in dst using data from src.
  
      src is the path as a string
      dst is the path as a string
      startFrom is the latest timestamp (archives are read backward)
      endAt is the earliest timestamp (archives are read backward).
            if absent, we take the earliest timestamp in the archive
      overwrite will write all non null points from src dst.
      lock using whisper lock if true