update tests

Author: jbrockmendel

pandas/conftest.py

@@ -936,7 +936,7 @@ def rand_series_with_duplicate_datetimeindex() -> Series:
         (Period("2012-01", freq="M"), "period[M]"),
         (Period("2012-02-01", freq="D"), "period[D]"),
         (
-            Timestamp("2011-01-01", tz="US/Eastern"),
+            Timestamp("2011-01-01", tz="US/Eastern").as_unit("s"),
             DatetimeTZDtype(unit="s", tz="US/Eastern"),
         ),
         (Timedelta(seconds=500), "timedelta64[ns]"),

pandas/tests/arrays/test_array.py

@@ -127,7 +127,7 @@ def test_dt64_array(dtype_unit):
         (
             pd.DatetimeIndex(["2000", "2001"]),
             None,
-            DatetimeArray._from_sequence(["2000", "2001"], dtype="M8[s]"),
+            DatetimeArray._from_sequence(["2000", "2001"], dtype="M8[us]"),
         ),
         (
             ["2000", "2001"],
@@ -323,7 +323,7 @@ def test_array_copy():
         ([pd.Interval(0, 1), pd.Interval(1, 2)], IntervalArray.from_breaks([0, 1, 2])),
         # datetime
         (
-            [pd.Timestamp("2000"), pd.Timestamp("2001")],
+            [pd.Timestamp("2000").as_unit("s"), pd.Timestamp("2001").as_unit("s")],
             DatetimeArray._from_sequence(["2000", "2001"], dtype="M8[s]"),
         ),
         (
@@ -342,7 +342,10 @@ def test_array_copy():
         ),
         # datetimetz
         (
-            [pd.Timestamp("2000", tz="CET"), pd.Timestamp("2001", tz="CET")],
+            [
+                pd.Timestamp("2000", tz="CET").as_unit("s"),
+                pd.Timestamp("2001", tz="CET").as_unit("s"),
+            ],
             DatetimeArray._from_sequence(
                 ["2000", "2001"], dtype=pd.DatetimeTZDtype(tz="CET", unit="s")
             ),

pandas/tests/extension/test_arrow.py

@@ -3470,9 +3470,9 @@ def test_string_to_datetime_parsing_cast():
     # GH 56266
     string_dates = ["2020-01-01 04:30:00", "2020-01-02 00:00:00", "2020-01-03 00:00:00"]
     result = pd.Series(string_dates, dtype="timestamp[s][pyarrow]")
-    expected = pd.Series(
-        ArrowExtensionArray(pa.array(pd.to_datetime(string_dates), from_pandas=True))
-    )
+
+    pd_res = pd.to_datetime(string_dates).as_unit("s")
+    expected = pd.Series(ArrowExtensionArray(pa.array(pd_res, from_pandas=True)))
     tm.assert_series_equal(result, expected)
 
 

pandas/tests/frame/methods/test_get_numeric_data.py

@@ -25,7 +25,7 @@ def test_get_numeric_data(self, using_infer_string):
         objectname = np.dtype(np.object_).name
 
         df = DataFrame(
-            {"a": 1.0, "b": 2, "c": "foo", "f": Timestamp("20010102")},
+            {"a": 1.0, "b": 2, "c": "foo", "f": Timestamp("20010102").as_unit("s")},
             index=np.arange(10),
         )
         result = df.dtypes

pandas/tests/frame/methods/test_to_csv.py

@@ -50,7 +50,7 @@ def test_to_csv_from_csv1_datetime(self, temp_file, datetime_frame):
         datetime_frame.to_csv(path)
         recons = self.read_csv(path, parse_dates=True)
         expected = datetime_frame.copy()
-        expected.index = expected.index.as_unit("s")
+        expected.index = expected.index.as_unit("us")
         tm.assert_frame_equal(expected, recons)
 
         datetime_frame.to_csv(path, index_label="index")
@@ -240,8 +240,8 @@ def make_dtnat_arr(n, nnat=None):
         result = self.read_csv(path).apply(to_datetime)
 
         expected = df[:]
-        expected["a"] = expected["a"].astype("M8[s]")
-        expected["b"] = expected["b"].astype("M8[s]")
+        expected["a"] = expected["a"].astype("M8[us]")
+        expected["b"] = expected["b"].astype("M8[us]")
         tm.assert_frame_equal(result, expected, check_names=False)
 
     def _return_result_expected(
@@ -585,7 +585,7 @@ def test_to_csv_multiindex(self, temp_file, float_frame, datetime_frame):
 
         # TODO to_csv drops column name
         expected = tsframe.copy()
-        expected.index = MultiIndex.from_arrays([old_index.as_unit("s"), new_index[1]])
+        expected.index = MultiIndex.from_arrays([old_index.as_unit("us"), new_index[1]])
         tm.assert_frame_equal(recons, expected, check_names=False)
 
         # do not load index

pandas/tests/frame/methods/test_to_numpy.py

@@ -55,11 +55,15 @@ def test_to_numpy_datetime_with_na(self):
 
         df = DataFrame(
             {
-                "a": [Timestamp("1970-01-01"), Timestamp("1970-01-02"), NaT],
+                "a": [
+                    Timestamp("1970-01-01").as_unit("s"),
+                    Timestamp("1970-01-02").as_unit("s"),
+                    NaT,
+                ],
                 "b": [
-                    Timestamp("1970-01-01"),
+                    Timestamp("1970-01-01").as_unit("s"),
                     np.nan,
-                    Timestamp("1970-01-02"),
+                    Timestamp("1970-01-02").as_unit("s"),
                 ],
                 "c": [
                     1,

pandas/tests/frame/test_block_internals.py

@@ -194,7 +194,7 @@ def test_construction_with_conversions(self):
 
         expected = DataFrame(
             {
-                "dt1": Timestamp("20130101"),
+                "dt1": Timestamp("20130101").as_unit("s"),
                 "dt2": date_range("20130101", periods=3).astype("M8[s]"),
                 # 'dt3' : date_range('20130101 00:00:01',periods=3,freq='s'),
                 # FIXME: don't leave commented-out

pandas/tests/frame/test_constructors.py

@@ -879,9 +879,10 @@ def create_data(constructor):
         )
 
         result_datetime64 = DataFrame(data_datetime64)
+        assert result_datetime64.index.unit == "s"
+        result_datetime64.index = result_datetime64.index.as_unit("us")
         result_datetime = DataFrame(data_datetime)
         assert result_datetime.index.unit == "us"
-        result_datetime.index = result_datetime.index.as_unit("s")
         result_Timestamp = DataFrame(data_Timestamp)
         tm.assert_frame_equal(result_datetime64, expected)
         tm.assert_frame_equal(result_datetime, expected)
@@ -944,7 +945,7 @@ def test_constructor_dict_extension_scalar(self, ea_scalar_and_dtype):
             (Period("2020-01"), PeriodDtype("M")),
             (Interval(left=0, right=5), IntervalDtype("int64", "right")),
             (
-                Timestamp("2011-01-01", tz="US/Eastern"),
+                Timestamp("2011-01-01", tz="US/Eastern").as_unit("s"),
                 DatetimeTZDtype(unit="s", tz="US/Eastern"),
             ),
         ],
@@ -1849,7 +1850,7 @@ def test_constructor_with_datetimes(self, using_infer_string):
                 "A": 1,
                 "B": "foo",
                 "C": "bar",
-                "D": Timestamp("20010101"),
+                "D": Timestamp("20010101").as_unit("s"),
                 "E": datetime(2001, 1, 2, 0, 0),
             },
             index=np.arange(10),
@@ -3076,9 +3077,9 @@ def test_from_tzaware_mixed_object_array(self):
         res = DataFrame(arr, columns=["A", "B", "C"])
 
         expected_dtypes = [
-            "datetime64[s]",
-            "datetime64[s, US/Eastern]",
-            "datetime64[s, CET]",
+            "datetime64[us]",
+            "datetime64[us, US/Eastern]",
+            "datetime64[us, CET]",
         ]
         assert (res.dtypes == expected_dtypes).all()
 

pandas/tests/groupby/test_timegrouper.py

@@ -738,7 +738,7 @@ def test_groupby_first_datetime64(self):
     def test_groupby_max_datetime64(self):
         # GH 5869
         # datetimelike dtype conversion from int
-        df = DataFrame({"A": Timestamp("20130101"), "B": np.arange(5)})
+        df = DataFrame({"A": Timestamp("20130101").as_unit("s"), "B": np.arange(5)})
         # TODO: can we retain second reso in .apply here?
         expected = df.groupby("A")["A"].apply(lambda x: x.max()).astype("M8[s]")
         result = df.groupby("A")["A"].max()

pandas/tests/indexes/datetimes/test_constructors.py

@@ -524,7 +524,7 @@ def test_construction_dti_with_mixed_timezones(self):
                 Timestamp("2011-01-01 10:00", tz="Asia/Tokyo"),
                 Timestamp("2011-01-02 10:00", tz="US/Eastern"),
             ],
-            dtype="M8[s, US/Eastern]",
+            dtype="M8[us, US/Eastern]",
             name="idx",
         )
         tm.assert_index_equal(dti, expected)
@@ -602,7 +602,7 @@ def test_constructor_coverage(self):
         expected = DatetimeIndex(strings.astype("O"))
         tm.assert_index_equal(result, expected)
 
-        from_ints = DatetimeIndex(expected.as_unit("ns").asi8).as_unit("s")
+        from_ints = DatetimeIndex(expected.as_unit("ns").asi8).as_unit("us")
         tm.assert_index_equal(from_ints, expected)
 
         # string with NaT
@@ -611,7 +611,7 @@ def test_constructor_coverage(self):
         expected = DatetimeIndex(strings.astype("O"))
         tm.assert_index_equal(result, expected)
 
-        from_ints = DatetimeIndex(expected.as_unit("ns").asi8).as_unit("s")
+        from_ints = DatetimeIndex(expected.as_unit("ns").asi8).as_unit("us")
         tm.assert_index_equal(from_ints, expected)
 
         # non-conforming
@@ -940,11 +940,11 @@ def test_dti_tz_constructors(self, tzstr):
 
         idx1 = to_datetime(arr).tz_localize(tzstr)
         idx2 = date_range(
-            start="2005-11-10 08:00:00", freq="h", periods=2, tz=tzstr, unit="s"
+            start="2005-11-10 08:00:00", freq="h", periods=2, tz=tzstr, unit="us"
         )
         idx2 = idx2._with_freq(None)  # the others all have freq=None
-        idx3 = DatetimeIndex(arr, tz=tzstr).as_unit("s")
-        idx4 = DatetimeIndex(np.array(arr), tz=tzstr).as_unit("s")
+        idx3 = DatetimeIndex(arr, tz=tzstr)
+        idx4 = DatetimeIndex(np.array(arr), tz=tzstr)
 
         tm.assert_index_equal(idx1, idx2)
         tm.assert_index_equal(idx1, idx3)
@@ -1198,9 +1198,9 @@ def test_dti_constructor_object_dtype_dayfirst_yearfirst_with_tz(self):
         yfirst = Timestamp(2005, 10, 16, tz="US/Pacific")
 
         result1 = DatetimeIndex([val], tz="US/Pacific", dayfirst=True)
-        expected1 = DatetimeIndex([dfirst]).as_unit("s")
+        expected1 = DatetimeIndex([dfirst])
         tm.assert_index_equal(result1, expected1)
 
         result2 = DatetimeIndex([val], tz="US/Pacific", yearfirst=True)
-        expected2 = DatetimeIndex([yfirst]).as_unit("s")
+        expected2 = DatetimeIndex([yfirst])
         tm.assert_index_equal(result2, expected2)