Address some of the code review responses

Author: kirkhansen

pandas/core/indexes/base.py

@@ -1201,7 +1201,7 @@ def is_monotonic(self):
         return self.is_monotonic_increasing
 
     @property
-    def is_strictly_monotonic(self):
+    def _is_strictly_monotonic(self):
         """ Checks if the index is sorted """
         return (self._is_strictly_monotonic_increasing or
                 self._is_strictly_monotonic_decreasing)

pandas/core/indexes/datetimelike.py

@@ -28,6 +28,7 @@
 from pandas._libs.period import Period
 
 from pandas.core.indexes.base import Index, _index_shared_docs
+from pandas.tseries.offsets import index_offsets_equal
 from pandas.util._decorators import Appender, cache_readonly
 import pandas.core.dtypes.concat as _concat
 import pandas.tseries.frequencies as frequencies
@@ -854,11 +855,7 @@ def _concat_same_dtype(self, to_concat, name):
             new_data = np.concatenate([c.asi8 for c in to_concat])
         return self._simple_new(new_data, **attribs)
 
-    def _slice_by_value(self, start, end):
-        sliced = self.values[slice(*self.slice_locs(start, end))]
-        return self._shallow_copy(sliced)
-
-    def _intersect_ascending(self, other, **empty_params):
+    def _intersect_ascending(self, other):
         # to make our life easier, "sort" the two ranges
         if self[0] <= other[0]:
             left, right = self, other
@@ -869,10 +866,10 @@ def _intersect_ascending(self, other, **empty_params):
         start = right[0]
 
         if end < start:
-            return type(self)(data=[], **empty_params)
-        return left._slice_by_value(start, end)
+            return []
+        return left.values[slice(*left.slice_locs(start, end))]
 
-    def _intersect_descending(self, other, **empty_params):
+    def _intersect_descending(self, other):
         # this is essentially a flip of _intersect_ascending
         if self[0] >= other[0]:
             left, right = self, other
@@ -883,17 +880,8 @@ def _intersect_descending(self, other, **empty_params):
         end = right[-1]
 
         if end > start:
-            return type(self)(data=[], **empty_params)
-        return left._slice_by_value(start, end)
-
-    def _offsets_equal(self, other):
-        offsets_equal = True
-        self_offset = getattr(self, 'offset', None)
-        other_offset = getattr(other, 'offset', None)
-        if self_offset is None or other_offset is None or \
-                self_offset != other_offset or other_offset.isAnchored():
-            offsets_equal = False
-        return offsets_equal
+            return Index()
+        return left.values[slice(*left.slice_locs(start, end))]
 
     def intersection(self, other):
         """
@@ -914,55 +902,44 @@ def intersection(self, other):
         if self.equals(other):
             return self._get_consensus_name(other)
 
-        if not isinstance(other, DatetimeIndexOpsMixin):
-            try:
-                other = DatetimeIndexOpsMixin(other)
-            except (TypeError, ValueError):
-                pass
+        lengths = len(self), len(other)
+        if lengths[0] == 0:
+            return self
+        if lengths[1] == 0:
+            return other
+
+        if not isinstance(other, Index):
             result = Index.intersection(self, other)
             return result
-        elif (self._offsets_equal(other) or
-              (not self.is_strictly_monotonic or
-                not other.is_strictly_monotonic)):
+        elif (index_offsets_equal(self, other) or
+                (not self._is_strictly_monotonic or
+                    not other._is_strictly_monotonic)):
             result = Index.intersection(self, other)
-            tz = getattr(self, 'tz', None)
             result = self._shallow_copy(result._values, name=result.name,
-                                        tz=tz, freq=None)
+                                        tz=getattr(self, 'tz', None))
             if result.freq is None:
                 result.offset = frequencies.to_offset(result.inferred_freq)
             return result
 
-        lenghts = len(self), len(other)
-        if lenghts[0] == 0:
-            return self
-        if lenghts[1] == 0:
-            return other
-
         # 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 lenghts[0] != lenghts[1] and (
-                    max(self) != max(other) or min(self) != min(other)):
+        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)
 
-        # Thanks, PeriodIndex
-        empty_params = {'freq': getattr(self, 'freq', None)}
-
         if self_ascending:
-            intersected = self._intersect_ascending(other, **empty_params)
+            intersected_slice = self._intersect_ascending(other)
         else:
-            intersected = self._intersect_descending(other, **empty_params)
+            intersected_slice = self._intersect_descending(other)
 
-        name = self.name
-        if self.name != other.name:
-            name = None
-        intersected.name = name
-        return intersected
+        intersected = self._shallow_copy(intersected_slice)
+        return intersected._get_consensus_name(other)
 
 
 def _ensure_datetimelike_to_i8(other):

pandas/core/indexes/period.py

@@ -843,7 +843,7 @@ def _maybe_cast_slice_bound(self, label, side, kind):
         Value of `side` parameter should be validated in caller.
 
         """
-        assert kind in ['ix', 'loc', 'getitem', None]
+        assert kind in ['ix', 'loc', 'getitem']
 
         if isinstance(label, datetime):
             return Period(label, freq=self.freq)

pandas/tseries/offsets.py

@@ -119,6 +119,26 @@ def _is_normalized(dt):
         return False
     return True
 
+
+def index_offsets_equal(first, second):
+    """
+    Checks if the two indexes have an offset, and if they equal each other
+    Parameters
+    ----------
+    first: Index
+    second: Index
+
+    Returns
+    -------
+    bool
+    """
+    first = getattr(first, 'offset', None)
+    second = getattr(second, 'offset', None)
+    are_offsets_equal = True
+    if first is None or second is None or first != second:
+        are_offsets_equal = False
+    return are_offsets_equal
+
 # ---------------------------------------------------------------------
 # DateOffset