Add Object nesting entity tracking fix some bugs with save_changes and update the README.md

Author: IdanHaim

README.md

@@ -41,12 +41,22 @@ There are three ways to install pyravendb.
     	foo = session.load("foos/1")
 ```
 
-load method have the option to track entity for you the only thing you need to do is add ```object_type```  when ou call to load 
-(load method will return a dynamic_stracture object by default).
+load method have the option to track entity for you the only thing you need to do is add ```object_type```  when you call to load 
+(load method will return a dynamic_stracture object by default) for class with nested object you can call load with ```nested_object_types``` dictionary for the other types. just put in the key the name of the object and in the value his class (without this option you will get the document as it is) .
 
 ```
 	foo = session.load("foos/1", object_type=Foo)
 ```
+
+```
+	class FooBar(object):
+		def __init__(self,name,foo):
+			self.name = name
+			self.foo = foo
+	
+	foo_bar = session.load("FooBars/1", object_type=FooBar,nested_object_types={"foo":Foo})
+			
+```
 To load several documents at once, supply a list of ids to session.load.
 
 ```
@@ -67,10 +77,15 @@ For storing with dict we will use database_commands the put command (see the sou
 
 ```
 class Foo(object):
-  def __init__(name,key = None):
-      self.name = name
-      self.key = key
+   def __init__(name,key = None):
+   	self.name = name
+      	self.key = key
       
+class FooBar(object):
+   def __init__(self,name,foo):
+	self.name = name
+	self.foo = foo
+
 with store.open_session() as session:
 	foo = Foo("PyRavenDB")
     session.store(foo)
@@ -87,12 +102,16 @@ with store.open_session() as session:
 * ```wait_for_non_stale_results``` - False by default if True the query will wait until the index will be non stale.
 * ```includes``` - A list of the properties we like to include in the query.
 * ``` with_statistics``` - when True the qury will return stats about the query.
+* ```nested_object_types``` - A dict of classes for nested object the key will be the name of the class and the value will be 
+           the object we want to get for that attribute
 
 ```
 with store.open_session() as session:
 	query_result = list(session.query().where_equals("name", "test101")
 	query_result = list(session.query(object_type=Foo).where_starts_with("name", "n"))
 	query_result = list(session.query(object_type=Foo).where_ends_with("name", "7"))
+	query_result = list(session.query(object_type=FooBar,nested_object_types={"foo":Foo}).where(name="foo_bar"))
+	
 ```
 
 You can also build the query with several options using the builder pattern.

pyravendb/connection/requests_factory.py

@@ -106,7 +106,8 @@ def _execute_with_replication(self, path, method, headers, data=None, admin=Fals
                 if headers is None:
                     headers = {}
                 headers.update(self.headers)
-                response = session.request(method, url=url, json=data, headers=headers)
+                data = json.dumps(data, default=self.convention.json_default_method)
+                response = session.request(method, url=url, data=data, headers=headers)
                 if response.status_code == 412 or response.status_code == 401:
                     try:
                         oauth_source = response.headers.__getitem__("OAuth-Source")

pyravendb/data/document_convention.py

@@ -1,4 +1,5 @@
 from pyravendb.data.indexes import SortOptions
+from datetime import datetime, timedelta
 from enum import Enum
 from inflector import Inflector
 
@@ -61,8 +62,20 @@ def __init__(self):
         self.timeout = 30
         self.failover_behavior = Failover.allow_reads_from_secondaries
         self.default_use_optimistic_concurrency = True
+        self.json_default_method = DocumentConvention.json_default
         self._system_database = "system"
 
+    @staticmethod
+    def json_default(o):
+        if isinstance(o, datetime):
+            return str(0)
+        elif isinstance(o, timedelta):
+            return str(0)
+        elif getattr(o, "__dict__"):
+            return o.__dict__
+        else:
+            raise TypeError(repr(o) + " is not JSON serializable (Try add a json default method to store convention)")
+
     @staticmethod
     def default_transform_plural(name):
         return inflector.conditional_plural(2, name)

pyravendb/store/document_session.py

@@ -80,12 +80,13 @@ def save_entity(self, key, entity, original_metadata, metadata, document, force_
                 "original_metadata": original_metadata, "etag": metadata.get("etag", None), "key": key,
                 "force_concurrency_check": force_concurrency_check}
 
-    def _convert_and_save_entity(self, key, document, object_type):
+    def _convert_and_save_entity(self, key, document, object_type, nested_object_types):
         if key not in self._entities_by_key:
-            entity, metadata, original_metadata = Utils.convert_to_entity(document, object_type, self.conventions)
+            entity, metadata, original_metadata = Utils.convert_to_entity(document, object_type, self.conventions,
+                                                                          nested_object_types)
             self.save_entity(key, entity, original_metadata, metadata, document)
 
-    def _multi_load(self, keys, object_type, includes):
+    def _multi_load(self, keys, object_type, includes, nested_object_types):
         if len(keys) == 0:
             return []
 
@@ -94,7 +95,7 @@ def _multi_load(self, keys, object_type, includes):
             ids_in_includes = [key for key in keys if key in self._includes]
             if len(ids_in_includes) > 0:
                 for include in ids_in_includes:
-                    self._convert_and_save_entity(include, self._includes[include], object_type)
+                    self._convert_and_save_entity(include, self._includes[include], object_type, nested_object_types)
                     self._includes.pop(include)
 
             ids_of_not_existing_object = [key for key in keys if
@@ -112,19 +113,22 @@ def _multi_load(self, keys, object_type, includes):
                     if results[i] is None:
                         self._known_missing_ids.add(ids_of_not_existing_object[i])
                         continue
-                    self._convert_and_save_entity(keys[i], results[i], object_type)
+                    self._convert_and_save_entity(keys[i], results[i], object_type, nested_object_types)
                 self.save_includes(response_includes)
         return [None if key in self._known_missing_ids else self._entities_by_key[
             key] if key in self._entities_by_key else None for key in keys]
 
-    def load(self, key_or_keys, object_type=None, includes=None):
+    def load(self, key_or_keys, object_type=None, includes=None, nested_object_types=None):
         """
         @param key_or_keys: Identifier of a document that will be loaded.
         :type str or list
         @param includes: The path to a reference inside the loaded documents can be list (property name)
         :type list or str
-        @param object_type:the class we want to get
+        @param object_type: The class we want to get
         :type classObj:
+        @param nested_object_types: A dict of classes for nested object the key will be the name of the class and the
+         value will be the object we want to get for that attribute
+        :type str
         @return: instance of object_type or None if document with given Id does not exist.
         :rtype:object_type or None
         """
@@ -134,15 +138,16 @@ def load(self, key_or_keys, object_type=None, includes=None):
             includes = [includes]
 
         if isinstance(key_or_keys, list):
-            return self._multi_load(key_or_keys, object_type, includes)
+            return self._multi_load(key_or_keys, object_type, includes, nested_object_types)
 
         if key_or_keys in self._known_missing_ids:
             return None
         if key_or_keys in self._entities_by_key and not includes:
             return self._entities_by_key[key_or_keys]
 
         if key_or_keys in self._includes:
-            self._convert_and_save_entity(key_or_keys, self._includes[key_or_keys], object_type)
+            self._convert_and_save_entity(key_or_keys, self._includes[key_or_keys], object_type,
+                                          nested_object_types)
             self._includes.pop(key_or_keys)
             if not includes:
                 return self._entities_by_key[key_or_keys]
@@ -155,7 +160,7 @@ def load(self, key_or_keys, object_type=None, includes=None):
             if len(result) == 0 or result[0] is None:
                 self._known_missing_ids.add(key_or_keys)
                 return None
-            self._convert_and_save_entity(key_or_keys, result[0], object_type)
+            self._convert_and_save_entity(key_or_keys, result[0], object_type, nested_object_types)
             self.save_includes(response_includes)
         return self._entities_by_key[key_or_keys] if key_or_keys in self._entities_by_key else None
 
@@ -310,13 +315,13 @@ def _prepare_for_puts_commands(self, data):
                 data.entities.append(entity)
                 if key is not None:
                     self._entities_by_key.pop(key)
-                    document = entity.__dict__
+                    document = entity.__dict__.copy()
                     document.pop('Id', None)
                 data.commands.append(commands_data.PutCommandData(key, etag, document, metadata))
 
     def _has_change(self, entity):
-        if self._entities_and_metadata[entity]["original_metadata"] != self._entities_and_metadata[entity][
-            "metadata"] or self._entities_and_metadata[entity]["original_value"] != entity.__dict__:
+        if self._entities_and_metadata[entity]["original_metadata"] != self._entities_and_metadata[entity]["metadata"] \
+                or self._entities_and_metadata[entity]["original_value"] != entity.__dict__:
             return True
         return False
 

pyravendb/store/session_query.py

@@ -14,12 +14,15 @@ def __init__(self, session):
         self._sort_fields = set()
 
     def __call__(self, object_type=None, index_name=None, using_default_operator=None,
-                 wait_for_non_stale_results=False, includes=None, with_statistics=False):
+                 wait_for_non_stale_results=False, includes=None, with_statistics=False, nested_object_types=None):
         """
         @param index_name: The index name we want to apply
         :type index_name: str
         @param object_type: The type of the object we want to track the entity too
         :type Type
+        @param nested_object_types: A dict of classes for nested object the key will be the name of the class and the
+        value will be the object we want to get for that attribute
+        :type str
         @param using_default_operator: If None, by default will use OR operator for the query (can use for OR or AND)
         @param with_statistics: Make it True to get the query statistics as well
         :type bool
@@ -30,6 +33,7 @@ def __call__(self, object_type=None, index_name=None, using_default_operator=Non
                 index_name += "/{0}".format(self.session.conventions.default_transform_plural(object_type.__name__))
         self.index_name = index_name
         self.object_type = object_type
+        self.nested_object_types = nested_object_types
         self.using_default_operator = using_default_operator
         self.wait_for_non_stale_results = wait_for_non_stale_results
         self.includes = includes
@@ -242,7 +246,8 @@ def _execute_query(self):
         response_results = response.pop("Results")
         response_includes = response.pop("Includes")
         for result in response_results:
-            entity, metadata, original_metadata = Utils.convert_to_entity(result, self.object_type, conventions)
+            entity, metadata, original_metadata = Utils.convert_to_entity(result, self.object_type, conventions,
+                                                                          self.nested_object_types)
             self.session.save_entity(key=original_metadata["@id"], entity=entity, original_metadata=original_metadata,
                                      metadata=metadata, document=result)
             results.append(entity)

pyravendb/tests/session_tests/load_test.py

@@ -9,6 +9,12 @@ def __init__(self, name):
         self.name = name
 
 
+class Company(object):
+    def __init__(self, name, product):
+        self.name = name
+        self.product = product
+
+
 class Foo(object):
     def __init__(self, name, key):
         self.name = name
@@ -23,6 +29,7 @@ def setUpClass(cls):
         cls.db.put("products/10", {"name": "test"}, {})
         cls.db.put("orders/105", {"name": "testing_order", "key": 92, "product": "products/101"},
                    {"Raven-Entity-Name": "Orders"})
+        cls.db.put("company/1", {"name": "test", "product": {"name": "testing_nested"}}, {})
         cls.document_store = documentstore(cls.default_url, cls.default_database)
         cls.document_store.initialize()
 
@@ -50,6 +57,11 @@ def test_load_track_entity_with_object_type(self):
             product = session.load("products/101", object_type=Product)
             self.assertTrue(isinstance(product, Product))
 
+    def test_load_track_entity_with_object_type_and_nested_object(self):
+        with self.document_store.open_session() as session:
+            company = session.load("company/1", object_type=Company, nested_object_types={"product": Product})
+            self.assertTrue(isinstance(company, Company) and isinstance(company.product, Product))
+
     def test_load_track_entity_with_object_type_fail(self):
         with self.document_store.open_session() as session:
             with self.assertRaises(exceptions.InvalidOperationException):

pyravendb/tests/session_tests/query_test.py

@@ -11,6 +11,12 @@ def __init__(self, name, key):
         self.key = key
 
 
+class Company(object):
+    def __init__(self, name, product):
+        self.name = name
+        self.product = product
+
+
 class TestQuery(TestBase):
     @classmethod
     def setUpClass(cls):
@@ -33,6 +39,8 @@ def setUpClass(cls):
                    {"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}},
+                   {"Raven-Entity-Name": "Companies"})
         cls.document_store = documentstore(cls.default_url, cls.default_database)
         cls.document_store.initialize()
 
@@ -124,3 +132,10 @@ def test_where_with_include(self):
             list(session.query(wait_for_non_stale_results=True, includes="product").where(key=92))
             session.load("products/108")
         self.assertEqual(session.number_of_requests_in_session, 1)
+
+    def test_query_with_nested_object(self):
+        with self.document_store.open_session() as session:
+            query_results = list(
+                session.query(object_type=Company, nested_object_types={"product": Product}).where_equals(
+                    "name", "withNesting"))
+            self.assertTrue(isinstance(query_results[0], Company) and isinstance(query_results[0].product, Product))

pyravendb/tests/session_tests/store_entities_test.py

@@ -8,7 +8,7 @@ class Foo(object):
     def __init__(self, name, key):
         self.name = name
         self.key = key
-        self.Id = None
+        # self.Id = None
 
 
 class TestSessionStore(TestBase):

pyravendb/tools/utils.py

@@ -88,7 +88,7 @@ def is_inherit(parent, child):
             return Utils.is_inherit(parent, child.__base__)
 
     @staticmethod
-    def convert_to_entity(document, object_type, conventions):
+    def convert_to_entity(document, object_type, conventions, nested_object_types=None):
         metadata = document.pop("@metadata")
         original_metadata = metadata.copy()
         type_from_metadata = conventions.try_get_type_from_metadata(metadata)
@@ -106,8 +106,29 @@ def convert_to_entity(document, object_type, conventions):
                     "Unable to cast object of type {0} to type {1}".format(object_from_metadata, object_type))
             entity.__class__ = object_from_metadata
         # Checking the class for initialize
+        entity_initialize_dict = Utils.make_initialize_dict(document, entity.__class__.__init__)
+        entity.__init__(**entity_initialize_dict)
+        if nested_object_types:
+            for key in nested_object_types:
+                attr = getattr(entity, key)
+                if attr:
+                    try:
+                        setattr(entity, key, nested_object_types[key](
+                            **Utils.make_initialize_dict(attr, nested_object_types[key].__init__)))
+                    except TypeError:
+                        pass
+
+        if 'Id' in entity.__dict__:
+            entity.Id = metadata.get('@id', None)
+        return entity, metadata, original_metadata
+
+    @staticmethod
+    def make_initialize_dict(document, entity_init):
+        if entity_init is None:
+            return document
+
         entity_initialize_dict = {}
-        args, __, __, defaults = inspect.getargspec(entity.__class__.__init__)
+        args, __, __, defaults = inspect.getargspec(entity_init)
         if (len(args) - 1) != len(document):
             remainder = len(args)
             if defaults:
@@ -118,10 +139,8 @@ def convert_to_entity(document, object_type, conventions):
                 entity_initialize_dict[args[i]] = document.get(args[i], defaults[i - remainder])
         else:
             entity_initialize_dict = document
-        entity.__init__(**entity_initialize_dict)
-        if 'Id' in entity.__dict__:
-            entity.Id = metadata.get('@id', None)
-        return entity, metadata, original_metadata
+
+        return entity_initialize_dict
 
     @staticmethod
     def to_lucene(value, action):
@@ -171,7 +190,8 @@ def numeric_to_lucene_syntax(value):
 
         if isinstance(value, float) or isinstance(value, int):
             value = "Dx{0}".format(value)
-        if isinstance(value, long):
+
+        elif isinstance(value, long):
             value = "Lx{0}".format(value)
         return value
 

setup.py

@@ -3,7 +3,7 @@
 setup(
     name='pyravendb',
     packages=find_packages(),
-    version='1.0.9',
+    version='1.1.0',
     description='This is the official python client for RavenDB document database',
     author='Idan Haim Shalom',
     author_email='haimdude@gmail.com',