From 47288e9e6e1e5f829e920623d2cdb977256833bf Mon Sep 17 00:00:00 2001
From: Brock <jbrockmendel@gmail.com>
Date: Wed, 12 Oct 2022 09:38:36 -0700
Subject: [PATCH 1/5] API: retain non-nano dtype in DatetimeArray constructor

---
 pandas/_libs/tslibs/__init__.py               |  4 ++
 pandas/core/arrays/datetimes.py               | 58 ++++++++++++++-----
 pandas/core/dtypes/cast.py                    |  3 +
 pandas/tests/arrays/test_array.py             |  4 +-
 pandas/tests/base/test_constructors.py        | 11 ++--
 .../frame/constructors/test_from_records.py   |  1 +
 pandas/tests/frame/indexing/test_setitem.py   | 15 +++--
 pandas/tests/frame/methods/test_astype.py     |  5 +-
 pandas/tests/frame/test_block_internals.py    |  4 +-
 .../indexes/datetimes/test_constructors.py    |  6 +-
 pandas/tests/reshape/merge/test_merge.py      | 16 ++++-
 pandas/tests/series/test_constructors.py      | 55 +++++++++++++-----
 pandas/tests/tools/test_to_datetime.py        | 10 +++-
 pandas/tests/tslibs/test_api.py               |  2 +
 pandas/tests/window/test_online.py            |  2 +-
 15 files changed, 147 insertions(+), 49 deletions(-)

diff --git a/pandas/_libs/tslibs/__init__.py b/pandas/_libs/tslibs/__init__.py
index 47143b32d6dbe..42f84619ddbe5 100644
--- a/pandas/_libs/tslibs/__init__.py
+++ b/pandas/_libs/tslibs/__init__.py
@@ -31,13 +31,17 @@
     "periods_per_day",
     "periods_per_second",
     "is_supported_unit",
+    "npy_unit_to_abbrev",
+    "get_supported_reso",
 ]
 
 from pandas._libs.tslibs import dtypes
 from pandas._libs.tslibs.conversion import localize_pydatetime
 from pandas._libs.tslibs.dtypes import (
     Resolution,
+    get_supported_reso,
     is_supported_unit,
+    npy_unit_to_abbrev,
     periods_per_day,
     periods_per_second,
 )
diff --git a/pandas/core/arrays/datetimes.py b/pandas/core/arrays/datetimes.py
index 79e8d2d90ab1e..4c11f78f864ea 100644
--- a/pandas/core/arrays/datetimes.py
+++ b/pandas/core/arrays/datetimes.py
@@ -30,12 +30,14 @@
     astype_overflowsafe,
     fields,
     get_resolution,
+    get_supported_reso,
     get_unit_from_dtype,
     ints_to_pydatetime,
     is_date_array_normalized,
     is_supported_unit,
     is_unitless,
     normalize_i8_timestamps,
+    npy_unit_to_abbrev,
     timezones,
     to_offset,
     tz_convert_from_utc,
