DEPR: remove numpy deprecation warnings for i8 vs integer comparisions

Author: jreback

pandas/core/common.py

@@ -462,6 +462,10 @@ def array_equivalent(left, right, strict_nan=False):
     if issubclass(left.dtype.type, (np.floating, np.complexfloating)):
         return ((left == right) | (np.isnan(left) & np.isnan(right))).all()
 
+    # numpy will will not allow this type of datetimelike vs integer comparison
+    elif is_datetimelike_v_integer(left, right):
+        return False
+
     # NaNs cannot occur otherwise.
     return np.array_equal(left, right)
 
@@ -2539,6 +2543,13 @@ def is_datetime_or_timedelta_dtype(arr_or_dtype):
     return issubclass(tipo, (np.datetime64, np.timedelta64))
 
 
+def is_datetimelike_v_integer(a, b):
+    # return if we have an i8 convertible and and integer comparision
+    a = np.asarray(a)
+    b = np.asarray(b)
+    return (needs_i8_conversion(a) and is_integer_dtype(b)) or (
+        needs_i8_conversion(b) and is_integer_dtype(a))
+
 needs_i8_conversion = is_datetime_or_timedelta_dtype
 
 def i8_boxer(arr_or_dtype):

pandas/core/generic.py

@@ -3574,7 +3574,14 @@ def where(self, cond, other=np.nan, inplace=False, axis=None, level=None,
                 except ValueError:
                     new_other = np.array(other)
 
-                matches = (new_other == np.array(other))
+                # we can end up comparing integers and m8[ns]
+                # which is a numpy no no
+                is_i8 = com.needs_i8_conversion(self.dtype)
+                if is_i8:
+                    matches = False
+                else:
+                    matches = (new_other == np.array(other))
+
                 if matches is False or not matches.all():
 
                     # coerce other to a common dtype if we can

pandas/core/internals.py

@@ -14,7 +14,7 @@
                                 is_null_datelike_scalar, _maybe_promote,
                                 is_timedelta64_dtype, is_datetime64_dtype,
                                 array_equivalent, _maybe_convert_string_to_object,
-                                is_categorical)
+                                is_categorical, needs_i8_conversion, is_datetimelike_v_integer)
 from pandas.core.index import Index, MultiIndex, _ensure_index
 from pandas.core.indexing import maybe_convert_indices, length_of_indexer
 from pandas.core.categorical import Categorical, maybe_to_categorical
@@ -3885,9 +3885,16 @@ def _vstack(to_stack, dtype):
 
 
 def _possibly_compare(a, b, op):
-    res = op(a, b)
+
     is_a_array = isinstance(a, np.ndarray)
     is_b_array = isinstance(b, np.ndarray)
+
+    # numpy deprecation warning to have i8 vs integer comparisions
+    if is_datetimelike_v_integer(a, b):
+        res = False
+    else:
+        res = op(a, b)
+
     if np.isscalar(res) and (is_a_array or is_b_array):
         type_names = [type(a).__name__, type(b).__name__]
 

pandas/core/ops.py

@@ -17,7 +17,7 @@
 from pandas.tslib import iNaT
 from pandas.core.common import(bind_method, is_list_like, notnull, isnull,
                                _values_from_object, _maybe_match_name,
-                               needs_i8_conversion, is_integer_dtype)
+                               needs_i8_conversion, is_datetimelike_v_integer, is_integer_dtype)
 
 # -----------------------------------------------------------------------------
 # Functions that add arithmetic methods to objects, given arithmetic factory
@@ -574,9 +574,7 @@ def na_op(x, y):
             # we are not NotImplemented, otherwise
             # we would allow datetime64 (but viewed as i8) against
             # integer comparisons
-            if needs_i8_conversion(x) and (not isscalar(y) and is_integer_dtype(y)):
-                raise TypeError("invalid type comparison")
-            elif (not isscalar(y) and needs_i8_conversion(y)) and is_integer_dtype(x):
+            if is_datetimelike_v_integer(x, y):
                 raise TypeError("invalid type comparison")
 
             # we have a datetime/timedelta and may need to convert
@@ -690,15 +688,15 @@ def na_op(x, y):
         return result
 
     def wrapper(self, other):
-        is_self_int_dtype = com.is_integer_dtype(self.dtype)
+        is_self_int_dtype = is_integer_dtype(self.dtype)
 
         fill_int = lambda x: x.fillna(0)
         fill_bool = lambda x: x.fillna(False).astype(bool)
 
         if isinstance(other, pd.Series):
             name = _maybe_match_name(self, other)
             other = other.reindex_like(self)
-            is_other_int_dtype = com.is_integer_dtype(other.dtype)
+            is_other_int_dtype = is_integer_dtype(other.dtype)
             other = fill_int(other) if is_other_int_dtype else fill_bool(other)
 
             filler = fill_int if is_self_int_dtype and is_other_int_dtype else fill_bool
@@ -711,7 +709,7 @@ def wrapper(self, other):
 
         else:
             # scalars, list, tuple, np.array
-            filler = fill_int if is_self_int_dtype and com.is_integer_dtype(np.asarray(other)) else fill_bool
+            filler = fill_int if is_self_int_dtype and is_integer_dtype(np.asarray(other)) else fill_bool
             return filler(self._constructor(na_op(self.values, other),
                                     index=self.index)).__finalize__(self)