BUG: Timedelta == ndarray[td64]

doc/source/whatsnew/v1.1.0.rst

@@ -395,6 +395,7 @@ Timedelta
 - Bug in dividing ``np.nan`` or ``None`` by :class:`Timedelta`` incorrectly returning ``NaT`` (:issue:`31869`)
 - Timedeltas now understand ``µs`` as identifier for microsecond (:issue:`32899`)
 - :class:`Timedelta` string representation now includes nanoseconds, when nanoseconds are non-zero (:issue:`9309`)
+- Bug in comparing a :class:`Timedelta`` object against a ``np.ndarray`` with ``timedelta64`` dtype incorrectly viewing all entries as unequal (:issue:`33441`)
 
 Timezones
 ^^^^^^^^^

pandas/_libs/tslibs/timedeltas.pyx

@@ -778,36 +778,32 @@ cdef class _Timedelta(timedelta):
 
         if isinstance(other, _Timedelta):
             ots = other
-        elif PyDelta_Check(other) or isinstance(other, Tick):
+        elif (is_timedelta64_object(other) or PyDelta_Check(other)
+              or isinstance(other, Tick)):
             ots = Timedelta(other)
-        else:
-            ndim = getattr(other, "ndim", -1)
+            # TODO: watch out for overflows
 
-            if ndim != -1:
-                if ndim == 0:
-                    if is_timedelta64_object(other):
-                        other = Timedelta(other)
-                    else:
-                        if op == Py_EQ:
-                            return False
-                        elif op == Py_NE:
-                            return True
-                        # only allow ==, != ops
-                        raise TypeError(f'Cannot compare type '
-                                        f'{type(self).__name__} with '
-                                        f'type {type(other).__name__}')
-                if util.is_array(other):
-                    return PyObject_RichCompare(np.array([self]), other, op)
-                return PyObject_RichCompare(other, self, reverse_ops[op])
-            else:
-                if other is NaT:
-                    return PyObject_RichCompare(other, self, reverse_ops[op])
-                elif op == Py_EQ:
-                    return False
-                elif op == Py_NE:
-                    return True
-                raise TypeError(f'Cannot compare type {type(self).__name__} with '
-                                f'type {type(other).__name__}')
+        elif other is NaT:
+            return op == Py_NE
+
+        elif util.is_array(other):
+            # TODO: watch out for zero-dim
+            if other.dtype.kind == "m":
+                return PyObject_RichCompare(self.asm8, other, op)
+            elif other.dtype.kind == "O":
+                # operate element-wise
+                return np.array(
+                    [PyObject_RichCompare(self, x, op) for x in other],
+                    dtype=bool,
+                )
+            if op == Py_EQ:
+                return np.zeros(other.shape, dtype=bool)
+            elif op == Py_NE:
+                return np.ones(other.shape, dtype=bool)
+            return NotImplemented  # let other raise TypeError
+
+        else:
+            return NotImplemented
 
         return cmp_scalar(self.value, ots.value, op)
 

pandas/core/internals/managers.py

@@ -880,6 +880,7 @@ def to_dict(self, copy: bool = True):
         for b in self.blocks:
             bd.setdefault(str(b.dtype), []).append(b)
 
+        # TODO(EA2D): the combine will be unnecessary with 2D EAs
         return {dtype: self._combine(blocks, copy=copy) for dtype, blocks in bd.items()}
 
     def fast_xs(self, loc: int) -> ArrayLike:

pandas/tests/arithmetic/test_datetime64.py

@@ -734,7 +734,7 @@ def test_dti_cmp_object_dtype(self):
         result = dti == other
         expected = np.array([True] * 5 + [False] * 5)
         tm.assert_numpy_array_equal(result, expected)
-        msg = "Cannot compare type"
+        msg = ">=' not supported between instances of 'Timestamp' and 'Timedelta'"
         with pytest.raises(TypeError, match=msg):
             dti >= other
 

pandas/tests/scalar/timedelta/test_arithmetic.py

@@ -904,6 +904,25 @@ def test_compare_timedelta_ndarray(self):
         expected = np.array([False, False])
         tm.assert_numpy_array_equal(result, expected)
 
+    def test_compare_td64_ndarray(self):
+        # GG#33441
+        arr = np.arange(5).astype("timedelta64[ns]")
+        td = pd.Timedelta(arr[1])
+
+        expected = np.array([False, True, False, False, False], dtype=bool)
+
+        result = td == arr
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = arr == td
+        tm.assert_numpy_array_equal(result, expected)
+
+        result = td != arr
+        tm.assert_numpy_array_equal(result, ~expected)
+
+        result = arr != td
+        tm.assert_numpy_array_equal(result, ~expected)
+
     @pytest.mark.skip(reason="GH#20829 is reverted until after 0.24.0")
     def test_compare_custom_object(self):
         """
@@ -943,7 +962,7 @@ def __gt__(self, other):
     def test_compare_unknown_type(self, val):
         # GH#20829
         t = Timedelta("1s")
-        msg = "Cannot compare type Timedelta with type (int|str)"
+        msg = "not supported between instances of 'Timedelta' and '(int|str)'"
         with pytest.raises(TypeError, match=msg):
             t >= val
         with pytest.raises(TypeError, match=msg):
@@ -984,7 +1003,7 @@ def test_ops_error_str():
         with pytest.raises(TypeError, match=msg):
             left + right
 
-        msg = "Cannot compare type"
+        msg = "not supported between instances of"
         with pytest.raises(TypeError, match=msg):
             left > right