implement assert_tzawareness_compat for DatetimeIndex

pandas/core/indexes/datetimes.py

@@ -11,7 +11,7 @@
 
 from pandas.core.dtypes.common import (
     _NS_DTYPE, _INT64_DTYPE,
-    is_object_dtype, is_datetime64_dtype,
+    is_object_dtype, is_datetime64_dtype, is_datetime64tz_dtype,
     is_datetimetz, is_dtype_equal,
     is_integer, is_float,
     is_integer_dtype,
@@ -105,8 +105,11 @@ def _dt_index_cmp(opname, nat_result=False):
 
     def wrapper(self, other):
         func = getattr(super(DatetimeIndex, self), opname)
-        if (isinstance(other, datetime) or
-                isinstance(other, compat.string_types)):
+        if isinstance(other, (datetime, compat.string_types)):
+            if isinstance(other, compat.string_types):
+                # We need to convert in order to assert tzawareness
+                other = Timestamp(other)
+            self._assert_tzawareness_compat(other)
             other = _to_m8(other, tz=self.tz)
             result = func(other)
             if isna(other):
@@ -116,6 +119,7 @@ def wrapper(self, other):
                 other = DatetimeIndex(other)
             elif not isinstance(other, (np.ndarray, Index, ABCSeries)):
                 other = _ensure_datetime64(other)
+            self._assert_tzawareness_compat(other)
             result = func(np.asarray(other))
             result = _values_from_object(result)
 
@@ -649,6 +653,20 @@ def _simple_new(cls, values, name=None, freq=None, tz=None,
         result._reset_identity()
         return result
 
+    def _assert_tzawareness_compat(self, other):
+        # adapted from _Timestamp._assert_tzawareness_compat
+        other_tz = getattr(other, 'tzinfo', None)
+        if is_datetime64tz_dtype(other):
+            # Get tzinfo from Series dtype
+            other_tz = other.dtype.tz
+        if self.tz is None:
+            if other_tz is not None:
+                raise TypeError('Cannot compare tz-naive and tz-aware '
+                                'datetime-like objects.')
+        elif other_tz is None:
+            raise TypeError('Cannot compare tz-naive and tz-aware '
+                            'datetime-like objects')
+
     @property
     def tzinfo(self):
         """

pandas/core/internals.py

@@ -3486,10 +3486,20 @@ def replace_list(self, src_list, dest_list, inplace=False, regex=False,
         # figure out our mask a-priori to avoid repeated replacements
         values = self.as_matrix()
 
-        def comp(s):
-            if isna(s):
-                return isna(values)
-            return _maybe_compare(values, getattr(s, 'asm8', s), operator.eq)
+        if is_datetime64tz_dtype(self):
+            # need to be careful not to compare tznaive to tzaware
+            tz = values.dtype.tz
+            def comp(s):
+                if isna(s):
+                    return isna(values)
+                return _maybe_compare(values, s, operator.eq)
+                # TODO: Is just not-converting `s` the right thing to do here?
+        else:
+            def comp(s):
+                if isna(s):
+                    return isna(values)
+                return _maybe_compare(values, getattr(s, 'asm8', s),
+                                      operator.eq)
 
         masks = [comp(s) for i, s in enumerate(src_list)]
 

pandas/tests/indexes/datetimes/test_datetime.py

@@ -1,3 +1,5 @@
+import operator
+
 import pytest
 
 import numpy as np
@@ -223,6 +225,36 @@ def test_append_join_nondatetimeindex(self):
         # it works
         rng.join(idx, how='outer')
 
+    def test_comparison_tzawareness_compat(self):
+        # GH#18162
+        dr = pd.date_range('2016-01-01', periods=6)
+        dz = dr.tz_localize('US/Pacific')
+
+        ops = [operator.eq, operator.ne,
+               operator.gt, operator.ge,
+               operator.lt, operator.le]
+
+        for left, right in [(dr, dz), (dz, dr)]:
+            for op in ops:
+                with pytest.raises(TypeError):
+                    op(left, right)
+
+        # Check that there isn't a problem aware-aware and naive-naive do not
+        # raise
+        assert (dr == dr).all()
+        assert (dz == dz).all()
+
+        naive_series = pd.Series(dr)
+        aware_series = pd.Series(dz)
+        for op in ops:
+            with pytest.raises(TypeError):
+                op(dz, naive_series)
+            with pytest.raises(TypeError):
+                op(dr, aware_series)
+
+        # TODO: implement _assert_tzawareness_compat for the reverse
+        # comparison with the Series on the left-hand side
+
     def test_comparisons_coverage(self):
         rng = date_range('1/1/2000', periods=10)