Improve compatibility with timezone implementations

Not all implementations of timezones play nicely with custom datetime
implementations. In such cases, we need to fall back to native datetimes.

Author: robsdedude

neo4j/time/__init__.py

@@ -27,6 +27,7 @@
     datetime,
     time,
     timedelta,
+    timezone,
 )
 from functools import total_ordering
 from re import compile as re_compile
@@ -778,7 +779,7 @@ def __getattr__(self, name):
     def today(cls, tz=None):
         """Get the current date.
 
-        :param tz: timezone or None to get a local :class:`.Date`.
+        :param tz: timezone or None to get the local :class:`.Date`.
         :type tz: datetime.tzinfo or None
 
         :rtype: Date
@@ -790,11 +791,11 @@ def today(cls, tz=None):
         if tz is None:
             return cls.from_clock_time(Clock().local_time(), UnixEpoch)
         else:
-            return tz.fromutc(
-                DateTime.from_clock_time(
-                    Clock().utc_time(), UnixEpoch
-                ).replace(tzinfo=tz)
-            ).date()
+            return (
+                DateTime.utc_now()
+                .replace(tzinfo=timezone.utc).astimezone(tz)
+                .date()
+            )
 
     @classmethod
     def utc_today(cls):
@@ -819,14 +820,7 @@ def from_timestamp(cls, timestamp, tz=None):
             supported by the platform C localtime() function. It’s common for
             this to be restricted to years from 1970 through 2038.
         """
-        if tz is None:
-            return cls.from_clock_time(
-                ClockTime(timestamp) + Clock().local_offset(), UnixEpoch
-            )
-        else:
-            return tz.fromutc(
-                DateTime.utc_from_timestamp(timestamp).replace(tzinfo=tz)
-            ).date()
+        return cls.from_native(datetime.fromtimestamp(timestamp, tz))
 
     @classmethod
     def utc_from_timestamp(cls, timestamp):
@@ -1427,7 +1421,11 @@ def now(cls, tz=None):
         if tz is None:
             return cls.from_clock_time(Clock().local_time(), UnixEpoch)
         else:
-            return tz.fromutc(DateTime.from_clock_time(Clock().utc_time(), UnixEpoch)).time().replace(tzinfo=tz)
+            return (
+                DateTime.utc_now()
+                .replace(tzinfo=timezone.utc).astimezone(tz)
+                .timetz()
+            )
 
     @classmethod
     def utc_now(cls):
@@ -1768,7 +1766,12 @@ def replace(self, **kwargs):
     def _utc_offset(self, dt=None):
         if self.tzinfo is None:
             return None
-        value = self.tzinfo.utcoffset(dt)
+        try:
+            value = self.tzinfo.utcoffset(dt)
+        except TypeError:
+            # For timezone implementations not compatible with the custom
+            # datetime implementations, we can't do better than this.
+            value = self.tzinfo.utcoffset(dt.to_native())
         if value is None:
             return None
         if isinstance(value, timedelta):
@@ -1810,7 +1813,12 @@ def dst(self):
         """
         if self.tzinfo is None:
             return None
-        value = self.tzinfo.dst(self)
+        try:
+            value = self.tzinfo.dst(self)
+        except TypeError:
+            # For timezone implementations not compatible with the custom
+            # datetime implementations, we can't do better than this.
+            value = self.tzinfo.dst(self.to_native())
         if value is None:
             return None
         if isinstance(value, timedelta):
@@ -1831,7 +1839,12 @@ def tzname(self):
         """
         if self.tzinfo is None:
             return None
-        return self.tzinfo.tzname(self)
+        try:
+            return self.tzinfo.tzname(self)
+        except TypeError:
+            # For timezone implementations not compatible with the custom
+            # datetime implementations, we can't do better than this.
+            return self.tzinfo.tzname(self.to_native())
 
     def to_clock_time(self):
         """Convert to :class:`.ClockTime`.
@@ -1860,8 +1873,8 @@ def iso_format(self):
         :rtype: str
         """
         s = "%02d:%02d:%02d.%09d" % self.hour_minute_second_nanosecond
