Add suggestion search.

We are wrapping the suggestion part.
With all the preparatory work, it is pretty simple.

Author: mgautierfr

libzim/libwrapper.h

@@ -29,6 +29,7 @@
 #include <zim/writer/item.h>
 #include <zim/writer/contentProvider.h>
 #include <zim/search.h>
+#include <zim/suggestion.h>
 
 struct _object;
 typedef _object PyObject;
@@ -201,6 +202,71 @@ class Searcher : public Wrapper<zim::Searcher>
     FORWARD(void, setVerbose)
     FORWARD(wrapper::Search, search)
 };
+
+class SuggestionItem : public Wrapper<zim::SuggestionItem>
+{
+  public:
+    SuggestionItem() = default;
+    SuggestionItem(const zim::SuggestionItem& o) : Wrapper(o) {};
+
+    FORWARD(std::string, getTitle)
+    FORWARD(std::string, getPath)
+    FORWARD(std::string, getSnippet)
+    FORWARD(bool, hasSnippet)
+};
+
+class SuggestionIterator : public Wrapper<zim::SuggestionIterator>
+{
+  public:
+    SuggestionIterator() = default;
+    SuggestionIterator(const zim::SuggestionIterator& o) : Wrapper(o) {};
+    zim::SuggestionIterator& operator*() const { return *mp_base; }
+
+    FORWARD(bool, operator==)
+    bool operator!=(const wrapper::SuggestionIterator& it) const {
+      return *mp_base != *it;
+    }
+    FORWARD(wrapper::SuggestionIterator, operator++)
+    SuggestionItem getSuggestionItem() const {
+      return mp_base->operator*();
+    }
+//    FORWARD(wrapper::SuggestionItem, operator*)
+    FORWARD(wrapper::Entry, getEntry)
+};
+
+class SuggestionResultSet : public Wrapper<zim::SuggestionResultSet>
+{
+  public:
+    SuggestionResultSet() = default;
+    SuggestionResultSet(const zim::SuggestionResultSet& o) : Wrapper(o) {};
+
+
+    FORWARD(wrapper::SuggestionIterator, begin)
+    FORWARD(wrapper::SuggestionIterator, end)
+    FORWARD(int, size)
+};
+
+
+class SuggestionSearch : public Wrapper<zim::SuggestionSearch>
+{
+  public:
+    SuggestionSearch() = default;
+    SuggestionSearch(zim::SuggestionSearch&& s) : Wrapper(std::move(s)) {};
+
+    FORWARD(int, getEstimatedMatches)
+    FORWARD(wrapper::SuggestionResultSet, getResults)
+};
+
+class SuggestionSearcher : public Wrapper<zim::SuggestionSearcher>
+{
+  public:
+    SuggestionSearcher() = default;
+    SuggestionSearcher(const wrapper::Archive& a) : Wrapper(zim::SuggestionSearcher(*a)) {};
+    SuggestionSearcher(const zim::SuggestionSearcher& o) : Wrapper(o) {};
+
+    FORWARD(void, setVerbose)
+    FORWARD(wrapper::SuggestionSearch, suggest)
+};
 } // namespace wrapper
 #undef FORWARD
 

libzim/wrapper.pyx

