utils: date_value_to_int moved from _Entity #29

Author: dan-obx

objectbox/model/entity.py

@@ -17,10 +17,10 @@
 import flatbuffers.flexbuffers
 from typing import Generic
 import numpy as np
-from math import floor
 from datetime import datetime, timezone
 from objectbox.c import *
 from objectbox.model.properties import Property
+from objectbox.utils import date_value_to_int
 import threading
 
 
@@ -137,34 +137,6 @@ def get_object_id(self, object) -> int:
     def set_object_id(self, object, id: int):
         setattr(object, self.id_property._name, id)
 
-    @staticmethod
-    def date_value_to_int(value, multiplier: int) -> int:
-        if isinstance(value, datetime):
-            try:
-                return round(value.timestamp() * multiplier)  # timestamp returns seconds
-            except OSError:
-                # On Windows, timestamp() raises an OSError for naive datetime objects with dates is close to the epoch.
-                # Thus, it is highly recommended to only use datetime *with* timezone information (no issue here).
-                # See bug reports:
-                # https://github.com/python/cpython/issues/81708 and https://github.com/python/cpython/issues/94414
-                # The workaround is to go via timezone-aware datetime objects, which seem to work - with one caveat.
-                local_tz = datetime.now().astimezone().tzinfo
-                value = value.replace(tzinfo=local_tz)
-                value = value.astimezone(timezone.utc)
-                # Caveat: times may be off by; offset should be 0 but actually was seen at -3600 in CEST (Linux & Win).
-                # See also https://stackoverflow.com/q/56931738/551269
-                # So, let's check value 0 as a reference and use the resulting timestamp as an offset for correction.
-                offset = datetime.fromtimestamp(0).replace(tzinfo=local_tz).astimezone(timezone.utc).timestamp()
-                return round((value.timestamp() - offset) * multiplier)  # timestamp returns seconds
-        elif isinstance(value, float):
-            return round(value * multiplier)  # floats typically represent seconds
-        elif isinstance(value, int):  # Interpret ints as-is (without the multiplier); e.g. milliseconds or nanoseconds
-            return value
-        else:
-            raise TypeError(
-                f"Unsupported Python datetime type: {type(value)}. Please use datetime, float (seconds based) or "
-                f"int (milliseconds for Date, nanoseconds for DateNano).")
-
     def marshal(self, object, id: int) -> bytearray:
         if not hasattr(self._tl, "builder"):
             self._tl.builder = flatbuffers.Builder(256)
@@ -215,9 +187,9 @@ def marshal(self, object, id: int) -> bytearray:
             else:
                 val = id if prop == self.id_property else self.get_value(object, prop)
                 if prop._ob_type == OBXPropertyType_Date:
-                    val = self.date_value_to_int(val, 1000)  # convert to milliseconds
+                    val = date_value_to_int(val, 1000)  # convert to milliseconds
                 elif prop._ob_type == OBXPropertyType_DateNano:
-                    val = self.date_value_to_int(val, 1000000000)  # convert to nanoseconds
+                    val = date_value_to_int(val, 1000000000)  # convert to nanoseconds
                 builder.Prepend(prop._fb_type, val)
 
             builder.Slot(prop._fb_slot)

objectbox/utils.py

@@ -2,7 +2,7 @@
 
 from objectbox.c import *
 from objectbox.model.properties import VectorDistanceType
-
+from datetime import datetime, timezone
 
 def check_float_vector(vector: Union[np.ndarray, List[float]], vector_name: str):
     """ Checks that the given vector is a float vector (either np.ndarray or Python's list). """
@@ -28,3 +28,30 @@ def vector_distance_f32(distance_type: VectorDistanceType,
 def vector_distance_to_relevance(distance_type: VectorDistanceType, distance: float) -> float:
     """ Converts the given distance to a relevance score in range [0.0, 1.0], according to its type. """
     return obx_vector_distance_to_relevance(distance_type, distance)
+
+def date_value_to_int(value, multiplier: int) -> int:
+    if isinstance(value, datetime):
+        try:
+            return round(value.timestamp() * multiplier)  # timestamp returns seconds
+        except OSError:
+            # On Windows, timestamp() raises an OSError for naive datetime objects with dates is close to the epoch.
+            # Thus, it is highly recommended to only use datetime *with* timezone information (no issue here).
+            # See bug reports:
+            # https://github.com/python/cpython/issues/81708 and https://github.com/python/cpython/issues/94414
+            # The workaround is to go via timezone-aware datetime objects, which seem to work - with one caveat.
+            local_tz = datetime.now().astimezone().tzinfo
+            value = value.replace(tzinfo=local_tz)
+            value = value.astimezone(timezone.utc)
+            # Caveat: times may be off by; offset should be 0 but actually was seen at -3600 in CEST (Linux & Win).
+            # See also https://stackoverflow.com/q/56931738/551269
+            # So, let's check value 0 as a reference and use the resulting timestamp as an offset for correction.
+            offset = datetime.fromtimestamp(0).replace(tzinfo=local_tz).astimezone(timezone.utc).timestamp()
+            return round((value.timestamp() - offset) * multiplier)  # timestamp returns seconds
+    elif isinstance(value, float):
+        return round(value * multiplier)  # floats typically represent seconds
+    elif isinstance(value, int):  # Interpret ints as-is (without the multiplier); e.g. milliseconds or nanoseconds
+        return value
+    else:
+        raise TypeError(
+            f"Unsupported Python datetime type: {type(value)}. Please use datetime, float (seconds based) or "
+            f"int (milliseconds for Date, nanoseconds for DateNano).")

tests/test_utils.py

@@ -3,24 +3,23 @@
 
 import pytest
 
-from objectbox.model.entity import _Entity
 from objectbox.utils import *
 
 
 def test_date_value_to_int__basics():
-    assert _Entity.date_value_to_int(1234, 1000) == 1234
-    assert _Entity.date_value_to_int(1234, 1000000000) == 1234
-    assert _Entity.date_value_to_int(1234.0, 1000) == 1234000  # milliseconds
-    assert _Entity.date_value_to_int(1234.0, 1000000000) == 1234000000000  # nanoseconds
+    assert date_value_to_int(1234, 1000) == 1234
+    assert date_value_to_int(1234, 1000000000) == 1234
+    assert date_value_to_int(1234.0, 1000) == 1234000  # milliseconds
+    assert date_value_to_int(1234.0, 1000000000) == 1234000000000  # nanoseconds
     dt = datetime.fromtimestamp(12345678)  # May 1970; 1234 is too close to the epoch (special case for that below)
-    assert _Entity.date_value_to_int(dt, 1000) == 12345678000  # milliseconds
+    assert date_value_to_int(dt, 1000) == 12345678000  # milliseconds
 
 
 def test_date_value_to_int__close_to_epoch():
-    assert _Entity.date_value_to_int(datetime.fromtimestamp(0, timezone.utc), 1000) == 0
-    assert _Entity.date_value_to_int(datetime.fromtimestamp(1234, timezone.utc), 1000) == 1234000
-    assert _Entity.date_value_to_int(datetime.fromtimestamp(0), 1000) == 0
-    assert _Entity.date_value_to_int(datetime.fromtimestamp(1234), 1000) == 1234000
+    assert date_value_to_int(datetime.fromtimestamp(0, timezone.utc), 1000) == 0
+    assert date_value_to_int(datetime.fromtimestamp(1234, timezone.utc), 1000) == 1234000
+    assert date_value_to_int(datetime.fromtimestamp(0), 1000) == 0
+    assert date_value_to_int(datetime.fromtimestamp(1234), 1000) == 1234000
 
     # "Return the local date corresponding to the POSIX timestamp"; but not always!? Was -1 hour off with CEST:
     dt0naive = datetime.fromtimestamp(0)
@@ -47,7 +46,7 @@ def test_date_value_to_int__close_to_epoch():
         # Non-Windows platforms should work fine
         assert dt.timestamp() == 1234
 
-    assert _Entity.date_value_to_int(dt, 1000) == 1234000  # milliseconds
+    assert date_value_to_int(dt, 1000) == 1234000  # milliseconds
 
 
 def test_date_value_to_int__timezone():
@@ -62,8 +61,8 @@ def test_date_value_to_int__timezone():
 
     # Actual test
     expected: int = 957184245123
-    assert _Entity.date_value_to_int(dt_utc, 1000) == expected
-    assert _Entity.date_value_to_int(dt_plus2, 1000) == expected
+    assert date_value_to_int(dt_utc, 1000) == expected
+    assert date_value_to_int(dt_plus2, 1000) == expected
 
 
 def test_date_value_to_int__naive():
@@ -76,7 +75,7 @@ def test_date_value_to_int__naive():
     assert dt_naive.timestamp() == dt_local.timestamp()
 
     # Actual test
-    assert _Entity.date_value_to_int(dt_naive, 1000) == _Entity.date_value_to_int(dt_local, 1000)
+    assert date_value_to_int(dt_naive, 1000) == date_value_to_int(dt_local, 1000)
 
 
 def test_vector_distance_f32():