RDBC-766 Python client - time series 3 - stage #1 + test for roll-ups

Author: poissoncorp

ravendb/documents/operations/time_series.py

@@ -330,7 +330,7 @@ def to_json(self) -> Dict[str, Any]:
 
     def append(self, append_operation: AppendOperation) -> None:
         if self._appends is None:
-            self._appends = [] # todo: perf
+            self._appends = []  # todo: perf
         filtered = self._appends
 
         # if len(filtered) != 0:

ravendb/documents/session/document_session.py

@@ -2314,7 +2314,7 @@ def get(
         to_date: Optional[datetime] = None,
         start: int = 0,
         page_size: int = int_max,
-    ):
+    ) -> List[TypedTimeSeriesRollupEntry[_T_TS_Values_Bindable]]:
         if self._not_in_cache(from_date, to_date):
             results = self.get_time_series_and_includes(from_date, to_date, None, start, page_size)
             return [TypedTimeSeriesRollupEntry.from_entry(self._object_type, x) for x in results]

ravendb/documents/session/time_series.py

@@ -68,37 +68,44 @@ def _create_instance(self) -> _T_Values:
         except Exception as e:
             raise RavenException(f"Unable to create instance of class: {self._object_type.__name__}", e)
 
-    def get_max(self) -> _T_Values:
+    @property
+    def max(self) -> _T_Values:
         if self._max is None:
             self._max = self._create_instance()
         return self._max
 
-    def get_min(self) -> _T_Values:
+    @property
+    def min(self) -> _T_Values:
         if self._min is None:
             self._min = self._create_instance()
         return self._min
 
-    def get_count(self) -> _T_Values:
+    @property
+    def count(self) -> _T_Values:
         if self._count is None:
             self._count = self._create_instance()
         return self._count
 
-    def get_first(self) -> _T_Values:
+    @property
+    def first(self) -> _T_Values:
         if self._first is None:
             self._first = self._create_instance()
         return self._first
 
-    def get_last(self) -> _T_Values:
+    @property
+    def last(self) -> _T_Values:
         if self._last is None:
             self._last = self._create_instance()
         return self._last
 
-    def get_sum(self) -> _T_Values:
+    @property
+    def sum(self) -> _T_Values:
         if self._sum is None:
             self._sum = self._create_instance()
         return self._sum
 
-    def get_average(self) -> _T_Values:
+    @property
+    def average(self) -> _T_Values:
         if self._average is not None:
             return self._average
 
@@ -139,7 +146,9 @@ def _assign_rollup(self, target: List[float], source: _T_Values, offset: int) ->
                     target[i * 6 + offset] = values[i]
 
     @classmethod
-    def from_entry(cls, ts_bindable_object_type: Type[_T_TSBindable], entry: TimeSeriesEntry):
+    def from_entry(
+        cls, ts_bindable_object_type: Type[_T_TSBindable], entry: TimeSeriesEntry
+    ) -> TypedTimeSeriesRollupEntry[_T_TSBindable]:
         result = TypedTimeSeriesRollupEntry(ts_bindable_object_type, entry.timestamp)
         result.rollup = True
         result.tag = entry.tag
@@ -153,6 +162,8 @@ def from_entry(cls, ts_bindable_object_type: Type[_T_TSBindable], entry: TimeSer
         result._sum = TimeSeriesValuesHelper.set_fields(ts_bindable_object_type, cls.extract_values(values, 4))
         result._count = TimeSeriesValuesHelper.set_fields(ts_bindable_object_type, cls.extract_values(values, 5))
 
+        return result
+
     @staticmethod
     def extract_values(input: List[float], offset: int) -> List[float]:
         length = math.ceil((len(input) - offset) / 6.0)

ravendb/tests/jvm_migrated_tests/client_tests/time_series_tests/test_time_series_typed_session.py

@@ -7,12 +7,13 @@
     TimeSeriesCollectionConfiguration,
     TimeSeriesConfiguration,
     ConfigureTimeSeriesOperation,
+    RawTimeSeriesPolicy,
 )
 from ravendb.documents.session.time_series import ITimeSeriesValuesBindable, TypedTimeSeriesEntry
 from ravendb.infrastructure.entities import User
 from ravendb.primitives.time_series import TimeValue
 from ravendb.tests.test_base import TestBase
-
+from ravendb.tools.raven_test_helper import RavenTestHelper
 
 document_id = "users/gracjan"
 company_id = "companies/1-A"
