Improves performances of timezone switching

Author: sdispater

pendulum/tz/timezone.py

@@ -4,7 +4,7 @@
 from datetime import datetime
 
 from .loader import Loader
-from .timezone_info import TimezoneInfo
+from .timezone_info import TimezoneInfo, UTC
 from .breakdown import local_time as _local_time
 from .transition_type import TransitionType
 
@@ -73,6 +73,9 @@ def convert(self, dt):
         else:
             converted = self._convert(dt)
 
+        if not isinstance(converted, tuple):
+            return converted
+
         return dt.__class__(*converted)
 
     def _normalize(self, dt):
@@ -95,7 +98,6 @@ def _normalize(self, dt):
         # Find the first transition after our target date/time
         begin = self._transitions[0]
         end = self._transitions[-1]
-        offset = None
 
         if dt < begin.time:
             tr = begin
@@ -118,6 +120,10 @@ def _normalize(self, dt):
                 # Before first transition, so use the default offset.
                 offset = self._default_transition_type.utc_offset
                 unix_time = (dt - datetime(1970, 1, 1)).total_seconds() - offset
+
+                return self._to_local_time(
+                    unix_time, self._default_transition_type
+                )
             else:
                 # tr.pre_time < dt < tr.time
                 # Skipped time
@@ -152,7 +158,7 @@ def _normalize(self, dt):
 
                 transition_type = tr.pre_transition_type
 
-        return self._to_local_time(unix_time, transition_type, offset)
+        return self._to_local_time(unix_time, transition_type)
 
     def _convert(self, dt):
         """
@@ -173,23 +179,21 @@ def _convert(self, dt):
         if not self._transitions:
             transition_type = self._default_transition_type
         else:
-            idx = max(0, self._find_transition_index(unix_time) - 1)
+            idx = max(0, self._find_transition_index(unix_time, '_unix_time') - 1)
             tr = self._transitions[idx]
             transition_type = tr.transition_type
 
         return self._to_local_time(unix_time, transition_type)
 
-    def _to_local_time(self, unix_time, transition_type, offset=None):
+    def _to_local_time(self, unix_time, transition_type):
         local_time = _local_time(
             unix_time,
             transition_type
         )
 
         tzinfo = TimezoneInfo(
             self,
-            offset if offset is not None else transition_type.utc_offset,
-            transition_type.is_dst,
-            transition_type.abbrev
+            transition_type
         )
 
         return local_time[:7] + (tzinfo,)
@@ -211,13 +215,9 @@ def _get_timestamp(self, dt):
 
         return t
 
-    def _find_transition_index(self, dt):
+    def _find_transition_index(self, dt, prop='_time'):
         lo, hi = 0, len(self._transitions)
 
-        prop = '_time'
-        if isinstance(dt, (int, float)):
-            prop = '_unix_time'
-
         while lo < hi:
             mid = (lo + hi) // 2
             if dt < getattr(self._transitions[mid], prop):
@@ -258,11 +258,11 @@ class _UTC(Timezone):
     def __init__(self):
         super(_UTC, self).__init__('UTC', [], [], TransitionType(0, False, 'GMT'))
 
-        self._tzinfo = TimezoneInfo(self, 0, False, 'UTC')
+        UTC._tz = self
+        self._tzinfo = UTC
 
     @property
     def tzinfo(self):
         return self._tzinfo
 
 UTCTimezone = _UTC()
-UTC = UTCTimezone.tzinfo

pendulum/tz/timezone_info.py

@@ -1,50 +1,49 @@
 # -*- coding: utf-8 -*-
 
-from datetime import tzinfo, timedelta
+from datetime import tzinfo
+
+from .transition_type import TransitionType
 
 
 class TimezoneInfo(tzinfo):
 
-    def __init__(self, tz, offset, is_dst, abbrev):
+    def __init__(self, tz, transition_type):
         """
         :type tz: Timezone
 
