Renames the PendulumInterval class to simply Interval

Author: sdispater

pendulum/__init__.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 
 from .pendulum import Pendulum
-from .pendulum_interval import PendulumInterval
+from .interval import Interval
 
 # Constants
 MONDAY = Pendulum.MONDAY
@@ -54,4 +54,4 @@
 combine = Pendulum.combine
 
 # Interval
-interval = PendulumInterval
+interval = Interval

pendulum/pendulum_interval.py pendulum/interval.pypendulum/pendulum_interval.py renamed to pendulum/interval.py

@@ -5,7 +5,7 @@
 from .translator import Translator
 
 
-class PendulumInterval(timedelta):
+class Interval(timedelta):
 
     _y = None
     _m = None
@@ -32,11 +32,11 @@ def __init__(self, days=0, seconds=0, microseconds=0,
     @classmethod
     def instance(cls, delta):
         """
-        Creates a PendulumInterval from a timedelta
+        Creates a Interval from a timedelta
 
         :type delta: timedelta
 
-        :rtype: PendulumInterval
+        :rtype: Interval
         """
         return cls(days=delta.days, seconds=delta.seconds, microseconds=delta.microseconds)
 
@@ -233,56 +233,56 @@ def __repr__(self):
 
     def __add__(self, other):
         if isinstance(other, timedelta):
-            return PendulumInterval(seconds=self.total_seconds() + other.total_seconds())
+            return Interval(seconds=self.total_seconds() + other.total_seconds())
 
         return NotImplemented
 
     def __sub__(self, other):
         if isinstance(other, timedelta):
             # for CPython compatibility, we cannot use
             # our __class__ here, but need a real timedelta
-            return PendulumInterval(seconds=self.total_seconds() - other.total_seconds())
+            return Interval(seconds=self.total_seconds() - other.total_seconds())
 
         return NotImplemented
 
     def __neg__(self):
         # for CPython compatibility, we cannot use
         # our __class__ here, but need a real timedelta
-        return PendulumInterval(seconds=-self.total_seconds())
+        return Interval(seconds=-self.total_seconds())
 
 
-class AbsolutePendulumInterval(PendulumInterval):
+class AbsoluteInterval(Interval):
 
     def total_seconds(self):
-        return abs(super(AbsolutePendulumInterval, self).total_seconds())
+        return abs(super(AbsoluteInterval, self).total_seconds())
 
     @property
     def weeks(self):
-        return abs(super(AbsolutePendulumInterval, self).weeks)
+        return abs(super(AbsoluteInterval, self).weeks)
 
     @property
     def days(self):
-        return abs(super(AbsolutePendulumInterval, self).days)
+        return abs(super(AbsoluteInterval, self).days)
 
     @property
     def hours(self):
-        return abs(super(AbsolutePendulumInterval, self).hours)
+        return abs(super(AbsoluteInterval, self).hours)
 
     @property
     def minutes(self):
-        return abs(super(AbsolutePendulumInterval, self).minutes)
+        return abs(super(AbsoluteInterval, self).minutes)
 
     @property
     def seconds(self):
-        return abs(super(AbsolutePendulumInterval, self).seconds)
+        return abs(super(AbsoluteInterval, self).seconds)
 
     @property
     def microseconds(self):
-        return abs(super(AbsolutePendulumInterval, self).microseconds)
+        return abs(super(AbsoluteInterval, self).microseconds)
 
     @property
     def invert(self):
-        return super(AbsolutePendulumInterval, self).total_seconds() < 0
+        return super(AbsoluteInterval, self).total_seconds() < 0
 
     def _sign(self, value):
         return 1

pendulum/pendulum.py

@@ -17,7 +17,7 @@
 
 from .translator import Translator
 
-from .pendulum_interval import PendulumInterval, AbsolutePendulumInterval
+from .interval import Interval, AbsoluteInterval
 from .exceptions import PendulumException
 from ._compat import PY33, basestring
 
@@ -1484,24 +1484,24 @@ def seconds_until_end_of_day(self):
 
     def diff(self, dt=None, abs=True):
         """
-        Returns the difference between two Pendulum objects represented as a PendulumInterval.
+        Returns the difference between two Pendulum objects represented as a Interval.
 
         :type dt: Pendulum or None
 
         :param abs: Whether to return an absolute interval or not
         :type abs: bool
 
-        :rtype: PendulumInterval
+        :rtype: Interval
         """
         if dt is None:
             dt = self.now(self._tz)
 
         delta = self._get_datetime(dt) - self._datetime
 
         if abs:
-            return AbsolutePendulumInterval.instance(delta)
+            return AbsoluteInterval.instance(delta)
 
-        return PendulumInterval.instance(delta)
+        return Interval.instance(delta)
 
     def diff_for_humans(self, other=None, absolute=False, locale=None):
         """

tests/__init__.py

@@ -5,7 +5,7 @@
 from unittest import TestCase
 from contextlib import contextmanager
 
-from pendulum import Pendulum, PendulumInterval
+from pendulum import Pendulum, Interval
 
 
 class AbstractTestCase(TestCase):
@@ -62,7 +62,7 @@ def assertIsInstanceOfPendulum(self, d):
         self.assertIsInstance(d, Pendulum)
 
     def assertIsInstanceOfInterval(self, d):
-        self.assertIsInstance(d, PendulumInterval)
+        self.assertIsInstance(d, Interval)
 
     @contextmanager
     def wrap_with_test_now(self, dt=None):

tests/interval_tests/test_add_sub.py

@@ -1,49 +1,49 @@
 # -*- coding: utf-8 -*-
 
 from datetime import timedelta
-from pendulum import PendulumInterval
+from pendulum import Interval
 
 from .. import AbstractTestCase
 
 
 class AddSubTestCase(AbstractTestCase):
 
     def test_add_interval(self):
-        p1 = PendulumInterval(days=23, seconds=32)
-        p2 = PendulumInterval(days=12, seconds=30)
+        p1 = Interval(days=23, seconds=32)
+        p2 = Interval(days=12, seconds=30)
 
         p = p1 + p2
         self.assertInterval(p, 5, 0, 0, 1, 2)
 
     def test_add_timedelta(self):
-        p1 = PendulumInterval(days=23, seconds=32)
+        p1 = Interval(days=23, seconds=32)
         p2 = timedelta(days=12, seconds=30)
 
         p = p1 + p2
         self.assertInterval(p, 5, 0, 0, 1, 2)
 
     def test_add_unsupported(self):
-        p = PendulumInterval(days=23, seconds=32)
+        p = Interval(days=23, seconds=32)
         self.assertEqual(NotImplemented, p.__add__(5))
 
     def test_sub_interval(self):
-        p1 = PendulumInterval(days=23, seconds=32)
-        p2 = PendulumInterval(days=12, seconds=28)
+        p1 = Interval(days=23, seconds=32)
+        p2 = Interval(days=12, seconds=28)
 
         p = p1 - p2
         self.assertInterval(p, 1, 4, 0, 0, 4)
 
     def test_sub_timedelta(self):
-        p1 = PendulumInterval(days=23, seconds=32)
+        p1 = Interval(days=23, seconds=32)
         p2 = timedelta(days=12, seconds=28)
 
         p = p1 - p2
         self.assertInterval(p, 1, 4, 0, 0, 4)
 
     def test_sub_unsupported(self):
-        p = PendulumInterval(days=23, seconds=32)
+        p = Interval(days=23, seconds=32)
         self.assertEqual(NotImplemented, p.__sub__(5))
 
     def test_neg(self):
-        p = PendulumInterval(days=23, seconds=32)
+        p = Interval(days=23, seconds=32)
         self.assertInterval(-p, -4, -5, 0, 0, -28)

tests/interval_tests/test_construct.py

@@ -1,60 +1,60 @@
 # -*- coding: utf-8 -*-
 
 from datetime import timedelta
-from pendulum import PendulumInterval
-from pendulum.pendulum_interval import AbsolutePendulumInterval
+from pendulum import Interval
+from pendulum.interval import AbsoluteInterval
 
 from .. import AbstractTestCase
 
 
 class ConstructTest(AbstractTestCase):
 
     def test_defaults(self):
-        pi = PendulumInterval()
+        pi = Interval()
         self.assertIsInstanceOfInterval(pi)
         self.assertInterval(pi, 0, 0, 0, 0, 0)
 
     def test_weeks(self):
-        pi = PendulumInterval(days=365)
+        pi = Interval(days=365)
         self.assertInterval(pi, 52)
 
-        pi = PendulumInterval(days=13)
+        pi = Interval(days=13)
         self.assertInterval(pi, 1)
 
     def test_days(self):
-        pi = PendulumInterval(days=6)
+        pi = Interval(days=6)
         self.assertInterval(pi, 0, 6, 0, 0, 0)
 
-        pi = PendulumInterval(days=16)
+        pi = Interval(days=16)
         self.assertInterval(pi, 2, 2, 0, 0, 0)
 
     def test_hours(self):
-        pi = PendulumInterval(seconds=3600 * 3)
+        pi = Interval(seconds=3600 * 3)
         self.assertInterval(pi, 0, 0, 3, 0, 0)
 
     def test_minutes(self):
-        pi = PendulumInterval(seconds=60 * 3)
+        pi = Interval(seconds=60 * 3)
         self.assertInterval(pi, 0, 0, 0, 3, 0)
 
-        pi = PendulumInterval(seconds=60 * 3 + 12)
+        pi = Interval(seconds=60 * 3 + 12)
         self.assertInterval(pi, 0, 0, 0, 3, 12)
 
     def test_all(self):
-        pi = PendulumInterval(days=1177, seconds=7284, microseconds=1000000)
+        pi = Interval(days=1177, seconds=7284, microseconds=1000000)
         self.assertInterval(pi, 168, 1, 2, 1, 25)
 
     def test_instance(self):
-        pi = PendulumInterval.instance(timedelta(days=1177, seconds=7284, microseconds=1000000))
+        pi = Interval.instance(timedelta(days=1177, seconds=7284, microseconds=1000000))
         self.assertInterval(pi, 168, 1, 2, 1, 25)
 
     def test_absolute_interval(self):
-        pi = AbsolutePendulumInterval(days=-1177, seconds=-7284, microseconds=-1000001)
+        pi = AbsoluteInterval(days=-1177, seconds=-7284, microseconds=-1000001)
         self.assertInterval(pi, 168, 1, 2, 1, 25)
         self.assertEqual(999999, pi.microseconds)
 
     def test_invert(self):
-        pi = PendulumInterval(days=1177, seconds=7284, microseconds=1000000)
+        pi = Interval(days=1177, seconds=7284, microseconds=1000000)
         self.assertFalse(pi.invert)
 
-        pi = PendulumInterval(days=-1177, seconds=-7284, microseconds=-1000000)
+        pi = Interval(days=-1177, seconds=-7284, microseconds=-1000000)
         self.assertTrue(pi.invert)

tests/interval_tests/test_in_methods.py

@@ -1,36 +1,36 @@
 # -*- coding: utf-8 -*-
 
-from pendulum.pendulum_interval import PendulumInterval
+from pendulum.interval import Interval
 
 from .. import AbstractTestCase
 
 
 class InMethodsTest(AbstractTestCase):
 
     def test_in_years(self):
-        it = PendulumInterval(days=365)
+        it = Interval(days=365)
         self.assertEqual(1, it.in_years())
 
     def test_in_months(self):
-        it = PendulumInterval(days=75)
+        it = Interval(days=75)
         self.assertEqual(2, it.in_months())
 
     def test_in_weeks(self):
-        it = PendulumInterval(days=17)
+        it = Interval(days=17)
         self.assertEqual(2, it.in_weeks())
 
     def test_in_days(self):
-        it = PendulumInterval(days=3)
+        it = Interval(days=3)
         self.assertEqual(3, it.in_days())
 
     def test_in_hours(self):
-        it = PendulumInterval(days=3, minutes=72)
+        it = Interval(days=3, minutes=72)
         self.assertEqual(73, it.in_hours())
 
     def test_in_minutes(self):
-        it = PendulumInterval(minutes=6, seconds=72)
+        it = Interval(minutes=6, seconds=72)
         self.assertEqual(7, it.in_minutes())
 
     def test_in_seconds(self):
-        it = PendulumInterval(seconds=72)
+        it = Interval(seconds=72)
         self.assertEqual(72, it.in_seconds())

tests/interval_tests/test_in_words.py

@@ -1,6 +1,6 @@
 # -*- coding: utf-8 -*-
 
-from pendulum import PendulumInterval
+from pendulum import Interval
 
 from .. import AbstractTestCase
 
@@ -10,35 +10,35 @@ class ForHumansTest(AbstractTestCase):
     def setUp(self):
         super(ForHumansTest, self).setUp()
 
-        PendulumInterval.set_locale('en')
+        Interval.set_locale('en')
 
     def test_week(self):
-        self.assertEqual('52 weeks', PendulumInterval(days=364).in_words())
-        self.assertEqual('1 week', PendulumInterval(days=7).in_words())
+        self.assertEqual('52 weeks', Interval(days=364).in_words())
+        self.assertEqual('1 week', Interval(days=7).in_words())
 
     def test_week_to_string(self):
-        self.assertEqual('52 weeks', str(PendulumInterval(days=364)))
-        self.assertEqual('1 week', str(PendulumInterval(days=7)))
+        self.assertEqual('52 weeks', str(Interval(days=364)))
+        self.assertEqual('1 week', str(Interval(days=7)))
 
     def test_weeks_and_day(self):
-        self.assertEqual('52 weeks 1 day', PendulumInterval(days=365).in_words())
+        self.assertEqual('52 weeks 1 day', Interval(days=365).in_words())
 
     def test_all(self):
-        pi = PendulumInterval(days=1177, seconds=7284, microseconds=1000000)
+        pi = Interval(days=1177, seconds=7284, microseconds=1000000)
         self.assertEqual(
             '168 weeks 1 day 2 hours 1 minute 25 seconds',
             pi.in_words()
         )
 
     def test_in_french(self):
-        pi = PendulumInterval(days=1177, seconds=7284, microseconds=1000000)
+        pi = Interval(days=1177, seconds=7284, microseconds=1000000)
         self.assertEqual(
             '168 semaines 1 jour 2 heures 1 minute 25 secondes',
             pi.in_words(locale='fr')
         )
 
     def test_repr(self):
-        pi = PendulumInterval(days=1177, seconds=7284, microseconds=1000000)
+        pi = Interval(days=1177, seconds=7284, microseconds=1000000)
         self.assertEqual(
             '168 weeks 1 day 2 hours 1 minute 25 seconds',
             repr(pi)