+
+# TokenStream tokenStream = analyzer.tokenStream(fieldName, reader);
+# OffsetAttribute offsetAttribute = tokenStream.getAttribute(OffsetAttribute.class);
+# CharTermAttribute charTermAttribute = tokenStream.getAttribute(CharTermAttribute.class);
+
+# while (tokenStream.incrementToken()) {
+# int startOffset = offsetAttribute.startOffset();
+# int endOffset = offsetAttribute.endOffset();
+# String term = charTermAttribute.toString();
+# }
+
+
+class SearchResult(object):
+ def __init__(self, searcher, scoreDocs, score=None, how_found=None, snippets=None):
+ self.snippets = []
+
+ if score:
+ self.score = score
+ else:
+ self.score = scoreDocs.score
+
+ self.hits = []
+
+ stored = searcher.doc(scoreDocs.doc)
+ self.book_id = int(stored.get("book_id"))
+
+ header_type = stored.get("header_type")
+ if not header_type:
+ return
+
+ sec = (header_type, int(stored.get("header_index")))
+ header_span = stored.get('header_span')
+ header_span = header_span is not None and int(header_span) or 1
+
+ fragment = stored.get("fragment_anchor")
+
+ hit = (sec + (header_span,), fragment, scoreDocs.score, {'how_found': how_found, 'snippets': snippets})
+
+ self.hits.append(hit)
+
+ def merge(self, other):
+ if self.book_id != other.book_id:
+ raise ValueError("this search result is or book %d; tried to merge with %d" % (self.book_id, other.book_id))
+ self.hits += other.hits
+ if other.score > self.score:
+ self.score = other.score
+ return self
+
+ def get_book(self):
+ return catalogue.models.Book.objects.get(id=self.book_id)
+
+ book = property(get_book)
+
+ def process_hits(self):
+ frags = filter(lambda r: r[1] is not None, self.hits)
+ sect = filter(lambda r: r[1] is None, self.hits)
+ sect = filter(lambda s: 0 == len(filter(
+ lambda f: s[0][1] >= f[0][1] and s[0][1] < f[0][1] + f[0][2],
+ frags)), sect)
+
+ hits = []
+
+ for s in sect:
+ m = {'score': s[2],
+ 'header_index': s[0][1]
+ }
+ m.update(s[3])
+ hits.append(m)
+
+ for f in frags:
+ frag = catalogue.models.Fragment.objects.get(anchor=f[1])
+ m = {'score': f[2],
+ 'fragment': frag,
+ 'themes': frag.tags.filter(category='theme')
+ }
+ m.update(f[3])
+ hits.append(m)
+
+ hits.sort(lambda a, b: cmp(a['score'], b['score']), reverse=True)
+
+ print("--- %s" % hits)
+
+ return hits
+
+ def __unicode__(self):
+ return u'SearchResult(book_id=%d, score=%d)' % (self.book_id, self.score)
+
+ @staticmethod
+ def aggregate(*result_lists):
+ books = {}
+ for rl in result_lists:
+ for r in rl:
+ if r.book_id in books:
+ books[r.book_id].merge(r)
+ #print(u"already have one with score %f, and this one has score %f" % (books[book.id][0], found.score))
+ else:
+ books[r.book_id] = r
+ return books.values()
+
+ def __cmp__(self, other):
+ return cmp(self.score, other.score)
+
+
+class Hint(object):
+ def __init__(self, search):
+ self.search = search
+ self.book_tags = {}
+ self.part_tags = []
+ self._books = []
+
+ def books(self, *books):
+ self._books = books
+
+ def tags(self, tags):
+ for t in tags:
+ if t.category in ['author', 'title', 'epoch', 'genre', 'kind']:
+ lst = self.book_tags.get(t.category, [])
+ lst.append(t)
+ self.book_tags[t.category] = lst
+ if t.category in ['theme']:
+ self.part_tags.append(t)
+
+ def tag_filter(self, tags, field='tags'):
+ q = BooleanQuery()
+
+ for tag in tags:
+ toks = self.search.get_tokens(tag.name, field=field)
+ tag_phrase = PhraseQuery()
+ for tok in toks:
+ tag_phrase.add(Term(field, tok))
+ q.add(BooleanClause(tag_phrase, BooleanClause.Occur.MUST))
+
+ return QueryWrapperFilter(q)
+
+ def book_filter(self):
+ tags = reduce(lambda a, b: a + b, self.book_tags.values(), [])
+ if tags:
+ return self.tag_filter(tags)
+ else:
+ return None
+
+ def part_filter(self):
+ fs = []
+ if self.part_tags:
+ fs.append(self.tag_filter(self.part_tags, field='themes'))
+
+ if self._books != []:
+ bf = BooleanFilter()
+ for b in self._books:
+ id_filter = NumericRangeFilter.newIntRange('book_id', b.id, b.id, True, True)
+ bf.add(FilterClause(id_filter, BooleanClause.Occur.SHOULD))
+ fs.append(bf)
+
+ return MultiSearch.chain_filters(fs)
+
+ def should_search_for_book(self):
+ return self._books == []
+
+ def just_search_in(self, all):
+ """Holds logic to figure out which indexes should be search, when we have some hinst already"""
+ some = []
+ for field in all:
+ if field == 'authors' and 'author' in self.book_tags:
+ continue
+ if field == 'title' and self._books != []:
+ continue
+ if (field == 'themes' or field == 'themes_pl') and self.part_tags:
+ continue
+ some.append(field)
+ return some
+
+
+class MultiSearch(Search):
+ """Class capable of IMDb-like searching"""
+ def get_tokens(self, searched, field='content'):
+ """returns tokens analyzed by a proper (for a field) analyzer
+ argument can be: StringReader, string/unicode, or tokens. In the last case
+ they will just be returned (so we can reuse tokens, if we don't change the analyzer)
+ """
+ if isinstance(searched, str) or isinstance(searched, unicode):
+ searched = StringReader(searched)
+ elif isinstance(searched, list):
+ return searched
+
+ searched.reset()
+ tokens = self.analyzer.reusableTokenStream(field, searched)
+ toks = []
+ while tokens.incrementToken():
+ cta = tokens.getAttribute(CharTermAttribute.class_)
+ toks.append(cta.toString())
+ return toks
+
+ def fuzziness(self, fuzzy):
+ if not fuzzy:
+ return None
+ if isinstance(fuzzy, float) and fuzzy > 0.0 and fuzzy <= 1.0:
+ return fuzzy
+ else:
+ return 0.5
+
+ def make_phrase(self, tokens, field='content', slop=2, fuzzy=False):
+ if fuzzy:
+ phrase = MultiPhraseQuery()
+ for t in tokens:
+ term = Term(field, t)
+ fuzzterm = FuzzyTermEnum(self.searcher.getIndexReader(), term, self.fuzziness(fuzzy))
+ fuzzterms = []
+
+ while True:
+ # print("fuzz %s" % unicode(fuzzterm.term()).encode('utf-8'))
+ ft = fuzzterm.term()
+ if ft:
+ fuzzterms.append(ft)
+ if not fuzzterm.next(): break
+ if fuzzterms:
+ phrase.add(JArray('object')(fuzzterms, Term))
+ else:
+ phrase.add(term)
+ else:
+ phrase = PhraseQuery()
+ phrase.setSlop(slop)
+ for t in tokens:
+ term = Term(field, t)
+ phrase.add(term)
+ return phrase
+
+ def make_term_query(self, tokens, field='content', modal=BooleanClause.Occur.SHOULD, fuzzy=False):
+ q = BooleanQuery()
+ for t in tokens:
+ term = Term(field, t)
+ if fuzzy:
+ term = FuzzyQuery(term, self.fuzziness(fuzzy))
+ else:
+ term = TermQuery(term)
+ q.add(BooleanClause(term, modal))
+ return q
+
+ # def content_query(self, query):
+ # return BlockJoinQuery(query, self.parent_filter,
+ # BlockJoinQuery.ScoreMode.Total)
+
+ def search_perfect_book(self, searched, max_results=20, fuzzy=False, hint=None):
+ fields_to_search = ['authors', 'title']
+ only_in = None
+ if hint:
+ if not hint.should_search_for_book():
+ return []
+ fields_to_search = hint.just_search_in(fields_to_search)
+ only_in = hint.book_filter()
+
+ qrys = [self.make_phrase(self.get_tokens(searched, field=fld), field=fld, fuzzy=fuzzy) for fld in fields_to_search]
+
+ books = []
+ for q in qrys:
+ top = self.searcher.search(q,
+ self.chain_filters([only_in, self.term_filter(Term('is_book', 'true'))]),
+ max_results)
+ for found in top.scoreDocs:
+ books.append(SearchResult(self.searcher, found))
+ return books
+
+ def search_perfect_parts(self, searched, max_results=20, fuzzy=False, hint=None):
+ qrys = [self.make_phrase(self.get_tokens(searched), field=fld, fuzzy=fuzzy) for fld in ['content']]
+
+ flt = None
+ if hint:
+ flt = hint.part_filter()
+
+ books = []
+ for q in qrys:
+ top = self.searcher.search(q,
+ self.chain_filters([self.term_filter(Term('is_book', 'true'), inverse=True),
+ flt
+ ]),
+ max_results)
+ for found in top.scoreDocs:
+ books.append(SearchResult(self.searcher, found, snippets=self.get_snippets(found, q)))
+
+ return books
+
+ def search_everywhere(self, searched, max_results=20, fuzzy=False, hint=None):
+ books = []
+ only_in = None
+
+ if hint:
+ only_in = hint.part_filter()
+
+ # content only query : themes x content
+ q = BooleanQuery()
+
+ tokens = self.get_tokens(searched)
+ if hint is None or hint.just_search_in(['themes_pl']) != []:
+ q.add(BooleanClause(self.make_term_query(tokens, field='themes_pl',
+ fuzzy=fuzzy), BooleanClause.Occur.MUST))
+
+ q.add(BooleanClause(self.make_term_query(tokens, field='content',
+ fuzzy=fuzzy), BooleanClause.Occur.SHOULD))
+
+ topDocs = self.searcher.search(q, only_in, max_results)
+ for found in topDocs.scoreDocs:
+ books.append(SearchResult(self.searcher, found))
+
+ # query themes/content x author/title/tags
+ q = BooleanQuery()
+ # in_meta = BooleanQuery()
+ in_content = BooleanQuery()
+
+ for fld in ['themes', 'content', 'tags', 'authors', 'title']:
+ in_content.add(BooleanClause(self.make_term_query(tokens, field=fld, fuzzy=False), BooleanClause.Occur.SHOULD))
+
+ topDocs = self.searcher.search(q, only_in, max_results)
+ for found in topDocs.scoreDocs:
+ books.append(SearchResult(self.searcher, found))
+
+ return books
+
+ def multisearch(self, query, max_results=50):
+ """
+ Search strategy:
+ - (phrase) OR -> content
+ -> title
+ -> authors
+ - (keywords) -> authors
+ -> motyw
+ -> tags
+ -> content
+ """
+ # queryreader = StringReader(query)
+ # tokens = self.get_tokens(queryreader)
+
+ # top_level = BooleanQuery()
+ # Should = BooleanClause.Occur.SHOULD
+
+ # phrase_level = BooleanQuery()
+ # phrase_level.setBoost(1.3)
+
+ # p_content = self.make_phrase(tokens, joined=True)
+ # p_title = self.make_phrase(tokens, 'title')
+ # p_author = self.make_phrase(tokens, 'author')
+
+ # phrase_level.add(BooleanClause(p_content, Should))
+ # phrase_level.add(BooleanClause(p_title, Should))
+ # phrase_level.add(BooleanClause(p_author, Should))
+
+ # kw_level = BooleanQuery()
+
+ # kw_level.add(self.make_term_query(tokens, 'author'), Should)
+ # j_themes = self.make_term_query(tokens, 'themes', joined=True)
+ # kw_level.add(j_themes, Should)
+ # kw_level.add(self.make_term_query(tokens, 'tags'), Should)
+ # j_con = self.make_term_query(tokens, joined=True)
+ # kw_level.add(j_con, Should)
+
+ # top_level.add(BooleanClause(phrase_level, Should))
+ # top_level.add(BooleanClause(kw_level, Should))
+
+ return None
+
+ def book_search(self, query, filter=None, max_results=50, collector=None):
+ tops = self.searcher.search(query, filter, max_results)
+ #tops = self.searcher.search(p_content, max_results)
+
+ bks = []
+ for found in tops.scoreDocs:
+ doc = self.searcher.doc(found.doc)
+ b = catalogue.models.Book.objects.get(id=doc.get("book_id"))
+ bks.append(b)
+ print "%s (%d) -> %f" % (b, b.id, found.score)
+ return bks
+
+ def get_snippets(self, scoreDoc, query, field='content'):
+ htmlFormatter = SimpleHTMLFormatter()
+ highlighter = Highlighter(htmlFormatter, QueryScorer(query))
+
+ stored = self.searcher.doc(scoreDoc.doc)
+
+ # locate content.
+ snippets = Snippets(stored.get('book_id')).open()
+ try:
+ text = snippets.get((int(stored.get('snippets_position')),
+ int(stored.get('snippets_length'))))
+ finally:
+ snippets.close()
+
+ tokenStream = TokenSources.getAnyTokenStream(self.searcher.getIndexReader(), scoreDoc.doc, field, self.analyzer)
+ # highlighter.getBestTextFragments(tokenStream, text, False, 10)
+ # import pdb; pdb.set_trace()
+ snip = highlighter.getBestFragments(tokenStream, text, 3, "...")
+
+ return [snip]
+
+ @staticmethod
+ def enum_to_array(enum):
+ """
+ Converts a lucene TermEnum to array of Terms, suitable for
+ addition to queries
+ """
+ terms = []
+
+ while True:
+ t = enum.term()
+ if t:
+ terms.append(t)
+ if not enum.next(): break
+
+ if terms:
+ return JArray('object')(terms, Term)
+
+ def search_tags(self, query, filter=None, max_results=40):
+ tops = self.searcher.search(query, filter, max_results)
+
+ tags = []
+ for found in tops.scoreDocs:
+ doc = self.searcher.doc(found.doc)
+ tag = catalogue.models.Tag.objects.get(id=doc.get("tag_id"))
+ tags.append(tag)
+ print "%s (%d) -> %f" % (tag, tag.id, found.score)
+
+ return tags
+
+ def search_books(self, query, filter=None, max_results=10):
+ bks = []
+ tops = self.searcher.search(query, filter, max_results)
+ for found in tops.scoreDocs:
+ doc = self.searcher.doc(found.doc)
+ bks.append(catalogue.models.Book.objects.get(id=doc.get("book_id")))
+ return bks
+
+ def create_prefix_phrase(self, toks, field):
+ q = MultiPhraseQuery()
+ for i in range(len(toks)):
+ t = Term(field, toks[i])
+ if i == len(toks) - 1:
+ pterms = MultiSearch.enum_to_array(PrefixTermEnum(self.searcher.getIndexReader(), t))
+ if pterms:
+ q.add(pterms)
+ else:
+ q.add(t)
+ else:
+ q.add(t)
+ return q
+
+ @staticmethod
+ def term_filter(term, inverse=False):
+ only_term = TermsFilter()
+ only_term.addTerm(term)
+
+ if inverse:
+ neg = BooleanFilter()
+ neg.add(FilterClause(only_term, BooleanClause.Occur.MUST_NOT))
+ only_term = neg
+
+ return only_term
+
+ def hint_tags(self, string, max_results=50):
+ toks = self.get_tokens(string, field='SIMPLE')
+ top = BooleanQuery()
+
+ for field in ['tag_name', 'tag_name_pl']:
+ q = self.create_prefix_phrase(toks, field)
+ top.add(BooleanClause(q, BooleanClause.Occur.SHOULD))
+
+ no_book_cat = self.term_filter(Term("tag_category", "book"), inverse=True)
+
+ return self.search_tags(top, no_book_cat, max_results=max_results)
+
+ def hint_books(self, string, max_results=50):
+ toks = self.get_tokens(string, field='SIMPLE')
+
+ q = self.create_prefix_phrase(toks, 'title')
+
+ return self.book_search(q, self.term_filter(Term("is_book", "true")), max_results=max_results)
+
+ @staticmethod
+ def chain_filters(filters, op=ChainedFilter.AND):
+ filters = filter(lambda x: x is not None, filters)
+ if not filters:
+ return None
+ chf = ChainedFilter(JArray('object')(filters, Filter), op)
+ return chf
+
+ def filtered_categories(self, tags):
+ cats = {}
+ for t in tags:
+ cats[t.category] = True
+ return cats.keys()
+
+ def hint(self):
+ return Hint(self)
fnp / wolnelektury.git / blobdiff