Renames sub() method to subtract()

Author: sdispater

pendulum/pendulum.py

@@ -275,7 +275,7 @@ def yesterday(cls, tz=None):
 
         :rtype: Pendulum
         """
-        return cls.today(tz).sub(days=1)
+        return cls.today(tz).subtract(days=1)
 
     @classmethod
     def _create_datetime(cls, tz, year=None, month=None, day=None,
@@ -1400,7 +1400,7 @@ def add(self, years=0, months=0, weeks=0, days=0,
 
         return self.instance(self._datetime + delta)
 
-    def sub(self, years=0, months=0, weeks=0, days=0,
+    def subtract(self, years=0, months=0, weeks=0, days=0,
             hours=0, minutes=0, seconds=0, microseconds=0,
             weekdays=None):
         """
@@ -1452,7 +1452,7 @@ def add_timedelta(self, delta):
         return self.add(days=delta.days, seconds=delta.seconds,
                         microseconds=delta.microseconds)
 
-    def sub_timedelta(self, delta):
+    def subtract_timedelta(self, delta):
         """
         Remove timedelta duration from the instance.
 
@@ -1461,8 +1461,8 @@ def sub_timedelta(self, delta):
 
         :rtype: Pendulum
         """
-        return self.sub(days=delta.days, seconds=delta.seconds,
-                        microseconds=delta.microseconds)
+        return self.subtract(days=delta.days, seconds=delta.seconds,
+                             microseconds=delta.microseconds)
 
     # DIFFERENCES
 
@@ -1795,9 +1795,9 @@ def previous(self, day_of_week=None):
         if day_of_week is None:
             day_of_week = self.day_of_week
 
-        dt = self.start_of('day').sub(days=1)
+        dt = self.start_of('day').subtract(days=1)
         while dt.day_of_week != day_of_week:
-            dt = dt.sub(days=1)
+            dt = dt.subtract(days=1)
 
         return dt
 
@@ -2122,7 +2122,7 @@ def for_json(self):
 
     def __sub__(self, other):
         if isinstance(other, datetime.timedelta):
-            return self.sub_timedelta(other)
+            return self.subtract_timedelta(other)
 
         return self._get_datetime(other, True).diff(self, False)
 

tests/localization_tests/test_da.py

@@ -13,46 +13,46 @@ class DaTest(AbstractLocalizationTestCase, AbstractTestCase):
 
     def diff_for_humans(self):
         with self.wrap_with_test_now():
-            d = Pendulum.now().sub(seconds=1)
+            d = Pendulum.now().subtract(seconds=1)
             self.assertEqual('1 sekund siden', d.diff_for_humans())
 
-            d = Pendulum.now().sub(seconds=2)
+            d = Pendulum.now().subtract(seconds=2)
             self.assertEqual('2 sekunder siden', d.diff_for_humans())
 
-            d = Pendulum.now().sub(minutes=1)
+            d = Pendulum.now().subtract(minutes=1)
             self.assertEqual('1 minut siden', d.diff_for_humans())
 
-            d = Pendulum.now().sub(minutes=2)
+            d = Pendulum.now().subtract(minutes=2)
             self.assertEqual('2 minutter siden', d.diff_for_humans())
 
-            d = Pendulum.now().sub(hours=1)
+            d = Pendulum.now().subtract(hours=1)
             self.assertEqual('1 time siden', d.diff_for_humans())
 
-            d = Pendulum.now().sub(hours=2)
+            d = Pendulum.now().subtract(hours=2)
             self.assertEqual('2 timer siden', d.diff_for_humans())
 
-            d = Pendulum.now().sub(days=1)
+            d = Pendulum.now().subtract(days=1)
             self.assertEqual('1 dag siden', d.diff_for_humans())
 
-            d = Pendulum.now().sub(days=2)
+            d = Pendulum.now().subtract(days=2)
             self.assertEqual('2 dage siden', d.diff_for_humans())
 
-            d = Pendulum.now().sub(weeks=1)
+            d = Pendulum.now().subtract(weeks=1)
             self.assertEqual('1 uge siden', d.diff_for_humans())
 