@@ -261,3 +262,54 @@ def test_can_execute_simple_rollup(self):
 
             ts3 = session.time_series_for(document_id, p3.get_time_series_name(ts_name1)).get()
             self.assertEqual(len(ts1) // 4, len(ts3))
+
+    def test_can_work_with_rollup_time_series_2(self):
+        raw_hours = 24
+        raw = RawTimeSeriesPolicy(TimeValue.of_hours(raw_hours))
+
+        p1 = TimeSeriesPolicy("By6Hours", TimeValue.of_hours(6), TimeValue.of_hours(raw_hours * 4))
+        p2 = TimeSeriesPolicy("By1Day", TimeValue.of_days(1), TimeValue.of_hours(raw_hours * 5))
+        p3 = TimeSeriesPolicy("By30Minutes", TimeValue.of_minutes(30), TimeValue.of_hours(raw_hours * 2))
+        p4 = TimeSeriesPolicy("By1Hour", TimeValue.of_hours(1), TimeValue.of_hours(raw_hours * 3))
+
+        time_series_collection_configuration = TimeSeriesCollectionConfiguration()
+        time_series_collection_configuration.raw_policy = raw
+        time_series_collection_configuration.policies = [p1, p2, p3, p4]
+
+        config = TimeSeriesConfiguration()
+        config.collections = {"users": time_series_collection_configuration}
+        config.policy_check_frequency = timedelta(seconds=1)
+
+        self.store.maintenance.send(ConfigureTimeSeriesOperation(config))
+        self.store.time_series.register_type(User, StockPrice)
+
+        total = TimeValue.of_days(12).value // 60
+        base_line = RavenTestHelper.utc_today() - timedelta(days=12)
+
+        with self.store.open_session() as session:
+            session.store(User(name="Karmel"), "users/karmel")
+
+            ts = session.typed_time_series_for(StockPrice, "users/karmel")
+            for i in range(total + 1):
+                open = i
+                close = i + 100_000
+                high = i + 200_000
+                low = i + 300_000
+                volume = i + 400_000
+                ts.append(
+                    base_line + timedelta(minutes=i), StockPrice(open, close, high, low, volume), "watches/fitbit"
+                )
+
+            session.save_changes()
+
+        time.sleep(1.5)  # wait for rollups
+
+        with self.store.open_session() as session:
+            ts1 = session.time_series_rollup_for(StockPrice, "users/karmel", p1.name)
+            r = ts1.get()[0]
+            self.assertIsNotNone(r.first)
+            self.assertIsNotNone(r.last)
+            self.assertIsNotNone(r.min)
+            self.assertIsNotNone(r.max)
+            self.assertIsNotNone(r.count)
+            self.assertIsNotNone(r.average)

ravendb/tests/jvm_migrated_tests/issues_tests/test_ravenDB_16060.py

@@ -436,13 +436,15 @@ def test_can_serve_time_series_from_cache_rollup(self):
             session.store(User(name="Karmel"), "users/karmel")
 
             ts = session.typed_time_series_for(StockPrice, "users/karmel")
-            for i in range(total+1):
+            for i in range(total + 1):
                 open = i
                 close = i + 100_000
                 high = i + 200_000
                 low = i + 300_000
                 volume = i + 400_000
-                ts.append(base_line + timedelta(minutes=i), StockPrice(open, close, high, low, volume), "watches/fitbit")
+                ts.append(
+                    base_line + timedelta(minutes=i), StockPrice(open, close, high, low, volume), "watches/fitbit"
+                )
 
             session.save_changes()
 
@@ -458,3 +460,55 @@ def test_can_serve_time_series_from_cache_rollup(self):
             res = ts.get(base_line, base_line + timedelta(days=365))
             self.assertEqual(16, len(res))
             self.assertEqual(1, session.advanced.number_of_requests)
+
+    def test_can_include_typed_time_series_rollup(self):
+        raw = RawTimeSeriesPolicy(TimeValue.of_hours(24))
+
+        p1 = TimeSeriesPolicy("By6Hours", TimeValue.of_hours(6), TimeValue.of_days(4))
+        p2 = TimeSeriesPolicy("By1Day", TimeValue.of_days(1), TimeValue.of_days(5))
+        p3 = TimeSeriesPolicy("By30Minutes", TimeValue.of_minutes(30), TimeValue.of_days(2))
+        p4 = TimeSeriesPolicy("By1Hour", TimeValue.of_hours(1), TimeValue.of_days(3))
+
+        time_series_collection_configuration = TimeSeriesCollectionConfiguration()
+        time_series_collection_configuration.raw_policy = raw
+        time_series_collection_configuration.policies = [p1, p2, p3, p4]
+
+        config = TimeSeriesConfiguration()
+        config.collections = {"users": time_series_collection_configuration}
+        config.policy_check_frequency = timedelta(seconds=1)
+
+        self.store.maintenance.send(ConfigureTimeSeriesOperation(config))
+        self.store.time_series.register_type(User, StockPrice)
+
+        total = TimeValue.of_days(12).value
+        base_line = RavenTestHelper.utc_today() - timedelta(days=12)
+
+        with self.store.open_session() as session:
+            session.store(User(name="Karmel"), "users/karmel")
+
+            ts = session.typed_time_series_for(StockPrice, "users/karmel")
+            for i in range(total + 1):
+                open = i
+                close = i + 100_000
+                high = i + 200_000
+                low = i + 300_000
+                volume = i + 400_000
+                ts.append(
+                    base_line + timedelta(minutes=i), StockPrice(open, close, high, low, volume), "watches/fitbit"
+                )
+
+            session.save_changes()
+
+        time.sleep(1.2)
+
+        with self.store.open_session() as session:
+            user = (
+                session.query(object_type=User)
+                .include(lambda i: i.include_time_series(f"stockPrices@{p1.name}"))
+                .first()
+            )
+
+            # should not go to server
+            res = session.time_series_rollup_for(StockPrice, user.Id, p1.name).get()
+            self.assertEqual(16, len(res))
+            self.assertEqual(1, session.advanced.number_of_requests)