Fix an offset error for datetimes between the before last and last transition

Author: sdispater

CHANGELOG.md

@@ -5,6 +5,7 @@
 ### Fixed
 
 - Fixed an error when comparing a Period to a timedelta in PyPy.
+- Fixed an offset error for datetimes between the before last and last transition.
 
 
 ## [1.4.0] - 2018-01-22

pendulum/tz/timezone.py

@@ -218,65 +218,55 @@ def _normalize(self, dt, dst_rule=None):
                     offset = self._tzinfos[tzinfo_index].offset
                     unix_time = (dt - datetime(1970, 1, 1)).total_seconds() - offset
                 else:
-                    # tr.pre_time < dt < tr.time
-                    # Skipped time
-                    if dst_rule == self.TRANSITION_ERROR:
-                        raise NonExistingTime(dt)
-                    elif dst_rule == self.PRE_TRANSITION:
-                        # We do not apply the transition
-                        (unix_time,
-                         tzinfo_index) = self._get_previous_transition_time(tr, dt, skipped=True)
-                    else:
-                        unix_time = tr.unix_time - (tr.time - dt).total_seconds()
+                    unix_time, tzinfo_index = self._get_time(dt, tr, dst_rule)
         elif tr is end:
             if tr.pre_time < dt:
                 # After the last transition.
                 unix_time = tr.unix_time + (dt - tr.time).total_seconds()
             else:
-                # tr.time <= dt <= tr.pre_time
-                # Repeated time
-                if dst_rule == self.TRANSITION_ERROR:
-                    raise AmbiguousTime(dt)
-                elif dst_rule == self.PRE_TRANSITION:
-                    # We do not apply the transition
-                    (unix_time,
-                     tzinfo_index) = self._get_previous_transition_time(tr, dt)
-                else:
-                    unix_time = tr.unix_time + (dt - tr.time).total_seconds()
+                unix_time, tzinfo_index = self._get_time(dt, tr, dst_rule)
         else:
-            if tr.pre_time <= dt < tr.time:
-                # tr.pre_time <= dt < tr.time
-                # Skipped time
-                if dst_rule == self.TRANSITION_ERROR:
-                    raise NonExistingTime(dt)
-                elif dst_rule == self.PRE_TRANSITION:
-                    # We do not apply the transition
-                    (unix_time,
-                     tzinfo_index) = self._get_previous_transition_time(tr, dt, skipped=True)
-                else:
-                    unix_time = tr.unix_time - (tr.pre_time - dt).total_seconds()
-            elif tr.time <= dt <= tr.pre_time:
-                # tr.time <= dt <= tr.pre_time
-                # Repeated time
-                if dst_rule == self.TRANSITION_ERROR:
-                    raise AmbiguousTime(dt)
-                elif dst_rule == self.PRE_TRANSITION:
-                    # We do not apply the transition
-                    (unix_time,
-                     tzinfo_index) = self._get_previous_transition_time(tr, dt)
-                else:
-                    unix_time = tr.unix_time + (dt - tr.time).total_seconds()
-            else:
-                # In between transitions
-                # The actual transition type is the previous transition one
-                (unix_time,
-                 tzinfo_index) = self._get_previous_transition_time(tr, dt)
+            unix_time, tzinfo_index = self._get_time(dt, tr, dst_rule)
 
         return self._to_local_time(
             unix_time, dt.microsecond, tzinfo_index,
             fold
         )
 
+    def _get_time(self, dt, tr, dst_rule):
+        tzinfo_index = tr._tzinfo_index
+
+        if tr.pre_time <= dt < tr.time:
+            # tr.pre_time <= dt < tr.time
+            # Skipped time
+            if dst_rule == self.TRANSITION_ERROR:
+                raise NonExistingTime(dt)
+            elif dst_rule == self.PRE_TRANSITION:
+                # We do not apply the transition
+                (unix_time,
+                 tzinfo_index) = self._get_previous_transition_time(tr, dt,
+                                                                    skipped=True)
+            else:
+                unix_time = tr.unix_time - (tr.pre_time - dt).total_seconds()
+        elif tr.time <= dt <= tr.pre_time:
+            # tr.time <= dt <= tr.pre_time
+            # Repeated time
+            if dst_rule == self.TRANSITION_ERROR:
+                raise AmbiguousTime(dt)
+            elif dst_rule == self.PRE_TRANSITION:
+                # We do not apply the transition
+                (unix_time,
+                 tzinfo_index) = self._get_previous_transition_time(tr, dt)
+            else:
+                unix_time = tr.unix_time + (dt - tr.time).total_seconds()
+        else:
+            # In between transitions
+            # The actual transition type is the previous transition one
+            (unix_time,
+             tzinfo_index) = self._get_previous_transition_time(tr, dt)
+
+        return unix_time, tzinfo_index
+
     def _convert(self, dt):
         """
         Converts a timezone-aware datetime to local time.

tests/tz_tests/test_timezone.py

@@ -227,6 +227,15 @@ def test_on_last_transition(self):
         assert dt.microsecond == 0
         assert dt.utcoffset().total_seconds() == 7200
 
+    def test_just_before_last_transition(self):
+        tz = pendulum.timezone('Asia/Shanghai')
+        dt = datetime(1991, 4, 20, 1, 49, 8)
+        dt = tz.convert(dt, dst_rule=tz.POST_TRANSITION)
+
+        epoch = datetime(1970, 1, 1, tzinfo=timezone('UTC'))
+        expected = (dt - epoch).total_seconds()
+        assert expected == 672079748.0
+
     def test_convert_fold_attribute_is_honored(self):
         self.skip_if_not_36()