self.addAnalyzer("source_url", keyword)
self.addAnalyzer("source_name", simple)
self.addAnalyzer("publisher", simple)
- self.addAnalyzer("author", simple)
+ self.addAnalyzer("authors", simple)
self.addAnalyzer("is_book", keyword)
+ # shouldn't the title have two forms? _pl and simple?
self.addAnalyzer("themes", simple)
self.addAnalyzer("themes_pl", polish)
self.addAnalyzer("tag_name", simple)
self.addAnalyzer("tag_name_pl", polish)
+ self.addAnalyzer("translators", simple)
+
self.addAnalyzer("KEYWORD", keyword)
self.addAnalyzer("SIMPLE", simple)
self.addAnalyzer("POLISH", polish)
q = NumericRangeQuery.newIntRange("book_id", book.id, book.id, True, True)
self.index.deleteDocuments(q)
- def index_book(self, book, overwrite=True):
+ def index_book(self, book, book_info=None, overwrite=True):
if overwrite:
self.remove_book(book)
book_doc = self.create_book_doc(book)
- meta_fields = self.extract_metadata(book)
+ meta_fields = self.extract_metadata(book, book_info)
for f in meta_fields.values():
if isinstance(f, list) or isinstance(f, tuple):
for elem in f:
self.index.addDocument(book_doc)
del book_doc
- self.index_content(book, book_fields=[meta_fields['title'], meta_fields['author']])
+ self.index_content(book, book_fields=[meta_fields['title'], meta_fields['authors']])
master_tags = [
'opowiadanie',
doc.add(NumericField("parent_id", Field.Store.YES, True).setIntValue(book.parent.id))
return doc
- def extract_metadata(self, book):
+ def extract_metadata(self, book, book_info=None):
fields = {}
- book_info = dcparser.parse(book.xml_file)
- print("extract metadata for book %s id=%d, thread%d" % (book.slug, book.id, current_thread().ident))
+ if book_info is None:
+ book_info = dcparser.parse(open(book.xml_file.path))
fields['slug'] = Field("slug", book.slug, Field.Store.NO, Field.Index.ANALYZED_NO_NORMS)
fields['tags'] = self.add_gaps([Field("tags", t.name, Field.Store.NO, Field.Index.ANALYZED) for t in book.tags], 'tags')
dt = getattr(book_info, field.name)
fields[field.name] = Field(field.name, "%04d%02d%02d" %\
(dt.year, dt.month, dt.day), Field.Store.NO, Field.Index.NOT_ANALYZED)
+
return fields
def get_master(self, root):
return reduce(lambda a, b: a + b, zip(fields, gap()))[0:-1]
def index_content(self, book, book_fields=[]):
- wld = WLDocument.from_file(book.xml_file.path)
+ wld = WLDocument.from_file(book.xml_file.path, parse_dublincore=False)
root = wld.edoc.getroot()
master = self.get_master(root)
return
def fix_format(text):
- return re.sub("/$", "", text, flags=re.M)
+ return re.sub("(?m)/$", "", text)
def add_part(snippets, **fields):
doc = self.create_book_doc(book)
if you cannot rely on atexit, use ReusableIndex.close_reusable() yourself.
"""
index = None
- pool = None
- pool_jobs = None
def open(self, analyzer=None, threads=4):
if ReusableIndex.index is not None:
self.index = ReusableIndex.index
else:
print("opening index")
- ReusableIndex.pool = ThreadPool(threads, initializer=lambda: JVM.attachCurrentThread() )
- ReusableIndex.pool_jobs = []
Index.open(self, analyzer)
ReusableIndex.index = self.index
atexit.register(ReusableIndex.close_reusable)
- def index_book(self, *args, **kw):
- job = ReusableIndex.pool.apply_async(log_exception_wrapper(Index.index_book), (self,) + args, kw)
- ReusableIndex.pool_jobs.append(job)
+ # def index_book(self, *args, **kw):
+ # job = ReusableIndex.pool.apply_async(log_exception_wrapper(Index.index_book), (self,) + args, kw)
+ # ReusableIndex.pool_jobs.append(job)
@staticmethod
def close_reusable():
if ReusableIndex.index is not None:
- print("wait for indexing to finish")
- for job in ReusableIndex.pool_jobs:
- job.get()
- sys.stdout.write('.')
- sys.stdout.flush()
- print("done.")
- ReusableIndex.pool.close()
-
ReusableIndex.index.optimize()
ReusableIndex.index.close()
ReusableIndex.index = None
bks.append(catalogue.models.Book.objects.get(id=doc.get("book_id")))
return (bks, tops.totalHits)
+
def search(self, query, max_results=50):
query = self.query(query)
query = self.wrapjoins(query, ["content", "themes"])
self.search = search
self.book_tags = {}
self.part_tags = []
- self._book = None
+ self._books = []
- def book(self, book):
- self._book = book
+ def books(self, *books):
+ self._books = books
def tags(self, tags):
for t in tags:
fs = []
if self.part_tags:
fs.append(self.tag_filter(self.part_tags, field='themes'))
- if self._book is not None:
- fs.append(NumericRangeFilter.newIntRange('book_id', self._book.id, self._book.id, True, True))
+
+ 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._book is None
+ 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 == 'author' and 'author' in self.book_tags:
+ if field == 'authors' and 'author' in self.book_tags:
continue
- if field == 'title' and self._book is not None:
+ if field == 'title' and self._books != []:
continue
if (field == 'themes' or field == 'themes_pl') and self.part_tags:
continue
q.add(BooleanClause(term, modal))
return q
- def content_query(self, query):
- return BlockJoinQuery(query, self.parent_filter,
- BlockJoinQuery.ScoreMode.Total)
+ # 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 = ['author', 'title']
+ fields_to_search = ['authors', 'title']
only_in = None
if hint:
if not hint.should_search_for_book():
# query themes/content x author/title/tags
q = BooleanQuery()
- in_meta = BooleanQuery()
+ # in_meta = BooleanQuery()
in_content = BooleanQuery()
- for fld in ['themes', 'content', 'tags', 'author', 'title']:
+ 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)
books.append(SearchResult(self.searcher, found))
return books
-
def multisearch(self, query, max_results=50):
"""
Search strategy:
- (phrase) OR -> content
-> title
- -> author
- - (keywords) -> author
+ -> authors
+ - (keywords) -> authors
-> motyw
-> tags
-> content
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)):
fnp / wolnelektury.git / blobdiff