@@ -955,14 +955,108 @@ search_public_objects = [
 search = create_module(search_module_name, search_module_doc, search_public_objects)
 
 
+###############################################################################
+#   Suggestion module                                                         #
+###############################################################################
+
+suggestion_module_name = f"{__name__}.suggestion"
+
+cdef class SuggestionResultSet:
+    __module__ = suggestion_module_name
+    cdef zim.SuggestionResultSet c_resultset
+
+    @staticmethod
+    cdef from_resultset(zim.SuggestionResultSet _resultset):
+        cdef SuggestionResultSet resultset = SuggestionResultSet()
+        resultset.c_resultset = move(_resultset)
+        return resultset
+
+    def __iter__(self):
+        cdef zim.SuggestionIterator current = self.c_resultset.begin()
+        cdef zim.SuggestionIterator end = self.c_resultset.end()
+        while current != end:
+            yield current.getSuggestionItem().getPath().decode('UTF-8')
+            preincrement(current)
+
+cdef class SuggestionSearch:
+    __module__ = suggestion_module_name
+    cdef zim.SuggestionSearch c_search
+
+    # Factory functions - Currently Cython can't use classmethods
+    @staticmethod
+    cdef from_search(zim.SuggestionSearch _search):
+        """ Creates a python ReadArticle from a C++ Article (zim::) -> ReadArticle
+
+            Parameters
+            ----------
+            _item : Item
+                A C++ Item
+            Returns
+            ------
+            Item
+                Casted item """
+        cdef SuggestionSearch search = SuggestionSearch()
+        search.c_search = move(_search)
+        return search
+
+    def getEstimatedMatches(self):
+        return self.c_search.getEstimatedMatches()
+
+    def getResults(self, start, count):
+        return SuggestionResultSet.from_resultset(move(self.c_search.getResults(start, count)))
+
+
+cdef class SuggestionSearcher:
+    """ Zim Archive SuggestionSearcher
+
+        Attributes
+        ----------
+        *c_archive : Searcher
+            a pointer to a C++ Searcher object
+    """
+    __module__ = suggestion_module_name
+
+    cdef zim.SuggestionSearcher c_searcher
+
+    def __cinit__(self, object archive: Archive):
+        """ Constructs an Archive from full zim file path
+
+            Parameters
+            ----------
+            filename : pathlib.Path
+                Full path to a zim file """
+
+        self.c_searcher = move(zim.SuggestionSearcher(archive.c_archive))
+
+    def suggest(self, query: str):
+        return SuggestionSearch.from_search(move(self.c_searcher.suggest(query.encode('utf8'))))
+
+suggestion_module_doc = """ libzim suggestion module
+
+Usage:
+
+archive = Archive(fpath)
+suggestion_searcher = SuggestionSearcher(archive)
+suggestion = suggestion searcher.suggest("foo")
+resultSet = suggestion.getResult(10, 10) # get result from 10 to 20 (10 results)
+for path in resultSet:
+    print(path)"""
+suggestion_public_objects = [
+    SuggestionSearcher
+]
+suggestion = create_module(suggestion_module_name, suggestion_module_doc, suggestion_public_objects)
+
+
+
 class ModuleLoader(importlib.abc.Loader):
     # Create our module. Easy, just return the created module
     @staticmethod
     def create_module(spec):
         return {
             'libzim.writer': writer,
             'libzim.reader': reader,
-            'libzim.search': search
+            'libzim.search': search,
+            'libzim.suggestion': suggestion
         }.get(spec.name, None)
 
     @staticmethod
@@ -981,5 +1075,5 @@ class ModuleFinder(importlib.abc.MetaPathFinder):
 # register finder for our submodules
 sys.meta_path.insert(0, ModuleFinder())
 
-__all__ = ["writer", "reader", "search"]
+__all__ = ["writer", "reader", "search", "suggestion"]
 

libzim/zim.pxd

@@ -176,3 +176,32 @@ cdef extern from "libwrapper.h" namespace "wrapper":
         SearchIterator begin()
         SearchIterator end()
         int size()
+
+    cdef cppclass SuggestionItem:
+        string getPath()
+        string getTitle()
+        string getSnippet()
+        bool hasSnippet()
+
+    cdef cppclass SuggestionIterator:
+        SuggestionIterator()
+        SuggestionIterator operator++()
+        bint operator==(SuggestionIterator)
+        bint operator!=(SuggestionIterator)
+        SuggestionItem getSuggestionItem()
+        Entry getEntry()
+
+    cdef cppclass SuggestionSearcher:
+        SuggestionSearcher()
+        SuggestionSearcher(const Archive& archive) except +
+        setVerbose(bool verbose)
+        SuggestionSearch suggest(string query) except +
+
+    cdef cppclass SuggestionSearch:
+        int getEstimatedMatches() except +
+        SuggestionResultSet getResults(int start, int count) except +
+
+    cdef cppclass SuggestionResultSet:
+        SuggestionIterator begin()
+        SuggestionIterator end()
+        int size()

tests/test_libzim_reader.py

@@ -11,6 +11,7 @@
 import libzim.writer
 from libzim.reader import Archive
 from libzim.search import Searcher, Query
+from libzim.suggestion import SuggestionSearcher
 
 
 # expected data for tests ZIMs (see `all_zims`)
@@ -122,9 +123,12 @@
         "entry_count": 60,
         "all_entry_count": 75,
         "article_count": 0,
-        "suggestion_string": "favicon",
+        "suggestion_string": "Free",
         "suggestion_count": 1,
-        "suggestion_result": ["favicon.png"],
+        "suggestion_result": [
+            "FreedomBox for Communities_Offline Wikipedia "
+            + "- Wikibooks, open books for an open world.html"
+        ],
         "search_string": "main",
         "search_count": 2,
         "search_result": [
@@ -411,12 +415,11 @@ def test_reader_suggest_search(
         assert search.getEstimatedMatches() == search_count
         assert list(search.getResults(0, search_count)) == search_result
 
-#TODO: restore suggestion search
-#     assert (
-#         zim.get_estimated_suggestions_results_count(suggestion_string)
-#         == suggestion_count
-#     )
-#     assert list(zim.suggest(suggestion_string)) == suggestion_result
+    if suggestion_string is not None:
+        suggestion_searcher = SuggestionSearcher(zim)
+        suggestion = suggestion_searcher.suggest(suggestion_string)
+        assert suggestion.getEstimatedMatches() == suggestion_count
+        assert list(suggestion.getResults(0, suggestion_count)) == suggestion_result
 
 
 @pytest.mark.parametrize(