BUG: Timestamp == date match stdlib

doc/source/whatsnew/v1.3.0.rst

@@ -147,6 +147,7 @@ Deprecations
 - Deprecating allowing scalars passed to the :class:`Categorical` constructor (:issue:`38433`)
 - Deprecated allowing subclass-specific keyword arguments in the :class:`Index` constructor, use the specific subclass directly instead (:issue:`14093`,:issue:`21311`,:issue:`22315`,:issue:`26974`)
 - Deprecated ``astype`` of datetimelike (``timedelta64[ns]``, ``datetime64[ns]``, ``Datetime64TZDtype``, ``PeriodDtype``) to integer dtypes, use ``values.view(...)`` instead (:issue:`38544`)
+- Deprecated comparison of :class:`Timestamp` object with ``datetime.date`` objects.  Instead of e.g. ``ts <= mydate`` use ``ts <= pd.Timestamp(mydate)`` or ``ts.date() <= mydate`` (:issue:`36131`)
 -
 -
 

pandas/_libs/tslibs/timestamps.pyx

@@ -16,6 +16,7 @@ from numpy cimport int8_t, int64_t, ndarray, uint8_t
 cnp.import_array()
 
 from cpython.datetime cimport (  # alias bc `tzinfo` is a kwarg below
+    PyDate_Check,
     PyDateTime_Check,
     PyDateTime_IMPORT,
     PyDelta_Check,
@@ -281,6 +282,18 @@ cdef class _Timestamp(ABCTimestamp):
                 return np.zeros(other.shape, dtype=np.bool_)
             return NotImplemented
 
+        elif PyDate_Check(other):
+            # returning NotImplemented defers to the `date` implementation
+            #  which incorrectly drops tz and normalizes to midnight
+            #  before comparing
+            # We follow the stdlib datetime behavior of never being equal
+            warnings.warn(
+                "Comparison of Timestamp with datetime.date is deprecated in "
+                "order to match the standard library behavior.  "
+                "In a future version these will be considered non-comparable."
+                "Use ts == pd.Timestamp(dt) instead.", FutureWarning
+            )
+            return NotImplemented
         else:
             return NotImplemented
 

pandas/tests/frame/indexing/test_indexing.py

@@ -1429,7 +1429,10 @@ def test_loc_setitem_datetime_coercion(self):
         assert Timestamp("2008-08-08") == df.loc[0, "c"]
         assert Timestamp("2008-08-08") == df.loc[1, "c"]
         df.loc[2, "c"] = date(2005, 5, 5)
-        assert Timestamp("2005-05-05") == df.loc[2, "c"]
+        with tm.assert_produces_warning(FutureWarning):
+            # Comparing Timestamp to date obj is deprecated
+            assert Timestamp("2005-05-05") == df.loc[2, "c"]
+        assert Timestamp("2005-05-05").date() == df.loc[2, "c"]
 
     def test_loc_setitem_datetimelike_with_inference(self):
         # GH 7592

pandas/tests/scalar/timestamp/test_comparisons.py

@@ -142,6 +142,42 @@ def test_compare_invalid(self):
         assert val != np.float64(1)
         assert val != np.int64(1)
 
+    @pytest.mark.parametrize("tz", [None, "US/Pacific"])
+    def test_compare_date(self, tz):
+        # GH#36131 comparing Timestamp with date object is deprecated
+        ts = Timestamp.now(tz)
+        dt = ts.to_pydatetime().date()
+        # These are incorrectly considered as equal because they
+        #  dispatch to the date comparisons which truncates ts
+
+        for left, right in [(ts, dt), (dt, ts)]:
+            with tm.assert_produces_warning(FutureWarning):
+                assert left == right
+            with tm.assert_produces_warning(FutureWarning):
+                assert not left != right
+            with tm.assert_produces_warning(FutureWarning):
+                assert not left < right
+            with tm.assert_produces_warning(FutureWarning):
+                assert left <= right
+            with tm.assert_produces_warning(FutureWarning):
+                assert not left > right
+            with tm.assert_produces_warning(FutureWarning):
+                assert left >= right
+
+        # Once the deprecation is enforced, the following assertions
+        #  can be enabled:
+        #    assert not left == right
+        #    assert left != right
+        #
+        #    with pytest.raises(TypeError):
+        #        left < right
+        #    with pytest.raises(TypeError):
+        #        left <= right
+        #    with pytest.raises(TypeError):
+        #        left > right
+        #    with pytest.raises(TypeError):
+        #        left >= right
+
     def test_cant_compare_tz_naive_w_aware(self, utc_fixture):
         # see GH#1404
         a = Timestamp("3/12/2012")

pandas/tests/series/methods/test_drop_duplicates.py

@@ -67,76 +67,164 @@ def test_drop_duplicates_no_duplicates(any_numpy_dtype, keep, values):
 
 
 class TestSeriesDropDuplicates:
-    @pytest.mark.parametrize(
-        "dtype",
-        ["int_", "uint", "float_", "unicode_", "timedelta64[h]", "datetime64[D]"],
+    @pytest.fixture(
+        params=["int_", "uint", "float_", "unicode_", "timedelta64[h]", "datetime64[D]"]
     )
-    def test_drop_duplicates_categorical_non_bool(self, dtype, ordered):
-        cat_array = np.array([1, 2, 3, 4, 5], dtype=np.dtype(dtype))
+    def dtype(self, request):
+        return request.param
 
+    @pytest.fixture
+    def cat_series1(self, dtype, ordered):
         # Test case 1
+        cat_array = np.array([1, 2, 3, 4, 5], dtype=np.dtype(dtype))
+
         input1 = np.array([1, 2, 3, 3], dtype=np.dtype(dtype))
+
         tc1 = Series(Categorical(input1, categories=cat_array, ordered=ordered))
-        if dtype == "datetime64[D]":
-            # pre-empty flaky xfail, tc1 values are seemingly-random
-            if not (np.array(tc1) == input1).all():
-                pytest.xfail(reason="GH#7996")
+        return tc1
+
+    def _maybe_xfail_tc(self, tc, request):
+        warn = None
+        if tc.cat.categories.dtype.kind == "M":
+            if len(tc) == 4:
+                # This is cat_series1
+                input_arr = np.array([1, 2, 3, 3], dtype=np.dtype("datetime64[D]"))
+            else:
+                # This is tc2
+                input_arr = np.array(
+                    [1, 2, 3, 5, 3, 2, 4], dtype=np.dtype("datetime64[D]")
+                )
+
+            if not (np.array(tc) == input_arr).all():
+                mark = pytest.mark.xfail(
+                    reason="GH#7996 tc1/tc2 values are seemingly-random",
+                    raises=AssertionError,
+                )
+                request.node.add_marker(mark)
+
+                # Also warn about Timestamp vs date deprecation
+                warn = FutureWarning
+        return warn
+
+    def test_drop_duplicates_categorical_non_bool(self, cat_series1, request):
+        tc1 = cat_series1
+        warn = self._maybe_xfail_tc(tc1, request)
 
         expected = Series([False, False, False, True])
-        tm.assert_series_equal(tc1.duplicated(), expected)
-        tm.assert_series_equal(tc1.drop_duplicates(), tc1[~expected])
-        sc = tc1.copy()
-        return_value = sc.drop_duplicates(inplace=True)
-        assert return_value is None
-        tm.assert_series_equal(sc, tc1[~expected])
+
+        with tm.assert_produces_warning(warn):
+            result = tc1.duplicated()
+            tm.assert_series_equal(result, expected)
+
+            result = tc1.drop_duplicates()
+            tm.assert_series_equal(result, tc1[~expected])
+
+            sc = tc1.copy()
+            return_value = sc.drop_duplicates(inplace=True)
+            assert return_value is None
+            tm.assert_series_equal(sc, tc1[~expected])
+
+    def test_drop_duplicates_categorical_non_bool_keeplast(self, cat_series1, request):
+        tc1 = cat_series1
+        warn = self._maybe_xfail_tc(tc1, request)
 
         expected = Series([False, False, True, False])
-        tm.assert_series_equal(tc1.duplicated(keep="last"), expected)
-        tm.assert_series_equal(tc1.drop_duplicates(keep="last"), tc1[~expected])
-        sc = tc1.copy()
-        return_value = sc.drop_duplicates(keep="last", inplace=True)
-        assert return_value is None
-        tm.assert_series_equal(sc, tc1[~expected])
+
+        with tm.assert_produces_warning(warn):
+            result = tc1.duplicated(keep="last")
+            tm.assert_series_equal(result, expected)
+
+            result = tc1.drop_duplicates(keep="last")
+            tm.assert_series_equal(result, tc1[~expected])
+
+            sc = tc1.copy()
+            return_value = sc.drop_duplicates(keep="last", inplace=True)
+            assert return_value is None
+            tm.assert_series_equal(sc, tc1[~expected])
+
+    def test_drop_duplicates_categorical_non_bool_keepfalse(self, cat_series1, request):
+        tc1 = cat_series1
+        warn = self._maybe_xfail_tc(tc1, request)
 
         expected = Series([False, False, True, True])
-        tm.assert_series_equal(tc1.duplicated(keep=False), expected)
-        tm.assert_series_equal(tc1.drop_duplicates(keep=False), tc1[~expected])
-        sc = tc1.copy()
-        return_value = sc.drop_duplicates(keep=False, inplace=True)
-        assert return_value is None
-        tm.assert_series_equal(sc, tc1[~expected])
 
-        # Test case 2
+        with tm.assert_produces_warning(warn):
+            result = tc1.duplicated(keep=False)
+            tm.assert_series_equal(result, expected)
+
+            result = tc1.drop_duplicates(keep=False)
+            tm.assert_series_equal(result, tc1[~expected])
+
+            sc = tc1.copy()
+            return_value = sc.drop_duplicates(keep=False, inplace=True)
+            assert return_value is None
+            tm.assert_series_equal(sc, tc1[~expected])
+
+    @pytest.fixture
+    def cat_series2(self, dtype, ordered):
+        # Test case 2; TODO: better name
+        cat_array = np.array([1, 2, 3, 4, 5], dtype=np.dtype(dtype))
+
         input2 = np.array([1, 2, 3, 5, 3, 2, 4], dtype=np.dtype(dtype))
         tc2 = Series(Categorical(input2, categories=cat_array, ordered=ordered))
-        if dtype == "datetime64[D]":
-            # pre-empty flaky xfail, tc2 values are seemingly-random
-            if not (np.array(tc2) == input2).all():
-                pytest.xfail(reason="GH#7996")
+        return tc2
+
+    def test_drop_duplicates_categorical_non_bool2(self, cat_series2, request):
+        # Test case 2; TODO: better name
+        tc2 = cat_series2
+        warn = self._maybe_xfail_tc(tc2, request)
 
         expected = Series([False, False, False, False, True, True, False])
-        tm.assert_series_equal(tc2.duplicated(), expected)
-        tm.assert_series_equal(tc2.drop_duplicates(), tc2[~expected])
-        sc = tc2.copy()
-        return_value = sc.drop_duplicates(inplace=True)
-        assert return_value is None
-        tm.assert_series_equal(sc, tc2[~expected])
+
+        with tm.assert_produces_warning(warn):
+            result = tc2.duplicated()
+            tm.assert_series_equal(result, expected)
+
+            result = tc2.drop_duplicates()
+            tm.assert_series_equal(result, tc2[~expected])
+
+            sc = tc2.copy()
+            return_value = sc.drop_duplicates(inplace=True)
+            assert return_value is None
+            tm.assert_series_equal(sc, tc2[~expected])
+
+    def test_drop_duplicates_categorical_non_bool2_keeplast(self, cat_series2, request):
+        tc2 = cat_series2
+        warn = self._maybe_xfail_tc(tc2, request)
 
         expected = Series([False, True, True, False, False, False, False])
-        tm.assert_series_equal(tc2.duplicated(keep="last"), expected)
-        tm.assert_series_equal(tc2.drop_duplicates(keep="last"), tc2[~expected])
-        sc = tc2.copy()
-        return_value = sc.drop_duplicates(keep="last", inplace=True)
-        assert return_value is None
-        tm.assert_series_equal(sc, tc2[~expected])
+
+        with tm.assert_produces_warning(warn):
+            result = tc2.duplicated(keep="last")
+            tm.assert_series_equal(result, expected)
+
+            result = tc2.drop_duplicates(keep="last")
+            tm.assert_series_equal(result, tc2[~expected])
+
+            sc = tc2.copy()
+            return_value = sc.drop_duplicates(keep="last", inplace=True)
+            assert return_value is None
+            tm.assert_series_equal(sc, tc2[~expected])
+
+    def test_drop_duplicates_categorical_non_bool2_keepfalse(
+        self, cat_series2, request
+    ):
+        tc2 = cat_series2
+        warn = self._maybe_xfail_tc(tc2, request)
 
         expected = Series([False, True, True, False, True, True, False])
-        tm.assert_series_equal(tc2.duplicated(keep=False), expected)
-        tm.assert_series_equal(tc2.drop_duplicates(keep=False), tc2[~expected])
-        sc = tc2.copy()
-        return_value = sc.drop_duplicates(keep=False, inplace=True)
-        assert return_value is None
-        tm.assert_series_equal(sc, tc2[~expected])
+
+        with tm.assert_produces_warning(warn):
+            result = tc2.duplicated(keep=False)
+            tm.assert_series_equal(result, expected)
+
+            result = tc2.drop_duplicates(keep=False)
+            tm.assert_series_equal(result, tc2[~expected])
+
+            sc = tc2.copy()
+            return_value = sc.drop_duplicates(keep=False, inplace=True)
+            assert return_value is None
+            tm.assert_series_equal(sc, tc2[~expected])
 
     def test_drop_duplicates_categorical_bool(self, ordered):
         tc = Series(