Improves performances

Author: sdispater

pendulum/pendulum.py

@@ -164,7 +164,9 @@ def __new__(cls, year, month, day,
 
     def __init__(self, year, month, day,
                  hour=0, minute=0, second=0, microsecond=0,
-                 tzinfo='UTC'):
+                 tzinfo=UTC):
+        self.__float_timestamp = None
+
         # If a TimezoneInfo is passed we do not convert:
         if isinstance(tzinfo, TimezoneInfo):
             self._tz = tzinfo.tz
@@ -183,7 +185,7 @@ def __init__(self, year, month, day,
             ))
 
     @classmethod
-    def instance(cls, dt, tz='UTC'):
+    def instance(cls, dt, tz=UTC):
         """
         Create a Carbon instance from a datetime one.
 
@@ -197,7 +199,6 @@ def instance(cls, dt, tz='UTC'):
         """
         tz = dt.tzinfo or tz
 
-        # Bypassing default constructor
         return cls(
             dt.year, dt.month, dt.day,
             dt.hour, dt.minute, dt.second, dt.microsecond,
@@ -349,7 +350,7 @@ def _create_datetime(cls, tz, year=None, month=None, day=None,
     @classmethod
     def create(cls, year=None, month=None, day=None,
                hour=None, minute=None, second=None, microsecond=None,
-               tz='UTC'):
+               tz=UTC):
         """
         Create a new Carbon instance from a specific date and time.
 
@@ -432,23 +433,23 @@ def create_from_format(cls, time, fmt, tz=UTC):
         return cls.instance(dt, tz)
 
     @classmethod
-    def create_from_timestamp(cls, timestamp, tz='UTC'):
+    def create_from_timestamp(cls, timestamp, tz=UTC):
         """
         Create a Pendulum instance from a timestamp.
 
         :param timestamp: The timestamp
         :type timestamp: int or float
 
         :param tz: The timezone
-        :type tz: tzinfo or str or int or None
+        :type tz: TimezoneInfo or str or int or None
 
         :rtype: Pendulum
         """
         dt = datetime.datetime.utcfromtimestamp(timestamp).replace(tzinfo=UTC)
+        if tz is not UTC and tz != 'UTC':
+            tz = cls._safe_create_datetime_zone(tz)
 
-        tz = cls._safe_create_datetime_zone(tz)
-
-        dt = tz.convert(dt)
+            dt = tz.convert(dt)
 
         return cls.instance(dt)
 
@@ -552,18 +553,23 @@ def timestamp(self):
 
     @property
     def float_timestamp(self):
+        if self.__float_timestamp is not None:
+            return self.__float_timestamp
+
         # If Python > 3.3 we use the native function
         # else we emulate it
         if PY33:
-            return self._datetime.timestamp()
-
-        if self._datetime.tzinfo is None:
-            return _time.mktime((self.year, self.month, self.day,
-                                 self.hour, self.minute, self.second,
-                                 -1, -1, -1)) + self.microsecond / 1e6
+            self.__float_timestamp = self._datetime.timestamp()
+        elif self._datetime.tzinfo is None:
+            self.__float_timestamp = _time.mktime(
+                (self.year, self.month, self.day,
+                 self.hour, self.minute, self.second,
+                -1, -1, -1)) + self.microsecond / 1e6
 
         else:
-            return (self._datetime - self._EPOCH).total_seconds()
+            self.__float_timestamp = (self._datetime - self._EPOCH).total_seconds()
+
+        return self.__float_timestamp
 
     @property
     def week_of_month(self):
@@ -712,7 +718,7 @@ def in_timezone(self, tz):
         """
         tz = self._safe_create_datetime_zone(tz)
 
-        return self.instance(tz.convert(self._datetime))
+        return tz.convert(self)
 
     def in_tz(self, tz):
         """

pendulum/tz/timezone.py

@@ -110,14 +110,7 @@ def _normalize(self, dt):
         elif not dt < end.time:
             tr = end
         else:
-            # For some reason, Python 2.7 does not use
-            # the Transition comparison methods.
-            if PY2:
-                transitions = map(lambda t: t.time, self._transitions)
-            else:
-                transitions = self._transitions
-
-            idx = max(0, bisect_right(transitions, dt))
+            idx = self._find_transition_index(dt)
             tr = self._transitions[idx]
 
             if idx > 0:
@@ -188,7 +181,7 @@ def _convert(self, dt):
         if not self._transitions:
             transition_type = self._default_transition_type
         else:
-            idx = max(0, bisect_right(self._transitions, unix_time) - 1)
+            idx = max(0, self._find_transition_index(unix_time) - 1)
             tr = self._transitions[idx]
             transition_type = tr.transition_type
 
@@ -235,6 +228,22 @@ def _get_timestamp(self, dt):
 
         return t
 
+    def _find_transition_index(self, dt):
+        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):
+                hi = mid
+            else:
+                lo = mid + 1
+
+        return lo
+
     def __repr__(self):
         return '<Timezone [{}]>'.format(self._name)
 

pendulum/tz/transition.py

@@ -93,18 +93,18 @@ def __ge__(self, other):
 
     def _get_comparables(self, other):
         if isinstance(other, Transition):
-            own = self.unix_time
-            other = other.unix_time
+            own = self._unix_time
+            other = other._unix_time
         elif isinstance(other, datetime):
-            own = self.time
+            own = self._time
         else:
-            own = self.unix_time
+            own = self._unix_time
 
         return own, other
 
     def __repr__(self):
         return '<Transition [{}, {} -> {}]>'.format(
-            self.unix_time,
-            self.pre_time,
-            self.time
+            self._unix_time,
+            self._pre_time,
+            self._time
         )