docs: def check_fast(self, reproduce=False, **args):
          """
          Check hash value for all filepaths using a fast hash function and fall
          back to slower full hash functions if fast hashes fail to agree.
          """
          hashvals = {}
  
          fast_check = self.check_file(
              filepaths=self.data.keys(),
              hashvals=hashvals,
              hashfn=fast_hashes,
              shortcircuit=True,
              **args
          )
  
          if not fast_check:
  
              # Save all the fast hashes for failed files that we've already
              # calculated
              for filepath in hashvals:
                  for hash, val in hashvals[filepath].items():
                      self.data[filepath]['hashes'][hash] = val
  
              if reproduce:
                  for filepath in hashvals:
                      print('Check failed for {0} {1}'
                            ''.format(filepath, hashvals[filepath]))
                      tmphash = {}
                      full_check = self.check_file(
                          filepaths=filepath,
                          hashfn=full_hashes,
                          hashvals=tmphash,
                          shortcircuit=False,
                          **args
                      )
  
                      if full_check:
                          # File is still ok, so replace fast hashes
                          print('Full hashes ({0}) checked ok'
                                ''.format(full_hashes))
                          print('Updating fast hashes for {0} in {1}'
                                ''.format(filepath, self.path))
                          self.add_fast(filepath, force=True)
                          print('Saving updated manifest')
                          self.needsync = True
                      else:
                          sys.stderr.write(
                              'Run cannot reproduce: manifest {0} is not '
                              'correct\n'.format(self.path)
                          )
                          for path, hashdict in tmphash.items():
                              print('    {0}:'.format(path))
                              for hash, val in hashdict.items():
                                  hash_table = self.data[path]['hashes']
                                  hash_table_val = hash_table.get(hash, None)
                                  print('        {0}: {1} != {2}'
                                        ''.format(hash, val, hash_table_val))
                          sys.exit(1)
              else:
                  # Not relevant if full hashes are correct. Regenerate full
                  # hashes for all filepaths that failed fast check.
                  print('Updating full hashes for {0} files in {1}'
                        ''.format(len(hashvals), self.path))
  
                  # Add all full hashes at once -- much faster. Definitely want
                  # to force the full hash to be updated. In the specific case of
                  # an empty hash the value will be None, without force it will
                  # be written as null.
                  self.add(
                      filepaths=list(hashvals.keys()),
                      hashfn=full_hashes,
                      force=True,
                      fullpaths=[self.fullpath(fpath) for fpath
                                 in list(hashvals.keys())]
                  )
  
                  # Flag need to update version on disk
                  self.needsync = True