Fixes arithmetic operations on intervals not returning intervals

Author: sdispater

docs/index.rst

@@ -1316,6 +1316,20 @@ instances that generated it, so that it can give access to more methods and prop
     10
 
 
+.. warning::
+
+    Due to its nature (fixed duration between two datetimes), most arithmetic operations will
+    return an ``Interval`` instead of a ``Period``.
+
+    .. code-block:: python
+
+        dt1 = Pendulum(2016, 8, 7, 12, 34, 56)
+        dt2 = dt1.add(days=6, seconds=34)
+        period = Period(dt1, dt2)
+        period * 2
+        # <Interval [1 week 5 days 1 minute 8 seconds]>
+
+
 Instantiation
 -------------
 

pendulum/interval.py

@@ -2,7 +2,29 @@
 
 from datetime import timedelta
 
-from .mixins.interval import WordableIntervalMixin, AbsoluteIntervalMixin
+from .mixins.interval import (
+    WordableIntervalMixin
+)
+
+
+def _divide_and_round(a, b):
+    """divide a by b and round result to the nearest integer
+
+    When the ratio is exactly half-way between two integers,
+    the even integer is returned.
+    """
+    # Based on the reference implementation for divmod_near
+    # in Objects/longobject.c.
+    q, r = divmod(a, b)
+    # round up if either r / b > 0.5, or r / b == 0.5 and q is odd.
+    # The expression r / b > 0.5 is equivalent to 2 * r > b if b is
+    # positive, 2 * r < b if b negative.
+    r *= 2
+    greater_than_half = r > b if b > 0 else r < b
+    if greater_than_half or r == b and q % 2 == 1:
+        q += 1
+
+    return q
 
 
 class BaseInterval(timedelta):
@@ -19,17 +41,26 @@ class BaseInterval(timedelta):
     _s = None
     _invert = None
 