-        if self.tzinfo is not None:
-            offset = self.tzinfo.utcoffset(self)
+        offset = self.utc_offset()
+        if offset is not None:
             s += "%+03d:%02d" % divmod(offset.total_seconds() // 60, 60)
         return s
 
@@ -1970,9 +1983,24 @@ def now(cls, tz=None):
         if tz is None:
             return cls.from_clock_time(Clock().local_time(), UnixEpoch)
         else:
-            return tz.fromutc(cls.from_clock_time(
-                Clock().utc_time(), UnixEpoch
-            ).replace(tzinfo=tz))
+            try:
+                return tz.fromutc(cls.from_clock_time(
+                    Clock().utc_time(), UnixEpoch
+                ).replace(tzinfo=tz))
+            except TypeError:
+                # For timezone implementations not compatible with the custom
+                # datetime implementations, we can't do better than this.
+                utc_now = cls.from_clock_time(
+                    Clock().utc_time(), UnixEpoch
+                )
+                utc_now_native = utc_now.to_native()
+                now_native = tz.fromutc(utc_now_native)
+                now = cls.from_native(now_native)
+                return now.replace(
+                    nanosecond=(now.nanosecond
+                                + utc_now.nanosecond
+                                - utc_now_native.microsecond * 1000)
+                )
 
     @classmethod
     def utc_now(cls):
@@ -2019,8 +2047,9 @@ def from_timestamp(cls, timestamp, tz=None):
                 ClockTime(timestamp) + Clock().local_offset(), UnixEpoch
             )
         else:
