DEPR: Remove special date-datetime64 case in indexing

doc/source/whatsnew/v3.0.0.rst

@@ -659,6 +659,7 @@ Other API changes
 - :meth:`CategoricalIndex.append` no longer attempts to cast different-dtype indexes to the caller's dtype (:issue:`41626`)
 - :meth:`ExtensionDtype.construct_array_type` is now a regular method instead of a ``classmethod`` (:issue:`58663`)
 - Comparison operations between :class:`Index` and :class:`Series` now consistently return :class:`Series` regardless of which object is on the left or right (:issue:`36759`)
+- Indexing and comparison with sequences of ``datetime.date`` objects are now consistent with scalar ``datetime.date`` behavior in :class:`DatetimeIndex` (:issue:`62158`)
 - Numpy functions like ``np.isinf`` that return a bool dtype when called on a :class:`Index` object now return a bool-dtype :class:`Index` instead of ``np.ndarray`` (:issue:`52676`)
 
 .. ---------------------------------------------------------------------------

pandas/core/arrays/datetimes.py

@@ -229,7 +229,7 @@ class DatetimeArray(dtl.TimelikeOps, dtl.DatelikeOps):
     _is_recognized_dtype: Callable[[DtypeObj], bool] = lambda x: lib.is_np_dtype(
         x, "M"
     ) or isinstance(x, DatetimeTZDtype)
-    _infer_matches = ("datetime", "datetime64", "date")
+    _infer_matches = ("datetime", "datetime64")
 
     @property
     def _scalar_type(self) -> type[Timestamp]:

pandas/core/indexes/base.py

@@ -40,7 +40,6 @@
     no_default,
 )
 from pandas._libs.tslibs import (
-    OutOfBoundsDatetime,
     Timestamp,
     tz_compare,
 )
@@ -6221,11 +6220,6 @@ def _maybe_downcast_for_indexing(self, other: Index) -> tuple[Index, Index]:
                 # standardize on UTC
                 return self.tz_convert("UTC"), other.tz_convert("UTC")
 
-        elif self.inferred_type == "date" and isinstance(other, ABCDatetimeIndex):
-            try:
-                return type(other)(self), other
-            except OutOfBoundsDatetime:
-                return self, other
         elif self.inferred_type == "timedelta" and isinstance(other, ABCTimedeltaIndex):
             # TODO: we dont have tests that get here
             return type(other)(self), other

pandas/tests/frame/methods/test_asfreq.py

@@ -186,15 +186,15 @@ def test_asfreq_fillvalue(self):
         tm.assert_series_equal(expected_series, actual_series)
 
     def test_asfreq_with_date_object_index(self, frame_or_series):
+        # GH#62158 date objects lose indexing special case
         rng = date_range("1/1/2000", periods=20)
         ts = frame_or_series(np.random.default_rng(2).standard_normal(20), index=rng)
+        ts.index = [x.date() for x in ts.index]
 
-        ts2 = ts.copy()
-        ts2.index = [x.date() for x in ts2.index]
-
-        result = ts2.asfreq("4h", method="ffill")
-        expected = ts.asfreq("4h", method="ffill")
-        tm.assert_equal(result, expected)
+        with pytest.raises(
+            TypeError, match="Cannot compare Timestamp with datetime.date"
+        ):
+            ts.asfreq("4h", method="ffill")
 
     def test_asfreq_with_unsorted_index(self, frame_or_series):
         # GH#39805

pandas/tests/indexes/datetimes/test_indexing.py

@@ -536,10 +536,11 @@ def test_get_indexer_pyarrow(self, as_td):
         tm.assert_numpy_array_equal(result2, expected)
 
     def test_get_indexer_date_objs(self):
+        # GH#62158 date objects lose indexing special case
         rng = date_range("1/1/2000", periods=20)
-
         result = rng.get_indexer(rng.map(lambda x: x.date()))
-        expected = rng.get_indexer(rng)
+
+        expected = np.full(len(rng), -1, dtype=np.intp)
         tm.assert_numpy_array_equal(result, expected)
 
     def test_get_indexer(self):