-            d = Pendulum.now().sub(weeks=2)
+            d = Pendulum.now().subtract(weeks=2)
             self.assertEqual('2 uger siden', d.diff_for_humans())
 
-            d = Pendulum.now().sub(months=1)
+            d = Pendulum.now().subtract(months=1)
             self.assertEqual('1 måned siden', d.diff_for_humans())
 
-            d = Pendulum.now().sub(months=2)
+            d = Pendulum.now().subtract(months=2)
             self.assertEqual('2 måneder siden', d.diff_for_humans())
 
-            d = Pendulum.now().sub(years=1)
+            d = Pendulum.now().subtract(years=1)
             self.assertEqual('1 år siden', d.diff_for_humans())
 
-            d = Pendulum.now().sub(years=2)
+            d = Pendulum.now().subtract(years=2)
             self.assertEqual('2 år siden', d.diff_for_humans())
 
             d = Pendulum.now().add(seconds=1)

tests/localization_tests/test_de.py

@@ -13,46 +13,46 @@ class DeTest(AbstractLocalizationTestCase, AbstractTestCase):
 
     def diff_for_humans(self):
         with self.wrap_with_test_now():
-            d = Pendulum.now().sub(seconds=1)
+            d = Pendulum.now().subtract(seconds=1)
             self.assertEqual('vor 1 Sekunde', d.diff_for_humans())
 
-            d = Pendulum.now().sub(seconds=2)
+            d = Pendulum.now().subtract(seconds=2)
             self.assertEqual('vor 2 Sekunden', d.diff_for_humans())
 
-            d = Pendulum.now().sub(minutes=1)
+            d = Pendulum.now().subtract(minutes=1)
             self.assertEqual('vor 1 Minute', d.diff_for_humans())
 
-            d = Pendulum.now().sub(minutes=2)
+            d = Pendulum.now().subtract(minutes=2)
             self.assertEqual('vor 2 Minuten', d.diff_for_humans())
 
-            d = Pendulum.now().sub(hours=1)
+            d = Pendulum.now().subtract(hours=1)
             self.assertEqual('vor 1 Stunde', d.diff_for_humans())
 
-            d = Pendulum.now().sub(hours=2)
+            d = Pendulum.now().subtract(hours=2)
             self.assertEqual('vor 2 Stunden', d.diff_for_humans())
 
-            d = Pendulum.now().sub(days=1)
+            d = Pendulum.now().subtract(days=1)
             self.assertEqual('vor 1 Tag', d.diff_for_humans())
 
-            d = Pendulum.now().sub(days=2)
+            d = Pendulum.now().subtract(days=2)
             self.assertEqual('vor 2 Tagen', d.diff_for_humans())
 
-            d = Pendulum.now().sub(weeks=1)
+            d = Pendulum.now().subtract(weeks=1)
             self.assertEqual('vor 1 Woche', d.diff_for_humans())
 
-            d = Pendulum.now().sub(weeks=2)
+            d = Pendulum.now().subtract(weeks=2)
             self.assertEqual('vor 2 Wochen', d.diff_for_humans())
 
-            d = Pendulum.now().sub(months=1)
+            d = Pendulum.now().subtract(months=1)
             self.assertEqual('vor 1 Monat', d.diff_for_humans())
 
-            d = Pendulum.now().sub(months=2)
+            d = Pendulum.now().subtract(months=2)
             self.assertEqual('vor 2 Monaten', d.diff_for_humans())
 
-            d = Pendulum.now().sub(years=1)
+            d = Pendulum.now().subtract(years=1)
             self.assertEqual('vor 1 Jahr', d.diff_for_humans())
 
-            d = Pendulum.now().sub(years=2)
+            d = Pendulum.now().subtract(years=2)
             self.assertEqual('vor 2 Jahren', d.diff_for_humans())
 
             d = Pendulum.now().add(seconds=1)

tests/localization_tests/test_es.py

@@ -13,46 +13,46 @@ class EsTest(AbstractLocalizationTestCase, AbstractTestCase):
 
     def diff_for_humans(self):
         with self.wrap_with_test_now():
-            d = Pendulum.now().sub(seconds=1)
+            d = Pendulum.now().subtract(seconds=1)
             self.assertEqual('hace 1 segundo', d.diff_for_humans())
 
