- Fixing time series range deletion

- Adding events to handle various actions in the client

Author: ayende

pyravendb/raven_operations/timeseries_operations.py

@@ -93,7 +93,7 @@ def to_json(self):
         if self.appends:
             self.appends = next(Utils.sort_iterable(self.appends, key=lambda ao: ao.timestamp.timestamp()))
         return {"Name": self.name, "Appends": [a.to_json() for a in self.appends] if self.appends else self.appends,
-                "Removals": [r.to_json() for r in self.removals] if self.removals else self.removals}
+                "Deletes": [r.to_json() for r in self.removals] if self.removals else self.removals}
 
     class AppendOperation:
         def __init__(self, timestamp: datetime, values: List[float] or float, tag: Optional[str] = None):

pyravendb/store/document_session.py

@@ -48,6 +48,19 @@ def __init__(self, database, document_store, requests_executor, session_id, **kw
         self.no_tracking = kwargs.get("no_tracking", False)
         self.no_caching = kwargs.get("no_caching", False)
         self.advanced = Advanced(self)
+        self._events = None
+
+    @property
+    def readonly_events(self):
+        if self._events is None:
+            return self._document_store.events.clone()
+        return self._events
+
+    @property
+    def events(self):
+        if self._events is None:
+            self._events = self._document_store.events.clone()
+        return self._events
 
     def __enter__(self):
         return self
@@ -141,6 +154,7 @@ def _convert_and_save_entity(self, key, document, object_type, nested_object_typ
         if key not in self._documents_by_id:
             entity, metadata, original_metadata, original_document = Utils.convert_to_entity(document, object_type,
                                                                                              self.conventions,
+                                                                                             self.readonly_events,
                                                                                              nested_object_types)
             self.save_entity(key, entity, original_metadata, metadata, original_document)
 
@@ -235,6 +249,7 @@ def delete_by_entity(self, entity):
         if "Raven-Read-Only" in self._documents_by_entity[entity]["original_metadata"]:
             raise exceptions.InvalidOperationException(
                 "{0} is marked as read only and cannot be deleted".format(entity))
+
         self._included_documents_by_id.pop(self._documents_by_entity[entity]["key"], None)
         self._known_missing_ids.add(self._documents_by_entity[entity]["key"])
         self._deleted_entities.add(entity)
@@ -375,6 +390,8 @@ def _update_batch_result(self, batch_result, data):
                         document_info["metadata"] = item
                         document_info["key"] = item["@id"]
                         document_info["original_value"] = entity.__dict__.copy()
+                        self.readonly_events.after_save_change(self, item["@id"], entity)
+
                 elif item["Type"] == "Counters":
                     cache = self._counters_by_document_id.get(item["Id"], None)
                     if not cache:
@@ -415,13 +432,15 @@ def _prepare_for_puts_commands(self, data):
                 change_vector = None
                 if self.advanced.use_optimistic_concurrency and self._documents_by_entity[entity][
                     "force_concurrency_check"] != "disabled" or self._documents_by_entity[entity][
-                    "force_concurrency_check"] == "forced":
+                        "force_concurrency_check"] == "forced":
                     change_vector = self._documents_by_entity[entity]["change_vector"]
+                self.readonly_events.before_store(self, key, entity)
                 data.entities.append(entity)
                 if key:
                     self._documents_by_id.pop(key)
                     document = entity.__dict__.copy()
                     document.pop('Id', None)
+
                 data.commands.append(commands_data.PutCommandData(key, change_vector, document, metadata))
 
     def _has_change(self, entity):
@@ -477,6 +496,7 @@ def stream(self, query):
             results = ijson.backend.common.items(parser, "Results")
             for result in next(results, None):
                 document, metadata, _, _ = Utils.convert_to_entity(result, query.object_type, self.session.conventions,
+                                                                   self.session.readonly_events,
                                                                    query.nested_object_types)
                 yield {"document": document, "metadata": metadata, "id": metadata.get("@id", None),
                        "change-vector": metadata.get("@change-vector", None)}

pyravendb/store/document_store.py

@@ -35,6 +35,11 @@ def __init__(self, urls=None, database=None, certificate=None):
         self._maintenance_operation_executor = None
         self.subscriptions = DocumentSubscriptions(self)
         self._database_changes = {}
+        self._events = DocumentEvents()
+
+    @property
+    def events(self):
+        return self._events
 
     @property
     def conventions(self):
@@ -133,13 +138,31 @@ def open_session(self, database=None, request_executor=None):
         self._assert_initialize()
         session_id = uuid.uuid4()
         requests_executor = request_executor if request_executor is not None else self.get_request_executor(database)
-        return DocumentSession(database, self, requests_executor, session_id)
+        session = DocumentSession(database, self, requests_executor, session_id)
+        self.events.session_created(session)
+        return session
 
     def generate_id(self, db_name, entity):
         if self.generator:
             return self.generator.generate_document_key(db_name, entity)
 
 
+class DocumentEvents:
+    def __init__(self):
+        self.before_store = lambda session, doc_id, entity: None
+        self.before_query = lambda session, query: None
+        self.after_save_change = lambda session, doc_id, entity: None
+        self.before_delete = lambda session, doc_id, entity: None
+        self.session_created = lambda session: None
+        self.before_conversion_to_entity = lambda document, metadata, type_from_metadata: None
+        self.after_conversion_to_entity = lambda entity, document, metadata: None
+
+    def clone(self):
+        other = DocumentEvents()
+        other.__dict__ = self.__dict__.copy()
+        return other
+
+
 # ------------------------------Operation executors ---------------------------->
 class MaintenanceOperationExecutor:
     def __init__(self, document_store, database_name=None):

pyravendb/store/session_query.py

@@ -802,7 +802,8 @@ def _execute_query(self):
         self.session.save_includes(response_includes)
         for result in response_results:
             entity, metadata, original_metadata, original_document = Utils.convert_to_entity(result, self.object_type,
-                                                                                             conventions,
+                                                                                             self.session.conventions,
+                                                                                             self.session.readonly_events,
                                                                                              self.nested_object_types)
             if self.object_type != dict and not self.fields_to_fetch:
                 self.session.save_entity(key=original_metadata.get("@id", None), entity=entity,

pyravendb/subscriptions/subscription.py

@@ -344,6 +344,7 @@ def initialize(self):
 
             entity, metadata, _, _ = Utils.convert_to_entity(item['Data'], self._object_type,
                                                              self._store.conventions,
+                                                             self._store.events,
                                                              nested_object_types=self._nested_object_type)
             if not metadata:
                 raise InvalidOperationException("Document must have a @metadata field")

pyravendb/tests/session_tests/test_conversion.py

@@ -10,6 +10,11 @@ def __init__(self, td, dt):
         self.dt = dt
 
 
+class Item(object):
+    def __init__(self, val):
+        self.val = val
+
+
 class TestConversion(TestBase):
     def setUp(self):
         super(TestConversion, self).setUp()
@@ -25,6 +30,20 @@ def tearDown(self):
         super(TestConversion, self).tearDown()
         self.delete_all_topology_files()
 
+    def test_before_store(self):
+        def update_item(session, doc_id, entity):
+            entity.val = 2
+
+        with self.store.open_session() as session:
+            session.events.before_store = update_item
+            session.store(Item(1), "item/1")
+            session.save_changes()
+
+        with self.store.open_session() as session:
+            time = session.load("item/1", object_type=Item)
+            self.assertEqual(2, time.val)
+
+
     def test_load_timedelta_and_datetime(self):
         with self.store.open_session() as session:
             times = session.load("times/3", object_type=Time, nested_object_types={"td": timedelta, "dt": datetime})

pyravendb/tests/subscription_test/test_subscription.py

@@ -61,7 +61,7 @@ def test_create_and_run_subscription_with_object(self):
         self.assertEqual(len(self.results), 0)
         with self.store.subscriptions.get_subscription_worker(connection_options, object_type=User) as subscription:
             subscription.run(self.process_documents)
-            self.event.wait(timeout=5)
+            self.event.wait(timeout=60)
 
         self.assertEqual(len(self.results), 2)
         for item in self.results:

pyravendb/tools/utils.py

@@ -98,21 +98,27 @@ def initialize_object(obj, object_type, convert_to_snake_case=None):
         return o
 
     @staticmethod
-    def convert_to_entity(document, object_type, conventions, nested_object_types=None):
+    def convert_to_entity(document, object_type, conventions, events, nested_object_types=None):
+
         metadata = document.pop("@metadata")
         original_document = deepcopy(document)
         original_metadata = deepcopy(metadata)
         type_from_metadata = conventions.try_get_type_from_metadata(metadata)
         mapper = conventions.mappers.get(object_type, None)
 
+        events.before_conversion_to_entity(document, metadata, type_from_metadata)
+
         if object_type == dict:
+            events.after_conversion_to_entity(document, document, metadata)
             return document, metadata, original_metadata, original_document
 
         if type_from_metadata is None:
             if object_type is not None:
                 metadata["Raven-Python-Type"] = "{0}.{1}".format(object_type.__module__, object_type.__name__)
             else:  # no type defined on document or during load, return a dict
-                return _DynamicStructure(**document), metadata, original_metadata, original_document
+                dyn = _DynamicStructure(**document)
+                events["after_conversion_to_entity"](dyn, document, metadata)
+                return dyn, metadata, original_metadata, original_document
         else:
             object_from_metadata = Utils.import_class(type_from_metadata)
             if object_from_metadata is not None:
@@ -156,6 +162,7 @@ def convert_to_entity(document, object_type, conventions, nested_object_types=No
 
         if 'Id' in entity.__dict__:
             entity.Id = metadata.get('@id', None)
+        events.after_conversion_to_entity(entity, document, metadata)
         return entity, metadata, original_metadata, original_document
 
     @staticmethod