@@ -584,17 +585,23 @@ def test_get_indexer(self):
             idx.get_indexer(idx[[0]], method="nearest", tolerance="foo")
 
     @pytest.mark.parametrize(
-        "target",
+        "target, expected",
         [
-            [date(2020, 1, 1), Timestamp("2020-01-02")],
-            [Timestamp("2020-01-01"), date(2020, 1, 2)],
+            (
+                [date(2020, 1, 1), Timestamp("2020-01-02")],
+                np.array([-1, 1], dtype=np.intp),
+            ),
+            (
+                [Timestamp("2020-01-01"), date(2020, 1, 2)],
+                np.array([0, -1], dtype=np.intp),
+            ),
         ],
     )
-    def test_get_indexer_mixed_dtypes(self, target):
-        # https://github.com/pandas-dev/pandas/issues/33741
+    def test_get_indexer_mixed_dtypes(self, target, expected):
+        # GH#33741 regression test: mixed dtypes should not error
+        # GH#62158 date objects lose indexing special case
         values = DatetimeIndex([Timestamp("2020-01-01"), Timestamp("2020-01-02")])
         result = values.get_indexer(target)
-        expected = np.array([0, 1], dtype=np.intp)
         tm.assert_numpy_array_equal(result, expected)
 
     @pytest.mark.parametrize(

pandas/tests/io/parser/dtypes/test_categorical.py

@@ -275,13 +275,24 @@ def test_categorical_coerces_numeric(all_parsers):
 def test_categorical_coerces_datetime(all_parsers):
     parser = all_parsers
     dti = pd.DatetimeIndex(["2017-01-01", "2018-01-01", "2019-01-01"], freq=None)
+
     dtype = {"b": CategoricalDtype(dti)}
 
     data = "b\n2017-01-01\n2018-01-01\n2019-01-01"
     expected = DataFrame({"b": Categorical(dtype["b"].categories)})
 
-    result = parser.read_csv(StringIO(data), dtype=dtype)
-    tm.assert_frame_equal(result, expected)
+    if parser.engine == "pyarrow":
+        msg = "Constructing a Categorical with a dtype and values containing"
+        with tm.assert_produces_warning(
+            Pandas4Warning, match=msg, check_stacklevel=False
+        ):
+            result = parser.read_csv(StringIO(data), dtype=dtype)
+        tm.assert_series_equal(
+            result["b"].isna(), pd.Series([True, True, True], name="b")
+        )
+    else:
+        result = parser.read_csv(StringIO(data), dtype=dtype)
+        tm.assert_frame_equal(result, expected)
 
 
 def test_categorical_coerces_timestamp(all_parsers):
@@ -291,8 +302,16 @@ def test_categorical_coerces_timestamp(all_parsers):
     data = "b\n2014-01-01\n2014-01-01"
     expected = DataFrame({"b": Categorical([Timestamp("2014")] * 2)})
 
-    result = parser.read_csv(StringIO(data), dtype=dtype)
-    tm.assert_frame_equal(result, expected)
+    if parser.engine == "pyarrow":
+        msg = "Constructing a Categorical with a dtype and values containing"
+        with tm.assert_produces_warning(
+            Pandas4Warning, match=msg, check_stacklevel=False
+        ):
+            result = parser.read_csv(StringIO(data), dtype=dtype)
+        tm.assert_series_equal(result["b"].isna(), pd.Series([True, True], name="b"))
+    else:
+        result = parser.read_csv(StringIO(data), dtype=dtype)
+        tm.assert_frame_equal(result, expected)
 
 
 def test_categorical_coerces_timedelta(all_parsers):

pandas/tests/series/test_arithmetic.py

@@ -840,6 +840,7 @@ def test_datetime_understood(self, unit):
         tm.assert_series_equal(result, expected)
 
     def test_align_date_objects_with_datetimeindex(self):
+        # GH#62158: datetime.date objects no longer auto-align with Timestamps
         rng = date_range("1/1/2000", periods=20)
         ts = Series(np.random.default_rng(2).standard_normal(20), index=rng)
 
@@ -849,10 +850,11 @@ def test_align_date_objects_with_datetimeindex(self):
 
         result = ts + ts2
         result2 = ts2 + ts
-        expected = ts + ts[5:]
-        expected.index = expected.index._with_freq(None)
+        expected = Series(dtype=float, index=result.index)
+        expected2 = Series(dtype=float, index=result2.index)
+
         tm.assert_series_equal(result, expected)
-        tm.assert_series_equal(result2, expected)
+        tm.assert_series_equal(result2, expected2)
 
 
 class TestNamePreservation: