Python spelling.SpellChecker类代码示例

 def create_spelling_suggestion(self, query_string):
     spelling_suggestion = None
     sp = SpellChecker(self.storage)
     cleaned_query = force_unicode(query_string)
     
     if not query_string:
         return spelling_suggestion
     
     # Clean the string.
     for rev_word in self.RESERVED_WORDS:
         cleaned_query = cleaned_query.replace(rev_word, '')
     
     for rev_char in self.RESERVED_CHARACTERS:
         cleaned_query = cleaned_query.replace(rev_char, '')
     
     # Break it down.
     query_words = cleaned_query.split()
     suggested_words = []
     
     for word in query_words:
         suggestions = sp.suggest(word, number=1)
         
         if len(suggestions) > 0:
             suggested_words.append(suggestions[0])
     
     spelling_suggestion = ' '.join(suggested_words)
     return spelling_suggestion

 def update(self, index, iterable, commit=True):
     if not self.setup_complete:
         self.setup()
     
     self.index = self.index.refresh()
     writer = AsyncWriter(self.index)
     
     for obj in iterable:
         doc = index.full_prepare(obj)
         
         # Really make sure it's unicode, because Whoosh won't have it any
         # other way.
         for key in doc:
             doc[key] = self._from_python(doc[key])
         
         writer.update_document(**doc)
     
     if len(iterable) > 0:
         # For now, commit no matter what, as we run into locking issues otherwise.
         writer.commit()
         
         # If spelling support is desired, add to the dictionary.
         if getattr(settings, 'HAYSTACK_INCLUDE_SPELLING', False) is True:
             sp = SpellChecker(self.storage)
             sp.add_field(self.index, self.content_field_name)

 def update(self, index, iterable, commit=True):
     if not self.setup_complete:
         self.setup()
     
     self.index = self.index.refresh()
     writer = self.index.writer()
     
     for obj in iterable:
         doc = {}
         doc['id'] = force_unicode(self.get_identifier(obj))
         doc['django_ct'] = force_unicode("%s.%s" % (obj._meta.app_label, obj._meta.module_name))
         doc['django_id'] = force_unicode(obj.pk)
         other_data = index.prepare(obj)
         
         # Really make sure it's unicode, because Whoosh won't have it any
         # other way.
         for key in other_data:
             other_data[key] = self._from_python(other_data[key])
         
         doc.update(other_data)
         writer.update_document(**doc)
     
     # For now, commit no matter what, as we run into locking issues otherwise.
     writer.commit()
     
     # If spelling support is desired, add to the dictionary.
     if getattr(settings, 'HAYSTACK_INCLUDE_SPELLING', False) is True:
         sp = SpellChecker(self.storage)
         sp.add_field(self.index, self.content_field_name)

 def update(self, documents, commit=True):
     writer = self.index.writer()
     
     for doc in documents:
         writer.update_document(**doc)
     
     if commit is True:
         writer.commit()
     
     # If spelling support is desired, add to the dictionary.
     if self.include_spelling is True:
         sp = SpellChecker(self.storage)
         sp.add_field(self.index, self.content_field_name)

def run_query(query, index):
    """
      Queries the index for data with the given text query

        @param  query   The text query to perform on the indexed data
        @return			A list of HTMl string snippets to return
    """

    # Create a searcher object for this index
    searcher = index.searcher()

    # Create a query parser that will parse multiple fields of the documents
    field_boosts = {
        'content': 1.0,
        'title': 3.0
    }
    query_parser = MultifieldParser(['content', 'title'], schema=index_schema, fieldboosts=field_boosts, group=OrGroup)

    # Build a query object from the query string
    query_object = query_parser.parse(query)

    # Build a spell checker in this index and add the "content" field to the spell checker
    spell_checker = SpellChecker(index.storage)
    spell_checker.add_field(index, 'content')
    spell_checker.add_field(index, 'title')

    # Extract the 'terms' that were found in the query string. This data can be used for highlighting the results
    search_terms = [text for fieldname, text in query_object.all_terms()]

    # Remove terms that are too short
    for search_term in search_terms:
        if len(search_term) <= 3:
            search_terms.remove(search_term)

    # Perform the query itself
    search_results = searcher.search(query_object)

    # Get an analyzer for analyzing the content of each page for highlighting
    analyzer = index_schema['content'].format.analyzer

    # Build the fragmenter object, which will automatically split up excerpts. This fragmenter will split up excerpts
    #   by 'context' in the content
    fragmenter = ContextFragmenter(frozenset(search_terms))

    # Build the formatter, which will dictate how to highlight the excerpts. In this case, we want to use HTML to
    #   highlight the results
    formatter = HtmlFormatter()

    # Iterate through the search results, highlighting and counting the results
    result_count = 0
    results = []
    for search_result in search_results:
        # Collect this search result
        results.append({
            'content': highlight(search_result['content'], search_terms, analyzer, fragmenter, formatter),
            'url': search_result['url'],
            'title': search_result['title']
        })
        result_count += 1

    # Build a list of 'suggest' words using the spell checker
    suggestions = []
    for term in search_terms:
        suggestions.append(spell_checker.suggest(term))

    # Return the list of web pages along with the terms used in the search
    return results, search_terms, suggestions, result_count