dispatch Series[datetime64] comparison ops to DatetimeIndex

pandas/core/indexes/base.py

@@ -3949,6 +3949,10 @@ def _evaluate_compare(self, other):
                         result = _comp_method_OBJECT_ARRAY(
                             op, self.values, other)
                 else:
+                    if isinstance(other, ABCSeries):
+                        # Windows builds with some numpy versions (1.13)
+                        # require specifically unwrapping Series GH#19800
+                        other = other.values
                     with np.errstate(all='ignore'):
                         result = op(self.values, np.asarray(other))
 

pandas/core/indexes/datetimes.py

@@ -142,6 +142,9 @@ def wrapper(self, other):
             else:
                 o_mask = other.view('i8') == libts.iNaT
 
+            # for older numpys we need to be careful not to pass a Series
+            # as a mask below
+            o_mask = com._values_from_object(o_mask)
             if o_mask.any():
                 result[o_mask] = nat_result
 

pandas/core/ops.py

@@ -10,8 +10,7 @@
 import numpy as np
 import pandas as pd
 
-from pandas._libs import (lib, index as libindex,
-                          algos as libalgos)
+from pandas._libs import lib, algos as libalgos
 
 from pandas import compat
 from pandas.util._decorators import Appender
@@ -944,24 +943,20 @@ def na_op(x, y):
             # integer comparisons
 
             # we have a datetime/timedelta and may need to convert
+            assert not needs_i8_conversion(x)
             mask = None
-            if (needs_i8_conversion(x) or
-                    (not is_scalar(y) and needs_i8_conversion(y))):
-
-                if is_scalar(y):
-                    mask = isna(x)
-                    y = libindex.convert_scalar(x, com._values_from_object(y))
-                else:
-                    mask = isna(x) | isna(y)
-                    y = y.view('i8')
+            if not is_scalar(y) and needs_i8_conversion(y):
+                mask = isna(x) | isna(y)
+                y = y.view('i8')
                 x = x.view('i8')
 
-            try:
+            method = getattr(x, name, None)
+            if method is not None:
                 with np.errstate(all='ignore'):
-                    result = getattr(x, name)(y)
+                    result = method(y)
                 if result is NotImplemented:
                     raise TypeError("invalid type comparison")
-            except AttributeError:
+            else:
                 result = op(x, y)
 
             if mask is not None and mask.any():
@@ -991,6 +986,12 @@ def wrapper(self, other, axis=None):
             return self._constructor(res_values, index=self.index,
                                      name=res_name)
 
+        if is_datetime64_dtype(self) or is_datetime64tz_dtype(self):
+            res_values = dispatch_to_index_op(op, self, other,
+                                              pd.DatetimeIndex)
+            return self._constructor(res_values, index=self.index,
+                                     name=res_name)
+
         elif is_timedelta64_dtype(self):
             res_values = dispatch_to_index_op(op, self, other,
                                               pd.TimedeltaIndex)
@@ -1008,8 +1009,7 @@ def wrapper(self, other, axis=None):
         elif isinstance(other, (np.ndarray, pd.Index)):
             # do not check length of zerodim array
             # as it will broadcast
-            if (not is_scalar(lib.item_from_zerodim(other)) and
-                    len(self) != len(other)):
+            if other.ndim != 0 and len(self) != len(other):
                 raise ValueError('Lengths must match to compare')
 
             res_values = na_op(self.values, np.asarray(other))

pandas/tests/indexes/datetimes/test_partial_slicing.py

@@ -2,7 +2,7 @@
 
 import pytest
 
-from datetime import datetime, date
+from datetime import datetime
 import numpy as np
 import pandas as pd
 import operator as op
@@ -349,7 +349,7 @@ def test_loc_datetime_length_one(self):
 
     @pytest.mark.parametrize('datetimelike', [
         Timestamp('20130101'), datetime(2013, 1, 1),
-        date(2013, 1, 1), np.datetime64('2013-01-01T00:00', 'ns')])
+        np.datetime64('2013-01-01T00:00', 'ns')])
     @pytest.mark.parametrize('op,expected', [
         (op.lt, [True, False, False, False]),
         (op.le, [True, True, False, False]),

pandas/tests/test_base.py

@@ -10,7 +10,7 @@
 import pandas as pd
 import pandas.compat as compat
 from pandas.core.dtypes.common import (
-    is_object_dtype, is_datetimetz,
+    is_object_dtype, is_datetimetz, is_datetime64_dtype,
     needs_i8_conversion)
 import pandas.util.testing as tm
 from pandas import (Series, Index, DatetimeIndex, TimedeltaIndex,
@@ -296,14 +296,16 @@ def test_none_comparison(self):
                 # result = None != o  # noqa
                 # assert result.iat[0]
                 # assert result.iat[1]
-
-                result = None > o
-                assert not result.iat[0]
-                assert not result.iat[1]
-
-                result = o < None
-                assert not result.iat[0]
-                assert not result.iat[1]
+                if not (is_datetime64_dtype(o) or is_datetimetz(o)):
+                    # Following DatetimeIndex (and Timestamp) convention,
+                    # inequality comparisons with Series[datetime64] raise
+                    result = None > o
+                    assert not result.iat[0]
+                    assert not result.iat[1]
+
+                    result = o < None
+                    assert not result.iat[0]
+                    assert not result.iat[1]
 
     def test_ndarray_compat_properties(self):