Improves diff() performance

Author: sdispater

CHANGELOG.md

@@ -8,6 +8,7 @@
 
 ### Changed
 
+- Greatly improved `diff()` performance.
 - Improved `diff_for_humans()` method to display more intuitive strings on edge cases.
 - Formatting (with f-strings or `format()`) will now use the configured formatter.
 

pendulum/helpers.py

@@ -1,5 +1,7 @@
 # -*- coding: utf-8 -*-
 
+import pendulum
+
 from math import copysign
 from datetime import timedelta
 
@@ -16,7 +18,7 @@ def is_leap(year):
 
 
 def add_duration(dt, years=0, months=0, weeks=0, days=0,
-        hours=0, minutes=0, seconds=0, microseconds=0):
+                 hours=0, minutes=0, seconds=0, microseconds=0):
     """
     Adds a duration to a datetime instance.
 
@@ -107,5 +109,106 @@ def add_duration(dt, years=0, months=0, weeks=0, days=0,
     )
 
 
+def precise_diff(d1, d2):
+    """
+    Calculate a precise difference between two datetimes.
+
+    :param d1: The first datetime
+    :type d1: pendulum.Pendulum or pendulum.Date
+
+    :param d2: The second datetime
+    :type d2: pendulum.Pendulum or pendulum.Date
+
+    :rtype: dict
+    """
+    diff = {
+        'years': 0,
+        'months': 0,
+        'days': 0,
+        'hours': 0,
+        'minutes': 0,
+        'seconds': 0,
+        'microseconds': 0
+    }
+    sign = 1
+
+    if d1 == d2:
+        return diff
+
+    if d1 > d2:
+        d1, d2 = d2, d1
+        sign = -1
+
+    y_diff = d2.year - d1.year
+    m_diff = d2.month - d1.month
+    d_diff = d2.day - d1.day
+    hour_diff = 0
+    min_diff = 0
+    sec_diff = 0
+    mic_diff = 0
+
+    if hasattr(d2, 'hour'):
+        hour_diff = d2.hour - d1.hour
+        min_diff = d2.minute - d1.minute
+        sec_diff = d2.second - d1.second
+        mic_diff = d2.microsecond - d1.microsecond
+
+        if mic_diff < 0:
+            mic_diff += 1000000
+            sec_diff -= 1
+
+        if sec_diff < 0:
+            sec_diff += 60
+            min_diff -= 1
+
+        if min_diff < 0:
+            min_diff += 60
+            hour_diff -= 1
+
+        if hour_diff < 0:
+            hour_diff += 24
+            d_diff -= 1
+
+    if d_diff < 0:
+        year = d2.year
+        month = d2.month
+
+        if month == 1:
+            month = 12
+            year -= 1
+        else:
+            month -= 1
+
+        leap = int(is_leap(year))
+
+        days_in_last_month = DAYS_PER_MONTHS[leap][month]
+        days_in_month = DAYS_PER_MONTHS[int(is_leap(d2.year))][d2.month]
+
+        if d_diff < days_in_month - days_in_last_month:
+            # We don't have a full month, we calculate days
+            if days_in_last_month < d1.day:
+                d_diff += d1.day
+            else:
+                d_diff += days_in_last_month
+
+            m_diff -= 1
+        else:
+            # We have a full month, remove days
+            d_diff = 0
+
+    if m_diff < 0:
+        m_diff += 12
+        y_diff -= 1
+
+    diff['microseconds'] = sign * mic_diff
+    diff['seconds'] = sign * sec_diff
+    diff['minutes'] = sign * min_diff
+    diff['hours'] = sign * hour_diff
+    diff['days'] = sign * d_diff
+    diff['months'] = sign * m_diff
+    diff['years'] = sign * y_diff
+
+    return diff
+
 def _sign(x):
     return int(copysign(1, x))

pendulum/period.py

@@ -1,12 +1,14 @@
 # -*- coding: utf-8 -*-
 
 import operator
-from dateutil.relativedelta import relativedelta
+import pendulum
+
 from datetime import datetime, date
 
 from .mixins.interval import WordableIntervalMixin
 from .interval import BaseInterval, Interval
 from .constants import MONTHS_PER_YEAR
+from .helpers import precise_diff
 
 
 class Period(WordableIntervalMixin, BaseInterval):
@@ -16,20 +18,17 @@ class Period(WordableIntervalMixin, BaseInterval):
     """
 
     def __new__(cls, start, end, absolute=False):
