Add full text search feature and boosting features.fix some bugs and added more tests

Author: IdanHaim

pyravendb/custom_exceptions/exceptions.py

@@ -16,3 +16,7 @@ class NonUniqueObjectException(Exception):
 
 class FetchConcurrencyException(Exception):
     pass
+
+
+class ArgumentOutOfRangeException(Exception):
+    pass

pyravendb/data/document_convention.py

@@ -73,7 +73,7 @@ def json_default(o):
             return Utils.datetime_to_string(o)
         elif isinstance(o, timedelta):
             return Utils.timedelta_to_str(o)
-        elif getattr(o, "__dict__"):
+        elif getattr(o, "__dict__", None):
             return o.__dict__
         else:
             raise TypeError(repr(o) + " is not JSON serializable (Try add a json default method to store convention)")

pyravendb/data/indexes.py

@@ -33,6 +33,9 @@ class FieldIndexing(Enum):
     # Index the field's value without using an Analyzer, so it can be searched.
     not_analyzed = "NotAnalyzed"
 
+    def __str__(self):
+        return self.value
+
 
 class IndexDefinition(object):
     def __init__(self, index_map, name=None, **kwargs):
@@ -88,7 +91,8 @@ def map(self, value):
 
     def to_json(self):
         return {"Analyzers": self.analyzers, "DisableInMemoryIndexing": self.disable_in_memory_indexing,
-                "Fields": self.fields, "Indexes": self.indexes, "IndexId": self.index_id,
+                "Fields": self.fields, "Indexes": {key: str(self.indexes[key]) for key in self.indexes},
+                "IndexId": self.index_id,
                 "InternalFieldsMapping": self.internal_fields_mapping, "IsCompiled": self._is_compiled,
                 "IsMapReduce": self.is_map_reduce, "IsSideBySideIndex": self.is_side_by_side_index,
                 "IsTestIndex": self.is_test_index, "LockMode": str(self.lock_mod), "Map": self.map,

pyravendb/store/session_query.py

@@ -1,5 +1,5 @@
 from enum import Enum
-from pyravendb.custom_exceptions.exceptions import ErrorResponseException
+from pyravendb.custom_exceptions.exceptions import *
 from pyravendb.data.indexes import IndexQuery
 from pyravendb.tools.utils import Utils
 from datetime import timedelta
@@ -72,7 +72,6 @@ def where_equals(self, field_name, value):
         if value is not None and not isinstance(value, str) and field_name is not None:
             sort_hint = self.session.conventions.get_default_sort_option(type(value).__name__)
             if sort_hint:
-                field_name = "{0}_Range".format(field_name)
                 if sys.version_info.major > 2:
                     if value > sys.maxsize:
                         sort_hint = self.session.conventions.get_default_sort_option("long")
@@ -97,6 +96,20 @@ def where(self, **kwargs):
                 self.where_equals(field_name, kwargs[field_name])
         return self
 
+    def search(self, field_name, search_terms):
+        """
+        for more complex text searching
+
+        @param field_name:The field name in the index you want to query.
+        :type str
+        @param search_terms: the terms you want to query
+        :type str
+        """
+        search_terms = Utils.quote_key(str(search_terms))
+        search_terms = self._lucene_builder(search_terms, "search")
+        self.query_builder += "{0}:{1}".format(field_name, search_terms)
+        return self
+
     def where_ends_with(self, field_name, value):
         """
         To get all the document that ends with the value in the giving field_name
@@ -255,6 +268,16 @@ def add_not(self):
         self.negate = True
         return self
 
+    def boost(self, value):
+        if len(self.query_builder) < 1:
+            raise InvalidOperationException("Missing where clause")
+        if value < 0:
+            raise ArgumentOutOfRangeException("boost", "boost factor must be a positive number")
+        if value != 1:
+            # 1 is the default
+            self.query_builder += "^{0}".format(value)
+        return self
+
     def _execute_query(self):
         self.session.increment_requests_count()
         conventions = self.session.conventions

pyravendb/tests/session_tests/full_text_search_tests.py

@@ -0,0 +1,76 @@
+from pyravendb.tests.test_base import TestBase
+from pyravendb.data.indexes import IndexDefinition
+from pyravendb.data.indexes import FieldIndexing
+from pyravendb.store.document_store import documentstore
+from datetime import datetime
+
+
+class LastFm(object):
+    def __init__(self, artist="", track_id="", title="", datetime_time=None, tags=None):
+        self.artist = artist
+        self.track_id = track_id
+        self.title = title
+        self.datetime_time = datetime_time if datetime_time is not None else datetime.now()
+        self.tags = tags if tags is not None else []
+
+
+class LastFmAnalyzed(object):
+    class Result(object):
+        def __init__(self, query):
+            self.query = query
+
+    def __init__(self):
+        index_map = ("from song in docs.LastFms "
+                     "select new {"
+                     "query = new object[] {"
+                     "song.artist,"
+                     "((object)song.datetime_time),"
+                     "song.tags,"
+                     "song.title,"
+                     "song.track_id}}")
+
+        indexes = {"query": FieldIndexing.analyzed}
+
+        self.index_definition = IndexDefinition(index_map=index_map, indexes=indexes)
+
+    def execute(self, store):
+        store.database_commands.put_index(LastFmAnalyzed.__name__, self.index_definition, True)
+
+
+class FullTextSearchTest(TestBase):
+    @classmethod
+    def setUpClass(cls):
+        super(FullTextSearchTest, cls).setUpClass()
+        cls.db.put("LastFms/1", {"artist": "Tania Maria", "track_id": "TRALPJJ128F9311763", "title": "Come With Me",
+                                 "datetime_time": datetime.now(), "tags": None},
+                   {"Raven-Entity-Name": "LastFms", "Raven-Python-Type": "full_text_search_test.LastFm"})
+        cls.db.put("LastFms/2", {"artist": "Meghan Trainor", "track_id": "TRBCNGI128F42597B4", "title": "Me Too",
+                                 "datetime_time": datetime.now(), "tags": None},
+                   {"Raven-Entity-Name": "LastFms", "Raven-Python-Type": "full_text_search_test.LastFm"})
+        cls.db.put("LastFms/3", {"artist": "Willie Bobo", "track_id": "TRAACNS128F14A2DF5", "title": "Spanish Grease",
+                                 "datetime_time": datetime.now(), "tags": None},
+                   {"Raven-Entity-Name": "LastFms", "Raven-Python-Type": "full_text_search_test.LastFm"})
+        cls.document_store = documentstore(cls.default_url, cls.default_database)
+        cls.document_store.initialize()
+        LastFmAnalyzed().execute(cls.document_store)
+
+    def test_full_text_search_one(self):
+        with self.document_store.open_session() as session:
+            query = list(session.query(object_type=LastFm, wait_for_non_stale_results=True,
+                                       index_name=LastFmAnalyzed.__name__).search("query", search_terms="Me"))
+            self.assertTrue(str(query[0].title) == "Come With Me" and str(query[1].title) == "Me Too")
+
+    def test_full_text_search_two(self):
+        with self.document_store.open_session() as session:
+            query = list(session.query(object_type=LastFm, wait_for_non_stale_results=True,
+                                       index_name=LastFmAnalyzed.__name__).search("query", search_terms="Me").search(
+                "query", search_terms="Bobo"))
+            self.assertEqual(len(query), 3)
+
+    def test_full_text_search_witg_boost(self):
+        with self.document_store.open_session() as session:
+            query = list(session.query(object_type=LastFm, wait_for_non_stale_results=True,
+                                       index_name=LastFmAnalyzed.__name__).search("query", search_terms="Me").boost(10).
+                         search("query", search_terms="Bobo").boost(2))
+            self.assertTrue(str(query[0].title) == "Come With Me" and str(query[1].title) == "Me Too" and str(
+                query[2].title) == "Spanish Grease")

pyravendb/tests/session_tests/query_test.py

@@ -6,9 +6,10 @@
 
 
 class Product(object):
-    def __init__(self, name, key):
+    def __init__(self, name, key, order):
         self.name = name
         self.key = key
+        self.order = order
 
 
 class Company(object):
@@ -35,11 +36,12 @@ def setUpClass(cls):
                    {"Raven-Entity-Name": "Products", "Raven-Python-Type": "query_test.Product"})
         cls.db.put("products/103", {"name": "test107", "key": 6},
                    {"Raven-Entity-Name": "Products", "Raven-Python-Type": "query_test.Product"})
-        cls.db.put("products/108", {"name": "new_testing", "key": 90},
+        cls.db.put("products/108", {"name": "new_testing", "key": 90, "order": "d"},
                    {"Raven-Entity-Name": "Products", "Raven-Python-Type": "query_test.Product"})
         cls.db.put("orders/105", {"name": "testing_order", "key": 92, "product": "products/108"},
                    {"Raven-Entity-Name": "Orders"})
-        cls.db.put("company/1", {"name": "withNesting", "product": {"name": "testing_order", "key": 150}},
+        cls.db.put("company/1",
+                   {"name": "withNesting", "product": {"name": "testing_order", "key": 4, "order": None}},
                    {"Raven-Entity-Name": "Companies"})
         cls.document_store = documentstore(cls.default_url, cls.default_database)
         cls.document_store.initialize()
@@ -115,7 +117,7 @@ def test_query_with_order_by_descending(self):
         with self.document_store.open_session() as session:
             query_results = list(
                 session.query(wait_for_non_stale_results=True).where_not_none("order").order_by_descending("order"))
-            self.assertEqual(query_results[0].order, "c")
+            self.assertEqual(query_results[0].order, "d")
 
     def test_where_not_None(self):
         found_none = False

pyravendb/tools/utils.py

@@ -147,7 +147,7 @@ def make_initialize_dict(document, entity_init):
             for i in range(remainder, len(args)):
                 entity_initialize_dict[args[i]] = document.get(args[i], defaults[i - remainder])
         else:
-            if keywords == "kwargs":
+            if keywords:
                 entity_initialize_dict = document
             else:
                 for key in document:
@@ -184,7 +184,8 @@ def to_lucene(value, action):
             query_text = "[{0} TO {1}]".format(
                 Utils.numeric_to_lucene_syntax(value[0]) if value[0] is not None else "*",
                 Utils.numeric_to_lucene_syntax(value[1]) if value[1] is not None else "NULL")
-
+        elif action == "search":
+            query_text = "({0})".format(value)
         else:
             query_text = value
             if value is None:

setup.py

@@ -3,19 +3,19 @@
 setup(
     name='pyravendb',
     packages=find_packages(),
-    version='1.1.1',
+    version='1.2.0',
     description='This is the official python client for RavenDB document database',
     author='Idan Haim Shalom',
     author_email='haimdude@gmail.com',
     url='https://github.com/IdanHaim/RavenDB-Python-Client',
     license='GNU',
-	keywords='pyravendb',
+    keywords='pyravendb',
     install_requires=
     [
         "pycrypto >= 2.6.1",
         "requests >= 2.9.1",
         "inflector >= 2.0.11",
-		"enum >= 0.4.6",
+        "enum >= 0.4.6",
     ],
-	zip_safe=False
+    zip_safe=False
 )