docs: def _spellchecker_for(word_set,
                        name,
                        spellcheck_cache_path=None,
                        sources=None):
      """Get a whoosh spellchecker for :word_set:.
  
      The word graph for this spellchecker will be stored on-disk with
      the unique-name :name: in :spellcheck_cache_path:, if it exists.
      This allows for much faster loading of word graphs after they have been
      pre-populated.
  
      :sources: is a list of filenames which will be checked to see if they
      are newer than the stored word graph. If they are newer, then the word
      graph gets repopulated.
      """
      assert "/" not in name and "\\" not in name
  
      if _spellchecker_cache.get(name, None) is not None:
          return _spellchecker_cache[name].corrector
  
      # Check the modification time of all the paths in :sources: to see
      # if they've been modified since the cache file was created. If so,
      # delete the cache file. This will cause it to be regenerated.
      #
      # Note that this relies on an implementation detail in whoosh, namely
      # that the cache file is always stored at spellcheck_cache_path/name.
      if spellcheck_cache_path:
  
          # Ensure that the directory has been created
          try:
              os.makedirs(spellcheck_cache_path)
          except OSError as error:
              if error.errno != errno.EEXIST:  # suppress(PYC90)
                  raise error
  
          graph_path = os.path.realpath(spellcheck_cache_path)
          file_storage = FileStorage(graph_path)
  
          preexisting_cache = os.path.abspath(os.path.join(spellcheck_cache_path,
                                                           name))
          if os.path.exists(preexisting_cache):
              cache_mtime = os.path.getmtime(preexisting_cache)
              for source in sources:
                  source_path = os.path.realpath(source)
                  if not os.path.exists(source_path):
                      continue
  
                  if os.path.getmtime(source_path) > cache_mtime:
                      file_storage.delete_file(name)
                      break
  
          try:
              word_graph = copy_to_ram(file_storage).open_file(name)
          except (IOError, NameError):
              word_graph = _create_word_graph_file(name, file_storage, word_set)
  
      else:
          ram_storage = RamStorage()
          word_graph = _create_word_graph_file(name, ram_storage, word_set)
  
      reader = fst.GraphReader(word_graph)
      corrector = spelling.GraphCorrector(reader)
      _spellchecker_cache[name] = SpellcheckerCacheEntry(corrector, reader)
      return corrector