-            d = Pendulum.now().sub(seconds=2)
+            d = Pendulum.now().subtract(seconds=2)
             self.assertEqual('hace 2 segundos', d.diff_for_humans())
 
-            d = Pendulum.now().sub(minutes=1)
+            d = Pendulum.now().subtract(minutes=1)
             self.assertEqual('hace 1 minuto', d.diff_for_humans())
 
-            d = Pendulum.now().sub(minutes=2)
+            d = Pendulum.now().subtract(minutes=2)
             self.assertEqual('hace 2 minutos', d.diff_for_humans())
 
-            d = Pendulum.now().sub(hours=1)
+            d = Pendulum.now().subtract(hours=1)
             self.assertEqual('hace 1 hora', d.diff_for_humans())
 
-            d = Pendulum.now().sub(hours=2)
+            d = Pendulum.now().subtract(hours=2)
             self.assertEqual('hace 2 horas', d.diff_for_humans())
 
-            d = Pendulum.now().sub(days=1)
+            d = Pendulum.now().subtract(days=1)
             self.assertEqual('hace 1 día', d.diff_for_humans())
 
-            d = Pendulum.now().sub(days=2)
+            d = Pendulum.now().subtract(days=2)
             self.assertEqual('hace 2 días', d.diff_for_humans())
 
-            d = Pendulum.now().sub(weeks=1)
+            d = Pendulum.now().subtract(weeks=1)
             self.assertEqual('hace 1 semana', d.diff_for_humans())
 
-            d = Pendulum.now().sub(weeks=2)
+            d = Pendulum.now().subtract(weeks=2)
             self.assertEqual('hace 2 semanas', d.diff_for_humans())
 
-            d = Pendulum.now().sub(months=1)
+            d = Pendulum.now().subtract(months=1)
             self.assertEqual('hace 1 mes', d.diff_for_humans())
 
-            d = Pendulum.now().sub(months=2)
+            d = Pendulum.now().subtract(months=2)
             self.assertEqual('hace 2 meses', d.diff_for_humans())
 
-            d = Pendulum.now().sub(years=1)
+            d = Pendulum.now().subtract(years=1)
             self.assertEqual('hace 1 año', d.diff_for_humans())
 
-            d = Pendulum.now().sub(years=2)
+            d = Pendulum.now().subtract(years=2)
             self.assertEqual('hace 2 años', d.diff_for_humans())
 
             d = Pendulum.now().add(seconds=1)

tests/localization_tests/test_fa.py

@@ -13,46 +13,46 @@ class FaTest(AbstractLocalizationTestCase, AbstractTestCase):
 
     def diff_for_humans(self):
         with self.wrap_with_test_now():
-            d = Pendulum.now().sub(seconds=1)
+            d = Pendulum.now().subtract(seconds=1)
             self.assertEqual('1 ثانیه پیش', d.diff_for_humans())
 
-            d = Pendulum.now().sub(seconds=2)
+            d = Pendulum.now().subtract(seconds=2)
             self.assertEqual('2 ثانیه پیش', d.diff_for_humans())
 
-            d = Pendulum.now().sub(minutes=1)
+            d = Pendulum.now().subtract(minutes=1)
             self.assertEqual('1 دقیقه پیش', d.diff_for_humans())
 
-            d = Pendulum.now().sub(minutes=2)
+            d = Pendulum.now().subtract(minutes=2)
             self.assertEqual('2 دقیقه پیش', d.diff_for_humans())
 
-            d = Pendulum.now().sub(hours=1)
+            d = Pendulum.now().subtract(hours=1)
             self.assertEqual('1 ساعت پیش', d.diff_for_humans())
 
-            d = Pendulum.now().sub(hours=2)
+            d = Pendulum.now().subtract(hours=2)
             self.assertEqual('2 ساعت پیش', d.diff_for_humans())
 
-            d = Pendulum.now().sub(days=1)
+            d = Pendulum.now().subtract(days=1)
             self.assertEqual('1 روز پیش', d.diff_for_humans())
 