-    def __init__(self, days=0, seconds=0, microseconds=0,
+    def __new__(cls, days=0, seconds=0, microseconds=0,
                 milliseconds=0, minutes=0, hours=0, weeks=0):
+        self = timedelta.__new__(
+            cls, days, seconds, microseconds,
+            milliseconds, minutes, hours, weeks
+        )
+
+        # Intuitive normalization
         total = self.total_seconds()
+
         m = 1
         if total < 0:
             m = -1
 
-        self._microseconds = total - int(total)
+        self._microseconds = round(total % 1 * 1e6)
         self._seconds = abs(int(total)) % 86400 * m
         self._days = abs(int(total)) // 86400 * m
 
+        return self
+
     def total_minutes(self):
         return self.total_seconds() / 60
 
@@ -104,6 +135,10 @@ def seconds(self):
 
         return self._s
 
+    @property
+    def microseconds(self):
+        return self._microseconds
+
     @property
     def invert(self):
         if self._invert is None:
@@ -138,12 +173,33 @@ def _sign(self, value):
 
         return 1
 
+
+class Interval(WordableIntervalMixin, BaseInterval):
+    """
+    Replacement for the standard timedelta class.
+
+    Provides several improvements over the base class.
+    """
+
+    @classmethod
+    def instance(cls, delta):
+        """
+        Creates a Interval from a timedelta
+
+        :type delta: timedelta
+
+        :rtype: Interval
+        """
+        return cls(days=delta.days, seconds=delta.seconds, microseconds=delta.microseconds)
+
     def __add__(self, other):
         if isinstance(other, timedelta):
             return self.__class__(seconds=self.total_seconds() + other.total_seconds())
 
         return NotImplemented
 
+    __radd__ = __add__
+
     def __sub__(self, other):
         if isinstance(other, timedelta):
             return self.__class__(seconds=self.total_seconds() - other.total_seconds())
@@ -153,27 +209,94 @@ def __sub__(self, other):
     def __neg__(self):
         return self.__class__(seconds=-self.total_seconds())
 
+    def _to_microseconds(self):
+        return ((self._days * (24*3600) + self._seconds) * 1000000 +
+                self._microseconds)
 
-class Interval(WordableIntervalMixin, BaseInterval):
-    """
-    Replacement for the standard timedelta class.
+    def __mul__(self, other):
+        if isinstance(other, int):
+            return self.__class__(seconds=self.total_seconds() * other)
 
-    Provides several improvements over the base class.
-    """
+        if isinstance(other, float):
+            usec = self._to_microseconds()
+            a, b = other.as_integer_ratio()
 
-    @classmethod
-    def instance(cls, delta):
-        """
-        Creates a Interval from a timedelta
+            return self.__class__(0, 0, _divide_and_round(usec * a, b))
 
-        :type delta: timedelta
+        return NotImplemented
 
-        :rtype: Interval
-        """
-        return cls(days=delta.days, seconds=delta.seconds, microseconds=delta.microseconds)
+    __rmul__ = __mul__
+
+    def __floordiv__(self, other):
+        if not isinstance(other, (int, timedelta)):
+            return NotImplemented
+
+        usec = self._to_microseconds()
+        if isinstance(other, timedelta):
+            return usec // other._to_microseconds()
+
+        if isinstance(other, int):
+            return self.__class__(0, 0, usec // other)
+
+    def __truediv__(self, other):
+        if not isinstance(other, (int, float, timedelta)):
+            return NotImplemented
+
+        usec = self._to_microseconds()
+        if isinstance(other, timedelta):
+            return usec / other._to_microseconds()
+
+        if isinstance(other, int):
+            return self.__class__(0, 0, _divide_and_round(usec, other))
+
+        if isinstance(other, float):
+            a, b = other.as_integer_ratio()
+
+            return self.__class__(0, 0, _divide_and_round(b * usec, a))
 
+    __div__ = __floordiv__
 
-class AbsoluteInterval(AbsoluteIntervalMixin, Interval):
+    def __mod__(self, other):
+        if isinstance(other, timedelta):
+            r = self._to_microseconds() % other._to_microseconds()
+
+            return self.__class__(0, 0, r)
+
+        return NotImplemented
+
+    def __divmod__(self, other):
+        if isinstance(other, timedelta):
+            q, r = divmod(self._to_microseconds(),
+                          other._to_microseconds())
+
+            return q, self.__class__(0, 0, r)
+
+        return NotImplemented
+
+Interval.min = Interval(-999999999)
+Interval.max = Interval(days=999999999, hours=23,
+                        minutes=59, seconds=59,
+                        microseconds=999999)
+Interval.resolution = Interval(microseconds=1)
+
+
+class AbsoluteInterval(Interval):
     """
     Interval that expresses a time difference in absolute values.
     """
+
+    def __new__(cls, days=0, seconds=0, microseconds=0,
+                milliseconds=0, minutes=0, hours=0, weeks=0):
+        self = super(AbsoluteInterval, cls).__new__(
+            cls, days, seconds, microseconds,
+            milliseconds, minutes, hours, weeks
+        )
+
+        # Intuitive normalization
+        total = self.total_seconds()
+
+        self._microseconds = abs(round(total % 1 * 1e6))
+        self._seconds = abs(int(total)) % 86400
+        self._days = abs(int(total)) // 86400
+
+        return self

pendulum/mixins/interval.py

@@ -36,40 +36,3 @@ def __str__(self):
 
     def __repr__(self):
         return '<{0} [{1}]>'.format(self.__class__.__name__, str(self))
-
-
-class AbsoluteIntervalMixin(object):
-
-    def total_seconds(self):
-        return abs(super(AbsoluteIntervalMixin, self).total_seconds())
-
-    @property
-    def weeks(self):
-        return abs(super(AbsoluteIntervalMixin, self).weeks)
-
-    @property
-    def days(self):
-        return abs(super(AbsoluteIntervalMixin, self).days)
-
-    @property
-    def hours(self):
-        return abs(super(AbsoluteIntervalMixin, self).hours)
-
-    @property
-    def minutes(self):
-        return abs(super(AbsoluteIntervalMixin, self).minutes)
-
-    @property
-    def seconds(self):
-        return abs(super(AbsoluteIntervalMixin, self).seconds)
-
-    @property
-    def microseconds(self):
-        return abs(super(AbsoluteIntervalMixin, self).microseconds)
-
-    @property
-    def invert(self):
-        return super(AbsoluteIntervalMixin, self).total_seconds() < 0
-
-    def _sign(self, value):
-        return 1

pendulum/period.py

@@ -2,7 +2,7 @@
 
 import operator
 from .mixins.interval import WordableIntervalMixin
-from .interval import BaseInterval
+from .interval import BaseInterval, Interval
 
 
 class Period(WordableIntervalMixin, BaseInterval):
@@ -103,6 +103,14 @@ def xrange(self, unit):
 
             start = getattr(start, method)(**{unit: 1})
 
+    def as_interval(self):
+        """
+        Return the Period as an Interval.
+
+        :rtype: Interval
+        """
+        return Interval(seconds=self.total_seconds())
+
     def __iter__(self):
         return self.xrange('days')
 
@@ -113,3 +121,41 @@ def __contains__(self, item):
             item = Pendulum.instance(item)
 
         return item.between(self.start, self.end)
+
+    def __add__(self, other):
+        return self.as_interval().__add__(other)
+
+    __radd__ = __add__
+
+    def __sub__(self, other):
+        return self.as_interval().__sub__(other)
+
+    def __neg__(self):
+        return self.__class__(self.end, self.start, self._absolute)
+
+    def __mul__(self, other):
+        return self.as_interval().__mul__(other)
+
+    __rmul__ = __mul__
+
+    def __floordiv__(self, other):
+        return self.as_interval().__floordiv__(other)
+
+    def __truediv__(self, other):
+        return self.as_interval().__truediv__(other)
+
+    __div__ = __floordiv__
+
+    def __mod__(self, other):
+        return self.as_interval().__mod__(other)
+
+    def __divmod__(self, other):
+        return self.as_interval().__divmod__(other)
+
+    def __abs__(self):
+        return self.__class__(self.start, self.end, True)
+
+    def __repr__(self):
+        return '<Period [{} -> {}]>'.format(
+            self._start, self._end
+        )

pendulum/tz/local_timezone.py

@@ -4,6 +4,7 @@
 import os
 import subprocess
 import re
+from contextlib import contextmanager
 
 from .timezone import Timezone
 from .parser import Parser
@@ -13,8 +14,13 @@ class LocalTimezone(object):
 
     _cache = None
 
+    _local_timezone = None
+
     @classmethod
     def get(cls, force=False):
+        if cls._local_timezone is not None:
+            return cls._local_timezone
+
         if cls._cache is None or force:
             name = cls.get_local_tz_name()
             if isinstance(name, Timezone):
@@ -24,6 +30,24 @@ def get(cls, force=False):
 
         return cls._cache
 
+    @classmethod
+    @contextmanager
+    def test(cls, mock):
+        """
+        Context manager to temporarily set the local_timezone value.
+
+        :type mock: Pendulum or None
+        """
+        cls.set_local_timezone(mock)
+
+        yield
+
+        cls.set_local_timezone()
+
+    @classmethod
+    def set_local_timezone(cls, local_timezone=None):
+        cls._local_timezone = local_timezone
+
     @classmethod
     def get_local_tz_name(cls):
         if sys.platform == 'win32':