-        :type offset: int
+        :type transition_type: TransitionType
 
         :type is_dst: bool
         """
         self._tz = tz
-        self._offset = offset
+        self._transition_type = transition_type
 
-        # Rounded to the nearest minute
-        # This is a fix so that it works
-        # with the datetime objects
-        self._adjusted_offset = round(offset / 60) * 60
-        self._is_dst = is_dst
-        self._abbrev = abbrev
+    @classmethod
+    def create(cls, tz, utc_offset, is_dst, abbrev):
+        return cls(tz, TransitionType(utc_offset, is_dst, abbrev))
 
     @property
     def tz(self):
         return self._tz
 
     @property
     def name(self):
-        return self.tz._name
+        return self._tz._name
 
     @property
     def offset(self):
-        return self._offset
+        return self._transition_type.utc_offset
 
     @property
     def is_dst(self):
-        return self._is_dst
+        return self._transition_type.is_dst
 
     @property
     def abbrev(self):
-        return self._abbrev
+        return self._transition_type.abbrev
 
     def tzname(self, dt):
-        return self._abbrev
+        return self.abbrev
 
     def utcoffset(self, dt):
         if dt is None:
@@ -54,7 +53,7 @@ def utcoffset(self, dt):
 
             return dt.tzinfo._adjusted_offset
         else:
-            return timedelta(seconds=self._adjusted_offset)
+            return self._transition_type.adjusted_offset
 
     def dst(self, dt):
         if not self.is_dst:
@@ -65,15 +64,13 @@ def dst(self, dt):
         elif dt.tzinfo is not self:
             dt = self.tz.convert(dt)
 
-            offset = dt.tzinfo._adjusted_offset
+            offset = dt.tzinfo._transition_type.adjusted_offset
         else:
-            offset = self._adjusted_offset
+            offset = self._transition_type.adjusted_offset
 
-        return timedelta(seconds=offset)
+        return offset
 
     def fromutc(self, dt):
-        from .timezone import UTC
-
         dt = dt.replace(tzinfo=UTC)
 
         return self.tz.convert(dt)
@@ -84,3 +81,24 @@ def __repr__(self):
             self.offset,
             self.is_dst
         )
+
+
+class _UTC(TimezoneInfo):
+
+    def __init__(self):
+        super(_UTC, self).__init__(None, TransitionType(0, False, 'GMT'))
+
+    @property
+    def name(self):
+        return 'UTC'
+
+    def utcoffset(self, dt):
+        return self._transition_type.adjusted_offset
+
+    def dst(self, dt):
+        return None
+
+    def fromutc(self, dt):
+        return dt.replace(tzinfo=self)
+
+UTC = _UTC()

pendulum/tz/transition.py

@@ -106,5 +106,5 @@ def __repr__(self):
         return '<Transition [{}, {} -> {}]>'.format(
             self._unix_time,
             self._pre_time,
-            self._time
+            self.time
         )

pendulum/tz/transition_type.py

@@ -1,10 +1,13 @@
 # -*- coding: utf-8 -*-
 
+from datetime import timedelta
+
 
 class TransitionType(object):
 
     def __init__(self, utc_offset, is_dst, abbrev):
         self.utc_offset = utc_offset
+        self.adjusted_offset = timedelta(seconds=round(utc_offset / 60) * 60)
         self.is_dst = is_dst
         self.abbrev = abbrev
 

tests/pendulum_tests/test_construct.py

@@ -112,5 +112,5 @@ def test_instance_naive_datetime_defaults_to_utc(self):
         self.assertEqual('UTC', now.timezone_name)
 
     def test_instance_timezone_aware_datetime(self):
-        now = Pendulum.instance(datetime.now(TimezoneInfo(timezone('Europe/Paris'), 7200, True, 'EST')))
+        now = Pendulum.instance(datetime.now(TimezoneInfo.create(timezone('Europe/Paris'), 7200, True, 'EST')))
         self.assertEqual('Europe/Paris', now.timezone_name)

tests/pendulum_tests/test_create_from_date.py

@@ -44,6 +44,6 @@ def test_create_from_date_with_timezone(self):
 
     def test_create_from_date_with_tzinfo(self):
         tz = timezone('Europe/London')
-        d = Pendulum.create_from_date(1975, 12, 25, tz=TimezoneInfo(tz, 3600, True, ''))
+        d = Pendulum.create_from_date(1975, 12, 25, tz=TimezoneInfo.create(tz, 3600, True, ''))
         self.assertPendulum(d, 1975, 12, 25)
         self.assertEqual('Europe/London', d.timezone_name)