Remove redeclared functions

Author: kirkhansen

pandas/core/indexes/datetimelike.py

@@ -745,39 +745,50 @@ def _time_shift(self, periods, freq=None):
         result.name = self.name
         return result
 
-    def _intersect_ascending(self, other):
-        # to make our life easier, "sort" the two ranges
-        if self[0] <= other[0]:
-            left, right = self, other
-        else:
-            left, right = other, self
-
-        end = min(left[-1], right[-1])
-        start = right[0]
+    def _fast_intersection(self, other):
+        """
+        Speedy intersection that works only if certain assumptions are met.
+        See intersection for details.
+        Parameters
+        ----------
+        other
 
-        if end < start:
-            return []
-        return left.values[slice(*left.slice_locs(start, end))]
+        Returns
+        -------
 
-    def _intersect_descending(self, other):
-        # this is essentially a flip of _intersect_ascending
-        if self[0] >= other[0]:
+        """
+        # Coerce into the same order
+        ascending = self.is_monotonic_increasing
+        if ascending != other.is_monotonic_increasing:
+            other = other.sort_values(ascending=ascending)
+        # Lots of 'if ascending' calls here to setup mirrored function calls
+        first_comparison = '__le__' if ascending else '__ge__'
+        second_comparison = '__lt__' if ascending else '__gt__'
+        if getattr(self[0], first_comparison)(other[0]):
             left, right = self, other
         else:
             left, right = other, self
 
-        start = min(left[0], right[0])
-        end = right[-1]
-
-        if end > start:
-            return Index()
-        return left.values[slice(*left.slice_locs(start, end))]
+        if ascending:
+            start = right[0]
+            end = min(left[-1], right[-1])
+        else:
+            start = min(left[0], right[0])
+            end = right[-1]
+        if getattr(end, second_comparison, start):
+            return left.values[slice(*left.slice_locs(start, end))]
+        return []
 
     def intersection(self, other):
         """
         Specialized intersection for DateTimeIndexOpsMixin objects.
         May be much faster than Index.intersection.
 
+        Fast intersection will occur if
+        1. Both are in a sorted order
+        2. Both indexes have a `freq` , and it's the same `freq`
+        3. Both are monotonic
+
         Parameters
         ----------
         other : Index or array-like
@@ -787,6 +798,9 @@ def intersection(self, other):
         Index
             A shallow copied intersection between the two things passed in
         """
+        # Run a few checks, and perform a regular intersection
+        # if the conditions aren't just right for fast intersection
+        # Perform a regular Index.intersection
         self._assert_can_do_setop(other)
 
         if self.equals(other):
@@ -798,12 +812,9 @@ def intersection(self, other):
         if lengths[1] == 0:
             return other
 
-        if not isinstance(other, Index):
-            result = Index.intersection(self, other)
-            return result
-        elif (index_offsets_equal(self, other) or
-                (not self._is_strictly_monotonic or
-                    not other._is_strictly_monotonic)):
+        if (not index_offsets_equal(self, other) or
+           (not self._is_strictly_monotonic or
+                not other._is_strictly_monotonic)):
             result = Index.intersection(self, other)
             result = self._shallow_copy(result._values, name=result.name,
                                         tz=getattr(self, 'tz', None),
@@ -813,23 +824,8 @@ def intersection(self, other):
                 result.offset = frequencies.to_offset(result.inferred_freq)
             return result
 
-        # handle intersecting things like this
-        # idx1 = pd.to_timedelta((1, 2, 3, 4, 5, 6, 7, 8), unit='s')
-        # idx2 = pd.to_timedelta((2, 3, 4, 8), unit='s')
-        if lengths[0] != lengths[1] and (
-                max(self) != max(other) or min(self) != min(other)):
-            return Index.intersection(self, other)
-
-        # coerce into same order
-        self_ascending = self.is_monotonic_increasing
-        if self_ascending != other.is_monotonic_increasing:
-            other = other.sort_values(ascending=self_ascending)
-
-        if self_ascending:
-            intersected_slice = self._intersect_ascending(other)
-        else:
-            intersected_slice = self._intersect_descending(other)
-
+        # Conditions met!
+        intersected_slice = self._fast_intersection(other)
         intersected = self._shallow_copy(intersected_slice)
         return intersected._get_consensus_name(other)
 

pandas/tests/indexes/timedeltas/test_setops.py

@@ -168,3 +168,25 @@ def intersect(idx1, idx2, expected):
               index2.sort_values(ascending=False),
               expected.sort_values(ascending=False)
               )
+
+
+@pytest.mark.parametrize("index1, index2, expected", [
+    (pd.to_timedelta((2, 4, 5, 6), unit='s'),
+     pd.to_timedelta((2, 3, 4, 6), unit='s'),
+     pd.to_timedelta((2, 4, 6), unit='s')),
+    (pd.to_timedelta((2, 4, 5), unit='s'),
+     pd.to_timedelta((3, 4, 5, 6), unit='s'),
+     pd.to_timedelta((4, 5), unit='s')),
+])
+def test_intersection_not_a_subset(index1, index2, expected):
+    def intersect(idx1, idx2, expected):
+        result = idx1.intersection(idx2)
+        tm.assert_index_equal(result, expected)
+        result = idx2.intersection(idx1)
+        tm.assert_index_equal(result, expected)
+
+    intersect(index1, index2, expected)
+    intersect(index1.sort_values(ascending=False),
+              index2.sort_values(ascending=False),
+              expected.sort_values(ascending=False)
+              )

pandas/tseries/offsets.py

@@ -112,23 +112,6 @@ def wrapper(self, other):
     return wrapper
 
 
-def apply_index_wraps(func):
-    @functools.wraps(func)
-    def wrapper(self, other):
-        result = func(self, other)
-        if self.normalize:
-            result = result.to_period('D').to_timestamp()
-        return result
-    return wrapper
-
-
-def _is_normalized(dt):
-    if (dt.hour != 0 or dt.minute != 0 or dt.second != 0 or
-            dt.microsecond != 0 or getattr(dt, 'nanosecond', 0) != 0):
-        return False
-    return True
-
-
 def index_offsets_equal(first, second):
     """
     Checks if the two indexes have an offset, and if they equal each other