-        from .pendulum import Pendulum
-        from .date import Date
-
         if absolute and start > end:
             end, start = start, end
 
-        if isinstance(start, Pendulum):
+        if isinstance(start, pendulum.Pendulum):
             start = start._datetime
-        elif isinstance(start, Date):
+        elif isinstance(start, pendulum.Date):
             start = date(start.year, start.month, start.day)
 
-        if isinstance(end, Pendulum):
+        if isinstance(end, pendulum.Pendulum):
             end = end._datetime
-        elif isinstance(end, Date):
+        elif isinstance(end, pendulum.Date):
             end = date(end.year, end.month, end.day)
 
         delta = end - start
@@ -39,33 +38,30 @@ def __new__(cls, start, end, absolute=False):
         )
 
     def __init__(self, start, end, absolute=False):
-        from .pendulum import Pendulum
-        from .date import Date
-
         super(Period, self).__init__()
 
-        if not isinstance(start, (Pendulum, Date)):
+        if not isinstance(start, (pendulum.Date)):
             if isinstance(start, datetime):
-                start = Pendulum.instance(start)
+                start = pendulum.Pendulum.instance(start)
             else:
-                start = Date.instance(start)
+                start = pendulum.Date.instance(start)
 
             _start = start
         else:
-            if isinstance(start, Pendulum):
+            if isinstance(start, pendulum.Pendulum):
                 _start = start._datetime
             else:
                 _start = date(start.year, start.month, start.day)
 
-        if not isinstance(end, (Pendulum, Date)):
+        if not isinstance(end, (pendulum.Date)):
             if isinstance(end, datetime):
-                end = Pendulum.instance(end)
+                end = pendulum.Pendulum.instance(end)
             else:
-                end = Date.instance(end)
+                end = pendulum.Date.instance(end)
 
             _end = end
         else:
-            if isinstance(end, Pendulum):
+            if isinstance(end, pendulum.Pendulum):
                 _end = end._datetime
             else:
                 _end = date(end.year, end.month, end.day)
@@ -81,27 +77,27 @@ def __init__(self, start, end, absolute=False):
         self._absolute = absolute
         self._start = start
         self._end = end
-        self._delta = relativedelta(_end, _start)
+        self._delta = precise_diff(_start, _end)
 
     @property
     def years(self):
-        return self._delta.years
+        return self._delta['years']
 
     @property
     def months(self):
-        return self._delta.months
+        return self._delta['months']
 
     @property
     def weeks(self):
-        return self._delta.weeks
+        return self._delta['days'] // 7
 
     @property
     def days(self):
         return self._days
 
     @property
     def remaining_days(self):
-        return abs(self._delta.days) % 7 * self._sign(self._days)
+        return abs(self._delta['days']) % 7 * self._sign(self._days)
 
     @property
     def start(self):

tests/date_tests/test_diff.py

@@ -123,8 +123,12 @@ def test_diff_for_humans_now_and_nearly_month(self):
         self.assertEqual('3 weeks ago', Date.today().subtract(weeks=3).diff_for_humans())
 
     def test_diff_for_humans_now_and_month(self):
-        self.assertEqual('4 weeks ago', Date.today().subtract(weeks=4).diff_for_humans())
-        self.assertEqual('1 month ago', Date.today().subtract(months=1).diff_for_humans())
+        with self.wrap_with_test_now(Pendulum.create(2016, 3, 1)):
+            self.assertEqual('4 weeks ago', Date.today().subtract(weeks=4).diff_for_humans())
+            self.assertEqual('1 month ago', Date.today().subtract(months=1).diff_for_humans())
+
+        with self.wrap_with_test_now(Pendulum.create(2017, 2, 28)):
+            self.assertEqual('1 month ago', Date.today().subtract(weeks=4).diff_for_humans())
 
     def test_diff_for_humans_now_and_months(self):
         self.assertEqual('2 months ago', Date.today().subtract(months=2).diff_for_humans())
@@ -161,6 +165,12 @@ def test_diff_for_humans_now_and_future_month(self):
             self.assertEqual('4 weeks from now', Date.today().add(weeks=4).diff_for_humans())
             self.assertEqual('1 month from now', Date.today().add(months=1).diff_for_humans())
 