-            return tz.fromutc(
-                cls.utc_from_timestamp(timestamp).replace(tzinfo=tz)
+            return (
+                cls.utc_from_timestamp(timestamp)
+                .replace(tzinfo=timezone.utc).astimezone(tz)
             )
 
     @classmethod
@@ -2326,7 +2355,15 @@ def __add__(self, other):
             time_ = Time.from_ticks(round_half_to_even(
                 seconds * NANO_SECONDS + t.nanoseconds
             ))
-            return self.combine(date_, time_)
+            return self.combine(date_, time_).replace(tzinfo=self.tzinfo)
+        if isinstance(other, Duration):
+            t = (self.to_clock_time()
+                 + ClockTime(other.seconds, other.nanoseconds))
+            days, seconds = symmetric_divmod(t.seconds, 86400)
+            date_ = self.date() + Duration(months=other.months,
+                                           days=days + other.days)
+            time_ = Time.from_ticks(seconds * NANO_SECONDS + t.nanoseconds)
+            return self.combine(date_, time_).replace(tzinfo=self.tzinfo)
         return NotImplemented
 
     def __sub__(self, other):
@@ -2356,7 +2393,7 @@ def __sub__(self, other):
             return timedelta(days=days, seconds=t.seconds,
                              microseconds=(t.nanoseconds // 1000))
         if isinstance(other, Duration):
-            return NotImplemented
+            return self.__add__(-other)
         if isinstance(other, timedelta):
             return self.__add__(-other)
         return NotImplemented
@@ -2415,7 +2452,18 @@ def as_timezone(self, tz):
         if self.tzinfo is None:
             return self
         utc = (self - self.utc_offset()).replace(tzinfo=tz)
-        return tz.fromutc(utc)
+        try:
+            return tz.fromutc(utc)
+        except TypeError:
+            # For timezone implementations not compatible with the custom
+            # datetime implementations, we can't do better than this.
+            native_utc = utc.to_native()
+            native_res = tz.fromutc(native_utc)
+            res = self.from_native(native_res)
+            return res.replace(
+                nanosecond=(native_res.microsecond * 1000
+                            + self.nanosecond % 1000)
+            )
 
     def utc_offset(self):
         """Get the date times utc offset.
@@ -2513,8 +2561,17 @@ def iso_format(self, sep="T"):
 
         :rtype: str
         """
-        return "%s%s%s" % (self.date().iso_format(), sep,
-                           self.timetz().iso_format())
+        s = "%s%s%s" % (self.date().iso_format(), sep,
+                        self.timetz().iso_format())
+        time_tz = self.timetz()
+        offset = time_tz.utc_offset()
+        if offset is not None:
+            # the time component will have taken care of formatting the offset
+            return s
+        offset = self.utc_offset()
+        if offset is not None:
+            s += "%+03d:%02d" % divmod(offset.total_seconds() // 60, 60)
+        return s
 
     def __repr__(self):
         """"""

tests/unit/common/time/__init__.py

@@ -14,3 +14,29 @@
 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 # See the License for the specific language governing permissions and
 # limitations under the License.
+
+
+from neo4j.time.clock_implementations import (
+    Clock,
+    ClockTime,
+)
+
+
+# The existence of this class will make the driver's custom date time
+# implementation use it instead of a real clock since its precision it higher
+# than all the other clocks (only up to nanoseconds).
+class FixedClock(Clock):
+    @classmethod
+    def available(cls):
+        return True
+
+    @classmethod
+    def precision(cls):
+        return 12
+
+    @classmethod
+    def local_offset(cls):
+        return ClockTime()
+
+    def utc_time(self):
+        return ClockTime(45296, 789000001)

tests/unit/common/time/test_date.py

@@ -17,10 +17,12 @@
 
 
 import copy
+import datetime
 from datetime import date
 from time import struct_time
 from unittest import TestCase
 
+import pytest
 import pytz
 
 from neo4j.time import (
@@ -31,7 +33,8 @@
 )
 
 
-eastern = pytz.timezone("US/Eastern")
+timezone_eastern = pytz.timezone("US/Eastern")
+timezone_utc = pytz.utc
 
 
 class TestDate(TestCase):
@@ -189,24 +192,12 @@ def test_cannot_use_year_higher_than_9999(self):
         with self.assertRaises(ValueError):
             _ = Date(10000, 2, 1)
 
-    def test_today(self):
-        d = Date.today()
-        self.assertIsInstance(d, Date)
-
-    def test_today_with_tz(self):
-        d = Date.today(tz=eastern)
-        self.assertIsInstance(d, Date)
-
-    def test_utc_today(self):
-        d = Date.utc_today()
-        self.assertIsInstance(d, Date)
-
     def test_from_timestamp_without_tz(self):
         d = Date.from_timestamp(0)
         self.assertEqual(d, Date(1970, 1, 1))
 
     def test_from_timestamp_with_tz(self):
-        d = Date.from_timestamp(0, tz=eastern)
+        d = Date.from_timestamp(0, tz=timezone_eastern)
         self.assertEqual(d, Date(1969, 12, 31))
 
     def test_utc_from_timestamp(self):
@@ -547,3 +538,23 @@ def test_date_deep_copy(self):
         d2 = copy.deepcopy(d)
         self.assertIsNot(d, d2)
         self.assertEqual(d, d2)
+
+
+@pytest.mark.parametrize(("tz", "expected"), (
+    (None, (1970, 1, 1)),
+    (timezone_eastern, (1970, 1, 1)),
+    (timezone_utc, (1970, 1, 1)),
+    (pytz.FixedOffset(-12 * 60), (1970, 1, 1)),
+    (datetime.timezone(datetime.timedelta(hours=-12)), (1970, 1, 1)),
+    (pytz.FixedOffset(-13 * 60), (1969, 12, 31)),
+    (datetime.timezone(datetime.timedelta(hours=-13)), (1969, 12, 31)),
+    (pytz.FixedOffset(11 * 60), (1970, 1, 1)),
+    (datetime.timezone(datetime.timedelta(hours=11)), (1970, 1, 1)),
+    (pytz.FixedOffset(12 * 60), (1970, 1, 2)),
+    (datetime.timezone(datetime.timedelta(hours=12)), (1970, 1, 2)),
+
+))
+def test_today(tz, expected):
+    d = Date.today(tz=tz)
+    assert isinstance(d, Date)
+    assert d.year_month_day == expected