-            d = Pendulum.now().sub(days=2)
+            d = Pendulum.now().subtract(days=2)
             self.assertEqual('2 روز پیش', d.diff_for_humans())
 
-            d = Pendulum.now().sub(weeks=1)
+            d = Pendulum.now().subtract(weeks=1)
             self.assertEqual('1 هفته پیش', d.diff_for_humans())
 
-            d = Pendulum.now().sub(weeks=2)
+            d = Pendulum.now().subtract(weeks=2)
             self.assertEqual('2 هفته پیش', d.diff_for_humans())
 
-            d = Pendulum.now().sub(months=1)
+            d = Pendulum.now().subtract(months=1)
             self.assertEqual('1 ماه پیش', d.diff_for_humans())
 
-            d = Pendulum.now().sub(months=2)
+            d = Pendulum.now().subtract(months=2)
             self.assertEqual('2 ماه پیش', d.diff_for_humans())
 
-            d = Pendulum.now().sub(years=1)
+            d = Pendulum.now().subtract(years=1)
             self.assertEqual('1 سال پیش', d.diff_for_humans())
 
-            d = Pendulum.now().sub(years=2)
+            d = Pendulum.now().subtract(years=2)
             self.assertEqual('2 سال پیش', d.diff_for_humans())
 
             d = Pendulum.now().add(seconds=1)

tests/localization_tests/test_fo.py

@@ -13,46 +13,46 @@ class FoTest(AbstractLocalizationTestCase, AbstractTestCase):
 
     def diff_for_humans(self):
         with self.wrap_with_test_now():
-            d = Pendulum.now().sub(seconds=1)
+            d = Pendulum.now().subtract(seconds=1)
             self.assertEqual('1 sekund síðan', d.diff_for_humans())
 
-            d = Pendulum.now().sub(seconds=2)
+            d = Pendulum.now().subtract(seconds=2)
             self.assertEqual('2 sekundir síðan', d.diff_for_humans())
 
-            d = Pendulum.now().sub(minutes=1)
+            d = Pendulum.now().subtract(minutes=1)
             self.assertEqual('1 minutt síðan', d.diff_for_humans())
 
-            d = Pendulum.now().sub(minutes=2)
+            d = Pendulum.now().subtract(minutes=2)
             self.assertEqual('2 minuttir síðan', d.diff_for_humans())
 
-            d = Pendulum.now().sub(hours=1)
+            d = Pendulum.now().subtract(hours=1)
             self.assertEqual('1 tími síðan', d.diff_for_humans())
 
-            d = Pendulum.now().sub(hours=2)
+            d = Pendulum.now().subtract(hours=2)
             self.assertEqual('2 tímar síðan', d.diff_for_humans())
 
-            d = Pendulum.now().sub(days=1)
+            d = Pendulum.now().subtract(days=1)
             self.assertEqual('1 dag síðan', d.diff_for_humans())
 
-            d = Pendulum.now().sub(days=2)
+            d = Pendulum.now().subtract(days=2)
             self.assertEqual('2 dagar síðan', d.diff_for_humans())
 
-            d = Pendulum.now().sub(weeks=1)
+            d = Pendulum.now().subtract(weeks=1)
             self.assertEqual('1 vika síðan', d.diff_for_humans())
 
-            d = Pendulum.now().sub(weeks=2)
+            d = Pendulum.now().subtract(weeks=2)
             self.assertEqual('2 vikur síðan', d.diff_for_humans())
 
-            d = Pendulum.now().sub(months=1)
+            d = Pendulum.now().subtract(months=1)
             self.assertEqual('1 mánaður síðan', d.diff_for_humans())
 
-            d = Pendulum.now().sub(months=2)
+            d = Pendulum.now().subtract(months=2)
             self.assertEqual('2 mánaðir síðan', d.diff_for_humans())
 
-            d = Pendulum.now().sub(years=1)
+            d = Pendulum.now().subtract(years=1)
             self.assertEqual('1 ár síðan', d.diff_for_humans())
 
-            d = Pendulum.now().sub(years=2)
+            d = Pendulum.now().subtract(years=2)
             self.assertEqual('2 ár síðan', d.diff_for_humans())
 
             d = Pendulum.now().add(seconds=1)