+        with self.wrap_with_test_now(Pendulum.create(2017, 3, 31)):
+            self.assertEqual('1 month from now', Date.today().add(months=1).diff_for_humans())
+
+        with self.wrap_with_test_now(Pendulum.create(2017, 4, 30)):
+            self.assertEqual('1 month from now', Date.today().add(months=1).diff_for_humans())
+
         with self.wrap_with_test_now(Pendulum.create(2017, 1, 31)):
             self.assertEqual('1 month from now', Date.today().add(weeks=4).diff_for_humans())
 
@@ -199,6 +209,12 @@ def test_diff_for_humans_other_and_month(self):
             self.assertEqual('4 weeks before', Date.today().diff_for_humans(Date.today().add(weeks=4)))
             self.assertEqual('1 month before', Date.today().diff_for_humans(Date.today().add(months=1)))
 
+        with self.wrap_with_test_now(Pendulum.create(2017, 3, 31)):
+            self.assertEqual('1 month before', Date.today().diff_for_humans(Date.today().add(months=1)))
+
+        with self.wrap_with_test_now(Pendulum.create(2017, 4, 30)):
+            self.assertEqual('1 month before', Date.today().diff_for_humans(Date.today().add(months=1)))
+
         with self.wrap_with_test_now(Pendulum.create(2017, 1, 31)):
             self.assertEqual('1 month before', Date.today().diff_for_humans(Date.today().add(weeks=4)))
 
@@ -233,8 +249,12 @@ def test_diff_for_humans_other_and_nearly_future_month(self):
         self.assertEqual('3 weeks after', Date.today().diff_for_humans(Date.today().subtract(weeks=3)))
 
     def test_diff_for_humans_other_and_future_month(self):
-        self.assertEqual('4 weeks after', Date.today().diff_for_humans(Date.today().subtract(weeks=4)))
-        self.assertEqual('1 month after', Date.today().diff_for_humans(Date.today().subtract(months=1)))
+        with self.wrap_with_test_now(Pendulum.create(2016, 3, 1)):
+            self.assertEqual('4 weeks after', Date.today().diff_for_humans(Date.today().subtract(weeks=4)))
+            self.assertEqual('1 month after', Date.today().diff_for_humans(Date.today().subtract(months=1)))
+
+        with self.wrap_with_test_now(Pendulum.create(2017, 2, 28)):
+            self.assertEqual('1 month after', Date.today().diff_for_humans(Date.today().subtract(weeks=4)))
 
     def test_diff_for_humans_other_and_future_months(self):
         self.assertEqual('2 months after', Date.today().diff_for_humans(Date.today().subtract(months=2)))

tests/test_helpers.py

@@ -0,0 +1,49 @@
+# -*- coding: utf-8 -*-
+
+from datetime import datetime
+from pendulum.helpers import precise_diff
+
+from . import AbstractTestCase
+
+
+class HelpersTestCase(AbstractTestCase):
+
+    def test_precise_diff(self):
+        dt1 = datetime(2003, 3, 1, 0, 0, 0)
+        dt2 = datetime(2003, 1, 31, 23, 59, 59)
+
+        diff = precise_diff(dt1, dt2)
+        self.assert_diff(diff, months=-1, seconds=-1)
+
+        diff = precise_diff(dt2, dt1)
+        self.assert_diff(diff, months=1, seconds=1)
+
+        dt1 = datetime(2012, 3, 1, 0, 0, 0)
+        dt2 = datetime(2012, 1, 31, 23, 59, 59)
+
+        diff = precise_diff(dt1, dt2)
+        self.assert_diff(diff, months=-1, seconds=-1)
+
+        diff = precise_diff(dt2, dt1)
+        self.assert_diff(diff, months=1, seconds=1)
+
+        dt1 = datetime(2001, 1, 1)
+        dt2 = datetime(2003, 9, 17, 20, 54, 47, 282310)
+
+        diff = precise_diff(dt1, dt2)
+        self.assert_diff(
+            diff,
+            years=2, months=8, days=16,
+            hours=20, minutes=54, seconds=47, microseconds=282310
+        )
+
+    def assert_diff(self, diff,
+                    years=0, months=0, days=0,
+                    hours=0, minutes=0, seconds=0, microseconds=0):
+        self.assertEqual(diff['years'], years)
+        self.assertEqual(diff['months'], months)
+        self.assertEqual(diff['days'], days)
+        self.assertEqual(diff['hours'], hours)
+        self.assertEqual(diff['minutes'], minutes)
+        self.assertEqual(diff['seconds'], seconds)
+        self.assertEqual(diff['microseconds'], microseconds)