@@ -322,6 +324,14 @@ def _from_sequence_not_strict(
         # if dtype has an embedded tz, capture it
         tz = validate_tz_from_dtype(dtype, tz, explicit_tz_none)
 
+        unit = None
+        if dtype is not None:
+            if isinstance(dtype, np.dtype):
+                unit = np.datetime_data(dtype)[0]
+            else:
+                # DatetimeTZDtype
+                unit = dtype.unit
+
         subarr, tz, inferred_freq = _sequence_to_dt64ns(
             data,
             copy=copy,
@@ -342,8 +352,12 @@ def _from_sequence_not_strict(
         if explicit_none:
             freq = None
 
-        dtype = tz_to_dtype(tz)
-        result = cls._simple_new(subarr, freq=freq, dtype=dtype)
+        data_unit = np.datetime_data(subarr.dtype)[0]
+        data_dtype = tz_to_dtype(tz, data_unit)
+        result = cls._simple_new(subarr, freq=freq, dtype=data_dtype)
+        if unit is not None and unit != result._unit:
+            # If unit was specified in user-passed dtype, cast to it here
+            result = result._as_unit(unit)
 
         if inferred_freq is None and freq is not None:
             # this condition precludes `freq_infer`
@@ -2005,7 +2019,8 @@ def sequence_to_datetimes(data, require_iso8601: bool = False) -> DatetimeArray:
         require_iso8601=require_iso8601,
     )
 
-    dtype = tz_to_dtype(tz)
+    unit = np.datetime_data(result.dtype)[0]
+    dtype = tz_to_dtype(tz, unit)
     dta = DatetimeArray._simple_new(result, freq=freq, dtype=dtype)
     return dta
 
@@ -2111,8 +2126,21 @@ def _sequence_to_dt64ns(
     elif is_datetime64_dtype(data_dtype):
         # tz-naive DatetimeArray or ndarray[datetime64]
         data = getattr(data, "_ndarray", data)
-        if data.dtype != DT64NS_DTYPE:
-            data = astype_overflowsafe(data, dtype=DT64NS_DTYPE)
+        new_dtype = data.dtype
+        data_unit = get_unit_from_dtype(new_dtype)
+        if not is_supported_unit(data_unit):
+            # Cast to the nearest supported unit, generally "s"
+            new_reso = get_supported_reso(data_unit)
+            new_unit = npy_unit_to_abbrev(new_reso)
+            new_dtype = np.dtype(f"M8[{new_unit}]")
+            data = astype_overflowsafe(data, dtype=new_dtype, copy=False)
+            copy = False
+
+        if data.dtype.byteorder == ">":
+            # TODO: better way to handle this?  non-copying alternative?
+            #  without this, test_constructor_datetime64_bigendian fails
+            data = data.astype(data.dtype.newbyteorder("<"))
+            new_dtype = data.dtype
             copy = False
 
         if tz is not None:
@@ -2120,11 +2148,11 @@ def _sequence_to_dt64ns(
             # TODO: if tz is UTC, are there situations where we *don't* want a
             #  copy?  tz_localize_to_utc always makes one.
             data = tzconversion.tz_localize_to_utc(
-                data.view("i8"), tz, ambiguous=ambiguous
+                data.view("i8"), tz, ambiguous=ambiguous, reso=data_unit
             )
-            data = data.view(DT64NS_DTYPE)
+            data = data.view(new_dtype)
 
-        assert data.dtype == DT64NS_DTYPE, data.dtype
+        assert data.dtype == new_dtype, data.dtype
         result = data
 
     else:
@@ -2138,7 +2166,9 @@ def _sequence_to_dt64ns(
         result = result.copy()
 
     assert isinstance(result, np.ndarray), type(result)
-    assert result.dtype == "M8[ns]", result.dtype
+    assert result.dtype.kind == "M"
+    assert result.dtype != "M8"
+    assert is_supported_unit(get_unit_from_dtype(result.dtype))
     return result, tz, inferred_freq
 
 
@@ -2359,12 +2389,14 @@ def _validate_dt64_dtype(dtype):
             )
             raise ValueError(msg)
 
-        if (isinstance(dtype, np.dtype) and dtype != DT64NS_DTYPE) or not isinstance(
-            dtype, (np.dtype, DatetimeTZDtype)
-        ):
+        if (
+            isinstance(dtype, np.dtype)
+            and (dtype.kind != "M" or not is_supported_unit(get_unit_from_dtype(dtype)))
+        ) or not isinstance(dtype, (np.dtype, DatetimeTZDtype)):
             raise ValueError(
                 f"Unexpected value for 'dtype': '{dtype}'. "
-                "Must be 'datetime64[ns]' or DatetimeTZDtype'."
+                "Must be 'datetime64[s]', 'datetime64[ms]', 'datetime64[us]', "
+                "'datetime64[ns]' or DatetimeTZDtype'."
             )
 
         if getattr(dtype, "tz", None):
diff --git a/pandas/core/dtypes/cast.py b/pandas/core/dtypes/cast.py
index 6b890f98e8cac..dd57ee72912e2 100644
--- a/pandas/core/dtypes/cast.py
+++ b/pandas/core/dtypes/cast.py
@@ -1370,6 +1370,9 @@ def maybe_cast_to_datetime(
                             # Note: NOT equivalent to dta.astype(dtype)
                             dta = dta.tz_localize(None)
 
+                        # TODO(2.0): Do this astype in sequence_to_datetimes to
+                        #  avoid potential extra copy?
+                        dta = dta.astype(dtype, copy=False)
                         value = dta
                     elif is_datetime64tz:
                         dtype = cast(DatetimeTZDtype, dtype)
diff --git a/pandas/tests/arrays/test_array.py b/pandas/tests/arrays/test_array.py
index 6666b613fb50a..7c813d7e129d4 100644
--- a/pandas/tests/arrays/test_array.py
+++ b/pandas/tests/arrays/test_array.py
@@ -242,7 +242,9 @@ def test_array_copy():
         ),
         (
             np.array([1, 2], dtype="M8[us]"),
-            DatetimeArray(np.array([1000, 2000], dtype="M8[ns]")),
+            DatetimeArray._simple_new(
+                np.array([1, 2], dtype="M8[us]"), dtype=np.dtype("M8[us]")
+            ),
         ),
         # datetimetz
         (
diff --git a/pandas/tests/base/test_constructors.py b/pandas/tests/base/test_constructors.py
index f66ebc451c239..c8b923031b9e8 100644
--- a/pandas/tests/base/test_constructors.py
+++ b/pandas/tests/base/test_constructors.py
@@ -146,9 +146,9 @@ def test_constructor_datetime_outofbound(self, a, constructor):
         # datetime64[non-ns] raise error, other cases result in object dtype
         # and preserve original data
         if a.dtype.kind == "M":
-            msg = "Out of bounds"
-            with pytest.raises(pd.errors.OutOfBoundsDatetime, match=msg):
-                constructor(a)
+            # Can't fit in nanosecond bounds -> get the nearest supported unit
+            result = constructor(a)
+            assert result.dtype == "M8[s]"
         else:
             result = constructor(a)
             assert result.dtype == "object"
@@ -162,7 +162,10 @@ def test_constructor_datetime_outofbound(self, a, constructor):
 
     def test_constructor_datetime_nonns(self, constructor):
         arr = np.array(["2020-01-01T00:00:00.000000"], dtype="datetime64[us]")
-        expected = constructor(pd.to_datetime(["2020-01-01"]))
+        dta = pd.core.arrays.DatetimeArray._simple_new(arr, dtype=arr.dtype)
+        expected = constructor(dta)
+        assert expected.dtype == arr.dtype
+
         result = constructor(arr)
         tm.assert_equal(result, expected)
 
diff --git a/pandas/tests/frame/constructors/test_from_records.py b/pandas/tests/frame/constructors/test_from_records.py
index 3b5a0c5a32bc4..b2efa0713b513 100644
--- a/pandas/tests/frame/constructors/test_from_records.py
+++ b/pandas/tests/frame/constructors/test_from_records.py
@@ -44,6 +44,7 @@ def test_from_records_with_datetimes(self):
         dtypes = [("EXPIRY", "<M8[m]")]
         recarray = np.core.records.fromarrays(arrdata, dtype=dtypes)
         result = DataFrame.from_records(recarray)
+        expected["EXPIRY"] = expected["EXPIRY"].astype("M8[m]")
         tm.assert_frame_equal(result, expected)
 
     def test_from_records_sequencelike(self):
diff --git a/pandas/tests/frame/indexing/test_setitem.py b/pandas/tests/frame/indexing/test_setitem.py
index c30ffcf9a7e5b..72b29fb8e715c 100644
--- a/pandas/tests/frame/indexing/test_setitem.py
+++ b/pandas/tests/frame/indexing/test_setitem.py
@@ -277,11 +277,11 @@ def test_setitem_dt64_ndarray_with_NaT_and_diff_time_units(self):
         expected = DataFrame({0: [1, None], "new": [1, None]}, dtype="datetime64[ns]")
         tm.assert_frame_equal(result, expected)
 
-        # OutOfBoundsDatetime error shouldn't occur
+        # OutOfBoundsDatetime error shouldn't occur; as of 2.0 we preserve "M8[s]"
         data_s = np.array([1, "nat"], dtype="datetime64[s]")
         result["new"] = data_s
-        expected = DataFrame({0: [1, None], "new": [1e9, None]}, dtype="datetime64[ns]")
-        tm.assert_frame_equal(result, expected)
+        tm.assert_series_equal(result[0], expected[0])
+        tm.assert_numpy_array_equal(result["new"].to_numpy(), data_s)
 
     @pytest.mark.parametrize("unit", ["h", "m", "s", "ms", "D", "M", "Y"])
     def test_frame_setitem_datetime64_col_other_units(self, unit):
@@ -291,12 +291,17 @@ def test_frame_setitem_datetime64_col_other_units(self, unit):
 
         dtype = np.dtype(f"M8[{unit}]")
         vals = np.arange(n, dtype=np.int64).view(dtype)
-        ex_vals = vals.astype("datetime64[ns]")
+        if unit in ["s", "ms"]:
+            # supported unit
+            ex_vals = vals
+        else:
+            # we get the nearest supported units, i.e. "s"
+            ex_vals = vals.astype("datetime64[s]")
 
         df = DataFrame({"ints": np.arange(n)}, index=np.arange(n))
         df[unit] = vals
 
-        assert df[unit].dtype == np.dtype("M8[ns]")
+        assert df[unit].dtype == ex_vals.dtype
         assert (df[unit].values == ex_vals).all()
 
     @pytest.mark.parametrize("unit", ["h", "m", "s", "ms", "D", "M", "Y"])
diff --git a/pandas/tests/frame/methods/test_astype.py b/pandas/tests/frame/methods/test_astype.py
index 28c264d5c7335..bcd77b6cfeab2 100644
--- a/pandas/tests/frame/methods/test_astype.py
+++ b/pandas/tests/frame/methods/test_astype.py
@@ -424,9 +424,8 @@ def test_astype_to_datetime_unit(self, unit):
             # GH#48928
             exp_dtype = dtype
         else:
-            # TODO(2.0): use the nearest supported dtype (i.e. M8[s]) instead
-            #  of nanos
-            exp_dtype = "M8[ns]"
+            # we use the nearest supported dtype (i.e. M8[s])
+            exp_dtype = "M8[s]"
         # TODO(2.0): once DataFrame constructor doesn't cast ndarray inputs.
         #  can simplify this
         exp_values = arr.astype(exp_dtype)
diff --git a/pandas/tests/frame/test_block_internals.py b/pandas/tests/frame/test_block_internals.py
index 46c712cf4d458..14e28624aac1b 100644
--- a/pandas/tests/frame/test_block_internals.py
+++ b/pandas/tests/frame/test_block_internals.py
@@ -227,11 +227,13 @@ def test_construction_with_conversions(self):
         expected = DataFrame(
             {
                 "dt1": Timestamp("20130101"),
-                "dt2": date_range("20130101", periods=3),
+                "dt2": date_range("20130101", periods=3).astype("M8[s]"),
                 # 'dt3' : date_range('20130101 00:00:01',periods=3,freq='s'),
             },
             index=range(3),
         )
+        assert expected.dtypes["dt1"] == "M8[ns]"
+        assert expected.dtypes["dt2"] == "M8[s]"
 
         df = DataFrame(index=range(3))
         df["dt1"] = np.datetime64("2013-01-01")
diff --git a/pandas/tests/indexes/datetimes/test_constructors.py b/pandas/tests/indexes/datetimes/test_constructors.py
index 907456e04300f..9914f4357cee4 100644
--- a/pandas/tests/indexes/datetimes/test_constructors.py
+++ b/pandas/tests/indexes/datetimes/test_constructors.py
@@ -913,9 +913,9 @@ def test_constructor_no_precision_raises(self):
             Index(["2000"], dtype="datetime64")
 
     def test_constructor_wrong_precision_raises(self):
-        msg = "Unexpected value for 'dtype': 'datetime64\\[us\\]'"
-        with pytest.raises(ValueError, match=msg):
-            DatetimeIndex(["2000"], dtype="datetime64[us]")
+        dti = DatetimeIndex(["2000"], dtype="datetime64[us]")
+        assert dti.dtype == "M8[us]"
+        assert dti[0] == Timestamp(2000, 1, 1)
 
     def test_index_constructor_with_numpy_object_array_and_timestamp_tz_with_nan(self):
         # GH 27011
diff --git a/pandas/tests/reshape/merge/test_merge.py b/pandas/tests/reshape/merge/test_merge.py
index 5cc6879f9660f..f309cf4f11382 100644
--- a/pandas/tests/reshape/merge/test_merge.py
+++ b/pandas/tests/reshape/merge/test_merge.py
@@ -731,18 +731,28 @@ def test_other_datetime_unit(self, unit):
 
         dtype = f"datetime64[{unit}]"
         df2 = ser.astype(dtype).to_frame("days")
-        # coerces to datetime64[ns], thus should not be affected
-        assert df2["days"].dtype == "datetime64[ns]"
+
+        if unit in ["D", "h", "m"]:
+            # not supported so we cast to the nearest supported unit, seconds
+            # TODO(2.0): cast to nearest (second) instead of ns
+            # coerces to datetime64[ns], thus should not be affected
+            exp_dtype = "datetime64[s]"
+        else:
+            exp_dtype = dtype
+        assert df2["days"].dtype == exp_dtype
 
         result = df1.merge(df2, left_on="entity_id", right_index=True)
 
+        days = np.array(["nat", "nat"], dtype=exp_dtype)
+        days = pd.core.arrays.DatetimeArray._simple_new(days, dtype=days.dtype)
         exp = DataFrame(
             {
                 "entity_id": [101, 102],
-                "days": np.array(["nat", "nat"], dtype="datetime64[ns]"),
+                "days": days,
             },
             columns=["entity_id", "days"],
         )
+        assert exp["days"].dtype == exp_dtype
         tm.assert_frame_equal(result, exp)
 
     @pytest.mark.parametrize("unit", ["D", "h", "m", "s", "ms", "us", "ns"])
diff --git a/pandas/tests/series/test_constructors.py b/pandas/tests/series/test_constructors.py
index a33912178bfd6..3690567b1a21f 100644
--- a/pandas/tests/series/test_constructors.py
+++ b/pandas/tests/series/test_constructors.py
@@ -919,6 +919,10 @@ def test_constructor_dtype_datetime64(self):
         assert isna(s[1])
         assert s.dtype == "M8[ns]"
 
+    @pytest.mark.xfail(
+        reason="Series(dates, dtype='M8[ms]') does not yet respect non-nano "
+        "dtype keyword"
+    )
     def test_constructor_dtype_datetime64_10(self):
         # GH3416
         pydates = [datetime(2013, 1, 1), datetime(2013, 1, 2), datetime(2013, 1, 3)]
@@ -931,15 +935,12 @@ def test_constructor_dtype_datetime64_10(self):
         assert ser.dtype == "M8[ns]"
 
         # GH3414 related
-        expected = Series(
-            pydates,
-            dtype="datetime64[ns]",
-        )
+        expected = Series(pydates, dtype="datetime64[ms]")
 
         result = Series(Series(dates).view(np.int64) / 1000000, dtype="M8[ms]")
         tm.assert_series_equal(result, expected)
 
-        result = Series(dates, dtype="datetime64[ns]")
+        result = Series(dates, dtype="datetime64[ms]")
         tm.assert_series_equal(result, expected)
 
         expected = Series(
@@ -990,10 +991,15 @@ def test_constructor_dtype_datetime64_7(self):
         values2 = dates.view(np.ndarray).astype("datetime64[ns]")
         expected = Series(values2, index=dates)
 
-        for dtype in ["s", "D", "ms", "us", "ns"]:
-            values1 = dates.view(np.ndarray).astype(f"M8[{dtype}]")
+        for unit in ["s", "D", "ms", "us", "ns"]:
+            dtype = np.dtype(f"M8[{unit}]")
+            values1 = dates.view(np.ndarray).astype(dtype)
             result = Series(values1, dates)
-            tm.assert_series_equal(result, expected)
+            if unit == "D":
+                # for unit="D" we cast to nearest-supported reso, i.e. "s"
+                dtype = np.dtype("M8[s]")
+            assert result.dtype == dtype
+            tm.assert_series_equal(result, expected.astype(dtype))
 
         # GH 13876
         # coerce to non-ns to object properly
@@ -1160,9 +1166,25 @@ def test_construction_to_datetimelike_unit(self, arr_dtype, kind, unit):
         # TODO: GH#19223 was about .astype, doesn't belong here
         dtype = f"{kind}8[{unit}]"
         arr = np.array([1, 2, 3], dtype=arr_dtype)
-        s = Series(arr)
-        result = s.astype(dtype)
-        expected = Series(arr.astype(dtype))
+        ser = Series(arr)
+        result = ser.astype(dtype)
+
+        if kind == "M":
+            if unit in ["ns", "us", "ms", "s"]:
+                exp_dtype = np.dtype(f"M8[{unit}]")
+            else:
+                exp_dtype = np.dtype("M8[s]")
+            exp_values = arr.astype(dtype).astype(exp_dtype)
+            # For now Series will cast to ns if we pass an ndarray, so we need
+            #  to pass specifically a DTA
+            dta = type(result._values)._simple_new(exp_values, dtype=exp_values.dtype)
+            expected = Series(dta)
+
+            # check that the constructor is doing what we expect
+            tm.assert_numpy_array_equal(np.asarray(expected), exp_values)
+        else:
+            # haven't (yet) updated the TimedeltaArray construction
+            expected = Series(arr.astype(dtype).astype("m8[ns]"))
 
         tm.assert_series_equal(result, expected)
 
@@ -1179,7 +1201,8 @@ def test_constructor_datetime64_bigendian(self):
         arr = np.array([np.datetime64(1, "ms")], dtype=">M8[ms]")
 
         result = Series(arr)
-        expected = Series([Timestamp(ms)])
+        expected = Series([Timestamp(ms)]).astype("M8[ms]")
+        assert expected.dtype == "M8[ms]"
         tm.assert_series_equal(result, expected)
 
     @pytest.mark.parametrize("interval_constructor", [IntervalIndex, IntervalArray])
@@ -1570,7 +1593,8 @@ def test_convert_non_ns(self):
             ["2013-01-01", "2013-01-02", "2013-01-03"], dtype="datetime64[D]"
         )
         ser = Series(arr)
-        expected = Series(date_range("20130101", periods=3, freq="D"))
+        expected = Series(date_range("20130101", periods=3, freq="D"), dtype="M8[s]")
+        assert expected.dtype == "M8[s]"
         tm.assert_series_equal(ser, expected)
 
         arr = np.array(
@@ -1578,7 +1602,10 @@ def test_convert_non_ns(self):
             dtype="datetime64[s]",
         )
         ser = Series(arr)
-        expected = Series(date_range("20130101 00:00:01", periods=3, freq="s"))
+        expected = Series(
+            date_range("20130101 00:00:01", periods=3, freq="s"), dtype="M8[s]"
+        )
+        assert expected.dtype == "M8[s]"
         tm.assert_series_equal(ser, expected)
 
     @pytest.mark.parametrize(
diff --git a/pandas/tests/tools/test_to_datetime.py b/pandas/tests/tools/test_to_datetime.py
index 3d59e115d4cf9..8a4f2d47899e6 100644
--- a/pandas/tests/tools/test_to_datetime.py
+++ b/pandas/tests/tools/test_to_datetime.py
@@ -1970,7 +1970,15 @@ def test_dti_constructor_numpy_timeunits(self, cache, dtype):
 
         values = base.values.astype(dtype)
 
-        tm.assert_index_equal(DatetimeIndex(values), base)
+        unit = dtype.split("[")[-1][:-1]
+        if unit in ["h", "m"]:
+            # we cast to closest supported unit
+            unit = "s"
+        exp_dtype = np.dtype(f"M8[{unit}]")
+        expected = DatetimeIndex(base.astype(exp_dtype))
+        assert expected.dtype == exp_dtype
+
+        tm.assert_index_equal(DatetimeIndex(values), expected)
         tm.assert_index_equal(to_datetime(values, cache=cache), base)
 
     def test_dayfirst(self, cache):
diff --git a/pandas/tests/tslibs/test_api.py b/pandas/tests/tslibs/test_api.py
index 2d195fad83644..264662a7e93cd 100644
--- a/pandas/tests/tslibs/test_api.py
+++ b/pandas/tests/tslibs/test_api.py
@@ -56,6 +56,8 @@ def test_namespace():
         "periods_per_day",
         "periods_per_second",
         "is_supported_unit",
+        "get_supported_reso",
+        "npy_unit_to_abbrev",
     ]
 
     expected = set(submodules + api)
diff --git a/pandas/tests/window/test_online.py b/pandas/tests/window/test_online.py
index 8e632cf53fd9f..875adf6cef4ac 100644
--- a/pandas/tests/window/test_online.py
+++ b/pandas/tests/window/test_online.py
@@ -71,7 +71,7 @@ def test_update_times_mean(
         times = Series(
             np.array(
                 ["2020-01-01", "2020-01-05", "2020-01-07", "2020-01-17", "2020-01-21"],
-                dtype="datetime64",
+                dtype="datetime64[ns]",
             )
         )
         expected = obj.ewm(

From 375be1a903be5560f62db1d23adfac7857494156 Mon Sep 17 00:00:00 2001
From: Brock <jbrockmendel@gmail.com>
Date: Wed, 12 Oct 2022 13:53:56 -0700
Subject: [PATCH 2/5] update test

---
 pandas/tests/tools/test_to_datetime.py | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/pandas/tests/tools/test_to_datetime.py b/pandas/tests/tools/test_to_datetime.py
index f9ed98c0bc88d..4ef78e100cc2f 100644
--- a/pandas/tests/tools/test_to_datetime.py
+++ b/pandas/tests/tools/test_to_datetime.py
@@ -717,10 +717,9 @@ def test_to_datetime_array_of_dt64s(self, cache, unit):
         ] * 30
         # Assuming all datetimes are in bounds, to_datetime() returns
         # an array that is equal to Timestamp() parsing
-        tm.assert_index_equal(
-            to_datetime(dts, cache=cache),
-            DatetimeIndex([Timestamp(x).asm8 for x in dts]),
-        )
+        result = to_datetime(dts, cache=cache)
+        expected = DatetimeIndex([Timestamp(x).asm8 for x in dts], dtype="M8[ns]")
+        tm.assert_index_equal(result, expected)
 
         # A list of datetimes where the last one is out of bounds
         dts_with_oob = dts + [np.datetime64("9999-01-01")]

From 975bf48d6d2494d2b837e8fd1516b12a46aa550c Mon Sep 17 00:00:00 2001
From: Brock <jbrockmendel@gmail.com>
Date: Wed, 12 Oct 2022 17:56:50 -0700
Subject: [PATCH 3/5] un-xfail

---
 pandas/tests/series/methods/test_isin.py | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/pandas/tests/series/methods/test_isin.py b/pandas/tests/series/methods/test_isin.py
index 0eca3e0512849..449724508fcaa 100644
--- a/pandas/tests/series/methods/test_isin.py
+++ b/pandas/tests/series/methods/test_isin.py
@@ -57,10 +57,6 @@ def test_isin_datetimelike_mismatched_reso(self):
         result = ser.isin(dta)
         tm.assert_series_equal(result, expected)
 
-    @pytest.mark.xfail(
-        reason="DTA._from_sequence incorrectly treats Timestamp[s].value as "
-        "nanoseconds."
-    )
     def test_isin_datetimelike_mismatched_reso_list(self):
         expected = Series([True, True, False, False, False])
 

From 1ed2caeec5cd5b9d7f52ca0617404725730a8447 Mon Sep 17 00:00:00 2001
From: Brock <jbrockmendel@gmail.com>
Date: Wed, 12 Oct 2022 20:13:32 -0700
Subject: [PATCH 4/5] un-xfail

---
 pandas/tests/arrays/categorical/test_constructors.py | 9 ---------
 1 file changed, 9 deletions(-)

diff --git a/pandas/tests/arrays/categorical/test_constructors.py b/pandas/tests/arrays/categorical/test_constructors.py
index 633a763dab80a..d11f4648ec632 100644
--- a/pandas/tests/arrays/categorical/test_constructors.py
+++ b/pandas/tests/arrays/categorical/test_constructors.py
@@ -6,11 +6,6 @@
 import numpy as np
 import pytest
 
-from pandas.compat import (
-    IS64,
-    is_platform_windows,
-)
-
 from pandas.core.dtypes.common import (
     is_float_dtype,
     is_integer_dtype,
@@ -749,10 +744,6 @@ def test_from_sequence_copy(self):
 
         assert not tm.shares_memory(result, cat)
 
-    @pytest.mark.xfail(
-        not IS64 or is_platform_windows(),
-        reason="Incorrectly raising in astype_overflowsafe",
-    )
     def test_constructor_datetime64_non_nano(self):
         categories = np.arange(10).view("M8[D]")
         values = categories[::2].copy()

From d7257846563e6b3dedd2e4b4f0e85404b6d0fbdc Mon Sep 17 00:00:00 2001
From: Brock <jbrockmendel@gmail.com>
Date: Fri, 14 Oct 2022 18:39:45 -0700
Subject: [PATCH 5/5] un-xfail

---
 pandas/tests/series/test_constructors.py | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/pandas/tests/series/test_constructors.py b/pandas/tests/series/test_constructors.py
index 4c0501f721191..d05eccae922aa 100644
--- a/pandas/tests/series/test_constructors.py
+++ b/pandas/tests/series/test_constructors.py
@@ -925,10 +925,6 @@ def test_constructor_dtype_datetime64(self):
         assert isna(s[1])
         assert s.dtype == "M8[ns]"
 
-    @pytest.mark.xfail(
-        reason="Series(dates, dtype='M8[ms]') does not yet respect non-nano "
-        "dtype keyword"
-    )
     def test_constructor_dtype_datetime64_10(self):
         # GH3416
         pydates = [datetime(2013, 1, 1), datetime(2013, 1, 2), datetime(2013, 1, 3)]