Plan B logic for broken timestamp close to epoch on Windows #9 #29

Author: greenrobot

objectbox/model/entity.py

@@ -140,7 +140,22 @@ def set_object_id(self, object, id: int):
     @staticmethod
     def date_value_to_int(value, multiplier: int) -> int:
         if isinstance(value, datetime):
-            return round(value.timestamp() * multiplier)  # timestamp returns seconds
+            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

tests/test_box.py

@@ -206,7 +206,7 @@ def test_datetime_special_values():
     assert read.date_nano == datetime.fromtimestamp(0, timezone.utc)
 
     object.date = datetime.fromtimestamp(1.0, timezone.utc)
-    object.date_nano = datetime.fromtimestamp(1.0)
+    object.date_nano = datetime.fromtimestamp(1.0, timezone.utc)
     id = box.put(object)
 
     read = box.get(id)

tests/test_utils.py

@@ -12,16 +12,42 @@ def test_date_value_to_int__basics():
     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
+    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
+
+
+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
+
+    # "Return the local date corresponding to the POSIX timestamp"; but not always!? Was -1 hour off with CEST:
+    dt0naive = datetime.fromtimestamp(0)
+    local_tz = datetime.now().astimezone().tzinfo
+    dt0local = dt0naive.replace(tzinfo=local_tz)
+    dt0utc = dt0local.astimezone(timezone.utc)
+
+    # Print, don't assert... the result Seems to depend on the local timezone configuration!?
+    print("\nNaive:", dt0naive)  # Seen: 1970-01-01 01:00:00
+    print("Local:", dt0local)  # Seen: 1970-01-01 01:00:00+02:00
+    print("UTC:", dt0utc)  # Seen: 1969-12-31 23:00:00+00:00
+    print("Timestamp:", dt0utc.timestamp())  # Seen: -3600.0
+
     dt = datetime.fromtimestamp(1234)
     if sys.platform == "win32":
+        # On Windows, timestamp() seems to raise an OSError if the date is close to the epoch; see bug reports:
+        # https://github.com/python/cpython/issues/81708 and https://github.com/python/cpython/issues/94414
         try:
             dt.timestamp()
-            assert False, "Expected OSError"
+            assert False, "Expected OSError - Did Python on Windows get fixed?"
         except OSError as e:
             assert e.errno == 22
     else:
+        # Non-Windows platforms should work fine
         assert dt.timestamp() == 1234
-        assert _Entity.date_value_to_int(dt, 1000) == 1234000  # milliseconds
+
+    assert _Entity.date_value_to_int(dt, 1000) == 1234000  # milliseconds
 
 
 def test_date_value_to_int__timezone():